09-1 网络编程知识总结

目录

• 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.4.1 TCP协议
      • 1.2.4.2 UDP协议
    • 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的请求个客户端

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

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

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

4. 客户端返回一个带有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()