网络编程

网络架构：

C/S B/S ：

C：客户端，B：游览器(rowser)，S：服务端

C/S：客户端与服务器之间的架构：QQ，微信，游戏，App都属于cs架构
- 优点：安全，响应速度快，个性化功能多
- 缺点：开发和维护成本高，面向客户固定
B/S：游览器与服务器之间的架构：
- 优点：开发维护成本低，维护成本低，面向的用户广泛
- 缺点：相对不安全，响应速度相对慢，个性化设计单一

互联网通讯原理：

打电话示例：
互联网通信：
- 1，一堆物理介质将两个电话连接起来
- 2，拨号
- 3，统一的通信标准，一揽子协议，这些互联网协议就是一个个标准，最终可以通信

网络五层：

osi五层：
- OSI（Open System Interconnect）开放式系统互联
  - osi是一个标准，是一个规范,五层协议都是操作系统帮我们封装各种head
- 应用层 python (应用层包括会话层，表示层) 会话：保证多次网络传输准确性，表示:保证数据安全
  
  应用层常见协议：HTTP、HTTPS、FTP、SMTP、TELNET、POP3、DNS、DHCP
- 表示层数据的表示，安全，压缩，格式有JPEG,ASCII 加密格式等
- 会话成建立、管理、终止会话，对应主机进程，指本地主机与远程主机正在进行的会话
- 传输层 tcp udp 四层路由器四层交换机
- 网络层路由器三层交换机 ipv4 ipv6 (国际协议)
- 数据链路层二层傻瓜交换机，以太网协议，mac arp 网卡
- 物理层物理连接介质，网线，光纤，发送的是010101比特数据流

1.物理层：
- 物理连接介质：网线，光纤：发送的数据就是0101010 1比特数据流

2.数据链路层：

交换机
以太网协议：
- 以太网协议是局域网中的一种协议
- 将比特流数据分组，一组叫做一帧，每一数据帧分成：报头head和数据data两部分
数据头（head）|data数据：
数据头：固定长度18个字节(标准)（源地址，目的地址，端口，数据类型）
data数据：最短46字节，<=data <=1500字节

以太网问题：
1，数据头为什么要固定？
   固定就是一个标准，为了提取源地址以及目标地址
   
2，以太网协议中源目标地址如何设置唯一？
	网线直接接触的硬件就是网卡，网卡上有一个mac地址，确定计算机的唯一性的物理地址
    
网卡mac地址：12位，16进制组成的一串数字，前六位厂商编号：后六位：流水线号

head（源地址，目的地址，端口，数据类型）|data（"俊丽"）

广播/单播：

计算机最原始的通信方式
数据经过以太网协议封装后(head)|data，先要从局域网内广播,
- 广播：
  - 一对多连接，有了mac地址，两台主机通信，一台主机通过arp协议获取到另一台主机的mac地址
  - 广播只存在局域网内，广播通信基本靠吼
- 单播：
  - 一对一连接（第一次是广播访问，第二次交换机有学习功能，将mac写入表中，下次进行单播）
  - 优点：提升效率
交换机学习功能：

交换机对照(网口与MAC地址的)表:
1:    1C-1B-0D-DA-E8-8F
2:    FF-FF-FF-FF-FF-FF
3:    FF-FF-FF-FF-FF-FF
4:    FF-FF-FF-FF-FF-FF
5:    1C-1B-0F-4A-E8-8F

网口1: 出来一条信息:
# 第一次广播的形式发出去
网口1:源地址: 1C-1B-0D-DA-E8-8F 目标地址: 1C-1B-0F-4A-E8-8F  |   明天放假

2,3,4,5口接收到次消息,查看目标mac地址是否是自己的,5口确定是自己的.

每个网口都广播发送消息一遍之后,对照表就构建好,下次在任意的网口在发消息,就直接以单播的形式发送.
目的: 避免局域网内每一次都广播的形式通信.以后就可以单播,提升效率.
    
mac地址:head报头中的mac地址 ，都会替换，了解

arp协议：

通过ip获取到mac地址

ARP协议:就是将对方的ip地址获取到对方的MAC地址
如果两个用户进行第一次通信的时候,你不可能知道对象的mac地址么? 但是你必须要知道对方的IP地址.

IP + ARP协议 = 获取对方的MAC地址

源mac                           目标mac               源ip               目标ip                     数据部分
发送端mac: 1C-1B-0D-DA-E8-8F      FF:FF:FF:FF:FF:FF  172.16.10.10/24    172.16.10.11/34         今晚一起吃饭

目标计算机
(源mac:1C-1B-0F-4A-E8-8F  目标mac 1C-1B-0D-DA-E8-8F 源ip: 172.16.10.11/34 目标ip:172.16.10.10/24)

3.网络层：
- 路由器
- 网络层的作用是解决客户端到服务端连接中的各个节点问题
- IP协议：
  - ipv4 ipv6 国际互联网协议第四版
  - 广播，mac地址+IP == 可以找到世界上任意一台计算机
  - IP：
    - IP地址：
    - ip地址+子网掩码确定计算机所在网段，子网，局域网位置
      - ipv4地址：四点分十进制，范围 0-255.0-255.0-255.0-255
    - 子网掩码：
      - 一般都是c类
      - 255.255.255.0
      - ip地址+子网掩码可以计算出IP网段，可以分254个ip地址，同一局域网内的ip地址不能重复

传输层：（tcp,udp）

端口协议：传输层建立了点到点的连接
- 端口号：0-65535 系统占用端口：1-1023 软件端口：1024-8000
- 广播，mac地址+IP +端口 == 可以找到世界上任意一台计算机对应的软件
TCP：
- tcp是一种面向连接，可靠的，基于IP的传输层协议
- 使用的tcp的应用：Web浏览器，文件传输
- 优点：
  - 可靠的面向连接协议，稳定安全（面向连接就是双方通信）
- 缺点
  - 效率相对低，传输速度慢些
UDP：
- 面向数据报协议，无连接协议
- 使用UDP应用：域名系统，视频流，IP语言，微信，QQ
- 优点：
  - 效率高，速度快，发送数据前不需要建立连接
- 缺点：
  - 不安全，不可靠，容易丢包

应用层：

应用层存储的都是自己开发的程序，HTTP
软件自己定义的协议：
- qq：发送数据：“海洋“ ------> [”海洋“]
- 将数据按照自己定义的协议进行封装（http ftp协议等等）
物理层 --> 数据链路层(以太网协议，mac) --> 网络层 --> 传输层( tcp,udp) --> 应用层
mac地址 + 广播形式 +ip地址 + 端口 ==可以找到任意一台机器

握手状态：

seq 序号用来表示tcp源端像目标端发送字节流，发送方发送数据对此进行标记 32位
ACK 确认请求只有ACK标志位等于1事，确认序号才有效，ack = seq + 1
SYN 发送请求
FIN 释放一个连接
注意：确认方=发起方req + 1 ，两端配对

三次握手：

客户端与服务端第一次需要建立通信联系，需要三次握手：
第一次握手：
- 客户端向服务端发送syn=1的请求和一个随机seq等于x的报文，进入发送状态
第二次握手：
- 两条请求合并成一条请求
- 服务端收到客户端发送的syn报文，给客户端回应一个ack=x+1(我收到你的报文，进行+1)的确认请求和同样还会返回syn=1的请求一个随机seq等于y的报文，进入接收状态
第三次握手：
- 客户端收到服务器syn报文和确认请求，在回应服务器一个ack = y+1报文，客户端和服务端进入建立连接状态，完成三次握手
三次握手意义：
- 简述：主要防止客户端已经失效的连接请求报文突然传到了服务端，而产生的错误
客户端向服务端发送一个连接请求，这个请求因为网络节点问题滞留了，请求在到达服务器已经是一个失效的连接，如果没有三次握手，服务器确认请求，建立连接，但是请求是失效的，客户端不会理会服务器的确认信息，也不会发送消息，服务端一直等待客户端发送数据，这样很多资源就浪费了，这就是三次握手的作用
为什么要进行三次握手：
- TCP协议在建立连接时，需要确认通信的双方收发信息的功能都是正常的，因此要进行三次握手

四次挥手：

建立的连接不能一直连接着
第一次挥手：
- 客户端向服务器发送FIN=1，seq序号=x 客户端停止发送数据
第二次挥手：
- 服务端收到FIN，回复确认请求 ack=x+1
  
  客户端到服务端这条路断开
第三次挥手:
- 服务端向客户端发送FIN=1 ，seq=y
第四次挥手:
- 客户端发送ack=1 + y
  
  服务端到客户端这条路断开
为什么要进行四次挥手：
- tcp是一个面向连接，全双工模式，两条通道要进行两次确认才断开
- 客户端向服务端发送Fin关闭连接，服务端确认后，服务端确认后就表示服务端没有数据在发送给客户端，
- 客户端到服务端通道关闭
- 但是服务器的数据不一定都完整传给了客户端，服务器不会直接关闭，他可能还会发送数据给客户端，
- 之后，再次发送FIN报文，给客户端，客户端在同意后在关闭连接
- 服务端到客户端通道关闭

Socket:

socket 套接字就是一个网络通信的工具，建立客户端与服务端的通信，他存在于应用层和传输层之间的抽象层，这个通信工具封装好了所有的底层接口，可以直接调用这些接口，提高开发效率

TCP_Socket：

#服务端
import socket

phone = socket.socket()                 #创建socket对象，默认tcp协议
phone.bind(("127.0.0.1",666))           #绑定IP地址和端口
phone.listen(5)                         #监听，开机状态，5同时可以有多少个请求连接

conn,addr = phone.accept()              #建立连接，等待客户端，conn两条管道，addr客户端地址

while 1:
    from_client_data = conn.recv(1024)   #接受消息和多少字节
    print(f'来自客户端的{addr}消息{from_client_data.decode("utf-8")}')

    to_server = input(">>>>")
    conn.send(to_server.encode("utf-8"))  #发送

conn.close()    #关闭通道连接
phone.close()  #关闭socket套接字

#客户端
import socket

phone = socket.socket()
phone.connect(("127.0.0.1",666))            #连接server服务端信息

while 1:
    to_client = input(">>>")
    phone.send(to_client.encode("utf-8"))    #send发送

    from_server_data = phone.recv(1024)      #接受消息和多少字节
    print(from_server_data.decode("utf-8"))

phone.close()

通讯循环-一个对多个客户端，客户端需要排队

import socket

phone = socket.socket()                 #创建socket对象，默认tcp协议
phone.bind(("127.0.0.1",666))           #绑定IP地址和端口
phone.listen(5)                         #监听，开机状态，5同时可以有多少个请求连接

while 1:
    print("开启")
    conn,addr = phone.accept()          #建立连接，等待客户端，conn连接管道，addr客户端地址
    print(conn,addr)

    while 1:
        try:  #客户端异常退出报错进行异常处理
            from_client_data = conn.recv(1024)    #recv：接受消息和多少字节,夯住
            if from_client_data == "q".encode("utf-8"):
                break
            print(f'来自客户端的{addr}消息{from_client_data.decode("utf-8")}')

            to_server = input(">>>>")
            conn.send(to_server.encode("utf-8"))  #send：发送
        except ConnectionResetError:
            break

    conn.close()    #关闭通道连接
phone.close()  	    #关闭socket套接字

#客户端还引用上面那个

执行win端命令：

#服务端：
import subprocess
import socket

phone = socket.socket()                  #创建socket对象，默认tcp协议
phone.bind(("127.0.0.1",1666))          #绑定IP地址和端口
phone.listen(5)                          #监听，开机状态，5同时可以有多少个请求连接

while 1:
    print("开启")
    conn,addr = phone.accept()           #建立连接，等待客户端，conn连接管道，addr客户端地址
    while 1:
        try:
            cmd = conn.recv(1024)        #接受消息和多少字节,夯住
            obj = subprocess.Popen(cmd.decode("utf-8"),
                                   shell=True,
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.PIPE,
                                   )
            result = obj.stdout.read() + obj.stderr.read()
            conn.send(result)

        except ConnectionResetError:
            break

    conn.close()    #关闭通道连接
phone.close()       #关闭socket套接字

#客户端：
import socket
phone = socket.socket()
phone.connect(("127.0.0.1",1666))           #连接server服务端信息

while 1:
    cmd = input(">>>").strip()
    phone.send(cmd.encode("utf-8"))   #将命令转为utf-8发送

    result = phone.recv(1024)          #接受的消息为windows系统编码转为gbk
    print(result.decode("gbk"))

phone.close()

粘包:

缓冲区作用：
- Socket进行send和recv的时候，都要通过输出缓冲区和输入缓冲区，缓冲区可以暂时解决网络不稳定问题，提高稳定性
- 缓存区一般为8K
产生粘包的现象(只有TCP)：
- 粘包发生在tcp协议中
产生粘包的现象有两种recv和send：
- recv产生粘包：
  - 如果你的recv最大接受值为1024字节，当你接受一个1500的字节，recv只会接受1024剩下的476个字节会停留在输入缓存区，当你第二次在发送数据，造成了数据的粘包。
- send产生粘包：
  - 当你连续send发送少量的数据，tcp会根据优化算法将数据合并成一个TCP段发送出去

解决粘包方式：
- 1、可以扩大recv的上限，但是会对服务器内存占用
- 2、客户端sleep睡眠，这样会非常影响效率
正确思路：
- 当第二次接受数据前，循环recv将所有的数据取完

recv的工作原理：

send多次，recv一次（不是一发一收制）

当缓存区没有数据可取时，recv会一直处于阻塞状态，直到缓冲区至少有一个字节数据可取，或者远程端关闭，关闭远程端并读取所有数据后，返回空字符

low版：

问题1：非常大的数据使用struct会报错
问题2：报头信息不可能只包含数据总大小

# 服务端
import subprocess
import socket
import struct

phone = socket.socket()  		 # 创建socket对象，默认tcp协议
phone.bind(("127.0.0.1", 1666))  # 绑定IP地址和端口
phone.listen(5)  			     # 监听，开机状态，5同时可以有多少个请求连接

while 1:
    print("开启")
    conn, addr = phone.accept()    # 建立连接，等待客户端，conn连接管道，addr客户端地址
    while 1:
        try:
            cmd = conn.recv(1024)  # 接受消息和多少字节,夯住
            obj = subprocess.Popen(cmd.decode("utf-8"),
                                   shell=True,
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.PIPE,
                                   )
            result = obj.stdout.read() + obj.stderr.read()

            total_size = len(result)  # 制作报头（371）
            # 将不固定长度的int类型报头，转化成固定4字节（b'sx01x00x00'）
            total_size_bytes = struct.pack("i", total_size)

            conn.send(total_size_bytes)  # 发送字节长度和数据信息
            conn.send(result)

        except ConnectionResetError:
            break

    conn.close()
phone.close()

# 客户端：
import socket
import struct

phone = socket.socket()
phone.connect(("127.0.0.1", 1666))  # 连接server服务端信息

while 1:
    cmd = input(">>>").strip()
    phone.send(cmd.encode("utf-8"))

    head_bytes = phone.recv(4)  # 接受报头四个字节(b'sx01x00x00')
    total_size = struct.unpack("i", head_bytes)[0]  # 将报头反解回int类型（371）

    total_data = b''  # 循环接受原数据
    while len(total_data) < total_size:
        total_data += phone.recv(1024)

    print(total_data.decode("gbk"))

phone.close()

旗舰版-自定义报头版：

解决粘包思路：
- 1，当第二次接受数据前，循环recv将所有的数据取完
  - result 3000bytes recv 3次
    
    result 5000bytes recv 5次
    
    result 30000bytes recv ?次 ---> 循环次数相关
- 2，接受总数据bytes，进行while循环，当接受数据大于总数据，循环结束
- 3，怎么获取到总bytes个数：数据转成bytes之后len() =总bytes数
  - dict报头-->“dict报头”---->json("dict报头") = 字典数据
  - len(json("dict报头")) --->len()转成四个字节 = 字典报头长度
  - 先发送字典报头长度，在发送字典数据

#服务端：
import socket
import subprocess
import struct
import json

phone = socket.socket()
phone.bind(('127.0.0.1', 8888))
phone.listen(5)

while 1:
    print('start')
    conn, addr = phone.accept()
    while 1:
        try:
            cmd = conn.recv(1024)
            obj = subprocess.Popen(cmd.decode('utf-8'),
                                   shell=True,
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.PIPE,
                                   )

            result = obj.stdout.read() + obj.stderr.read()
            result = result.decode('gbk').encode('utf-8')

            head_dict = {
                'MD5': 'fdsaf2345544324dfs',
                'file_name': '视频文件',
                'file_size': len(result),
            }                                                 #制作报头

            head_dict_json = json.dumps(head_dict)            #将报头字典转化成json序列化
            head_dict_json_bytes = head_dict_json.encode('utf-8')   #将json字符串 转化成bytes

            head_len = len(head_dict_json_bytes)         #获取字典的长度(88)
            head_len_bytes = struct.pack('i',head_len)  #将长度转化成固定的4个字节 (b'Xx00x00x00')


            conn.send(head_len_bytes)      #字典报头长度--->4个字节(b'Xx00x00x00')
            conn.send(head_dict_json_bytes)  # 字典数据bytes
            conn.send(result)                #发送原数据bytes

        except ConnectionResetError:
            break
    conn.close()
phone.close()

#客户端：
import socket
import struct
import json

phone = socket.socket()
phone.connect(('127.0.0.1', 8888))

while 1:
    cmd = input('>>>').strip()
    phone.send(cmd.encode('utf-8'))

    jie_bytes = phone.recv(4)
    total_size = struct.unpack('i', jie_bytes)[0]     #接收字典报头长度，struct转化为int

    head_bytes = phone.recv(total_size)               #接受字典数据,total_size字典报头长度
    head_dict  = json.loads(head_bytes.decode("utf-8"))  #将json字典转为字典

    total_size = head_dict["file_size"]         #通过字典取出要发送过来数据的总长度

    recv_data = b''                             #循环累加接受原数据
    while len(recv_data) < total_size:          #不等于，当等于还会进去取值，这时值已经没有了
        recv_data += phone.recv(1024)

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

phone.close()

UDP_Socket:

udp协议：不可靠，相对来说不安全的协议，面向数据报无连接协议（可靠不可靠是指数据是否能到达）效率高，速度快

基础通信：

UDP通信没有tcp连接通道，服务端和客户端每次发送都需要带着IP地址和端口号

#服务端:
import socket

udp_server = socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #创建udp协议对象
udp_server.bind(("127.0.0.1",666))

while 1:
    from_client_data = udp_server.recvfrom(1024)  #(b'niha', ('127.0.0.1', 64180))
    print(f'来自{from_client_data[1]}{from_client_data[0].decode("utf-8")}')

    to_client_data = input("输入").strip()
    udp_server.sendto(to_client_data.encode("utf-8"),from_client_data[1])  
    
#客户端:
import socket

udp_client= socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #创建udp协议对象

while 1:
    to_client_data = input("输入").strip()
    udp_client.sendto(to_client_data.encode("utf-8"),("127.0.0.1",666))

    from_server_data = udp_client.recvfrom(1024)
    print(f'来自{from_server_data[1]}的消息：{from_server_data[0].decode("utf-8")}')

Socket_Server多线程通信：

#服务端：
import socketserver

class MyServer(socketserver.BaseRequestHandler): # 继承的类固定的

    def handle(self):  # 必须是这个handle名字，类的约束
        while 1:
            from_client_data = self.request.recv(1024).decode('utf-8') #self.request == conn管道
            print(from_client_data)

            to_client_data = input('>>>').strip()
            self.request.send(to_client_data.encode('utf-8'))

if __name__ == '__main__':

    ip_port = ('127.0.0.1',8848)
    server = socketserver.ThreadingTCPServer(ip_port,MyServer)
    # server.allow_reuse_address = True
    # print(socketserver.ThreadingTCPServer.mro())
    # [ThreadingTCPServer, ThreadingMixIn,TCPServer, BaseServer]
    server.serve_forever()
    
#客户端：
import socket

client = socket.socket()
client.connect(('127.0.0.1', 8848))

while 1:
    content = input('>>>').strip()
    client.send(f'海洋:{content}'.encode('utf-8'))

    from_server_data = client.recv(1024)  # 夯住,等待服务端的数据传过来
    print(f'来自服务端消息:{from_server_data.decode("utf-8")}')

phone.close()

网络编程

网络架构：

互联网通讯原理：

网络五层：

osi五层：

OSI（Open System Interconnect）开放式系统互联

1.物理层：

2.数据链路层：

3.网络层：

传输层：（tcp,udp）

TCP：

UDP：

应用层：

握手状态：

三次握手：

四次挥手：

Socket:

TCP_Socket：

通讯循环-一个对多个客户端，客户端需要排队

执行win端命令：

粘包:

缓冲区作用：

产生粘包的现象(只有TCP)：

low版：

旗舰版-自定义报头版：

UDP_Socket:

基础通信：

Socket_Server多线程通信：