Python21期 day8 之网络编程

网络编程

socket概念

理解套接字(socket)

socket是应用层与TCP/IP协议通信的中间软件抽象层，是一组接口。

其实站在你的角度上看，socket就是一个模块。我们通过调用模块中已经实现的方法建立两个进程之间的连接和通信。
也有人将socket说成ip+port，因为ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序。
所以我们只要确立了ip和port就能找到一个应用程序，并且使用socket模块来与之通信。

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

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

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

 

TCP和UDP协议

TCP（Transmission Control Protocol）可靠的、面向连接的协议（eg:打电话）、传输效率低全双工通信（发送缓存&接收缓存）、面向字节流。使用TCP的应用：Web浏览器；电子邮件、文件传输程序。

UDP（User Datagram Protocol）不可靠的、无连接的服务，传输效率高（发送前时延小），一对一、一对多、多对一、多对多、面向报文，尽最大努力服务，无拥塞控制。使用UDP的应用：域名系统 (DNS)；视频流；IP语音(VoIP)。

 

套接字（socket）使用

基于TCP协议，tcp是基于链接的，必须先启动服务器，然后再启动客户端去链接服务器

server端：

import socket

sk = socket.socket()
#加入下面一条socket配置，重用ip和端口
sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)　　
sk.bind(('127.0.0.1',8898))  #把地址绑定到套接字
sk.listen()          #监听链接
conn,addr = sk.accept() #接受客户端链接

ret = conn.recv(1024)  #接收客户端信息
print(ret)       #打印客户端信息
conn.send(b'hi')        #向客户端发送信息
conn.close()       #关闭客户端套接字
sk.close()        #关闭服务器套接字(可选)

Client端：

import socket

sk = socket.socket()           # 创建客户套接字
sk.connect(('127.0.0.1',8898))    # 尝试连接服务器

sk.send(b'hello!')
ret = sk.recv(1024)         # 对话(发送/接收)
print(ret)
sk.close()            # 关闭客户套接字

 

基于UDP协议的socket

udp是无链接的，启动服务之后，可以直接接受消息，不需要提前建立连接

server端：

import socket

sk = socket.socket(type=socket.SOCK_DGRAM) #创建一个服务器的套接字
sk.bind(('127.0.0.1',9000))        #绑定服务器套接字

msg,addr = sk.recvfrom(1024)
print(msg)
sk.sendto(b'hi',addr)    # 对话(接收与发送)

sk.close()        # 关闭服务器套接字

client端：

import sokcet 

sk = socket.socket(type=socket.SOCK_DGRAM)
sk.sendo(b'hello',('127.0.0.1',9000))

msg,addr = sk.recvfrom(1024)
print(msg.decode('utf-8'),addr)

 

QQ聊天

import socket

ip_port = ('127.0.0.1',8081)
udp_sk = socket.socket(socket.AF_INET,socket.SOCK.DGRAM)
udp_sk.bind(ip_port)

while True:
    msg,addr = udp_sk.recvfrom(1024)
    print('来自[%s:%s]的一条消息：'%(addr[0],addr[1],msg.decode('utf-8')))
    
    back_msg = input('回复消息：').strip()
    udp_sk.sendto(back_msg.encode('utf-8'),addr)

import socket
BUFSIZE = 1024
udp_sk = socket.socket(socket.AF_INET,socket.SOCK.DGRAM)

qq_name_dic = {
    '金老板':('127.0.0.1',8081),
    '哪吒':('127.0.0.1',8081),
    'egg':('127.0.0.1',8081),
    'yuan':('127.0.0.1',8081),
}

while True:
    qq_name = input('请选择聊天对象:').strip()
    while True:
        msg = input('请输入消息,回车发送,输入q结束和他的聊天: ').strip()
        if msg == 'q':break
        if not msg or not qq_name or qq_name not in qq_name_dic:continue
        udp_sk.sendto(msg.encode('utf-8'),qq_name_dic[qq_name])
        back_msg,addr = udp_sk.recvfrom(BUFSIZE)
        print('来自[%s:%s]一条消息：'%(addr[0],addr[1],back_msg.decode('utf-8')))

udp_sk.close()

 Socket参数详解

socket.socket(family=AF_INET,type=SOCK_STREAM,proto=0,fileno=None)

创建socket对象的参数说明：
family:地址系列应为AF_INET(默认值),AF_INET6,AF_UNIX,AF_CAN或AF_RDS。
（AF_UNIX 域实际上是使用本地 socket 文件来通信）


type:套接字类型应为SOCK_STREAM(默认值),SOCK_DGRAM,SOCK_RAW或其他SOCK_常量之一。
SOCK_STREAM 是基于TCP的，有保障的（即能保证数据正确传送到对方）面向连接的SOCKET，多用于资料传送。
SOCK_DGRAM 是基于UDP的，无保障的面向消息的socket，多用于在网络上发广播信息。

 

黏包

黏包成因：

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

MTU意思是网络上传送的最大数据包，单位是字节，大部分网络设备的MTU是1500，如果本机的MTU比

网关的MTU大，大的数据包就会被拆开来传送，这样会产生很多数据包碎片，增加丢包率，降低网络速度

基于TCP协议特点的黏包现象成因

socket数据传输过程中用户态和内核态说明

发送端可以是一K一K的发送数据，而接受端的应用程序可以两K两K的提走数据。也可以多K的提。
也就是说，应用程序所看到的数据是一个整体，或说是一个流(stream)，一条消息有多少字节对应用程序不可见，因此TCP协议是面向流的协议，这也是容易出现黏包问题的原因
而UDP是面向消息的协议，每个UDP段是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP不同

UDP不会发生黏包

UDP是无连接的，面向消息的，提供高效率服务
不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。 
对于空消息：tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），也可以被发送，udp协议会帮你封装上消息头发送过去。 
不可靠不黏包的udp协议：udp的recvfrom是阻塞的，一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y;x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠。

 

发生粘包的两种情况

情况一：发送方的缓存机制

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

情况二：接收方的缓存机制

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

总结

粘包现象只发生在TCP协议中：

1.从表面看，粘包问题主要是因为发送端和接收端的缓存机制，tcp协议面向流通信的特点

2.实际上，主要是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据造成的

 

黏包的解决方案

解决方案一

问题根源在于，接收方不知道接收多少字节的数据，所以粘包解决方法就是围绕如何让发送端在发送数据前，把自己

将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据。

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

解决方法进阶

通过一个struct模块，该模块快于把要发送的数据长度转换成固定长度的字节。这样客户端每次接收消息之间只要先接收这个固定长度字节的内容看一看接下来要接收的信息大小，那么最终接收的数据只要达到这个值就停止，就能刚好接收完整的数据了

struct模块

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

import struct

struct.pack('i',1111111)

import json,struct
#假设通过客户端上传1T:1073741824000的文件a.txt

#为避免粘包,必须自定制报头
header={'file_size':1073741824000,'file_name':'/a/b/c/d/e/a.txt','md5':'8f6fbf8347faa4924a76856701edb0f3'}    #1T数据,文件路径和md5值

#为了该报头能传送,需要序列化并且转为head
head_bytes = 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.send(文件内容)    #然后发真实内容的字节格式

#服务端开始接收
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_date_len = s.recv(header['file_size'])
s.recv(real_data_len)

 

使用struct解决粘包

借助struct模块，我们知道长度数字可以被转换成一个标准大小的4字节数字，因此可以利用这个特点来预先发送数据长度

发送时	接收时
先发送struct转换好的数据长度4字节	先接受4个字节使用struct转换成数字来获取要接收的数据长度
再发送数据	再按照长度接收数据

 

import socket,struct,json
import subprocess
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加

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

phone.listen(5)

while True:
    conn,addr=phone.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_ex(('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'))
    print(data.decode('gbk')) #windows默认gbk编码

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

发送时	接收时
先发送报头长度	先接收报头长度，用struct取出来
再编码报头内容然后发送   最后发真实内容	根据取出的长度收取报头内容， 然后解码，反序列化   从反序列化结果中取出待取数据的详细信息，然后去取真实的数据内容

 

Socket的更多方法介绍

服务端套接字函数
s.bind()    绑定(主机,端口号)到套接字
s.listen()  开始TCP监听
s.accept()  被动接受TCP客户的连接,(阻塞式)等待连接的到来

客户端套接字函数
s.connect()     主动初始化TCP服务器连接
s.connect_ex()  connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

公共用途的套接字函数
s.recv()            接收TCP数据
s.send()            发送TCP数据
s.sendall()         发送TCP数据
s.recvfrom()        接收UDP数据
s.sendto()          发送UDP数据
s.getpeername()     连接到当前套接字的远端的地址
s.getsockname()     当前套接字的地址
s.getsockopt()      返回指定套接字的参数
s.setsockopt()      设置指定套接字的参数
s.close()           关闭套接字

面向锁的套接字方法
s.setblocking()     设置套接字的阻塞与非阻塞模式
s.settimeout()      设置阻塞套接字操作的超时时间
s.gettimeout()      得到阻塞套接字操作的超时时间

面向文件的套接字的函数
s.fileno()          套接字的文件描述符
s.makefile()        创建一个与该套接字相关的文件

官方文档对socket模块下的socket.send()和socket.sendall()解释如下：

socket.send(string[, flags])
Send data to the socket. The socket must be connected to a remote socket. The optional flags argument has the same meaning as for recv() above. Returns the number of bytes sent. Applications are responsible for checking that all data has been sent; if only some of the data was transmitted, the application needs to attempt delivery of the remaining data.

send()的返回值是发送的字节数量，这个数量值可能小于要发送的string的字节数，也就是说可能无法发送string中所有的数据。如果有错误则会抛出异常。

–

socket.sendall(string[, flags])
Send data to the socket. The socket must be connected to a remote socket. The optional flags argument has the same meaning as for recv() above. Unlike send(), this method continues to send data from string until either all data has been sent or an error occurs. None is returned on success. On error, an exception is raised, and there is no way to determine how much data, if any, was successfully sent.

尝试发送string的所有数据，成功则返回None，失败则抛出异常。

故，下面两段代码是等价的：

#sock.sendall('Hello world\n')

#buffer = 'Hello world\n'
#while buffer:
#    bytes = sock.send(buffer)
#    buffer = buffer[bytes:]