网络编程
一、网络通信原理
1 互联网的本质就是一系列的网络协议
一台硬设有了操作系统，然后装上软件你就可以正常使用了，然而你也只能自己使用
如何能大家一起玩耍
internet为何物？
连接两台计算机之间的internet实际上就是一系列统一的标准，这些标准称之为互联网协议，互联网的本质就是一系列的协议，总称为‘互联网协议’（Internet Protocol Suite).
互联网协议的功能：定义计算机如何接入internet，以及接入internet的计算机通信的标准。
二、软件开发的架构
1.C/S架构
C/S即：Client与Server ，中文意思：客户端与服务器端架构，这种架构也是从用户层面（也可以是物理层面）来划分的。
这里的客户端一般泛指客户端应用程序EXE，程序需要先安装后，才能运行在用户的电脑上，对用户的电脑操作系统环境依赖较大。
2.B/S架构
B/S即：Browser与Server,中文意思：浏览器端与服务器端架构，这种架构是从用户层面来划分的。
Browser浏览器，其实也是一种Client客户端，只是这个客户端不需要大家去安装什么应用程序，只需在浏览器上通过HTTP请求服务器端相关的资源（网页资源），客户端Browser浏览器就能进行增删改查。
B/S和C/S架构的关系
所有的B/S架构都需要一个浏览器才能访问 浏览器是一个软件,相当于一个客户端 所有的B/S架构也都是C/S架构的 浏览器(browser)是特殊的客户端(client)
client(broser) <---> server
这两种架构哪个好
C/S 装好之后直接双击就可以使用了 B/S 极大的简化了我们使用软件的成本
B/S 更符合现在的使用理念 但是还有很多功能没有实现 在PC端统一了程序的入口
在手机端没有那么喜欢用浏览器 统一入口的软件
互联网中处处是C/S架构，你的浏览器是客户端（B/S架构也是C/S架构的一种）
C/S架构与socket的关系：
我们学习socket就是为了完成C/S架构的开发
三、网络基础
计算机网络的发展及基础网络概念
问题：网络到底是什么？计算机之间是如何通信的？
早期 ： 联机
以太网 ： 局域网与交换机
局域网
局域网（Local Area Network，LAN）是指在某一区域内由多台计算机互联成的计算机组。一般是方圆几千米以内。局域网可以实现文件管理、应用软件共享、打印机共享、工作组内的日程安排、电子邮件和传真通信服务等功能。局域网是封闭型的，可以由办公室内的两台计算机组成，也可以由一个公司内的上千台计算机组成。
广域网与路由器
路由器
四、互联网协议与osi协议
互联网协议按照功能不同分为osi七层或tcp/ip五层或tcp/ip四层。
每层运行常见物理设备
每层运行常见的协议
tcp协议和udp协议
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与一个应用程序通信时，传输数据之前源端和终端不建立连接。
当它想传送时就简单地去抓取来自应用程序的数据，并尽可能快地把它扔到网络上。
无连接\不可靠\快\不能传输过长的数据0 机器之间传递信息不需要建立连接 直接发就行 不可靠 : 数据有可能丢失
tcp和udp的对比
TCP---传输控制协议,提供的是面向连接、可靠的字节流服务。当客户和服务器彼此交换数据前，必须先在双方之间建立一个TCP连接，之后才能传输数据。TCP提供超时重发，丢弃重复数据，检验数据，流量控制等功能，保证数据能从一端传到另一端。
UDP---用户数据报协议，是一个简单的面向数据报的运输层协议。UDP不提供可靠性，它只是把应用程序传给IP层的数据报发送出去，但是并不能保证它们能到达目的地。由于UDP在传输数据报前不用在客户和服务器之间建立一个连接，且没有超时重发等机制，故而传输速度很快
udp协议 即时通讯类的软件 :qq 微信 飞信 歪歪 tcp协议 发邮件\文件的时候
tcp/ip五层模型讲解
我们将应用层，表示层，会话层并作应用层，从tcp／ip五层协议的角度来阐述每层的由来与功能，搞清楚了每层的主要协议
就理解了整个互联网通信的原理。
首先，用户感知到的只是最上面一层应用层，自上而下每层都依赖于下一层，所以我们从最下一层开始切入，比较好理解
每层都运行特定的协议，越往上越靠近用户，越往下越靠近硬件
1 物理层
物理层由来：上面提到，孤立的计算机之间要想一起玩，就必须接入internet，言外之意就是计算机之间必须完成组网
物理层功能：主要是基于电器特性发送高低电压(电信号)，高电压对应数字1，低电压对应数字0
2 数据链路层
数据链路层由来：单纯的电信号0和1没有任何意义，必须规定电信号多少位一组，每组什么意思
数据链路层的功能：定义了电信号的分组方式
以太网协议：
早期的时候各个公司都有自己的分组方式，后来形成了统一的标准，即以太网协议ethernet
ethernet规定
- 一组电信号构成一个数据包，叫做‘帧’
- 每一数据帧分成：报头head和数据data两部分
| head | data |
head包含：(固定18个字节)
- 发送者／源地址，6个字节
- 接收者／目标地址，6个字节
- 数据类型，6个字节
data包含：(最短46字节，最长1500字节)
- 数据包的具体内容
head长度＋data长度＝最短64字节，最长1518字节，超过最大限制就分片发送
mac地址：
head中包含的源和目标地址由来：ethernet规定接入internet的设备都必须具备网卡，发送端和接收端的地址便是指网卡的地址，即mac地址
mac地址：每块网卡出厂时都被烧制上一个世界唯一的mac地址，长度为48位2进制，通常由12位16进制数表示（前六位是厂商编号，后六位是流水线号）
（cmd-----ipconfig /all）
广播：
有了mac地址，同一网络内的两台主机就可以通信了（一台主机通过arp协议获取另外一台主机的mac地址）
ethernet采用最原始的方式，广播的方式进行通信，即计算机通信基本靠吼
3 网络层
网络层由来：有了ethernet、mac地址、广播的发送方式，世界上的计算机就可以彼此通信了，问题是世界范围的互联网是由
一个个彼此隔离的小的局域网组成的，那么如果所有的通信都采用以太网的广播方式，那么一台机器发送的包全世界都会收到，
这就不仅仅是效率低的问题了，这会是一种灾难
上图结论：必须找出一种方法来区分哪些计算机属于同一广播域，哪些不是，如果是就采用广播的方式发送，如果不是，
就采用路由的方式（向不同广播域／子网分发数据包），mac地址是无法区分的，它只跟厂商有关
网络层功能：引入一套新的地址用来区分不同的广播域／子网，这套地址即网络地址
IP协议：
- 规定网络地址的协议叫ip协议，它定义的地址称之为ip地址，广泛采用的v4版本即ipv4，它规定网络地址由32位2进制表示
- 范围0.0.0.0-255.255.255.255
- 一个ip地址通常写成四段十进制数，例：172.16.10.1
ip地址分成两部分
- 网络部分：标识子网
- 主机部分：标识主机
注意：单纯的ip地址段只是标识了ip地址的种类，从网络部分或主机部分都无法辨识一个ip所处的子网
例：172.16.10.1与172.16.10.2并不能确定二者处于同一子网
子网掩码
所谓”子网掩码”，就是表示子网络特征的一个参数。它在形式上等同于IP地址，也是一个32位二进制数字，它的网络部分全部为1，主机部分全部为0。比如，IP地址172.16.10.1，如果已知网络部分是前24位，主机部分是后8位，那么子网络掩码就是11111111.11111111.11111111.00000000，写成十进制就是255.255.255.0。
知道”子网掩码”，我们就能判断，任意两个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地址，另一个是确定哪些地址在同一个子网络。
ip数据包
ip数据包也分为head和data部分，无须为ip包定义单独的栏位，直接放入以太网包的data部分
head：长度为20到60字节
data：最长为65,515字节。
而以太网数据包的”数据”部分，最长只有1500字节。因此，如果IP数据包超过了1500字节，它就需要分割成几个以太网数据包，分开发送了。
| 以太网头 | ip 头 | ip数据 |
ARP协议
arp协议由来：计算机通信基本靠吼，即广播的方式，所有上层的包到最后都要封装上以太网头，然后通过以太网协议发送，在谈及以太网协议时候，我门了解到
通信是基于mac的广播方式实现，计算机在发包时，获取自身的mac是容易的，如何获取目标主机的mac，就需要通过arp协议
arp协议功能：广播的方式发送数据包，获取目标主机的mac地址
协议工作方式：每台主机ip都是已知的
例如：主机172.16.10.10/24访问172.16.10.11/24
一：首先通过ip地址和子网掩码区分出自己所处的子网
| 场景 | 数据包地址 |
| 同一子网 | 目标主机mac，目标主机ip |
| 不同子网 | 网关mac，目标主机ip |
二：分析172.16.10.10/24与172.16.10.11/24处于同一网络(如果不是同一网络，那么下表中目标ip为172.16.10.1,通过arp获取的是网关的mac)
| 源mac | 目标mac | 源ip | 目标ip | 数据部分 | |
| 发送端主机 | 发送端mac | FF:FF:FF:FF:FF:FF | 172.16.10.10/24 | 172.16.10.11/24 | 数据 |
三：这个包会以广播的方式在发送端所处的自网内传输，所有主机接收后拆开包，发现目标ip为自己的，就响应，返回自己的mac
4 传输层
传输层的由来：网络层的ip帮我们区分子网，以太网层的mac帮我们找到主机，然后大家使用的都是应用程序，你的电脑上可能同时开启qq，暴风影音，等多个应用程序，
那么我们通过ip和mac找到了一台特定的主机，如何标识这台主机上的应用程序，答案就是端口，端口即应用程序与网卡关联的编号。
传输层功能：建立端口到端口的通信
补充：端口范围0-65535，0-1023为系统占用端口
tcp协议：
可靠传输，TCP数据包没有长度限制，理论上可以无限长，但是为了保证网络的效率，通常TCP数据包的长度不会超过IP数据包的长度，以确保单个TCP数据包不必再分割。
| 以太网头 | ip 头 | tcp头 | 数据 |
udp协议：
不可靠传输，”报头”部分一共只有8个字节，总长度不超过65,535字节，正好放进一个IP数据包。
| 以太网头 | ip头 | udp头 | 数据 |
5 应用层
应用层由来：用户使用的都是应用程序，均工作于应用层，互联网是开发的，大家都可以开发自己的应用程序，数据多种多样，必须规定好数据的组织形式
应用层功能：规定应用程序的数据格式。
例：TCP协议可以为各种各样的程序传递数据，比如Email、WWW、FTP等等。那么，必须有不同协议规定电子邮件、网页、FTP数据的格式，这些应用程序协议就构成了”应用层”。
6 socket
Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。
所以，我们无需深入理解tcp/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。
其实站在你的角度上看，socket就是一个模块。我们通过调用模块中已经实现的方法建立两个进程之间的连接和通信。 也有人将socket说成ip+port，因为ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序。 所以我们只要确立了ip和port就能找到一个应用程序，并且使用socket模块来与之通信。
套接字发展史及分类
套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。 因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。
基于文件类型的套接字家族
套接字家族的名字：AF_UNIX
unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信
基于网络类型的套接字家族套接字家族的名字：AF_INET
(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)
套接字工作流程
TCP（Transmission Control Protocol）可靠的、面向连接的协议（eg:打电话）、传输效率低全双工通信（发送缓存&接收缓存）、面向字节流。使用TCP的应用：Web浏览器；电子邮件、文件传输程序。
UDP（User Datagram Protocol）不可靠的、无连接的服务，传输效率高（发送前时延小），一对一、一对多、多对一、多对多、面向报文，尽最大努力服务，无拥塞控制。使用UDP的应用：域名系统 (DNS)；视频流；IP语音(VoIP)。
先从服务器端说起。服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束
基于TCP协议的socket
tcp是基于链接的，必须先启动服务端，然后再启动客户端去链接服务端
server端
import socket sk = socket.socket() # socket对象,实际上是存储了所有的操作系统提供给我们的网络资源 sk.bind(('127.0.0.1',9001)) # 只有我自己能访问我自己,其他的机器无法访问 # sk.bind(('192.168.16.13',9000)) # 和我在一个局域网内的所有机器都可以访问 # # 但是如果这个代码移交给其他机器执行 # # 需要把ip地址修改成另一台机器的ip # sk.bind(('0.0.0.0',9000)) # 所有访问我这台机器的通信还是使用我的ip地址 sk.listen() conn,addr = sk.accept() # 等待用户来连接我 print(conn) # 像一个连通的电话连接,记录server的地址,client的地址 #<socket.socket fd=468, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9001), raddr=('127.0.0.1', 58461)> print(addr) #('127.0.0.1', 58461) conn.send('娃哈哈'.encode('utf-8')) content = conn.recv(1024) print(content.decode('utf-8')) #收到 conn.close() sk.close() # str 字符串 'alex' # bytes 字节 b'alex' # str -编码(encode)-> bytes # bytes -解码(decode)-> str # # '娃哈哈'.encode('utf-8') # input输入的所有都是字符串,要想进行网络传输 必须编码变成bytes
client端
import socket sk = socket.socket() sk.connect(('127.0.0.1',9001)) ret = sk.recv(1024) print(ret.decode('utf-8')) #娃哈哈 sk.send('收到'.encode('utf-8')) sk.close()
服务端套接字函数
s.bind() 绑定(主机,端口号)到套接字
s.listen() 开始TCP监听
s.accept() 被动接受TCP客户的连接,(阻塞式)等待连接的到来
客户端套接字函数
s.connect() 主动初始化TCP服务器连接
s.connect_ex() connect()函数的扩展版本,出错时返回出错码,而不是抛出异常
公共用途的套接字函数
s.recv() 接收TCP数据
s.send() 发送TCP数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完)
s.sendall() 发送完整的TCP数据(本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时,数据不丢失,循环调用send直到发完)
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() 创建一个与该套接字相关的文件
实现服务端与多个客户端连接，但只能一个结束后才可以与另一客户端聊天
import socket sk = socket.socket() sk.bind(('127.0.0.1',9001)) sk.listen() while True: conn,addr = sk.accept() # 等待用户来连接我 while True: msg = input('>>>') conn.send(msg.encode('utf-8')) if msg.upper() == 'Q': break content = conn.recv(1024).decode('utf-8') # 等待 客户端给我发消息 if content.upper() == 'Q': break print(content) conn.close() sk.close()
import socket sk = socket.socket() sk.connect(('127.0.0.1',9001)) while True: ret = sk.recv(1024).decode('utf-8') if ret.upper() == 'Q':break #如果收到服务端信息为Q，停止程序 print(ret) msg = input('>>>') sk.send(msg.encode('utf-8')) if msg.upper() == 'Q': #如果输入内容为Q,停止程序 break sk.close()
基于UDP协议的socket
udp是无链接的，启动服务之后可以直接接受消息，不需要提前建立链接
server端
import socket sk = socket.socket(type=socket.SOCK_DGRAM) sk.bind(('127.0.0.1',9001)) while True: msg,client_addr = sk.recvfrom(1024) print(msg.decode('utf-8')) content = input('>>>') sk.sendto(content.encode('utf-8'),client_addr) sk.close()
client端（多个客户端代码一致）
import socket sk = socket.socket(type=socket.SOCK_DGRAM) server_addr = ('127.0.0.1',9001) while True: content = input('>>>') if content.upper() == 'Q':break sk.sendto(content.encode('utf-8'),server_addr) msg = sk.recv(1024).decode('utf-8') if msg.upper() == 'Q':break print(msg) sk.close()
代码解释：客户端1，2等都可以与服务端连接，客户端先输入，如果输入内容为 ‘q’ 结束程序，服务端可以与多个客户端对话，但只能一个一个回复，回复q，停止与该客户端对话
练习
实现一对多聊天
import json import socket sk = socket.socket(type=socket.SOCK_DGRAM) sk.bind(('127.0.0.1',9001)) user_info = { 1234:('alex','\033[1;32m'), 5678:('宝元','\033[1;31m'), } while True: msg,addr = sk.recvfrom(1024) str_msg = msg.decode('utf-8') dic_msg = json.loads(str_msg) code = dic_msg['code'] content = dic_msg['msg'] print('%s%s : %s\033[0m'%(user_info[code][1],user_info[code][0],content)) ret = input('>>>').encode('utf-8') sk.sendto(ret,addr) sk.close()
import json import socket sk = socket.socket(type=socket.SOCK_DGRAM) addr = ('127.0.0.1',9001) code = 5678 while True: msg = input('>>>') if msg.upper() == 'Q': break send_msg = {'code':code,'msg':msg} str_msg = json.dumps(send_msg) sk.sendto(str_msg.encode('utf-8'),addr) ret = sk.recv(1024).decode('utf-8') if ret.upper() == 'Q': break print(ret) sk.close()
import json import socket sk = socket.socket(type=socket.SOCK_DGRAM) addr = ('127.0.0.1',9001) code = 1234 while True: msg = input('>>>') if msg.upper() == 'Q':break send_msg = {'code':code,'msg':msg} str_msg = json.dumps(send_msg) sk.sendto(str_msg.encode('utf-8'),addr) ret = sk.recv(1024).decode('utf-8') if ret.upper() == 'Q':break print(ret) sk.close()
登陆验证在server端加密
import sys import json import socket import hashlib def get_md5(username,password): md5 = hashlib.md5(username.encode('utf-8')) md5.update(password.encode('utf-8')) return md5.hexdigest() def login(dic_msg): print(dic_msg['user'], dic_msg['pwd']) with open('userinfo', encoding='utf-8') as f: for line in f: user, pwd = line.strip().split('|') if user == dic_msg['user'] and pwd == get_md5(dic_msg['user'], dic_msg['pwd']): return {'opt':'login','result':True} else:return {'opt':'login','result':False} sk= socket.socket() sk.bind(('127.0.0.1',9001)) sk.listen() while True: conn,addr = sk.accept() msg = conn.recv(1024).decode('utf-8') dic_msg = json.loads(msg) if hasattr(sys.modules[__name__],dic_msg['operate']): ret = getattr(sys.modules[__name__],dic_msg['operate'])(dic_msg) content = json.dumps(ret).encode('utf-8') conn.send(content) conn.close() sk.close()
import json import socket username = input('用户名 :') password = input('密 码 :') sk = socket.socket() sk.connect(('127.0.0.1',9001)) msg = {'operate':'login', 'user':username, 'pwd':password} str_msg = json.dumps(msg) sk.send(str_msg.encode('utf-8')) content = sk.recv(1024) str_content = content.decode('utf-8') dic_content = json.loads(str_content) if dic_content['result']: print('登录成功') else: print('登录失败') sk.close()
alex|ee838c58e5bb3c9e687065edd0ec454f
alex alex3714
在server端与client都加密
import sys import json import socket import hashlib def get_md5(username,password): md5 = hashlib.md5(username.encode('utf-8')) md5.update(password.encode('utf-8')) return md5.hexdigest() def login(dic_msg): print(dic_msg['user'], dic_msg['pwd']) with open('userinfo', encoding='utf-8') as f: for line in f: user, pwd = line.strip().split('|') print(pwd,get_md5(dic_msg['user'], dic_msg['pwd'])) if user == dic_msg['user'] and pwd == get_md5(dic_msg['user'], dic_msg['pwd']): return {'opt':'login','result':True} else:return {'opt':'login','result':False} sk= socket.socket() sk.bind(('127.0.0.1',9001)) sk.listen() while True: conn,addr = sk.accept() msg = conn.recv(1024).decode('utf-8') dic_msg = json.loads(msg) if hasattr(sys.modules[__name__],dic_msg['operate']): ret = getattr(sys.modules[__name__],dic_msg['operate'])(dic_msg) content = json.dumps(ret).encode('utf-8') conn.send(content) conn.close() sk.close()
import json import socket import hashlib def get_md5(username,password): md5 = hashlib.md5(username[::2].encode('utf-8')) md5.update(password.encode('utf-8')) return md5.hexdigest() username = input('用户名 :') password = input('密 码 :') sk = socket.socket() sk.connect(('127.0.0.1',9001)) msg = {'operate':'login', 'user':username, 'pwd':get_md5(username,password)} str_msg = json.dumps(msg) sk.send(str_msg.encode('utf-8')) content = sk.recv(1024) str_content = content.decode('utf-8') dic_content = json.loads(str_content) if dic_content['result']: print('登录成功') else: print('登录失败') sk.close()
alex|10378f7c5bcf811fdddd6efdee2c628f
alex alex3714
黏包
黏包现象
server 端
import socket sk = socket.socket() sk.bind(('127.0.0.1',9001)) sk.listen() conn,addr = sk.accept() conn.send(b'hello') conn.send(b'world') conn.close() sk.close()
client 端
import time import socket sk = socket.socket() sk.connect(('127.0.0.1',9001)) time.sleep(0.1) msg1 = sk.recv(1024) msg2= sk.recv(1024) print(msg1) print(msg2) sk.close()
打印结果出现了黏包现象
注意：只有TCP有粘包现象，UDP永远不会粘包
黏包成因
基于tcp协议特点的黏包现象成因
发送端可以是一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时才会清除缓冲区内容。数据是可靠的，但是会粘包。
黏包
tcp协议为了保证数据的可靠传输和传输效率
合包机制 : 连续多条短数据会合并成一条
拆包机制 : 一个过大的数据会在发出之前被拆成几个小包
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根本不会粘包，但是会丢数据，不可靠。 补充： 用UDP协议发送时，用sendto函数最大能发送数据的长度为：65535- IP头(20) – UDP头(8)＝65507字节。用sendto函数发送数据时，如果发送数据长度大于该值，则函数会返回错误。（丢弃这个包，不进行发送） 用TCP协议发送时，由于TCP是数据流协议，因此不存在包大小的限制（暂不考虑缓冲区的大小），这是指在用send函数时，数据长度参数不受限制。而实际上，所指定的这段数据并不一定会一次性发送出去，如果这段数据比较长，会被分段发送，如果比较短，可能会等待和下一次数据一起发送。
黏包的解决方案
解决方案一
问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据。
import socket sk = socket.socket() sk.bind(('127.0.0.1',9001)) sk.listen() conn,addr = sk.accept() conn.send(b'5') #将发送内容长度发送过去 conn.send(b'hello') conn.send(b'5') conn.send(b'world') conn.close() sk.close()
import time import socket sk = socket.socket() sk.connect(('127.0.0.1',9001)) time.sleep(0.1) num= sk.recv(1).decode('utf-8') #接收内容长度 num = int(num) msg1 = sk.recv(num) num= sk.recv(1).decode('utf-8') num = int(num) msg2 = sk.recv(num) print(msg1,msg2) sk.close()
解决方案进阶
我们可以借助一个模块，这个模块可以把要发送的数据长度转换成固定长度的字节。这样客户端每次接收消息之前只要先接受这个固定长度字节的内容看一看接下来要接收的信息大小，那么最终接受的数据只要达到这个值就停止，就能刚好不多不少的接收完整的数据了。
struct模块
import struct ret = struct.pack('i',112849) print(ret) #b'\xd1\xb8\x01\x00' struct.pack 把一个数字类型，转成固定长度 4 的bytes ret2 = struct.unpack('i',ret) print(ret2) #(112849,) struct.unpack 把长度 4 的bytes，转成一个元祖
利用struck 模块解决黏包问题
import struct import socket sk = socket.socket() sk.bind(('127.0.0.1',9001)) sk.listen() conn,addr = sk.accept() str_msg = 'hello,你好么' byets_msg = str_msg.encode('utf-8') num = len(byets_msg) len_bytes = struct.pack('i',num) conn.send(len_bytes) conn.send(byets_msg) conn.send(b'world') conn.close() sk.close()
import time import struct import socket sk = socket.socket() sk.connect(('127.0.0.1',9001)) time.sleep(0.1) num= sk.recv(4) num = struct.unpack('i',num)[0] msg2 = sk.recv(num) print(msg2.decode('utf-8')) print(sk.recv(1024)) sk.close()
解决黏包问题 实现文件上传
import struct import socket sk = socket.socket() sk.bind(('127.0.0.1',9001)) sk.listen() conn,addr = sk.accept() num = conn.recv(4) num = struct.unpack('i',num)[0] file_name = conn.recv(num).decode('utf-8') filesize = conn.recv(4) filesize = struct.unpack('i',filesize)[0] with open(file_name,'wb') as f: content = conn.recv(filesize) f.write(content) conn.close() sk.close()
import os import struct import socket sk = socket.socket() sk.connect(('127.0.0.1',9001)) filepath = input('请输入文件路径 :') filename = os.path.basename(filepath).encode('utf-8') name_len = struct.pack('i',len(filename)) sk.send(name_len) sk.send(filename) filesize = os.path.getsize(filepath) file_len = struct.pack('i',filesize) sk.send(file_len) with open(filepath,'rb') as f: content = f.read() sk.send(content) sk.close()
先发送字典的长度
再发字典 {'filename':xxxx,'filesize':xxxxx}
再发文件内容
import json import struct import socket sk = socket.socket() sk.bind(('127.0.0.1',9001)) sk.listen() conn,addr = sk.accept() num = conn.recv(4) num = struct.unpack('i',num)[0] str_dic = conn.recv(num).decode('utf-8') dic = json.loads(str_dic) with open(dic['filename'],'wb') as f: content = conn.recv(dic['filesize']) f.write(content) conn.close() sk.close()
import os import json import struct import socket sk = socket.socket() sk.connect(('127.0.0.1',9001)) filepath = input('请输入文件路径 :') filename = os.path.basename(filepath) filesize = os.path.getsize(filepath) dic = {'filename':filename,'filesize':filesize} str_dic = json.dumps(dic) bytes_dic = str_dic.encode('utf-8') len_dic = len(bytes_dic) bytes_len = struct.pack('i',len_dic) sk.send(bytes_len) sk.send(bytes_dic) with open(filepath,'rb') as f: content = f.read() sk.send(content) sk.close() # 先发送字典的长度 # 再发字典 {'filename':xxxx,'filesize':xxxxx} # 再发文件内容
练习
1.大文件的上传
import json import struct import socket sk = socket.socket() sk.bind(('127.0.0.1',9001)) sk.listen() conn,addr = sk.accept() len_bytes = conn.recv(4) num = struct.unpack('i',len_bytes)[0] str_dic = conn.recv(num).decode('utf-8') dic = json.loads(str_dic) with open(dic['filename'],'wb') as f: while dic['filesize']: content = conn.recv(2048) f.write(content) dic['filesize'] -= len(content)
import os import json import struct import socket sk = socket.socket() sk.connect(('127.0.0.1',9001)) file_path = input('>>>') filename = os.path.basename(file_path) filesize = os.path.getsize(file_path) dic = {'filename':filename,'filesize':filesize} bytes_dic = json.dumps(dic).encode('utf-8') len_bytes = struct.pack('i',len(bytes_dic)) sk.send(len_bytes) sk.send(bytes_dic) with open(file_path,'rb') as f: while filesize > 2048: content = f.read(2048) sk.send(content) filesize -= 2048 else: content = f.read() sk.send(content) sk.close()
2.登陆认证+大文件上传
import json import socket import struct import hashlib def get_md5(usr,pwd): md5 = hashlib.md5(usr.encode('utf-8')) md5.update(pwd.encode('utf-8')) return md5.hexdigest() def login(conn): msg = conn.recv(1024).decode('utf-8') dic = json.loads(msg) with open('userinfo', encoding='utf-8') as f: for line in f: username, password = line.strip().split('|') if username == dic['user'] and password == get_md5(dic['user'], dic['passwd']): res = json.dumps({'flag': True}).encode('utf-8') conn.send(res) return True else: res = json.dumps({'flag': False}).encode('utf-8') conn.send(res) return False def upload(conn): len_bytes = conn.recv(4) num = struct.unpack('i', len_bytes)[0] str_dic = conn.recv(num).decode('utf-8') dic = json.loads(str_dic) with open(dic['filename'], 'wb') as f: while dic['filesize']: content = conn.recv(2048) f.write(content) dic['filesize'] -= len(content) sk = socket.socket() sk.bind(('127.0.0.1',9001)) sk.listen() while True: try: conn,addr = sk.accept() ret = login(conn) if ret: upload(conn) except Exception as e: print(e) finally: conn.close() sk.close()
import os import json import socket import struct def upload(sk): # 上传文件 file_path = input('>>>') filename = os.path.basename(file_path) filesize = os.path.getsize(file_path) dic = {'filename': filename, 'filesize': filesize} bytes_dic = json.dumps(dic).encode('utf-8') len_bytes = struct.pack('i', len(bytes_dic)) sk.send(len_bytes) sk.send(bytes_dic) with open(file_path, 'rb') as f: while filesize > 2048: content = f.read(2048) sk.send(content) filesize -= 2048 else: content = f.read() sk.send(content) usr = input('username :') pwd = input('password :') dic = {'operate':'login','user':usr,'passwd':pwd} bytes_dic = json.dumps(dic).encode('utf-8') sk = socket.socket() sk.connect(('127.0.0.1',9001)) sk.send(bytes_dic) res = sk.recv(1024).decode('utf-8') dic = json.loads(res) if dic['flag']: print('登录成功') upload(sk) else: print('登录失败') sk.close()
alex|ee838c58e5bb3c9e687065edd0ec454f
alex alex3714
并发的socketserver
#server import time import socketserver class Myserver(socketserver.BaseRequestHandler): def handle(self): conn = self.request for i in range(200): conn.send(('hello%s'%i).encode('utf-8')) print(conn.recv(1024)) time.sleep(0.5) server = socketserver.ThreadingTCPServer(('127.0.0.1',9001),Myserver) server.serve_forever()
#client import socket sk = socket.socket() sk.connect(('127.0.0.1',9001)) while True: msg = sk.recv(1024) print(msg) sk.send(b'byebye') sk.close()
服务端可以与多个客户端相连
验证客户端的合法性
#hmac模块 import os import hmac #os.urandom(32) 给每一客户端发送一个随机的字符串,来保证即使数据被拦截你也不能使用这个消息 hmac = hmac.new(b'alex sb',os.urandom(32)) print(hmac.digest()) #b'\x03m\x95\x87\xb7\xda\xb9,\xb5\xf5x(\x04\xac\xddJ'
import os import hmac import socket secret_key = b'alex sb' #os.urandom(32) 给每一客户端发送一个随机的字符串,来保证即使数据被拦截你也不能使用这个消息 sk = socket.socket() sk.bind(('127.0.0.1',9001)) sk.listen() conn,addr = sk.accept() rand = os.urandom(32) conn.send(rand) hmac = hmac.new(secret_key,rand) res = hmac.digest() ret = conn.recv(1024) if ret == res: print('是合法的客户端') else: print('不是合法的客户端') conn.close()
import hmac import socket secret_key = b'alex sb' sk = socket.socket() sk.connect(('127.0.0.1',9001)) rand = sk.recv(32) hmac = hmac.new(secret_key,rand) res = hmac.digest() sk.send(res) sk.close()
socket 其他方法
# import socket # sk = socket.socket() # sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) # # 防止程序因为意外退出之后重启程序出现端口被占用的错 # # 生产环境中不能用,平时开发过程中可以设置 # sk.bind(('127.0.0.1',9001)) # sk.listen() # 其他代码 # sk.close() import socket sk = socket.socket() sk.bind(('127.0.0.1',9001)) sk.setblocking(False) # blocking阻塞 setblocking 设置阻塞 当（）中为True，即设置阻塞，和没有一样 当（）为False，即不设置阻塞 sk.listen() conn_l = [] while True: try: conn,addr = sk.accept() conn_l.append(conn) except BlockingIOError: for conn in conn_l: try: msg = conn.recv(1024).decode('utf-8') print(msg) conn.send(msg.upper().encode('utf-8')) except BlockingIOError: pass
