首页 > 代码库 > 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