首页 > 代码库 > 19-socket
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=http://www.mamicode.com/phone.recv(1024) data+=recv_data recv_size+=len(recv_data) print(data.decode(‘gbk‘)) phone.close()
19-socket
声明:以上内容来自用户投稿及互联网公开渠道收集整理发布,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任,若内容有误或涉及侵权可进行投诉: 投诉/举报 工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。