socket

socket

socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄，应用程序通常通过"套接字"向网络发出请求或者应答网络请求。

socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，对于文件用【打开】【读写】【关闭】模式来操作。socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）

2、socket和file的区别：

• file模块是针对某个指定文件进行【打开】【读写】【关闭】
• socket模块是针对 服务器端 和 客户端Socket 进行【打开】【读写】【关闭】

2、连接原理
根据连接启动的方式以及本地套接字要连接的目标，套接字之间的连接过程可以分为三个步骤：服务器监听，客户端请求，连接确认。

（1）服务器监听：是服务器端套接字并不定位具体的客户端套接字，而是处于等待连接的状态，实时监控网络状态。

（2）客户端请求：是指由客户端的套接字提出连接请求，要连接的目标是服务器端的套接字。为此，客户端的套接字必须首先描述它要连接的服务器的套接字，指出服务器端套接字的地址和端口号，然后就向服务器端套接字提出连接请求。

（3）连接确认：是指当服务器端套接字监听到或者说接收到客户端套接字的连接请求，它就响应客户端套接字的请求，建立一个新的线程，把服务器端套接字的描述发给客户端，一旦客户端确认了此描述，连接就建立好了。而服务器端套接字继续处于监听状态，继续接收其他客户端套接字的连接请求。

简单socket简单应用

#!/bin/bin/env python
# -*-coding:utf-8 -*-
# Author : rain
# socket 服务端

# 导入socket模块
import socket
# 创建连接对象
sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 绑定ip及端口
sk.bind(('127.0.0.1', 6666))
# 设置最大可以挂起的连接数
sk.listen(5)

while True:
    # 打印客户端连接后的界面
    print('wating client connection.......')
    # 客户连接阻塞（无客户连接时为阻塞状态）
    connection, address = sk.accept()
    print('123', connection)
    print(address)

    # 获取客户端传过来的数据(3.x版本之后接收的数据必须是bytes，之前的版本可以为str)
    client_messge = connection.recv(1024)
    print('接到客户端的信息：', client_messge)
    # 给客户端发送数据(3.x版本之后发送的数据必须是bytes，之前的版本可以为str)
    connection.sendall(bytes('hello client this server', 'utf8'))
    # 关闭当前客户连接
    connection.close()

#!/bin/bin/env python
# -*-coding:utf-8 -*-
# Author : rain
# socket 客户端

# 导入模块
import socket
# 创建连接对象
ck = socket.socket()
# 绑定ip及端口
ck.connect(('127.0.0.1', 6666))
# 给服务端发送数据(3.x版本之后发送的数据必须是bytes，之前的版本可以为str)
ck.sendall(bytes('hello server this is client', 'utf8'))
# 接收来息服务端的数据（3.x版本之后接收的数据必须是bytes，之前的版本可以为str）
server_answer = ck.recv(1024)
print('接收server端数据：', server_answer)
# 关闭当前客户端
ck.close()

说明：

accept()方法没有客户端连接过来的话是阻塞状态，直到有客户端连接过来

recv()方法表示，接收数据，如果没有数据可接受，也会阻塞知道有数据过来

更多功能

sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)

参数一：地址簇

　　socket.AF_INET IPv4（默认）
　　socket.AF_INET6 IPv6

　　socket.AF_UNIX 只能够用于单一的Unix系统进程间通信

参数二：类型

　　socket.SOCK_STREAM　　流式socket , for TCP （默认）
　　socket.SOCK_DGRAM　　 数据报式socket , for UDP

　　socket.SOCK_RAW 　　原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。
　　socket.SOCK_RDM 　　是一种可靠的UDP形式，即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问，在需要执行某些特殊操作时使用，如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。
　　socket.SOCK_SEQPACKET 可靠的连续数据包服务

参数三：协议

　　0　　（默认）与特定的地址家族相关的协议,如果是 0 ，则系统就会根据地址格式和套接类别,自动选择一个合适的协议

#!/bin/bin/env python
# -*-coding:utf-8 -*-
# Author : rain
# UDP sever


import socket
ip_port = ('127.0.0.1', 8009)
sk = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, 0)
sk.bind(ip_port)
sk.listen(5)

while True:
    data = sk.recv(1024)
    print(data)


#!/bin/bin/env python
# -*-coding:utf-8 -*-
# Author : rain
# UDP client

import socket
ip_port = ('127.0.0.1', 8009)

sk = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, 0)

while True:
    enter = input('>>>: ').strip()
    if enter == 'exit':
        break
    sk.sendto(bytes(enter, encoding='utf8'), ip_port)
sk.close()

sk.bind((address, port))

　　s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。

sk.listen(backlog)

　　开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。

      backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5
      这个值不能无限大，因为要在内核中维护连接队列

sk.setblocking(bool)

　　是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。

sk.accept()

　　接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。

　　接收TCP 客户的连接（阻塞式）等待连接的到来

sk.connect(address)

　　连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。

sk.connect_ex(address)

　　同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061

sk.close()

　　关闭套接字

sk.recv(bufsize[,flag])

　　接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。

sk.recvfrom(bufsize[.flag])

　　与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。

sk.send(string[,flag])

　　将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。

sk.sendall(string[,flag])

　　将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。

      内部通过递归调用send，将所有内容发送出去。

sk.sendto(string[,flag],address)

　　将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。

sk.settimeout(timeout)

　　设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）

sk.getpeername()

　　返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。

sk.getsockname()

　　返回套接字自己的地址。通常是一个元组(ipaddr,port)

sk.fileno()

　　套接字的文件描述符

简单的ssh实例

#!/bin/bin/env python
# -*-coding:utf-8 -*-
# Author : rain

# 导入socket模块
import socket
# 导入执行命令模块
import subprocess

ip_port = ('127.0.0.1', 9999)   # 定义元祖
sk = socket.socket()            # 绑定协议，生成套接字
sk.bind(ip_port)                # 绑定ip+协议+端口：用来唯一标识一个进程，ip_port必须是元组格式
sk.listen(5)                    # 定义最大可以挂起胡链接数

while True:                     # 用来重复接收新的链接
    try:
        conn, addr = sk.accept()    # 收消息，阻塞
        conn.sendall(bytes('---------ssh 登录界面----------', encoding='utf8'))
        while True:
            data = conn.recv(1024)
            if len(data) == 0: break
            c_data = subprocess.Popen(str(data, encoding='utf8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            cmd_data = c_data.stdout.read()
            if len(cmd_data) == 0:
                send_data = 'cmd err'
            else:
                send_data = str(cmd_data, encoding='gbk')
                print('%s  %s ' % (conn.getpeername(), data.decode()))

            conn.send(bytes(send_data, encoding='utf8'))
    except Exception:
        break

    conn.close()

#!/bin/bin/env python
# -*-coding:utf-8 -*-
# Author : rain

import socket

ip_port = ('127.0.0.1', 9999)
ck = socket.socket()
ck.connect(ip_port)
# ck.settimeout(5)

s_data = ck.recv(1024)
print(s_data.decode())
while True:
    inp = input("输入一个命令>>>:")
    ck.send(bytes(inp, encoding='utf8'))
    data = ck.recv(1024)
    print(data.decode())

ck.close()

socketserver