09-1 网络编程知识总结

叁歲伎倆 2023-08-17 15:24 50阅读 0赞

*  1 网络编程小结
    
     *  1.1 网络架构
        
         *  1.1.1 单机架构
         *  1.1.2 CS架构
         *  1.1.3 BS架构
     *  1.2 OSI七层协议
        
         *  1.2.1 物理层
         *  1.2.2 数据链路层
         *  1.2.3 网络层
         *  1.2.4 传输层
         *  1.2.5 应用层
         *  1.2.6 Socket抽象层
     *  1.3 TCP协议的三次握手和四次挥手
        
         *  1.3.1 三次握手建立连接
         *  1.3.2 四次挥手断开连接
     *  1.4 基于TCP协议的socket套接字编程
        
         *  1.4.1 服务端
         *  1.4.2 客户端
     *  1.5 模拟ssh远程执行命令
        
         *  1.5.1 服务端
         *  1.5.2 客户端
     *  1.6 粘包问题
     *  1.7 解决粘包问题
     *  1.8 基于UDP协议的socket套接字编程
        
         *  1.8.1 服务端
         *  1.8.2 客户端
     *  1.9 基于socketserver实现并发的socket套接字编程
        
         *  1.9.1 服务端

# 1 网络编程小结 #

## 1.1 网络架构 ##

### 1.1.1 单机架构 ###

只能在本台机器上，不能联网

### 1.1.2 CS架构 ###

客户端和服务端，两者直接进行交互。

### 1.1.3 BS架构 ###

浏览器和服务器的交互。

客户端嫁接在浏览器上，浏览器实际也是一个客户端。

## 1.2 OSI七层协议 ##

OSI七层模型： 全称为 开放互联系统参考模型。

互联网由硬件和软件组成，只能传送电信号0和1。

而OSI协议把0和1转换为用户可以识别的数据。

**我们一般只说五层协议**。

*  物理层
 *  数据链路层
 *  网络层
 *  传输层
 *  应用层

### 1.2.1 物理层 ###

计算机与计算机之间传输数据。

规定了连接介质相关的协议，例如RJ45。

### 1.2.2 数据链路层 ###

让同一个局域网下的计算机连接在一起。

它规定了一组电信号的长度，我们可以称之为数据帧。

每个机器都必须具备一个mac地址，这个地址是指计算机上网卡的地址。它固定不变，并且唯一。

在局域网中，你要和其他的机器进行通信，必须知道自己的mac地址还有对方的mac地址。通过交换机进行通信，但是交换机也不知道mac地址对应的计算机是哪一台，交换机就会以广播的形式发送给所有的计算机，收件人的计算机收到了就会解析这条命令，拿到内容了之后交换机会记录两个机器的mac地址。

交换机会自动学习mac地址和端口的映射关系，广播仅发生在第一次通信。

**通过mac地址可以确定唯一的计算机**

### 1.2.3 网络层 ###

让不同局域网内的计算机连接在一起。

网络层给每一个机器都分配了一个IP地址。

**为什么分配IP地址呢？**如果我们只知道MAC地址无法连接其他局域网内的计算机。因为mac地址只能被交换机识别，然而不同的局域网的交换机不一样，所以现在定义一个新的地址来表明这台机器是哪个局域网的。互联网就是多个局域网，局域网通过路由器连接。

目前使用的最多的还是ipv4，范围为0.0.0.0-255.255.255.255。其中子网掩码是用来区分不同的子网，这样一来就可以分区域的广播，降低广播范围。

网络层就是在数据链路层的基础上在数据上再包一层IP头。

这样，我们有了mac地址，有了IP地址就可以找到全世界独一无二的那台计算机。

arp 协议： 将IP地址转换为mac地址

**ip地址+mac地址找到全世界独一无二的计算机**

### 1.2.4 传输层 ###

每一个应用程序必须绑定一个端口号，用于表示唯一的一个进程。

端口号为一个数字，范围在0-65535之间。系统保留0-1024端口。

有了端口号，再加上IP地址MAC地址，

**ip地址+mac地址+端口找到全世界独一无二的计算机的唯一的应用程序**。

传输层中的传输协议：TCP和UDP

#### 1.2.4.1 TCP协议 ####

特点：可以保证数据的完整性

缺点： 效率低，需要发送确认消息

1.  通过三次握手建立连接保证数据通道是可用的。
2.  传输过程中需要接收对方返回的确认信息。
3.  通过四次挥手保证数据传输完毕了。

TCP中数据之间没有间隔，会出现粘包现象。

#### 1.2.4.2 UDP协议 ####

是基于数据报的传输协议，每一个数据报中必须包含接收方的信息，数据报是一个独立的数据单位，不会产生粘包。

特点： 无法保证数据的完整性

优点：效率高

### 1.2.5 应用层 ###

**数据交互，0和1转换成具体的功能**

### 1.2.6 Socket抽象层 ###

应用程和传输层之间,我们就是写了一个应用程序。服务端和客户端就是一个应用程序

## 1.3 TCP协议的三次握手和四次挥手 ##

### 1.3.1 三次握手建立连接 ###

1.  客户端像服务端发出连接的带上SYN的请求给服务端
2.  服务端接收到后,返回一个带上SYN和ACK的请求给客户端
3.  客户端进入连接状态,并且发送一个带上ACK的请求给服务端
4.  服务端收到进入连接状态

### 1.3.2 四次挥手断开连接 ###

1.  客户端发出带有FIN的请求给服务端
2.  服务端返回一个带有ACK的请求个客户端

**然后服务端还有可能会有遗留的数据返回给客户端,会在这个时候发完**

1.  服务端发完之后才会发送一个带有FIN和ACK的请求给客户端

**如果客户端没有接收到这条请求,就没有第四条请求给服务端,服务端会隔一段时间再发一次带有FIN和ACK的请求给客户端...如果在2MSL时间内,客户端一直没有响应,则强行关闭**

1.  客户端返回一个带有ACK请求给服务端,连接正常关闭

## 1.4 基于TCP协议的socket套接字编程 ##

### 1.4.1 服务端 ###

import socket
    
    # 1. 符合TCP协议的手机
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # TCP
    
    # 2. 绑定手机号 110
    server.bind(('127.0.0.1', 8000))  # 127.0.0.1代表本地
    # server.bind(('192.168.11.210',8000))  # 127.0.0.1代表本地
    
    server.listen(5)  # 半连接池
    
    # 3. 等待客户端连接
    print('start...')
    # 链接循环
    
    
    while True:
        # 通信循环
        conn, client_addr = server.accept()
        while True:
            try:
                # 4. 收到消息receive
                data = conn.recv(1024)
                print(data)
    
                # 5. 回消息
                conn.send(data.upper())
            except ConnectionAbortedError:
                continue
            except ConnectionResetError:
                break

### 1.4.2 客户端 ###

import socket
    
    # 1. 创建符合TCp协议的手机
    client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    
    # 2. 拨号
    client.connect(('127.0.0.1',8000))
    
    while True:
        msg = input('please enter your msg')  # dir
        # 3. 发送消息
        client.send(msg.encode('utf8'))
    
        # 4. 接收消息
        data = client.recv(1024)
        print(data)

## 1.5 模拟ssh远程执行命令 ##

在客户端处模拟ssh发送指令,服务端通过subprocess执行该命令,然后返回命令的结果

### 1.5.1 服务端 ###

import socket
    import subprocess
    
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    
    server.bind(('192.168.11.210', 8000))
    server.listen(5)
    
    print('start...')
    while True:
        conn, client_addr = server.accept()
        print(client_addr)
    
        while True:
            try:
                cmd = conn.recv(1024)  # dir
                print(cmd)
    
                # 帮你执行cmd命令,然后把执行结果保存到管道里
                pipeline = subprocess.Popen(cmd.decode('utf8'),
                                            shell=True,
                                            stderr=subprocess.PIPE,
                                            stdout=subprocess.PIPE)
    
                stderr = pipeline.stderr.read()
                stdout = pipeline.stdout.read()
    
                conn.send(stderr)
                conn.send(stdout)
    
            except ConnectionResetError:
                break

### 1.5.2 客户端 ###

import socket
    
    # 1. 创建符合TCp协议的手机
    client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    
    # 2. 拨号
    client.connect(('192.168.11.210',8000))
    
    while True:
        msg = input('please enter your msg')  # dir
        # 3. 发送消息
        client.send(msg.encode('utf8'))
    
        # 4. 接收消息
        data = client.recv(10)
        print(data.decode('gbk'))

## 1.6 粘包问题 ##

产生的原因：

1.  两个数据非常小,然后间隔时间又短
2.  数据太大,一次取不完,下一次还会取这个大数据

## 1.7 解决粘包问题 ##

1.  在传数据之前,传一个数据的大小,数据的大小必须得定长

## 1.8 基于UDP协议的socket套接字编程 ##

*  UDP无连接
 *  更加适用于传输数据量较小的场景，对数据完整性要求不高
 *  DNS解析服务使用的就是UDP协议。

### 1.8.1 服务端 ###

import socket
    
    server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    server.bind(('127.0.0.1', 8000))
    
    print('start...')
    while True:
        data, client_addr = server.recvfrom(1024)
        print(client_addr)
        print(data)
        server.sendto(data.upper(), client_addr)

### 1.8.2 客户端 ###

import socket
    
    client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    
    while True:
        msg = input('please enter your msg:')
        client.sendto(msg.encode('utf8'), ('127.0.0.1', 8000))
    
        data = client.recvfrom(1024)
        print(data)

## 1.9 基于socketserver实现并发的socket套接字编程 ##

*  让服务端同时和多个客户端进行连接,以前我们写的是一个警局有五部电话只有一个人,现在写的是五部电话五个人

### 1.9.1 服务端 ###

# 同一时刻有多个人在接听
    import socketserver
    import subprocess
    import struct
    
    
    class MyHandler(socketserver.BaseRequestHandler):
        # 通信循环
        def handle(self):
    
            while True:
                try:
                    cmd = self.request.recv(1024)
                    print(cmd)
    
                    pipeline = subprocess.Popen(cmd.decode('utf8'),
                                                shell=True,
                                                stderr=subprocess.PIPE,
                                                stdout=subprocess.PIPE)
    
                    stdout = pipeline.stdout.read()
                    stderr = pipeline.stderr.read()
    
                    count_len = len(stdout) + len(stderr)
                    guding_bytes = struct.pack('i', count_len)
    
                    self.request.send(guding_bytes)  # 4
    
                    self.request.send(stderr + stdout)
    
                except ConnectionResetError:
                    break
    
    
    # 使用socketserver的连接循环(并发),但是使用了自己的通信循环
    # myhandler = MyHandler()
    if __name__ == '__main__':
        server = socketserver.ThreadingTCPServer(('127.0.0.1', 8000), MyHandler, bind_and_activate=True)
        print('start...')
        server.serve_forever()

转载于:https://www.cnblogs.com/chenych/p/11227761.html