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 客户端编程的接口调用流程：

1. 调用socket()接口创建 socket 对象。

2. 调用connect()接口连接服务器。

3. 调用send()接口向服务器发送数据。

4. 调用recv()接口接收服务器下发的数据。

5. 循环执行第 3 步和第 4 步，业务满足一定条件或连接断开，调用close()接口关闭 socket，释放资源。

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

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

1. 调用socket()接口创建 socket 对象。

2. 调用bind()接口绑定本地的地址和端口。

3. 调用listen()接口监听客户端连接请求。

4. 调用accept()接口接受客户端连接请求。

5. 调用recv()接口接收客户端上行的数据。

6. 调用send()接口向客户端发送数据。

7. 每一个客户端连接中，循环执行第 5 步和第 6 步，业务满足一定条件或连接断开，调用close()接口关闭 socket，释放资源。

8. 在接受客户端连接请求的线程中，循环执行第 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))

常见问题：

1. 为什么连接服务器会失败？

 服务器必须是公网地址（连接模组本地的 server 除外）。

使用 PC上 的 TCP/UDP 测试工具客户端、或者 mqtt.fx，连接服务器确认一下是否可以连接成功，排除服务器故障。 

2. TCP 有自动重连功能吗？

底层没有自动重连，重连机制在应用层处理。

3.为什么我一包数据只有不到 50B，一天消耗的流量要远远大于实际传输值

如果使用的是 TCP 协议，需要三次握手四次挥手才算完成了一次数据交互，原始数据不多但是由于 TCP 协议决定的一包数据必须要加包头包尾帧校验等，所以实际消耗的流量不止 50B，部分运营商有限制每一包数据必须 1KB 起发，不足 1KB 也会加各种校验凑足 1KB。