19-socket
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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()
以上是关于19-socket的主要内容，如果未能解决你的问题，请参考以下文章