Python网络编程

Posted 2020-10-13

1 socket层在哪里

 

2 socket是什么

Socket又称"套接字"，应用程序通常通过"套接字"向网络发出请求或者应答网络请求，使主机间或者一台计算机上的进程间可以通讯。

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

 

3 套接字家族

基于文件类型的套接字家族：AF_UNIX

Unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信

低级别的网络服务支持基本的 Socket，它提供了标准的 BSD Sockets API，可以访问底层操作系统Socket接口的全部方法

基于网络类型的套接字家族：AF_INET

所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET

高级别的网络服务模块 SocketServer， 它提供了服务器中心类，可以简化网络服务器的开发

 

4 套接字工作流程

 

1. 服务端先初始化socket，然后与端口绑定（bind），对端口进行监听（listen），调用accept阻塞，等待客户端连接
2. 客户端初始化一个socket，然后连接服务器（connect），如果连接成功，这时客户端与服务器的连接就建立了
3. 客户端发送数据请求，服务端接收请求并进行处理，然后把回应数据发送给客户端
4. 客户端读取数据，最后关闭连接，一次交互结束

 

5 socket()函数

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套接字

 

6 socket对象（内建）方法

函数	描述
服务器端套接字
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()	创建一个与该套接字相关连的文件

 

7 基于TCP协议的简单套接字通信

服务器端代码：

#!/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()      #关闭客户端套接字

 

8 加上通信循环与连接循环

服务器端代码：

#!/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 时间

 

9 实现ssh远程执行命令的功能（自定制报头）

服务器端代码：

#!/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()

 

10 粘包现象

上例代码，客户端输入命令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会将这次发送的数据拆成几个数据包发送出去。

 

11 实现ssh远程执行命令的功能（自定制报头高级版）

我们可以把报头做成字典，字典里包含将要发送的真实数据的详细信息，然后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()