19-socket

Python 提供了两个基本的 socket 模块。

第一个是 Socket，它提供了标准的 BSD Sockets API。

第二个是 SocketServer， 它提供了服务器中心类，可以简化网络服务器的开发。

下面讲的是Socket模块功能

Socket 类型

套接字格式：

socket(family,type[,protocal]) 使用给定的地址族、套接字类型、协议编号（默认为0）来创建套接字

socket类型:

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

socket.AF_INET :服务器之间网络通信

socket.AF_INET6 :IPv6

socket.SOCK_STREAM :流式socket , for TCP

socket.SOCK_DGRAM :数据报式socket , for UDP

socket.SOCK_SEQPACKET :可靠的连续数据包服务

socket.SOCK_RAW :原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。

创建TCP Socket ：s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

创建UDP Socket ：s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

Socket 函数

注意点:

1）TCP发送数据时，已建立好TCP连接，所以不需要指定地址。UDP是面向无连接的，每次发送要指定是发给谁。

2）服务端与客户端不能直接发送列表，元组，字典。需要字符串化repr(data)。

****服务端socket函数****

s.bind()    绑定(主机,端口号)到套接字

s.listen()  开始TCP监听，backlog指定在拒绝连接之前，操作系统可以挂起的最大连接数量。该值至少为1，大部分应用程序设为5就可以了

s.accept()  被动接受TCP客户的连接,(阻塞式)等待连接的到来，接受TCP连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。

****客户端socket函数****

s.connect(address) :主动初始化TCP服务器连接，连接到address处的套接字。一般address的格式为元组（hostname,port），如果连接出错，返回socket.error错误。

s.connect_ex(adddress) :connect()函数的扩展版本,出错时返回出错码,而不是抛出异常，功能与connect(address)相同，但是成功返回0，失败返回errno的值

****公共socket函数****

公共用途的套接字函数

s.recv(bufsize[,flag]) :接受TCP套接字的数据。数据以字符串形式返回，bufsize指定要接收的最大数据量。flag提供有关消息的其他信息，通常可以忽略，(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完)

s.send(string[,flag]) :发送TCP数据。将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。

s.sendall(string[,flag]) :完整发送TCP数据。将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常；本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时,数据不丢失,循环调用send直到发完)

s.recvfrom(bufsize[.flag]) :接受UDP套接字的数据。与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。

s.sendto(string[,flag],address) :发送UDP数据。将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。

s.close() :关闭套接字。

s.getpeername() :返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。

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

s.setsockopt(level,optname,value) :设置指定套接字选项的值。

s.getsockopt(level,optname[.buflen]) :返回指定套接字选项的值。

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

s.gettimeout() :返回当前超时期的值，单位是秒，如果没有设置超时期，则返回None。

s.fileno() :返回套接字的文件描述符。

s.setblocking(flag) :如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值）。非阻塞模式下，如果调用recv()没有发现任何数据，或send()调用无法立即发送数据，那么将引起socket.error异常。

s.makefile() :创建一个与该套接字相关连的文件

****面向锁的套接字方法****

s.setblocking()     设置套接字的阻塞与非阻塞模式

s.settimeout()      设置阻塞套接字操作的超时时间

s.gettimeout()      得到阻塞套接字操作的超时时间

****面向文件的套接字的函数****

s.fileno()          套接字的文件描述符

s.makefile()        创建一个与该套接字相关的文件

socket编程思路

TCP服务端：

1 创建套接字，绑定套接字到本地IP与端口

# socket.socket(socket.AF_INET,socket.SOCK_STREAM) , s.bind()

2 开始监听连接

# s.listen()

3 进入循环，不断接受客户端的连接请求

# s.accept()

4 然后接收传来的数据，并发送给对方数据

# s.recv() , s.sendall()

5 传输完毕后，关闭套接字

# s.close()

TCP客户端:

1 创建套接字，连接远端地址

# socket.socket(socket.AF_INET,socket.SOCK_STREAM) , s.connect()

2 连接后发送数据和接收数据，默认为bytes格式

# s.sendall(), s.recv()

3 传输完毕后，关闭套接字

# s.close()

例如：

服务端代码：

#!/usr/bin/env python
#__author__ = ‘xiaofie‘
#
import socket
import commands

HOST=‘0.0.0.0‘  # 字符串
PORT=2200  # 整型

#定义socket类型为网络通信;模式为流即TCP模式
s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)

#绑定服务器的ip与端口,注意是元组形式
s.bind((HOST,PORT))

#监听TCP的最大连接数
s.listen(5)

while True:
    conn,addr=s.accept()   #等待接收TCP连接，addr为客户端地址，conn为新的套接字
    print(‘Connected by‘, addr)

    while True:
        data=conn.recv(1024)   #接收数据实例化
        print(data,type(data))  # 将接收到的客户端的数据打印出来，并看一下类型是bytes类型
        conn.send(data.upper())  # 对客户端传过来的数据做一个大写处理，并发送回客户端

    conn.close()  # 处理完毕记得断开与客户端的链接
s.close()  # 关闭服务端监听

客户端代码：

#!/usr/bin/env python
#__author__ = ‘xiaofei‘
#
import socket

HOST=‘0.0.0.0‘  # 字符串
PORT=2200  # 整型

#定义socket类型为网络通信;模式为流即TCP模式
s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.connect((HOST,PORT))

while True:
    cmd = input(‘>> ‘).strip()
    if len(cmd) == 0: continue
    s.send(cmd.encode(‘utf-8‘))

    data=s.recv(1024)
    print(data.decode(‘utf-8‘))  #这里要打印，注意编码的格式
s.close()

可能会出现的问题：

这个是由于你的服务端仍然存在四次挥手的time_wait状态在占用地址（如果不懂，请深入研究1.tcp三次握手，四次挥手 2.syn洪水攻击 3.服务器高并发情况下会有大量的time_wait状态的优化方法）

解决的办法：

在服务端加一条socket配置，重用ip和端口

phone=socket(AF_INET,SOCK_STREAM)
phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
phone.bind((‘127.0.0.1‘,8080))

如果发现系统存在大量TIME_WAIT状态的链接，通过调整linux内核参数可解决：

# vi /etc/sysctl.conf

编辑文件，加入以下内容：
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_fin_timeout = 30

然后执行 /sbin/sysctl -p 让参数生效。

net.ipv4.tcp_syncookies = 1 表示开启SYN Cookies。当出现SYN等待队列溢出时，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭；

net.ipv4.tcp_tw_reuse = 1 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭；

net.ipv4.tcp_tw_recycle = 1 表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭。

net.ipv4.tcp_fin_timeout 修改系統默认的 TIMEOUT 时间

粘包

只有TCP有粘包现象，UDP永远不会粘包，为何，且听我娓娓道来

首先需要掌握一个socket收发消息的原理：

发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。

例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束

所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。

此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。

1，TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。

2，UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。

3，tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头，实验略

udp的recvfrom是阻塞的，一个recvfrom(x)必须对一个一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠

tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包

两种情况下会发生粘包。

1，发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）

2，接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）

拆包的发生情况

当发送端缓冲区的长度大于网卡的MTU时，tcp会将这次发送的数据拆成几个数据包发送出去。

粘包的解决办法

问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕:

如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓

然后接收端来一个死循环接收完所有数据

服务端：

第一阶段：制作报头

定义字典，存储数据的长度

转换为固定字典格式的字符串，即报头长度

back_msg=res.stdout.read() 这是服务端将要返回给客户端的数据

head_dic={‘head_size‘: len(back_msg)}  定义一个字典，用于记录将要返回的数据的长度

head_json=json.dumps(head_dic)  将字典序列化

head_bytes=head_json.encode(‘utf-8‘)  通过utf-8转换为bytes格式

第二阶段：发送报头的长度

先把报头长度发送回客户端

conn.send(struct.pack(‘i‘,len(head_bytes)))  先发送head_bytes的长度给客户端

第三阶段：发报头

conn.send(head_bytes)  在发送head_bytes数据

第四阶段：发真实数据

conn.sendall(back_msg)  最后发送数据给客户端

客户端：

第一阶段：收取报头的长度

head=client.recv(4)

head_size=struct.unpack(‘i‘, head)[0]

第二阶段:根据报头的长度，来收取报头

head_bytes=client.recv(head_size)

head_json=head_bytes.decode(‘utf-8‘)   解码

head_dic=json.loads(head_json)   反序列化

data_size=head_dic[‘data_size‘]

第三阶段：根据获取到的数据的长度来循环收取真实数据

recv_size=0  #定义接收的数据长度

recv_bytes=b‘‘

while recv_size < data_size:   #判断客户端要接收的数据长度是否小于数据真实的长度

res=client.recv(1024)

recv_bytes = recv_bytes + res  #字符串拼接

recv_size= recv_size + len(res)

print(recv_bytes.decode(‘gbk‘))

struct模块 

该模块可以把一个类型，如数字，转成固定长度的bytes

>>> struct.pack(‘i‘,1111111111111)

。。。。。。。。。

struct.error: ‘i‘ format requires -2147483648 <= number <= 2147483647 #这个是范围

关于struct的详细用法

import json,struct
#假设通过客户端上传1T:1073741824000的文件a.txt

#为避免粘包,必须自定制报头
header={‘file_size‘:1073741824000,‘file_name‘:‘/a/b/c/d/e/a.txt‘,‘md5‘:‘8f6fbf8347faa4924a76856701edb0f3‘} #1T数据,文件路径和md5值

#为了该报头能传送,需要序列化并且转为bytes
head_bytes=bytes(json.dumps(header),encoding=‘utf-8‘) #序列化并转成bytes,用于传输

#为了让客户端知道报头的长度,用struck将报头长度这个数字转成固定长度:4个字节
head_len_bytes=struct.pack(‘i‘,len(head_bytes)) #这4个字节里只包含了一个数字,该数字是报头的长度

#客户端开始发送
conn.send(head_len_bytes) #先发报头的长度,4个bytes
conn.send(head_bytes) #再发报头的字节格式
conn.sendall(文件内容) #然后发真实内容的字节格式

#服务端开始接收
head_len_bytes=s.recv(4) #先收报头4个bytes,得到报头长度的字节格式
x=struct.unpack(‘i‘,head_len_bytes)[0] #提取报头的长度

head_bytes=s.recv(x) #按照报头长度x,收取报头的bytes格式
header=json.loads(json.dumps(header)) #提取报头

#最后根据报头的内容提取真实的数据,比如
real_data_len=s.recv(header[‘file_size‘])
s.recv(real_data_len)

***************

#_*_coding:utf-8_*_
#http://www.cnblogs.com/coser/archive/2011/12/17/2291160.html
__author__ = ‘Linhaifeng‘
import struct
import binascii
import ctypes

values1 = (1, ‘abc‘.encode(‘utf-8‘), 2.7)
values2 = (‘defg‘.encode(‘utf-8‘),101)
s1 = struct.Struct(‘I3sf‘)
s2 = struct.Struct(‘4sI‘)

print(s1.size,s2.size)
prebuffer=ctypes.create_string_buffer(s1.size+s2.size)
print(‘Before : ‘,binascii.hexlify(prebuffer))
# t=binascii.hexlify(‘asdfaf‘.encode(‘utf-8‘))
# print(t)

s1.pack_into(prebuffer,0,*values1)
s2.pack_into(prebuffer,s1.size,*values2)

print(‘After pack‘,binascii.hexlify(prebuffer))
print(s1.unpack_from(prebuffer,0))
print(s2.unpack_from(prebuffer,s1.size))

s3=struct.Struct(‘ii‘)
s3.pack_into(prebuffer,0,123,123)
print(‘After pack‘,binascii.hexlify(prebuffer))
print(s3.unpack_from(prebuffer,0))

我们可以把报头做成字典，字典里包含将要发送的真实数据的详细信息，然后json序列化，然后用struck将序列化后的数据长度打包成4个字节（4个自己足够用了）

发送时：

先发报头长度

再编码报头内容然后发送

最后发真实内容

接收时：

先手报头长度，用struct取出来

根据取出的长度收取报头内容，然后解码，反序列化

从反序列化的结果中取出待取数据的详细信息，然后去取真实的数据内容

解决粘包问题示例：

服务端：

import socket
import subprocess
import struct
import json
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #买手机
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
phone.bind((‘127.0.0.1‘,8080)) #插电话卡
phone.listen(5) #开机，backlog
while True:
    print(‘starting....‘)
    conn,addr=phone.accept()
    print(‘cliet addr‘,addr)
    while True:
        try:
            cmd=conn.recv(1024)
            if not cmd:break
            res=subprocess.Popen(cmd.decode(‘utf-8‘),shell=True,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE)
            err=res.stderr.read()
            if err:
                cmd_res=err
            else:
                cmd_res=res.stdout.read()

            # conn.send(struct.pack(‘i‘,len(cmd_res))) #先报报头
            head_dic={‘filename‘:None,‘hash‘:None,‘total_size‘:len(cmd_res)}
            head_json=json.dumps(head_dic)
            head_bytes=head_json.encode(‘utf-8‘)

            #先发送报头的长度
            conn.send(struct.pack(‘i‘,len(head_bytes)))

            #再发送报头的bytes
            conn.send(head_bytes)

            #最后发送真实的数据
            conn.send(cmd_res)

        except Exception:
            break
    conn.close()
phone.close()

客户端：

#!/usr/bin/python
# -*- coding:utf-8 -*-

import socket
import struct
import json
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect((‘127.0.0.1‘,8080)) #拨通电话

while True: #通信循环
    cmd=input(‘>>: ‘).strip()
    if not cmd:continue #防止客户端发空
    phone.send(cmd.encode(‘utf-8‘)) #发消息

    #先收报头的长度
    head_struct=phone.recv(4)
    head_len=struct.unpack(‘i‘,head_struct)[0]

    #再收报头的bytes
    head_bytes=phone.recv(head_len)
    head_json=head_bytes.decode(‘utf-8‘)
    head_dic=json.loads(head_json)

    #最后根据报头里的详细信息取真实的数据
    print(head_dic)
    total_size=head_dic[‘total_size‘]
    recv_size=0
    data=b‘‘
    while recv_size < total_size: #10240 +1
        recv_data=phone.recv(1024)
        data+=recv_data
        recv_size+=len(recv_data)
    print(data.decode(‘gbk‘))
phone.close()