python之网络编程

1.OSI协议与TCP/IP协议

OSI是Open System Interconnection的缩写，意为开放式系统互联。国际标准化组织（ISO）制定了OSI模型，该模型定义了不同计算机互联的标准，是设计和描述计算机网络通信的基本框架。OSI模型把网络通信的工作分为7层，分别是物理层、数据链路层、网络层、传输层、会话层、表示层和应用层。

这是一种事实上被TCP/IP 4层模型淘汰的协议。在当今世界上没有大规模使用。

业界广泛使用的是TCP/IP协议，将网络通信分为四层，分别是网络接口层，网络层，传输层，应用层。

 

 

2.socket层

那么用于网络通信的socket位于那一层呢？

 

3.socket是什么

Socket本质上就是在2台网络互通的电脑之间，架设一个通道，两台电脑通过这个通道来实现数据的互相传。它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

Socket=（IP地址：端口号）

4.套接字发展及分类

套接字Socket起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。 因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。

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

套接字家族的名字：AF_UNIX

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

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

套接字家族的名字：AF_INET

(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个。

6.socket底层工作原理解释

建立一个socket必须至少有2端， 一个服务端，一个客户端， 服务端被动等待并接收请求，客户端主动发起请求， 连接建立之后，双方可以互发数据。

基本流程

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

import socket
server = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #声明socket类型同时生成socket链接对象
server.bind(('127.0.0.1',8000)) #绑定要监听的端口
server.listen(5)#监听
conn,addr=server.accept() #等待
while True:
    msg = conn.recv(1024)   #收消息
    print('客户端发来的消息是：',msg)
    conn.send(msg.upper()) #发消息

conn.close()
server.close()

mport socket
client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)    #声明socket类型同时生成socket链接对象

client.connect(('127.0.0.1',8000)) #链接


while True:
    msg = input('>>').strip()
    client.send(msg.encode('utf-8')) #向服务端发送消息
    data = client.recv(1024) #接收来自服务端的消息
    print('收到服务端发来的消息：',data)

7.tcp三次握手与四次挥手

 

 

8.基于tcp实现远程执行命令

实现client端向server发送命令，server执行命令，并将结果返回给client端

 

from socket import *
import subprocess
tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(('127.0.0.1',8080))
tcp_socket_server.listen(5)

while True:
    conn,addr=tcp_socket_server.accept()
    print('客户端',addr)

    while True:
        cmd=conn.recv(1024)     #接收来自client发送的命令
        if len(cmd) == 0:break
        #执行命令
        act_res=subprocess.Popen(cmd.decode('utf-8'),shell=True,
                         stdout=subprocess.PIPE,
                         stdin=subprocess.PIPE,
                         stderr=subprocess.PIPE)

        stderr=act_res.stderr.read()  #标准错误
        stdout=act_res.stdout.read()  #标准输出
        conn.send(stderr)  #向client端返回执行结果
        conn.send(stdout)  #向client端返回错误信息

import socket
tcp_socket_client=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=tcp_socket_client.connect(('127.0.0.1',8080))

while True:
    msg=input('>>: ').strip()
    if len(msg) == 0:continue
    if msg == 'quit':break

    tcp_socket_client.send(msg.encode('utf-8'))  #向server端发送执行命令
    act_res=tcp_socket_client.recv(1024)  #接收执行完命令返回的结果

    print(act_res.decode('utf-8'),end='')

在客户端输入命令ls，错误的命令ll，以及ifconfig

返回结果

 

 

 可以看到返回结果有正确stdout结果，也有错误stderr结果。

9.粘包现象

在系统终端输入ifconfig命令，结果如下

咿？从最后的结果看怎么和上面client端展示的不一样啦？

让我们再次输入命令ls

发现输出依然是ifconfig未完的结果，并且ls执行结果也在最后返回了。

这就是因为发生了粘包

为什么会发生粘包现象呢？我们可以看看代码，其中conn.recv(1024) 代表一次接收的数据字节为1024K，但是我们并不知道发送方一次发送的数据大小呀，如果发送的内容超过1024K，意味着我们一次并不能接收到所有的内容。

此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方也会收到粘包数据。

我们知道tcp的协议的优点是数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是这种模式会产生粘包现象。

 让我们从发送和接收两端来分析

发送端：

需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据很小，会合到一起，产生粘包）

接受端：

不及时接收缓冲区的包，造成多个包接收（发送端发送了一段数据，接收端只收了一小部分，接受端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）

扩展一 ：拆包的发生情况

当发送端缓冲区的长度大于网卡的MTU时，tcp会将这次发送的数据拆成几个数据包发送出去。

扩展二：UDP协议与TCP协议比较

UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 

udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠。

 

10.粘包解决方法

问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据。

简单的解决方法

import socket,subprocess
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

s.bind(('127.0.0.1',8080))
s.listen(5)

while True:
    conn,addr=s.accept()
    print('客户端',addr)
    while True:
        msg=conn.recv(1024)
        if not msg:break
        res=subprocess.Popen(msg.decode('utf-8'),shell=True,\
                            stdin=subprocess.PIPE,\
                         stderr=subprocess.PIPE,\
                         stdout=subprocess.PIPE)
        err=res.stderr.read()
        if err:
            ret=err
        else:
            ret=res.stdout.read()
        data_length=len(ret)
        conn.send(str(data_length).encode('utf-8'))
        data=conn.recv(1024).decode('utf-8')
        if data == 'recv_ready':
            conn.sendall(ret)
    conn.close()

import socket,time
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect(('127.0.0.1',8080))

while True:
    msg=input('>>: ').strip()
    if len(msg) == 0:continue
    if msg == 'quit':break

    s.send(msg.encode('utf-8'))
    length=int(s.recv(1024).decode('utf-8'))
    s.send('recv_ready'.encode('utf-8'))
    send_size=0
    recv_size=0
    data=b''
    while recv_size < length:
        data+=s.recv(1024)
        recv_size+=len(data)


    print(data.decode('utf-8'))
复制代码

这种方法的缺陷是程序的运行速度远快于网络传输速度，所以在发送一段字节前，先用send去发送该字节流长度，这种方式会放大网络延迟带来的性能损耗。

高级一点的解决方法

为字节流加上自定义固定长度报头，报头中包含字节流长度，然后一次send到对端，对端在接收时，先从缓存中取出定长的报头，然后再取真实数据

 struct模块 

该模块可以把一个类型，如数字，转成固定长度的bytes

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)

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))
复制代码

 

import socket, struct, json
import subprocess

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)  # 就是它，在bind前加

server.bind(('127.0.0.1', 8080))

server.listen(5)

while True:
    conn, addr = server.accept()
    while True:
        cmd = conn.recv(1024)
        if not cmd: break
        print('cmd: %s' % cmd)

        res = subprocess.Popen(cmd.decode('utf-8'),
                               shell=True,
                               stdout=subprocess.PIPE,
                               stderr=subprocess.PIPE)
        err = res.stderr.read()
        print(err)
        if err:
            back_msg = err
        else:
            back_msg = res.stdout.read()

        conn.send(struct.pack('i', len(back_msg)))  # 先发back_msg的长度
        conn.sendall(back_msg)  # 在发真实的内容

    conn.close()

import socket, time, struct

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
res = s.connect(('127.0.0.1', 8080))

while True:
    msg = input('>>: ').strip()
    if len(msg) == 0: continue
    if msg == 'quit': break

    s.send(msg.encode('utf-8'))

    l = s.recv(4)
    x = struct.unpack('i', l)[0]
    print(type(x), x)
    # print(struct.unpack('I',l))
    r_s = 0
    data = b''
    while r_s < x:
        r_d = s.recv(1024)
        data += r_d
        r_s += len(r_d)

    print(data.decode('utf-8'))

 

我们可以把报头做成字典，字典里包含将要发送的真实数据的详细信息，然后json序列化，然后用struck将序列化后的数据长度打包成4个字节（4个字节足够用了）

发送时：

先发报头长度

再编码报头内容然后发送

最后发真实内容

 

接收时：

先收报头长度，用struct取出来

根据取出的长度收取报头内容，然后解码，反序列化

从反序列化的结果中取出待取数据的详细信息，然后去取真实的数据内容

import socket, struct, json
import subprocess

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)  # 就是它，在bind前加

server.bind(('127.0.0.1', 8080))

server.listen(5)

while True:
    conn, addr = server.accept()
    while True:
        cmd = conn.recv(1024)
        if not cmd: break
        print('cmd: %s' % cmd)

        res = subprocess.Popen(cmd.decode('utf-8'),
                               shell=True,
                               stdout=subprocess.PIPE,
                               stderr=subprocess.PIPE)
        err = res.stderr.read()
        print(err)
        if err:
            back_msg = err
        else:
            back_msg = res.stdout.read()

        headers = {'data_size':len(back_msg)} #定义报文头部
        head_json = json.dumps(headers)
        head_json_bytes = bytes(head_json,encoding='utf-8')
        conn.send(struct.pack('i', len(head_json_bytes)))  # 先发报头的长度
        conn.send(head_json_bytes)  # 再发报头
        conn.sendall(back_msg)  # 再发真实的内容

    conn.close()

import socket, time, struct,json

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
res = client.connect(('127.0.0.1', 8080))

while True:
    msg = input('>>: ').strip()
    if len(msg) == 0: continue
    if msg == 'quit': break

    client.send(msg.encode('utf-8'))

    head = client.recv(4)
    head_json_len = struct.unpack('i', head)[0]
    head_json = json.loads(client.recv(head_json_len).decode('utf-8'))
    data_len = head_json['data_size']
    receive_size = 0
    receive_data = b''
    while receive_size < data_len:
        receive_data = client.recv(1024)
        receive_size += len(receive_data)

    print(receive_data.decode('utf-8'))

 

11.socket sever实现并发

到目前为止我们可以实现两个端的简单通信，然而实际生活中的网络通信不可能只有一个接收端，一个发送端，你不可能只和一个人聊天，你想和多人聊天怎么办呢？这就用到了socket server。我们知道基于TCP的套接字 , 关键就是两个循环 , 一个链接循环(多人) , 一个通信循环(多消息)。

在socketserver模块中分为两大类 : server类 (解决链接问题) 和request类 (解决通信问题)。详情请看官方文档https://docs.python.org/3/library/socketserver.html?highlight=socketserver#module-socketserver

server类

request类

 

 

实现一个简单的socket server有4步：

1.创建一个请求处理类，这个类继承自BaseRequestHandler，且需要重写父类的handle()方法

2.实例化TCPServer，传递server IP 和上面创建的请求处理类给这个TCPServer

3.调用 handle_request()或者serve_forever()方法来处理一个或多个请求

4.调用server_close() 关闭套接字（使用了with语句自己不需要关闭）

import socketserver
class MyTCPHandler(socketserver.BaseRequestHandler):
    def handle(self):
        while True:
            try:
                self.data = self.request.recv(1024).strip()
                print('{} wrote'.format(self.client_address[0]))
                print(self.data.decode())
                self.request.send(self.data.upper())
            except ConnectionResetError as e :
                print('err',e)
                break
if __name__ == '__main__':
    HOST,PORT = '127.0.0.1',9999
    server = socketserver.ThreadingTCPServer((HOST,PORT),MyTCPHandler)
    server.serve_forever()
    server.server_close

12.认证客户端的链接合法性

实现一个简单的客户端链接认证功能，利用hmac+加盐的方式来实现，这么做的好处是限制客户端的链接，杜绝客户端通过IP+端口就对你的服务器进行访问。

 

from socket import *
import hmac, os

secret_key = b'anne is best'


def conn_auth(conn):
    '''
    认证客户端链接
    :param conn:
    :return:
    '''
    print('开始验证新链接的合法性')
    msg = os.urandom(32) # 随机产生一个32位的密钥
    print(msg)
    conn.sendall(msg)  #将这32位密码发送给client端
    h = hmac.new(secret_key, msg)  # hmac类似于md5,这里是加盐的方式
    digest = h.digest()   #生成密文
    respone = conn.recv(len(digest))    #接收来自client的验证密文
    return hmac.compare_digest(respone, digest)  #比对是否一致


def data_handler(conn, bufsize=1024):
    if not conn_auth(conn):
        print('该链接不合法,关闭')
        conn.close()
        return
    print('链接合法,开始通信')
    while True:
        data = conn.recv(bufsize)
        if not data: break
        conn.sendall(data.upper())


def server_handler(ip_port, bufsize, backlog=5):
    '''
    只处理链接
    :param ip_port:
    :return:
    '''
    tcp_socket_server = socket(AF_INET, SOCK_STREAM)
    tcp_socket_server.bind(ip_port)
    tcp_socket_server.listen(backlog)
    while True:
        conn, addr = tcp_socket_server.accept()
        print('新连接[%s:%s]' % (addr[0], addr[1]))
        data_handler(conn, bufsize)


if __name__ == '__main__':
    ip_port = ('127.0.0.1', 9998)
    bufsize = 1024
    server_handler(ip_port, bufsize)

 

from socket import *
import hmac, os

secret_key = b'anne is best'


def conn_auth(conn):
    '''
    验证客户端到服务器的链接
    :param conn:
    :return:
    '''
    msg = conn.recv(32)  #接收来自server的原始密钥
    h = hmac.new(secret_key, msg)
    digest = h.digest()  #生成最终秘文
    conn.sendall(digest) #发送秘文给客户端


def client_handler(ip_port, bufsize=1024):
    tcp_socket_client = socket(AF_INET, SOCK_STREAM)
    tcp_socket_client.connect(ip_port)

    conn_auth(tcp_socket_client)

    while True:
        data = input('>>: ').strip()
        if not data: continue
        if data == 'quit': break

        tcp_socket_client.sendall(data.encode('utf-8'))
        respone = tcp_socket_client.recv(bufsize)
        print(respone.decode('utf-8'))
    tcp_socket_client.close()


if __name__ == '__main__':
    ip_port = ('127.0.0.1', 9998)
    bufsize = 1024
    client_handler(ip_port, bufsize)

 

13.开发一个支持多用户在线的FTP程序