09-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协议

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

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

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

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

1.2.4.2 UDP协议

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

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

优点：效率高

1.2.5 应用层

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

1.2.6 Socket抽象层

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

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

1.3.1 三次握手建立连接

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

1.3.2 四次挥手断开连接

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

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

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

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

客户端返回一个带有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.7 解决粘包问题

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

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()