QuecPython 网络协议之TCP/UDP协议最祥解析

概述

IP 地址与域名

IP 地址是网络中的主机地址，用于两台网络主机能够互相找到彼此，这也是网络通信能够成功进行的基础。IP 地址一般以点分十进制的字符串来表示，如192.168.1.1。

我们日常访问的网站，其所在的服务器主机都有唯一的 IP 地址，网络中的主机不计其数，靠记 IP 地址的方式来区分不同的主机显然比较困难，并且同一个网站可能有多个不同的 IP 地址，或者 IP 地址会因为某种原因而更换。

因此，用域名表示网站地址的方式便应运而生，如我们常见的www.baidu.com比 IP 地址更容易被记住。因为实际的网络通信报文中使用的仍然是 IP 地址，所以需要使用域名解析协议去获取域名背后所对应的 IP 地址。

下文的讲解均以 IPv4 协议为基础。

OSI 七层模型

国际标准化组织（ISO）制定的一个用于计算机或通信系统的标准体系，一般被称为 OSI（Open System Interconnection）七层模型。它为网络通信协议的实现提供了一个标准，通信双方在相同的层使用相同的协议，即可进行通信；就同一台设备而言，下层协议为上层协议提供了调用接口，将上层协议打包为底层协议，最终发送到网络上进行传输。

这七层分别为：应用层、表示层、会话层、传输层、网络层、数据链路层、物理层。

为了简化协议实现或者方便理解，五层模型或者四层模型的概念也诞生了。四层模型一般被提及的比较多，包括：应用层、传输层、网络层、网络接口层。

上文中的 IP 地址则属于网络层。

网络层用于把该主机所有的网络数据转发到网卡，经由物理层电路发送到网络中去。

为了方便阐述，下文将按照四层模型来进行讲解。

传输层协议

IP 地址解决了网络中两台主机如何能够找到彼此，进而进行报文收发的问题。

试想下，一台主机上可能运行着多个应用程序，执行着不同的网络任务。这时，某台 IP 地址的主机收到了另一台主机的报文，这个报文数据要传递给哪个应用程序呢？

为了解决这个问题，人们基于网络层协议演化出了传输层协议，传输层协议为本地的网络应用分配不同的端口。收到网络层的报文后，根据不同的端口号，将数据递交给不同的应用。

为了应对不同的场景，传输层协议分为 UDP 和 TCP 协议。

UDP 协议

UDP 协议具有以下特点：

无连接
支持一对一、一对多和多对多通信
不保证可靠交付
全双工通信
面向报文

根据不同的需求，基于 UDP 衍生出了一些应用层协议，不同的应用会默认指定一个端口号。端口号亦可根据实际情况更换。

TCP 协议具有以下特点：

面向连接
每条连接只能有两个端点，即点对点
提供可靠的数据交付
全双工通信
面向字节流

根据不同的需求，基于 TCP 衍生出了一些应用层协议，不同的应用会默认指定一个端口号。端口号亦可根据实际情况更换

TCP 网络编程

在开始 TCP 网络编程之前，我们先通过下图，初步了解下 TCP 服务器与客户端的 socket 编程模型：

TCP 客户端网络编程

上图的右侧是最简的 TCP 客户端编程的接口调用流程：

调用socket()接口创建 socket 对象。
调用connect()接口连接服务器。
调用send()接口向服务器发送数据。
调用recv()接口接收服务器下发的数据。
循环执行第 3 步和第 4 步，业务满足一定条件或连接断开，调用close()接口关闭 socket，释放资源。

几乎所有编程语言实现的 socket 接口，默认都是阻塞模式的，即所有涉及到网络报文收发的接口，如connect()、send()、recv()、close()等，默认都是阻塞式接口。

TCP 服务器与客户端的 socket 编程模型示意图的左侧展示了服务器编程的接口调用流程：

调用socket()接口创建 socket 对象。
调用bind()接口绑定本地的地址和端口。
调用listen()接口监听客户端连接请求。
调用accept()接口接受客户端连接请求。
调用recv()接口接收客户端上行的数据。
调用send()接口向客户端发送数据。
每一个客户端连接中，循环执行第 5 步和第 6 步，业务满足一定条件或连接断开，调用close()接口关闭 socket，释放资源。
在接受客户端连接请求的线程中，循环执行第 4 步，以接受更多的客户端接入。

TCP 服务器编程调用的接口相比客户端，多了bind()、listen()、accept()三个接口。

TCP 服务器代码如下：

import usocket
import _thread

def _client_conn_proc(conn, ip_addr, port):
    while True:
        try:
            # Receive data sent by the client
            data = conn.recv(1024)
            print('[server] [client addr: %s, %s] recv data:' % (ip_addr, port), data)

            # Send data back to the client
            conn.send(data)
        except:
            # Exception occurred and connection closed
            print('[server] [client addr: %s, %s] disconnected' % (ip_addr, port))
            conn.close()
            break

def tcp_server(address, port):
    # Create a socket object
    sock = usocket.socket(usocket.AF_INET, usocket.SOCK_STREAM, usocket.IPPROTO_TCP_SER)
    print('[server] socket object created.')

    # Bind the server IP address and port
    sock.bind((address, port))
    print('[server] bind address: %s, %s' % (address, port))

    # Listen for client connection requests
    sock.listen(10)
    print('[server] started, listening ...')

    while True:
        # Accept a client connection request
        cli_conn, cli_ip_addr, cli_port = sock.accept()
        print('[server] accept a client: %s, %s' % (cli_ip_addr, cli_port))

        # Create a new thread for each client connection for concurrent processing
        _thread.start_new_thread(_client_conn_proc, (cli_conn, cli_ip_addr, cli_port))

TCP客户端代码如下

import usocket
import _thread

def _client_conn_proc(conn, ip_addr, port):
    while True:
        try:
            # Receive data sent by the client
            data = conn.recv(1024)
            print('[server] [client addr: %s, %s] recv data:' % (ip_addr, port), data)

            # Send data back to the client
            conn.send(data)
        except:
            # Exception occurred and connection closed
            print('[server] [client addr: %s, %s] disconnected' % (ip_addr, port))
            conn.close()
            break

def tcp_server(address, port):
    # Create a socket object
    sock = usocket.socket(usocket.AF_INET, usocket.SOCK_STREAM, usocket.IPPROTO_TCP_SER)
    print('[server] socket object created.')

    # Bind the server IP address and port
    sock.bind((address, port))
    print('[server] bind address: %s, %s' % (address, port))

    # Listen for client connection requests
    sock.listen(10)
    print('[server] started, listening ...')

    while True:
        # Accept a client connection request
        cli_conn, cli_ip_addr, cli_port = sock.accept()
        print('[server] accept a client: %s, %s' % (cli_ip_addr, cli_port))

        # Create a new thread for each client connection for concurrent processing
        _thread.start_new_thread(_client_conn_proc, (cli_conn, cli_ip_addr, cli_port))

主流程代码如下：

import checkNet
import _thread
import utime
import dataCall

if __name__ == '__main__':
    stage, state = checkNet.waitNetworkReady(30)
    if stage == 3 and state == 1: # Network connection is normal
        print('[net] Network connection successful.')

        # Get the IP address of the module
        server_addr = dataCall.getInfo(1, 0)[2][2]
        server_port = 80

        # Start the server thread to listen for client connection requests
        _thread.start_new_thread(udp_server, (server_addr, server_port))

        # Delay for a while to ensure that the server starts successfully
        print('sleep 3s to ensure that the server starts successfully.')
        utime.sleep(3)

        # Start the client
        udp_client(server_addr, server_port)
    else:
        print('[net] Network connection failed, stage={}, state={}'.format(stage, state))

UDP网络编程

在开始 UDP 网络编程之前，我们先通过下图，初步了解下 UDP 服务器与客户端的 socket 编程模型：

从图中可以看出，UDP 服务器也需要调用bind()接口，绑定本地的 IP 地址和端口号，这是作为服务器所必须的接口调用。

同时，UDP 编程在接口调用上也有与 TCP 编程不同之处：

socket()接口参数不同：
- TCP 编程时，第二个参数type为usocket.SOCK_STREAM，而 UDP 编程时，第二个参数type为usocket.SOCK_DGRAM。
- TCP 编程时，第三个参数proto为usocket.IPPROTO_TCP或usocket.IPPROTO_TCP_SER，而 UDP 编程时，第三个参数proto为usocket.IPPROTO_UDP。
由于 UDP 是无连接的，客户端无需调用connect()接口去连接服务器。
数据发送方只要直接调用sendto()接口将数据发送出去即可。
数据接收方调用recvfrom()接口接收数据。

sendto()接口是否能真正将数据发送到目的地，视网络环境而定，如果无法找到目标 IP 地址对应的主机，则数据被丢弃。

接下来，我们做一个实验：在模组中分别编写一个 UDP 服务器程序和一个 UDP 客户端程序，客户端周期性向服务器发送数据，而后等待服务器回送数据。

有了前面 TCP 编程的经验，我们直接给出实验代码

import usocket
import _thread
import utime
import checkNet
import dataCall

def udp_server(address, port):
    # Create a socket object
    sock = usocket.socket(usocket.AF_INET, usocket.SOCK_DGRAM, usocket.IPPROTO_UDP)
    print('[server] socket object created.')

    # Bind server IP address and port
    sock.bind((address, port))
    print('[server] bind address: %s, %s' % (address, port))

    while True:
        # Read client data
        data, sockaddr = sock.recvfrom(1024)
        print('[server] [client addr: %s] recv data: %s' % (sockaddr, data))

        # Send data back to the client
        sock.sendto(data, sockaddr)

def udp_client(address, port):
    # Create a socket object
    sock = usocket.socket(usocket.AF_INET, usocket.SOCK_DGRAM, usocket.IPPROTO_UDP)
    print('[client] socket object created.')

    data = b'1234567890'
    while True:
        # Send data to the server
        sock.sendto(data, (address, port))
        print('[client] send data:', data)

        # Read data sent back from the server
        data, sockaddr = sock.recvfrom(1024)
        print('[client] [server addr: %s] recv data: %s' % (sockaddr, data))
        print('[client] -------------------------')

        # Delay for 1 second
        utime.sleep(1)

if __name__ == '__main__':
    stage, state = checkNet.waitNetworkReady(30)
    if stage == 3 and state == 1: # Network connection is normal
        print('[net] Network connection successful.')

        # Get the IP address of the module
        server_addr = dataCall.getInfo(1, 0)[2][2]
        server_port = 80

        # Start the server thread
        _thread.start_new_thread(udp_server, (server_addr, server_port))

        # Delay for a while to ensure that the server starts successfully
        print('sleep 3s to ensure that the server starts successfully.')
        utime.sleep(3)

        # Start the client
        udp_client(server_addr, server_port)
    else:
        print('[net] Network connection failed, stage={}, state={}'.format(stage, state))