1. 技术文章
  2. 网络编程

网络编程

由 二次信任 提交于 2020-10-29 07:12:43

一、软件开发的架构

我们了解的涉及到两个程序之间通讯的应用大致可以分为两种：

第一种是应用类：QQ、微信、网盘、优酷这一类是属于需要安装的桌面应用

第二种是web类：比如百度、知乎、博客园等使用浏览器访问就可以直接使用的应用

这些应用的本质其实都是两个程序之间的通讯。而这两个分类又对应了两个软件开发的架构～

软件开发的架构分为C/S架构和B/S架构。

1.C/S架构

C/S即：Client与Server ，中文意思：客户端与服务器端架构，这种架构是从用户层面（也可以是物理层面）来划分的。

这里的客户端一般泛指客户端应用程序EXE，程序需要先安装后，才能运行在用户的电脑上，对用户的电脑操作系统环境依赖较大。

2.B/S架构

B/S即：Browser与Server,中文意思：浏览器端与服务器端架构，这种架构是从用户层面来划分的。

Browser浏览器，其实也是一种Client客户端，只是这个客户端不需要大家去安装什么应用程序，只需在浏览器上通过HTTP请求服务器端相关的资源（网页资源），客户端Browser浏览器就能进行增删改查。所以B/S架构是一种轻量级的架构，升级维护方便。

 

 小结：在网络编程中的C/S架构在计算机编程中占据着垄断地位。在C/S架构的基础上有了B/S架构，所以B/S架构是C/S架构的一种特殊形式。

二、网络基础

网络是什么？计算机之间是怎么通信的？

在计算机最早期，计算机之间是通过网线来实现通信的，随着计算机的发展，用户越来越多，使用网线通信就有很大的局限性，就出现了交换机。

 

　　如上图，用户发出信息，交换机会收集用户发出的信息和用户的ip以及接受信息的对象的ip，交换机将这些信息以广播的形式发送给与本交换机连接的所有服务器，所有服务器将接受的信息中的对象ip比对，如果不一样，就直接摒弃这些信息，如果一样，则做出回应，将自己的mac地址返回给交换机，交换机通过单播的形式将所接收对象的mac地址返回给发出信息的用户，这样就实现了不同计算机之间的通信。

　　通过对象的ip来得到对象的mac地址，在这之间，遵循一个协议：arp协议。而且arp协议中用到了交换机中的广播（发出信息时）和单播（返回信息时）功能。

交换机的广播形式

　　主机之间“一对所有”的通讯模式，网络对其中每一台主机发出的信号都进行无条件复制并转发，所有主机都可以接收到所有信息（不管你是否需要），由于其不用路径选择，所以其网络成本可以很低廉。有线电视网就是典型的广播型网络，我们的电视机实际上是接受到所有频道的信号，但只将一个频道的信号还原成画面。在数据网络中也允许广播的存在，但其被限制在二层交换机的局域网范围内，禁止广播数据穿过路由器，防止广播数据影响大面积的主机。

ip地址与ip协议

  • 规定网络地址的协议叫ip协议，它定义的地址称之为ip地址，ip地址分为ipv4协议的和ipv6协议的，广泛采用的v4版本即ipv4，它规定网络地址由32位2进制表示
  • 范围0.0.0.0-255.255.255.255      #八位二进制表示一位，所以每位转化成十进制最多是255
  • 一个ip地址通常写成四段十进制数，例：172.16.10.1，一些特殊的ip地址比如：127.0.0.1   代表本机       还有一些内网字段，比如在学校，公司  162.**

mac地址

　　head中包含的源和目标地址由来：ethernet规定接入internet的设备都必须具备网卡，发送端和接收端的地址便是指网卡的地址，即mac地址。

　　mac地址：每块网卡出厂时都被烧制上一个世界唯一的mac地址，长度为48位2进制，通常由12位16进制数表示（前六位是厂商编号，后六位是流水线号）

arp协议 ——查询IP地址和MAC地址的对应关系

　　地址解析协议，即ARP（Address Resolution Protocol），是根据IP地址获取物理地址的一个TCP/IP协议。
　　主机发送信息时将包含目标IP地址的ARP请求广播到网络上的所有主机，并接收返回消息，以此确定目标的物理地址。
　　收到返回消息后将该IP地址和物理地址存入本机ARP缓存中并保留一定时间，下次请求时直接查询ARP缓存以节约资源。
　　地址解析协议是建立在网络中各个主机互相信任的基础上的，网络上的主机可以自主发送ARP应答消息，其他主机收到应答报文时不会检测该报文的真实性就会将其记入本机ARP缓存；由此攻击者就可以向某一主机发送伪ARP应答报文，使其发送的信息无法到达预期的主机或到达错误的主机，这就构成了一个ARP欺骗。ARP命令可用于查询本机ARP缓存中IP地址和MAC地址的对应关系、添加或删除静态对应关系等。相关协议有RARP、代理ARP。NDP用于在IPv6中代替地址解析协议。 

路由器

　　路由器（Router），是连接因特网中各局域网、广域网的设备，它会根据信道的情况自动选择和设定路由，以最佳路径，按前后顺序发送信号。 路由器是互联网络的枢纽，"交通警察"。目前路由器已经广泛应用于各行各业，各种不同档次的产品已成为实现各种骨干网内部连接、骨干网间互联和骨干网与互联网互联互通业务的主力军。路由和交换机之间的主要区别就是交换机发生在OSI参考模型第二层（数据链路层），而路由发生在第三层，即网络层。这一区别决定了路由和交换机在移动信息的过程中需使用不同的控制信息，所以说两者实现各自功能的方式是不同的。
　　路由器（Router）又称网关设备（Gateway）是用于连接多个逻辑上分开的网络，所谓逻辑网络是代表一个单独的网络或者一个子网。当数据从一个子网传输到另一个子网时，可通过路由器的路由功能来完成。因此，路由器具有判断网络地址和选择IP路径的功能，它能在多网络互联环境中，建立灵活的连接，可用完全不同的数据分组和介质访问方法连接各种子网，路由器只接受源站或其他路由器的信息，属网络层的一种互联设备。

局域网

　　局域网（Local Area Network，LAN）是指在某一区域内由多台计算机互联成的计算机组。一般是方圆几千米以内。局域网可以实现文件管理、应用软件共享、打印机共享、工作组内的日程安排、电子邮件和传真通信服务等功能。局域网是封闭型的，可以由办公室内的两台计算机组成，也可以由一个公司内的上千台计算机组成。　　

子网掩码　

　　所谓”子网掩码”，就是表示子网络特征的一个参数。它在形式上等同于IP地址，也是一个32位二进制数字，它的网络部分全部为1，主机部分全部为0。比如，IP地址172.16.10.1，如果已知网络部分是前24位，主机部分是后8位，那么子网络掩码就是11111111.11111111.11111111.00000000，写成十进制就是255.255.255.0。

　　子网掩码与ip地址进行按位与运算就能得出一个机器所在的网段。

　　知道”子网掩码”，我们就能判断，任意两个IP地址是否处在同一个子网络。方法是将两个IP地址与子网掩码分别进行AND运算（两个数位都为1，运算结果为1，否则为0），然后比较结果是否相同，如果是的话，就表明它们在同一个子网络中，否则就不是。 

复制代码 
比如，已知IP地址172.16.10.1和172.16.10.2的子网掩码都是255.255.255.0，请问它们是否在同一个子网络？两者与子网掩码分别进行AND运算，

172.16.10.1：10101100.00010000.00001010.000000001
255255.255.255.0:11111111.11111111.11111111.00000000
AND运算得网络地址结果：10101100.00010000.00001010.000000001->172.16.10.0

 

172.16.10.2：10101100.00010000.00001010.000000010
255255.255.255.0:11111111.11111111.11111111.00000000
AND运算得网络地址结果：10101100.00010000.00001010.000000001->172.16.10.0
结果都是172.16.10.0，因此它们在同一个子网络。
复制代码

总结一下，IP协议的作用主要有两个，一个是为每一台计算机分配IP地址，另一个是确定哪些地址在同一个子网络。

TCP协议和UDP协议

用于应用程序之间的通信。如果说ip地址和mac地址帮我们确定唯一的一台机器，那么我们怎么找到一台机器上的一个软件呢？

端口

　　我们知道，一台拥有IP地址的主机可以提供许多服务，比如Web服务、FTP服务、SMTP服务等，这些服务完全可以通过1个IP地址来实现。那么，主机是怎样区分不同的网络服务呢？显然不能只靠IP地址，因为IP 地址与网络服务的关系是一对多的关系。实际上是通过“IP地址+端口号”来区分不同的服务的。

　　每一台计算机最多可以开65535（2**16-1）个端口（port），操作系统会默认的占据一些端口，有一些软件会默认开某些端口，还有一些特殊的端口，比如：酷狗音乐默认开8000端口，两个计算机如果根据SSH协议，则默认开22端口，而MySql 默认开3306端口。通过‘ip地址+端口号’我们可以在全网找到唯一的一台机器+唯一的应用，一般情况下我们写的程序选择开的端口都是8000以后的。

TCP协议

　　当应用程序希望通过 TCP 与另一个应用程序通信时，它会发送一个通信请求。这个请求必须被送到一个确切的地址。在双方“握手”之后，TCP 将在两个应用程序之间建立一个全双工 (full-duplex) 的通信。

　　这个全双工的通信将占用两个计算机之间的通信线路，直到它被一方或双方关闭为止。

 

复制代码 
TCP是因特网中的传输层协议，使用三次握手协议建立连接。当主动方发出SYN连接请求后，等待对方回答SYN+ACK[1]，并最终对对方的 SYN 执行 ACK 确认。这种建立连接的方法可以防止产生错误的连接。[1] 
TCP三次握手的过程如下：
客户端发送SYN（SEQ=x）报文给服务器端，进入SYN_SEND状态。
服务器端收到SYN报文，回应一个SYN （SEQ=y）ACK(ACK=x+1）报文，进入SYN_RECV状态。
客户端收到服务器端的SYN报文，回应一个ACK(ACK=y+1）报文，进入Established状态。 三次握手完成，TCP客户端和服务器端成功地建立连接，可以开始传输数据了。
复制代码

  

复制代码 
建立一个连接需要三次握手，而终止一个连接要经过四次握手，这是由TCP的半关闭（half-close）造成的。
(1) 某个应用进程首先调用close，称该端执行“主动关闭”（active close）。该端的TCP于是发送一个FIN分节，表示数据发送完毕。
(2) 接收到这个FIN的对端执行 “被动关闭”（passive close），这个FIN由TCP确认。
注意：FIN的接收也作为一个文件结束符（end-of-file）传递给接收端应用进程，放在已排队等候该应用进程接收的任何其他数据之后，因为，FIN的接收意味着接收端应用进程在相应连接上再无额外数据可接收。
(3) 一段时间后，接收到这个文件结束符的应用进程将调用close关闭它的套接字。这导致它的TCP也发送一个FIN。
(4) 接收这个最终FIN的原发送端TCP（即执行主动关闭的那一端）确认这个FIN。[1] 既然每个方向都需要一个FIN和一个ACK，因此通常需要4个分节。 注意： (1) “通常”是指，某些情况下，步骤1的FIN随数据一起发送，另外，步骤2和步骤3发送的分节都出自执行被动关闭那一端，有可能被合并成一个分节。[2] (2) 在步骤2与步骤3之间，从执行被动关闭一端到执行主动关闭一端流动数据是可能的，这称为“半关闭”（half-close）。 (3) 当一个Unix进程无论自愿地（调用exit或从main函数返回）还是非自愿地（收到一个终止本进程的信号）终止时，所有打开的描述符都被关闭，这也导致仍然打开的任何TCP连接上也发出一个FIN。 无论是客户还是服务器，任何一端都可以执行主动关闭。通常情况是，客户执行主动关闭，但是某些协议，例如，HTTP/1.0却由服务器执行主动关闭。[2]
复制代码

 

UDP协议

　　当应用程序希望通过UDP与一个应用程序通信时，传输数据之前源端和终端不建立连接。

　　当它想传送时就简单地去抓取来自应用程序的数据，并尽可能快地把它扔到网络上。

 

TCP协议与UDP协议的区别：

TCP---传输控制协议,提供的是面向连接、可靠的字节流服务。当客户和服务器彼此交换数据前，必须先在双方之间建立一个TCP连接，之后才能传输数据。TCP提供超时重发，丢弃重复数据，检验数据，流量控制等功能，保证数据能从一端传到另一端。
UDP---用户数据包协议，是一个简单的面向数据包的不可靠的高效的传输层协议。UDP不提供可靠性，它只是把应用程序传给IP层的数据报发送出去，但是并不能保证它们能到达目的地。由于UDP在传输数据报前不用在客户和服务器之间建立一个连接，且没有超时重发等机制，故而传输速度很快。

三、互联网协议与osi模型

互联网协议按照功能不同分为osi（开放系统互联(Open System Interconnection)）七层或tcp/ip五层或tcp/ip四层

每层运行常见物理设备

 

每层运行常见的协议

 

 

 四、套接字（socket）使用

 

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

　　套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。

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

套接字家族的名字：AF_UNIX

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

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

套接字家族的名字：AF_INET

(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)

基于TCP协议的socket

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

server端

复制代码 
import socket
sk = socket.socket()         #创建一个socket对象
sk.bind(('127.0.0.1',8898)) #把地址绑定到套接字 ip+端口必须是元组的形式 sk.listen() #监听链接 conn,addr = sk.accept() #接受客户端链接 ret = conn.recv(1024) #接收客户端信息 print(ret) #打印客户端信息 conn.send(b'hi') #向客户端发送信息 * bytes类型 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() # 关闭客户套接字
复制代码

 

问题：有的同学在重启服务端时可能会遇到

解决方法：

复制代码 
#加入一条socket配置，重用ip和端口
import socket
from socket import SOL_SOCKET,SO_REUSEADDR sk = socket.socket() sk.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加 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() #关闭服务器套接字(可选)
复制代码

  

基于UDP协议的socket

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

简单使用

server端

复制代码 
import socket
udp_sk = socket.socket(type=socket.SOCK_DGRAM)   #创建一个服务器的套接字
udp_sk.bind(('127.0.0.1',9000)) #绑定服务器套接字 msg,addr = udp_sk.recvfrom(1024) print(msg) udp_sk.sendto(b'hi',addr) # 对话(接收与发送) udp_sk.close() # 关闭服务器套接字
复制代码

client端

import socket
ip_port=('127.0.0.1',9000)
udp_sk=socket.socket(type=socket.SOCK_DGRAM)
udp_sk.sendto(b'hello',ip_port)
back_msg,addr=udp_sk.recvfrom(1024)
print(back_msg.decode('utf-8'),addr
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，多用于在网络上发广播信息。
proto 协议号通常为零,可以省略,或者在地址族为AF_CAN的情况下,协议应为CAN_RAW或CAN_BCM之一。
fileno 如果指定了fileno,则其他参数将被忽略,导致带有指定文件描述符的套接字返回。
与socket.fromfd()不同,fileno将返回相同的套接字,而不是重复的。
这可能有助于使用socket.close()关闭一个独立的插座。

 

五、黏包

　　我们基于TCP协议来实现一个远程执行命令的程序，在实现之前，先了解一个内置模块subprocess，它和os模块的功能有相似之处，都能够执行操作系统的命令。在os模块中，有一个os.popen("bash command).read() 运行shell命令，获取执行结果，可以实现调用操作系统的命令。同样的，subprocess中也可以实现调用操作系统的命令的功能，subprocess.Popen(''命令'')。

import os
ret = os.popen('ipconfig').read()
print(ret)      #可以查看电脑的ip等
ret = os.popen('dir').read()
print(ret)      #可以获取目录

ret = os.popen('ls').read()
print(ret)     #输入错误的命令，会乱码，会报错
os 
import subprocess
ret = subprocess.Popen('dir',    #要执行的命令
                 shell=True,      #告诉程序自己要执行的是shell命令    操作系统命令
                 stdout=subprocess.PIPE,     #这是与os模块最大的不同，os中不管正确的还是错误的命令都有ret返回执行结果
                 stderr=subprocess.PIPE)     #而subprocess中执行正确的结果由stdout来接收，错误的结果由stderr来接收
# print(ret.stdout.read()) #输出的结果为bytes类型   #b' \xc7\xfd\xb6\xaf\xc6\xf7 D \xd6\xd0\xb5\xc4\xbe\xed\x.....
res = ret.stdout.read()     #因为执行的是Windows操作系统的命令，所以输出的是gbk形式的bytes类型
print(res.decode('gbk'))    #转化为gbk格式的编码方式
print(ret.stderr.read().decode('gbk'))

ret = subprocess.Popen('ls',
                 shell=True,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE)
print(ret.stdout.read().decode('gbk'))
print(ret.stderr.read().decode('gbk'))  #'ls' 不是内部或外部命令，也不是可运行的程序或批处理文件。
subprocess 
#有问题的代码，只为验证黏包
import socket
sk = socket.socket()
sk.bind(('127.0.0.1',9000))
sk.listen()
conn,addr = sk.accept()
while 1:
    cmd = input('cmd:')
    if cmd == 'q':
        conn.send(cmd.encode('utf-8'))
        break
    conn.send(cmd.encode('utf-8'))
    msg = conn.recv(1024)
    print('stdout:',msg.decode('gbk'))
    msg1 = conn.recv(1024)
    print('stderr:',msg1.decode('gbk'))
conn.close()
sk.close()
server端 
#问题代码，验证黏包用
import socket
import subprocess
sk = socket.socket()
sk.connect(('127.0.0.1',9000))
while 1:
    msg = sk.recv(1024)
    if msg.decode('utf-8') == 'q':break
    ret = subprocess.Popen(msg.decode('utf-8'),shell=True,
                           stdout=subprocess.PIPE,stderr=subprocess.PIPE)
    stdout = ret.stdout.read()
    stderr = ret.stderr.read()
    sk.send(stdout)
    sk.send(stderr)
sk.close()
client端 
#输入dir后成功输出结果但是程序却一直在等，无法往下继续执行
#输入ipconfig后输出结果后程序可以继续执行，但是stdout和stderr都输出了结果（理论上只有stdout输出结果）
执行结果

　　由这个程序我们发现，当我们在client端执行多条发送命令，在server端执行多条接收命令时，如果client端发送的多条命令所包含的字节数很小时，server端的一条接收命令就会全部接收所有的发送内容，导致下面的接收代码无法继续接收发送的消息，导致程序的停滞，无法往下执行；如果client端发送的第一条内容很大时，就会被server端的多条接收指令所接受，导致下面的发送内容无法被一一对应的顺利接收。这就是黏包。

　　注：只有TCP才有黏包现象，UDP不会发生黏包

为什么TCP协议中会发生黏包现象呢？

tcp协议的拆包机制

当发送端缓冲区的长度大于网卡的MTU时，tcp会将这次发送的数据拆成几个数据包发送出去。 
MTU是Maximum Transmission Unit的缩写。意思是网络上传送的最大数据包。MTU的单位是字节。 大部分网络设备的MTU都是1500。如果本机的MTU比网关的MTU大，大的数据
包就会被拆开来传送，这样会产生很多数据包碎片，增加丢包率，降低网络速度。

面向流的通信特点和Nagle算法

复制代码 
TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。
收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量
小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。 
对于空消息：tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容
（直接回车），也可以被发送，udp协议会帮你封装上消息头发送过去。 
可靠黏包的tcp协议：tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。
复制代码

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

复制代码 
　　发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据。也就是说，应用程序所看
到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。而UDP是面向消息的
协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。
　　怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排
序完成后才呈现在内核缓冲区。
复制代码

例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束

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

UDP不会发生黏包

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

 

会发生黏包的两种情况

情况一 发送方的缓存机制

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

情况二 接收方的缓存机制

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

小结：

黏包现象只发生在tcp协议中：

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

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

总而言之：tcp协议是面向流的传输，而数据与数据之间是没有边界的。黏包最本质的原因就是接收方不知道接收的包有多大！

 

黏包的解决方案

解决方案一

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

解决方法二：（进阶）

　　我们可以借助一个模块，这个模块可以把要发送的数据长度转换成固定长度的字节。这样客户端每次接收消息之前只要先接受这个固定长度字节的内容看一看接下来要接收的信息大小，那么最终接受的数据只要达到这个值就停止，就能刚好不多不少的接收完整的数据了。

struct模块

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

>>> struct.pack('i',1111111111111)

struct.error: 'i' format requires -2147483648 <= number <= 2147483647 #这个是范围

 

 

import json
import struct
#假设客户端上传一个1T的文件（1T =1099511627776个字节），文件路径为/a/b/c/d/e/a.txt

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

#为了该报头能传送,需要序列化并且转为bytes
head_bytes=json.dumps(header).encode('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)

struct的用法

import struct
# struct.pack('数据类型所代表的符号',要转化的字符)        将任意字符转化为一个固定字节长度的类型
print(struct.pack('i',1234))   #b'\xd2\x04\x00\x00'    转化为固定四个字节的bytes类型
print(struct.pack('i',20))     #b'\x14\x00\x00\x00'
print(struct.pack('f',18.65))   #b'33\x95A'

#struct.unpack('数据类型所代表的符号',对应的固定长度)      是上面对应的反转
print(struct.unpack('i',b'\x14\x00\x00\x00'))   #  (20,)    元组类型的
print(struct.unpack('i',b'\x14\x00\x00\x00')[0])   #20    取元组的第一位就是对应的数据

使用struct解决黏包

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

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

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

发送时 接收时

先发报头长度

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

 六、socket的更多用法

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

# 客户端套接字函数
sk.connect((addr))    #主动初始化TCP服务器连接
sk.connect_ex(addr)   #是connect的扩展进阶版，容错性能更好，出错时返回出错码，而不是抛出异常

# 公共用途的套接字函数
sk.recv()            #接收TCP数据
sk.send()            #发送TCP数据    send与sendall的功能是一样的，不同的是send发送的字节数量，有可能会小于要发送的string
                                    #的字节数，有错误会抛出异常。而sendall发送string所有数据，成功返回None，失败抛出异常
                                    #相比较而言，send它会根据自身内核态（操作系统）的缓存区来决定string是一次发送，还是分次发送
                                    #所有，比较常用send
sk.sendall()         #发送TCP数据
sk.recvfrom()        #接收UDP数据
sk.sendto()          #发送UDP数据
sk.getpeername()     #接收连接到当前套接字的远端的地址     不常用
sk.getsockname()     #接收当前套接字的地址    不常用
sk.getsockopt()      #返回指定套接字的参数   
sk.setsockopt()      #设置指定套接字的参数
sk.close()           #关闭套接字

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

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

七、验证客户端链接的合法性

如果你想在分布式系统中实现一个简单的客户端链接认证功能，又不像SSL那么复杂，那么利用hmac+加盐的方式来实现，这也是验证客户端合法性常用的方式

在这之前，先来了解内置模块hmac模块

#用法跟hashlib相似
import os
import hmac
ret = os.urandom(32)
print(ret,type(ret),len(ret))
#hmac.new(key)    将要转化的bytes类型对象输入
hmac_obj = hmac.new(ret)
#hmac.new(加盐,key)     也可以将两个bytes类型对象转化为一种密文
hmac_obj1 = hmac.new(b'apple',ret)
print(hmac_obj1)   #<hmac.HMAC object at 0x000001CC6462C278>
#hmac_object.digest()   将转化为密文的对象取值
res = hmac_obj1.digest()
print(res)    #b'\xadS\xb0\xc3+\xd8k\xfc0\xe0Q]\xe5\xe6\xa5\x0c'
hmac模块的用法 
import os
import socket
import hmac
def check_client(conn):
    secret_key = 'agogo'  # 密钥
    ret = os.urandom(32)  # 借助os模块生成任意32位的bytes类型的字节    参考os模块的功能
    conn.send(ret)
    hmac_obj = hmac.new(secret_key.encode('utf-8'),ret)
    ret_hmac = hmac_obj.digest()
    recive = conn.recv(1024)
    if recive == ret_hmac:
        print('合法的用户')
        return True
    else:return False
sk = socket.socket()
sk.bind(('127.0.0.1',12345))
sk.listen()
conn,addr = sk.accept()
ret = check_client(conn)
if ret:
    conn.send(b'hello')
conn.close()
sk.close()
server 
import socket
import hmac
def verificate(sk):
    secret_key = 'agogo'  # 密钥
    str_bytes = sk.recv(1024)
    hmac_obj = hmac.new(secret_key.encode('utf-8'),str_bytes)
    ret_hmac = hmac_obj.digest()
    sk.send(ret_hmac)
sk = socket.socket()
sk.connect(('127.0.0.1',12345))
verificate(sk)
msg = sk.recv(1024)
print(msg)
sk.close()
client

我们也可以借助hashlib模块+os模块来实现

import os
import socket
import hashlib
def check_client(conn):
    secret_key = 'agogo'  # 密钥
    ret = os.urandom(32)  # 借助os模块生成任意32位的bytes类型的字节    参考os模块的功能
    conn.send(ret)
    md5_obj = hashlib.md5(secret_key.encode('utf-8'))
    md5_obj.update(ret)
    ret_md5 = md5_obj.hexdigest()
    recive = conn.recv(1024)
    if recive.decode('utf-8') == ret_md5:
        print('合法的用户')
        return True
    else:return False
sk = socket.socket()
sk.bind(('127.0.0.1',12345))
sk.listen()
conn,addr = sk.accept()
ret = check_client(conn)
if ret:
    conn.send(b'hello')
conn.close()
sk.close()
server 
import socket
import hashlib
def verificate(sk):
    secret_key = 'agogo'  # 密钥
    str_bytes = sk.recv(1024)
    md5_obj = hashlib.md5(secret_key.encode('utf-8'))
    md5_obj.update(str_bytes)
    ret_md5 = md5_obj.hexdigest()
    sk.send(ret_md5.encode('utf-8'))
sk = socket.socket()
sk.connect(('127.0.0.1',12345))
verificate(sk)
msg = sk.recv(1024)
print(msg)
sk.close()
client

八、socketserver模块

使用socketserver模块可以实现并发消息的功能

import socketserver
class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        msg = self.request.recv(1024)    #self.request 等同于 conn
        print(msg.decode('utf-8'))

addr = ('127.0.0.1',23456)
server = socketserver.ThreadingTCPServer(addr,MyServer)  #括号中为  地址，类名
server.serve_forever()     #保证server端一直是启动状态
server端 
#有两种写法

#常规写法
import socket
sk = socket.socket()
addr = ('127.0.0.1',23456)
sk.connect(addr)
sk.send(b'hello')
sk.close()

#另一种写法：利用with+as 关键字实现自我关闭
import socket
with socket.socket() as sk:
    sk.connect(('127.0.0.1',23456))
    sk.send(b'hello')
client端

 

标签
bind
iNet
def
socketserver
OpenSSL
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!