标签：成功 链接 不同 tag 连接数量 机制 最大 continue linux内核
Socket又称"套接字"，应用程序通常通过"套接字"向网络发出请求或者应答网络请求，使主机间或者一台计算机上的进程间可以通讯。
Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。
基于文件类型的套接字家族：AF_UNIX
Unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信
低级别的网络服务支持基本的 Socket，它提供了标准的 BSD Sockets API，可以访问底层操作系统Socket接口的全部方法
基于网络类型的套接字家族：AF_INET
所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET
高级别的网络服务模块 SocketServer， 它提供了服务器中心类，可以简化网络服务器的开发
python中，我们用socket()函数来创建套接字，语法格式如下：
socket.socket([family[, type[, proto]]]) #family：套接字家族可以使用AF_UNIX或者AF_INET #type: 套接字类型可以根据是面向连接的还是非连接分为SOCK_STREAM或SOCK_DGRAM #protocol: 一般不填默认为0
例子：
import socket tcpSock = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #获取TCP/IP套接字 udpSock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #获取UDP/IP套接字
|
函数 |
描述 |
|
服务器端套接字 |
|
|
s.bind() |
绑定地址（host,port）到套接字， 在AF_INET下,以元组（host,port）的形式表示地址。 |
|
s.listen() |
开始TCP监听。backlog指定在拒绝连接之前，操作系统可以挂起的最大连接数量。该值至少为1，大部分应用程序设为5就可以了。 |
|
s.accept() |
被动接受TCP客户端连接,(阻塞式)等待连接的到来 |
|
客户端套接字 |
|
|
s.connect() |
主动初始化TCP服务器连接。一般address的格式为元组（hostname,port），如果连接出错，返回socket.error错误。 |
|
s.connect_ex() |
connect()函数的扩展版本,出错时返回出错码,而不是抛出异常 |
|
公共用途的套接字函数 |
|
|
s.recv() |
接收TCP数据，数据以字符串形式返回，bufsize指定要接收的最大数据量。flag提供有关消息的其他信息，通常可以忽略。 |
|
s.send() |
发送TCP数据，将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。 |
|
s.sendall() |
完整发送TCP数据，将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。 |
|
s.recvform() |
接收UDP数据，与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。 |
|
s.sendto() |
发送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.setblocking(flag) |
如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值）。非阻塞模式下，如果调用recv()没有发现任何数据，或send()调用无法立即发送数据，那么将引起socket.error异常。 |
|
s.settimeout(timeout) |
设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如connect()） |
|
s.gettimeout() |
返回当前超时期的值，单位是秒，如果没有设置超时期，则返回None。 |
|
面向文件的套接字的函数 |
|
|
s.fileno() |
返回套接字的文件描述符。 |
|
s.makefile() |
创建一个与该套接字相关连的文件 |
服务器端代码：
#!/usr/bin/python # -*- coding: utf-8 -*- import socket ss = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #创建服务器套接字 ss.bind((‘127.0.0.1‘,8000)) #把地址绑定到套接字 ss.listen(5) #监听连接 conn,client_addr = ss.accept() #接受客户端连接 print(conn) #套接字链接，<socket.socket fd=272, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=(‘127.0.0.1‘, 8000), raddr=(‘127.0.0.1‘, 54418)> print(client_addr) #客户端的ip和port，(‘127.0.0.1‘, 54418) data = conn.recv(1024) #接收TCP数据,指定要接收的最大数据量为1024字节 print(data) #接收的数据，b‘hello‘ conn.send(data.upper()) #发送TCP数据 conn.close() #关系客户端套接字 ss.close() #关闭服务器套接字
客户端代码：
#!/usr/bin/python # -*- coding: utf-8 -*- import socket ss = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #创建客户端套接字 ss.connect((‘127.0.0.1‘,8000)) #连接服务器 ss.send(‘hello‘.encode(‘utf-8‘)) #发送TCP数据 data = ss.recv(1024) #接收TCP数据,指定要接收的最大数据量为1024字节 print(data) #接收的数据，b‘HELLO‘ ss.close() #关闭客户端套接字
服务器端代码：
#!/usr/bin/python # -*- coding: utf-8 -*- import socket ss = socket.socket(socket.AF_INET,socket.SOCK_STREAM) ss.bind((‘127.0.0.1‘,8000)) ss.listen(5) while True: #接收连接循环，可以不停的接收客户端请求 conn,client_addr = ss.accept() print(client_addr) while True: #通信循环，可以不断的通信，收发消息 try: data = conn.recv(1024) print(data) if not data:break #针对linux系统 conn.send(data.upper()) except ConnectionResetError: #防止已连接的客户端突然断开,recv便不再阻塞,死循环发生 break conn.close() ss.close()
客户端代码：
#!/usr/bin/python # -*- coding: utf-8 -*- import socket ss = socket.socket(socket.AF_INET,socket.SOCK_STREAM) ss.connect((‘127.0.0.1‘,8000)) while True: #通信循环，可以不断的通信，收发消息 msg = input(‘>>>:‘).strip() if not msg:continue ss.send(msg.encode(‘utf-8‘)) data = ss.recv(1024) print(data.decode(‘utf-8‘)) ss.close()
在重启服务端时可能会遇到下图的情况，这个是由于服务端仍然存在四次挥手的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 时间
服务器端代码：
#!/usr/bin/python # -*- coding: utf-8 -*- import socket import subprocess import struct ss = socket.socket(socket.AF_INET,socket.SOCK_STREAM) ss.bind((‘127.0.0.1‘,8000)) ss.listen(5) while True: conn,client_addr = ss.accept() print(client_addr) while True: try: cmd = conn.recv(1024) if not cmd:break #执行客户端发来的命令，拿到执行结果 obj = subprocess.Popen(cmd.decode(‘utf-8‘),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE) stdout_res = obj.stdout.read() stderr_res = obj.stderr.read() #计算数据大小，制作报头，发送报头 total_size = len(stdout_res) + len(stderr_res) conn.send(struct.pack(‘i‘,total_size)) #发送真实数据 conn.send(stdout_res) conn.send(stderr_res) except ConnectionResetError: break conn.close() ss.close()
客户端代码：
#!/usr/bin/python # -*- coding: utf-8 -*- import socket import struct ss = socket.socket(socket.AF_INET,socket.SOCK_STREAM) ss.connect((‘127.0.0.1‘,8000)) while True: #发送命令 cmd = input(‘>>>:‘).strip() if not cmd:continue ss.send(cmd.encode(‘utf-8‘)) #接收报头 header_struct = ss.recv(4) total_size = struct.unpack(‘i‘,header_struct)[0] #接收命令执行的结果 cmd_res = b‘‘ recv_size = 0 while recv_size < total_size: recv_data = ss.recv(1024) cmd_res += recv_data recv_size += len(recv_data) print(cmd_res.decode(‘gbk‘)) ss.close()
上例代码，客户端输入命令ls -l ; lllllll ; pwd 的结果是既有正确stdout结果，又有错误stderr结果，出现了粘包现象
基于tcp的socket在运行时会发生粘包，基于udp的socket在运行时永远不会发生粘包
发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。
例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束
所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。
此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。
TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头。
udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠
tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。
两种情况下会发生粘包：
接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）
发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）
拆包的发生情况：当发送端缓冲区的长度大于网卡的MTU时，tcp会将这次发送的数据拆成几个数据包发送出去。
我们可以把报头做成字典，字典里包含将要发送的真实数据的详细信息，然后json序列化，然后用struck将序列化后的数据长度打包成4个字节（4个自己足够用了）
发送时：
先发报头长度
再编码报头内容然后发送
最后发真实内容
接收时：
先手报头长度，用struct取出来
根据取出的长度收取报头内容，然后解码，反序列化
从反序列化的结果中取出待取数据的详细信息，然后去取真实的数据内容
服务器端代码：
#!/usr/bin/python # -*- coding: utf-8 -*- import socket import subprocess import struct import json ss = socket.socket(socket.AF_INET,socket.SOCK_STREAM) ss.bind((‘127.0.0.1‘,8000)) ss.listen(5) while True: conn,client_addr = ss.accept() print(client_addr) while True: try: cmd = conn.recv(1024) if not cmd:break #执行客户端发来的命令，拿到执行结果 obj = subprocess.Popen(cmd.decode(‘utf-8‘),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE) stdout_res = obj.stdout.read() stderr_res = obj.stderr.read() #制作报头 header_dic = { ‘filename‘:‘a.txt‘, ‘total_size‘:len(stdout_res)+len(stderr_res), ‘md5‘:‘xxxxxx‘ } head_json = json.dumps(header_dic) head_bytes = head_json.encode(‘utf-8‘) #发送报头长度 conn.send(struct.pack(‘i‘,len(head_bytes))) #发送报头 conn.send(head_bytes) #发送真实数据 conn.send(stdout_res) conn.send(stderr_res) except ConnectionResetError: break conn.close() ss.close()
客户端代码：
#!/usr/bin/python # -*- coding: utf-8 -*- import socket import struct import json ss = socket.socket(socket.AF_INET,socket.SOCK_STREAM) ss.connect((‘127.0.0.1‘,8000)) while True: #发送命令 cmd = input(‘>>>:‘).strip() if not cmd:continue ss.send(cmd.encode(‘utf-8‘)) #接收报头长度 header_struct = ss.recv(4) header_size = struct.unpack(‘i‘,header_struct)[0] #接收报头 head_bytes = ss.recv(header_size) head_json = head_bytes.decode(‘utf-8‘) head_dic = json.loads(head_json) #接收命令执行的结果 cmd_res = b‘‘ recv_size = 0 total_size = head_dic[‘total_size‘] while recv_size < total_size: recv_data = ss.recv(1024) cmd_res += recv_data recv_size += len(recv_data) print(cmd_res.decode(‘gbk‘)) ss.close()
标签：成功 链接 不同 tag 连接数量 机制 最大 continue linux内核
原文地址：http://www.cnblogs.com/yanmj/p/7811346.html
