《TCP/IP网络编程》学习笔记 | Chapter 6：基于UDP的服务器端/客户端

本篇文章简单描述了UDP传输协议的工作原理及特点。

理解UDP

UDP和TCP一样同属于TCP/IP协议栈的第二层，即传输层。

UDP套接字的特点

• 提供的是一种不可靠的数据传输服务。
• 从通信速度上来讲，UDP通常是要快于TCP的；每次交换的数据量越大，TCP的传输速率就越接近于UDP。
• UDP在通信结构上较TCP更为简洁，通常性能也要优于TCP。
• 没有流控制机制。

区分TCP和UDP最重要的标志是流控制，流控制赋予了TCP可靠性的特点，也说TCP的生命在于流控制。

UDP内部工作原理

可以看出，IP的作用就是让离开主机B的UDP数据包准确传递到主机A，而UDP则是把UDP包最终交给主机A的某一UDP套接字。UDP最重要的作用就是根据端口号将传输到主机的数据包交付给最终的UDP套接字。

UDP的高效使用

TCP用于对可靠性要求较高的场景，比如要传输一个重要文件或是压缩包，这种情况往往丢失一个数据包就会引起严重的问题；而对于多媒体数据来说，丢失一部分数据包并没有太大问题，因为实时性更为重要，速度就成为了重要考虑因素。TCP慢于UDP主要在于以下两点：

• 收发数据前后进行的连接及清理过程。
• 收发数据过程中为保证可靠性而添加的流控制。

因此，如果收发的数据量小但需要频繁的连接时，UDP比TCP更为高效。

实现基于UDP的服务器端/客户端

UDP中的服务器端和客户端没有连接

和TCP不同，UDP服务器端/客户端并不需要在连接状态下交换数据。不必调用listen和accept函数。UDP的通信只有创建套接字和数据交换的过程。

UDP服务器端和客户端均只需1个套接字

TCP套接字是一对一的关系，且服务器端还需要一个额外的TCP套接字用于监听连接请求；而UDP通信中，无论服务器端还是客户端都只需要一个套接字即可，且可以实现一对多的通信关系。

下图展示了一个UDP套接字与两台主机进行数据交换的过程。

基于UDP的数据I/O函数

TCP套接字建立连接之后，数据传输过程便无需额外添加地址信息，因为TCP套接字会保持与对端的连接状态；而UDP则没有这种连接状态，因此每次数据交换过程都需要添加目标地址信息。下面是UDP套接字数据传输函数，与TCP传输函数最大的区别在于，该函数需要额外添加传递目标的地址信息。

#include <sys/socket.h>

ssize_t sendto(int sock, void *buff, size_t nbytes, int flags, struct sockaddr *to, socklen_t addrlen);

成功时返回传输的字节数，失败时返回-1。

参数：

• sock：这是套接字描述符，是一个整数值，唯一标识了一个打开的套接字。
• buff：指向要发送的数据缓冲区的指针。
• nbytes：要发送的数据的长度（以字节为单位）。
• flags：这是一个选项标志，用于修改 sendto 函数的行为，没有则为0。
• to：指向目标地址的指针，该地址结构包含了目的主机的网络地址信息。
• addrlen：目的地址结构 (to) 的长度。

由于UDP数据的发送端并不固定，因此，UDP套接字的数据接收函数定义了存储发送端地址信息的数据结构。

#include <sys/socket.h>

ssize_t recvfrom(int sock, void *buff, size_t nbytes, int flags, struct sockaddr *from, socklen_t addrlen);

成功时返回接收的字节数，失败时返回-1。

参数：

• sock：这是套接字描述符，是一个整数值，唯一标识了一个打开的套接字。
• buff：指向一个缓冲区的指针，用于存储接收到的数据。
• nbytes：缓冲区的长度（以字节为单位）。
• flags：这是一个选项标志，用于修改 recvfrom 函数的行为，没有则为0。
• from：指向一个sockaddr结构的指针，用于存储发送方的地址信息。
• addrlen：发送方地址结构 (from) 的长度。

基于UDP的回声服务器端/客户端

UDP通信函数调用流程：

UDP不同于TCP，不存在请求连接和受理连接的过程，因此某种意义上并没有明确的服务器端和客户端之分。如下是示例源码。

uecho_server.c：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define BUF_SIZE 30
void error_handling(char *message);

int main(int argc, char *argv[])
{
    int serv_sock;
    char message[BUF_SIZE];
    int str_len;
    socklen_t clnt_adr_sz;
    struct sockaddr_in serv_adr, clnt_adr;
    if (argc != 2)
    {
        printf("Usage : %s <port>\n", argv[0]);
        exit(1);
    }
    serv_sock = socket(PF_INET, SOCK_DGRAM, 0);
    if (serv_sock == -1)
        error_handling("UDP socket creation error");
    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family = AF_INET;
    serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_adr.sin_port = htons(atoi(argv[1]));
    if (bind(serv_sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) == -1)
        error_handling("bind() error");
    while (1)
    {
        clnt_adr_sz = sizeof(clnt_adr);
        str_len = recvfrom(serv_sock, message, BUF_SIZE, 0,
                           (struct sockaddr *)&clnt_adr, &clnt_adr_sz);
        sendto(serv_sock, message, str_len, 0,
               (struct sockaddr *)&clnt_adr, clnt_adr_sz);
    }
    close(serv_sock);
    return 0;
}

void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

uecho_client.c：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define BUF_SIZE 30
void error_handling(char *message);

int main(int argc, char *argv[])
{
    int sock;
    char message[BUF_SIZE];
    int str_len;
    socklen_t adr_sz;

    struct sockaddr_in serv_adr, from_adr;
    if (argc != 3)
    {
        printf("Usage : %s <IP> <port>\n", argv[0]);
        exit(1);
    }

    sock = socket(PF_INET, SOCK_DGRAM, 0);
    if (sock == -1)
        error_handling("socket() error");

    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family = AF_INET;
    serv_adr.sin_addr.s_addr = inet_addr(argv[1]);
    serv_adr.sin_port = htons(atoi(argv[2]));

    while (1)
    {
        fputs("Insert message(q to quit): ", stdout);
        fgets(message, sizeof(message), stdin);
        if (!strcmp(message, "q\n") || !strcmp(message, "Q\n"))
            break;

        sendto(sock, message, strlen(message), 0,
               (struct sockaddr *)&serv_adr, sizeof(serv_adr));
        adr_sz = sizeof(from_adr);
        str_len = recvfrom(sock, message, BUF_SIZE, 0,
                           (struct sockaddr *)&from_adr, &adr_sz);

        message[str_len] = 0;
        printf("Message from server: %s", message);
    }
    close(sock);
    return 0;
}

void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

示例代码运行结果：

UDP客户端套接字的地址分配

从上述示例源码来看，服务器端UDP套接字需要手动bind地址信息，而客户端UDP套接字则无此过程。我们已经知道，客户端TCP套接字是在调用connect函数的时机，由操作系统为我们自动绑定了地址信息；而客户端UDP套接字同样存在该过程，如果没有手动bind地址信息，则在首次调用sendto函数时自动分配IP和端口号等地址信息。和TCP一样，IP是主机IP，端口号则随机分配（客户的临时端口是在第一次调用sendto函数时一次性选定，不能改变；然而客户的IP地址却可以随客户发送的每个UDP数据报而变动（如果客户没有绑定一个具体的IP地址到其套接字上）。其原因在于如果客户主机是多宿的，客户有可能在两个目的地之间交替选择）。

UDP数据传输特性和调用connect函数

之前我们介绍了TCP传输数据不存在数据边界，下面将会验证UDP数据传输存在数据边界的特性，并介绍UDP传输调用connect函数的作用。

存在数据边界的UDP套接字

UDP协议具有数据边界，这就意味着数据交换的双方输入函数和输出函数必须一一对应，这样才能保证可完整接收数据。如下是验证UDP存在数据边界的示例源码。

bound_host1.c：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define BUF_SIZE 30
void error_handling(char *message);

int main(int argc, char *argv[])
{
    int sock;
    char message[BUF_SIZE];
    struct sockaddr_in my_adr, your_adr;
    socklen_t adr_sz;
    int str_len, i;

    if (argc != 2)
    {
        printf("Usage : %s <port>\n", argv[0]);
        exit(1);
    }

    sock = socket(PF_INET, SOCK_DGRAM, 0);
    if (sock == -1)
        error_handling("socket() error");

    memset(&my_adr, 0, sizeof(my_adr));
    my_adr.sin_family = AF_INET;
    my_adr.sin_addr.s_addr = htonl(INADDR_ANY);
    my_adr.sin_port = htons(atoi(argv[1]));

    if (bind(sock, (struct sockaddr *)&my_adr, sizeof(my_adr)) == -1)
        error_handling("bind() error");

    for (i = 0; i < 3; i++)
    {
        sleep(5); // delay 5 sec.
        adr_sz = sizeof(your_adr);
        str_len = recvfrom(sock, message, BUF_SIZE, 0,
                           (struct sockaddr *)&your_adr, &adr_sz);

        printf("Message %d: %s \n", i + 1, message);
    }
    close(sock);
    return 0;
}

void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

bound_host2.c：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define BUF_SIZE 30
void error_handling(char *message);

int main(int argc, char *argv[])
{
    int sock;
    char message[BUF_SIZE];
    struct sockaddr_in my_adr, your_adr;
    socklen_t adr_sz;
    int str_len, i;

    if (argc != 2)
    {
        printf("Usage : %s <port>\n", argv[0]);
        exit(1);
    }

    sock = socket(PF_INET, SOCK_DGRAM, 0);
    if (sock == -1)
        error_handling("socket() error");

    memset(&my_adr, 0, sizeof(my_adr));
    my_adr.sin_family = AF_INET;
    my_adr.sin_addr.s_addr = htonl(INADDR_ANY);
    my_adr.sin_port = htons(atoi(argv[1]));

    if (bind(sock, (struct sockaddr *)&my_adr, sizeof(my_adr)) == -1)
        error_handling("bind() error");

    for (i = 0; i < 3; i++)
    {
        sleep(5); // delay 5 sec.
        adr_sz = sizeof(your_adr);
        str_len = recvfrom(sock, message, BUF_SIZE, 0,
                           (struct sockaddr *)&your_adr, &adr_sz);

        printf("Message %d: %s \n", i + 1, message);
    }
    close(sock);
    return 0;
}

void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

示例代码运行结果：

发送方调用了3次sendto函数发送数据，接收方的recvfrom函数调用间隔为5s，因此，数据早就传输到了缓冲区中。如果是TCP程序，这时只需要调用一次输入函数即可读入数据。UDP则不同，必须调用3次recvfrom函数。

调用connect函数的UDP套接字

TCP套接字需要手动注册传输数据的目标IP和端口号，而UDP则是调用sendto函数时自动完成目标地址信息的注册，该过程如下：

• 第一阶段：向UDP套接字注册目标IP和端口号
• 第二阶段：传输数据
• 第三阶段：删除UDP套接字中注册的目标地址信息

每次调用sendto函数都会重复执行以上过程，这也是为什么同一个UDP套接字可和不同目标进行数据交换的原因。像UDP这种未注册目标地址信息的套接字称为未连接套接字，而TCP这种注册了目标地址信息的套接字称为连接connected套接字。当需要和同一目标主机进行长时间通信时，UDP的这种无连接的特点则会非常低效。通过调用connect函数使UDP变为已连接套接字则会有效改善这一点，因为上述的第一阶段和第三阶段会占用整个通信过程近1/3的时间。

已连接的UDP套接字不仅可以使用之前的sendto和recvfrom函数，还可以使用没有地址信息参数的write和read函数。

需要注意的是，调用connect函数的已连接UDP套接字并非真的与目标UDP套接字建立连接，仅仅是向本端UDP套接字注册了目标IP和端口号信息而已。

修改之前的uecho_client代码为已连接UDP套接字，代码如下所示：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define BUF_SIZE 30
void error_handling(char *message);

int main(int argc, char *argv[])
{
    int sock;
    char message[BUF_SIZE];
    int str_len;
    socklen_t adr_sz;

    struct sockaddr_in serv_adr, from_adr;
    if (argc != 3)
    {
        printf("Usage : %s <IP> <port>\n", argv[0]);
        exit(1);
    }

    sock = socket(PF_INET, SOCK_DGRAM, 0);
    if (sock == -1)
        error_handling("socket() error");

    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family = AF_INET;
    serv_adr.sin_addr.s_addr = inet_addr(argv[1]);
    serv_adr.sin_port = htons(atoi(argv[2]));

    connect(sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr));

    while (1)
    {
        fputs("Insert message(q to quit): ", stdout);
        fgets(message, sizeof(message), stdin);
        if (!strcmp(message, "q\n") || !strcmp(message, "Q\n"))
            break;
        /*
        sendto(sock, message, strlen(message), 0,
                    (struct sockaddr*)&serv_adr, sizeof(serv_adr));
        */
        write(sock, message, strlen(message));

        /*
        adr_sz=sizeof(from_adr);
        str_len=recvfrom(sock, message, BUF_SIZE, 0,
                    (struct sockaddr*)&from_adr, &adr_sz);
        */
        str_len = read(sock, message, sizeof(message) - 1);

        message[str_len] = 0;
        printf("Message from server: %s", message);
    }
    close(sock);
    return 0;
}

void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

拓展：关于recvfrom函数

recvfrom是一个阻塞函数，那么该函数的返回时机是怎样的？

显然如果客户端正常收到应答数据，recvfrom自然可以返回。但如果发生其他情况呢？

对端调用close函数关闭UDP套接字时是否会发送EOF信息，本端recvfrom函数又会有什么动作吗？是否会像TCP套接字的read函数那样收到EOF信息而返回0？

由于UDP套接字无连接的特性，即使对端调用close函数关闭套接字，本端也不会有任何感知，recvfrom自然不会返回。那如果是调用了connect函数的已连接UDP套接字呢，服务端的close函数调用是否会使客户端的recvfrom函数退出阻塞状态？

仍然不会。因为调用connect函数的已连接UDP套接字并非真的像TCP套接字那样建立了连接，仅仅是为了数据交换的便利性向本端UDP套接字注册了目标地址信息而已；而对端并不能感知到这些，close函数自然也不会向TCP那样向本端发送文件结束标志EOF。因此，正常情况下，只有接收到发送端消息的recvfrom函数才会退出阻塞状态而返回。

如果一个客户端数据报丢失（譬如说，被客户主机与服务主机之间的某个路由器丢弃），客户端将永远阻塞于recvfrom 调用，等待一个永远不会到达的服务器应答。类似地，如果客户端数据报到达服务器，但是服务器的应答丢失了，客户端也将永远阻塞于recvfrom 调用。防止这样永久阻塞的一般方法是给客户端的recvfrom 调用设置一个超时时间。

基于 Windows 的实现

数据I/O函数

sendto 函数和 recvfrom函数的参数及其含义与 Linux 无太大区别。

#include <winsock2.h>

int sendto(SOCKET s, const char *buf, int len, int flags, const struct sockaddr *to, int tolen);

成功时返回传输的字节数，失败时返回SOCKET_ERROR。

#include <winsock2.h>

int recvfrom(SOCKET s, char *buf, int len, int flags, struct sockaddr *from, int fromlen);

成功时返回接收的字节数，失败时返回SOCKET_ERROR。

基于 Windows 的 UDP 回声服务器端/客户端

uecho_server_win.c：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>

#define BUF_SIZE 30

void ErrorHanding(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    SOCKET serverSock;
    SOCKADDR_IN serverAddr, clientAddr;
    int clientAddrSize;

    int strLen;
    char message[BUF_SIZE];

    if (argc != 2)
    {
        printf("Usage: %s <port>\n", argv[0]);
        exit(1);
    }

    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
        ErrorHanding("WSAStartup() error!");

    serverSock = socket(PF_INET, SOCK_DGRAM, 0);
    if (serverSock == INVALID_SOCKET)
        ErrorHanding("socket() error!");

    memset(&serverAddr, 0, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serverAddr.sin_port = htons(atoi(argv[1]));

    if (bind(serverSock, (SOCKADDR *)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR)
        ErrorHanding("bind() error!");

    while (1)
    {
        clientAddrSize = sizeof(clientAddr);
        strLen = recvfrom(serverSock, message, BUF_SIZE, 0, (SOCKADDR *)&clientAddr, &clientAddrSize);
        sendto(serverSock, message, strLen, 0, (SOCKADDR *)&clientAddr, clientAddrSize);
    }

    closesocket(serverSock);
    WSACleanup();

    return 0;
}

uecho_client_win.c：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>

#define BUF_SIZE 1024

void ErrorHanding(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    SOCKET sock;
    SOCKADDR_IN serverAddr, fromAddr;
    int fromAddrSize;

    int strLen;
    char message[BUF_SIZE];

    if (argc != 3)
    {
        printf("Usage: %s <IP> <port>\n", argv[0]);
        exit(1);
    }

    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
        ErrorHanding("WSAStartup() error!");

    sock = socket(PF_INET, SOCK_DGRAM, 0);
    if (sock == INVALID_SOCKET)
        ErrorHanding("sock() error!");

    memset(&serverAddr, 0, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = inet_addr(argv[1]);
    serverAddr.sin_port = htons(atoi(argv[2]));

    while (1)
    {
        fputs("Insert message(q to quit): ", stdout);
        fgets(message, BUF_SIZE, stdin);
        if (!strcmp(message, "q\n") || !strcmp(message, "Q\n"))
            break;

        sendto(sock, message, strlen(message), 0, (SOCKADDR *)&serverAddr, sizeof(serverAddr));
        fromAddrSize = sizeof(fromAddr);
        strLen = recvfrom(sock, message, BUF_SIZE, 0, (SOCKADDR *)&fromAddr, &fromAddrSize);

        message[strLen] = '\0';
        printf("Message from server: %s", message);
    }

    closesocket(sock);
    WSACleanup();

    return 0;
}

编译：

gcc uecho_server_win.c -lwsock32 -o uechoServWin
gcc uecho_client_win.c -lwsock32 -o uechoClntWin

运行结果：

// 服务器端
C:\Users\81228\Documents\Program\TCP IP Project\Chapter 6>uechoServWin 9190

// 客户端
C:\Users\81228\Documents\Program\TCP IP Project\Chapter 6>uechoClntWin 127.0.0.1 9190
Insert message(q to quit): Hi UDP Server?
Message from server: Hi UDP Server?
Insert message(q to quit): Nicew to meet you!
Message from server: Nicew to meet you!
Insert message(q to quit): Good bye~
Message from server: Good bye~
Insert message(q to quit): q

基于 Windows 的存在数据边界的 UDP 套接字

bound_host1_win.c：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>

#define BUF_SIZE 30

void ErrorHanding(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    SOCKET serverSock;
    SOCKADDR_IN serverAddr, clientAddr;
    int clientAddrSize;

    int strLen;
    char message[BUF_SIZE];

    if (argc != 2)
    {
        printf("Usage: %s <port>\n", argv[0]);
        exit(1);
    }

    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
        ErrorHanding("WSAStartup() error!");

    serverSock = socket(PF_INET, SOCK_DGRAM, 0);
    if (serverSock == INVALID_SOCKET)
        ErrorHanding("socket() error!");

    memset(&serverAddr, 0, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serverAddr.sin_port = htons(atoi(argv[1]));

    if (bind(serverSock, (SOCKADDR *)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR)
        ErrorHanding("bind() error!");

    for (int i = 0; i < 3; i++)
    {
        Sleep(5000);
        clientAddrSize = sizeof(clientAddr);
        strLen = recvfrom(serverSock, message, BUF_SIZE, 0, (SOCKADDR *)&clientAddr, &clientAddrSize);
        printf("Message %d: %s\n", i + 1, message);
    }

    closesocket(serverSock);
    WSACleanup();

    return 0;
}

bound_host2_win.c：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>

void ErrorHanding(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    SOCKET sock;
    SOCKADDR_IN serverAddr;

    char msg1[] = "Hi!";
    char msg2[] = "I'm another UDP host!";
    char msg3[] = "Nice to meet you.";

    if (argc != 3)
    {
        printf("Usage: %s <IP> <port>\n", argv[0]);
        exit(1);
    }

    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
        ErrorHanding("WSAStartup() error!");

    sock = socket(PF_INET, SOCK_DGRAM, 0);
    if (sock == INVALID_SOCKET)
        ErrorHanding("sock() error!");

    memset(&serverAddr, 0, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = inet_addr(argv[1]);
    serverAddr.sin_port = htons(atoi(argv[2]));

    sendto(sock, msg1, sizeof(msg1), 0, (SOCKADDR *)&serverAddr, sizeof(serverAddr));
    sendto(sock, msg2, sizeof(msg2), 0, (SOCKADDR *)&serverAddr, sizeof(serverAddr));
    sendto(sock, msg3, sizeof(msg3), 0, (SOCKADDR *)&serverAddr, sizeof(serverAddr));

    closesocket(sock);
    WSACleanup();

    return 0;
}

编译：

gcc bound_host1_win.c -lwsock32 -o boundHost1
gcc bound_host2_win.c -lwsock32 -o boundHost2

运行结果：

// 服务器端
C:\Users\81228\Documents\Program\TCP IP Project\Chapter 6>boundHost1 9190
Message 1: Hi!
Message 2: I'm another UDP host!
Message 3: Nice to meet you.

// 客户端
C:\Users\81228\Documents\Program\TCP IP Project\Chapter 6>boundHost2 127.0.0.1 9190

基于 Windows 的已连接 UDP 套接字

uecho_con_client_win.c：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>

#define BUF_SIZE 1024

void ErrorHanding(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    SOCKET sock;
    SOCKADDR_IN serverAddr, fromAddr; // 不再需要 fromAddr
    int fromAddrSize;                 // 多余变量

    int strLen;
    char message[BUF_SIZE];

    if (argc != 3)
    {
        printf("Usage: %s <IP> <port>\n", argv[0]);
        exit(1);
    }

    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
        ErrorHanding("WSAStartup() error!");

    sock = socket(PF_INET, SOCK_DGRAM, 0);
    if (sock == INVALID_SOCKET)
        ErrorHanding("sock() error!");

    memset(&serverAddr, 0, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = inet_addr(argv[1]);
    serverAddr.sin_port = htons(atoi(argv[2]));

    connect(sock, (SOCKADDR *)&serverAddr, sizeof(serverAddr));

    while (1)
    {
        fputs("Insert message(q to quit): ", stdout);
        fgets(message, BUF_SIZE, stdin);
        if (!strcmp(message, "q\n") || !strcmp(message, "Q\n"))
            break;

        /*
        sendto(sock, message, strlen(message), 0, (SOCKADDR *)&serverAddr, sizeof(serverAddr));
        */
        send(sock, message, strlen(message), 0);

        /*
        fromAddrSize = sizeof(fromAddr);
        strLen = recvfrom(sock, message, BUF_SIZE, 0, (SOCKADDR *)&fromAddr, &fromAddrSize);
        */
        strLen = recv(sock, message, sizeof(message) - 1, 0);

        message[strLen] = '\0';
        printf("Message from server: %s", message);
    }

    closesocket(sock);
    WSACleanup();

    return 0;
}

习题

（1）UDP为什么比TCP速度快？为什么TCP数据传输可靠而UDP数据传输不可靠？

UDP是面向报文、无连接的传输层协议。UDP尽最大努力交付数据但不保证可靠传输。

TCP有流控制和重传机制保证数据传输可靠，而UDP没有这些机制。

（2）下列不属于UDP特点的是？

a. UDP不同于TCP，不存在连接的概念，所以不像TCP那样只能进行一对一的数据传输。
b. 利用UDP传输数据时，如果有2个目标，则需要2个套接字。
c. UDP套接字中无法使用已分配给TCP的同一端口号。
d. UDP套接字和TCP套接字可以共存。若需要，可以在同一主机进行TCP和UDP数据传输。
e. 针对UDP可以调用connect函数，此时UDP套接字和TCP套接字相同，也需要经过3次握手过程。

答：b、c、e。

（3）UDP数据包向对方主机的UDP套接字传递过程中，IP和UDP分别负责哪些部分？

IP负责链路选择，让UDP数据包准确传递到目的主机。

UDP负责端到端的传输，根据端口号将传输到主机的数据包交付给最终的UDP套接字。

（4）UDP一般比TCP快，但根据交换数据的特点，其差异可大可小。请说明何种情况下UDP的性能优于TCP？

TCP于UDP传输过程最大不同就是TCP要先建立连接，数据传输结束还要断开连接。所以在传输数据少，又要频繁传输数据的情况下，UDP简单轻巧的优势就凸显出来了。

（5）客户端TCP套接字调用connect函数时自动分配IP和端口号。UDP中不调用bind函数，那何时分配IP和端口号？

如果没有手动bind地址信息，则在首次调用sendto函数时自动分配IP和端口号等地址信息（IP是主机IP，端口号则随机分配）。

（6）TCP客户端必须调用connect函数，而UDP中可以选择性调用。请问，在UDP中调用connect函数有哪些好处？

每当以UDP套接字为对象调用sendto函数时，都要经过以下过程：

• 第一阶段：向UDP套接字注册目标和端口号
• 第二阶段：数据传输
• 第三阶段：删除UDP套接字中注册的IP和端口号

如果调用connect函数，就可以忽略每次传输数据时反复进行的第一阶段和第三阶段。然而，调用connect函数并不意味着经过连接过程，只是将IP地址和端口号绑定在UDP套接字上。这样connect函数使用后，还可以用write、read函数进行数据处理，不需要sendto、recvfrom函数指定目的地址。

（7）请参考本章给出的uecho_sever.c和uecho_client.c，编写示例使服务器端和客户端轮流收发消息。收发的消息均要输出到控制台窗口。

定义协议：

• 客户端先发，服务端先收
• 收发的消息均要输出到控制台窗口

6_7_server.c：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>

#define BUF_SIZE 30

void ErrorHanding(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    SOCKET serverSock;
    SOCKADDR_IN serverAddr, clientAddr;
    int clientAddrSize;

    int strLen;
    char message[BUF_SIZE];

    if (argc != 2)
    {
        printf("Usage: %s <port>\n", argv[0]);
        exit(1);
    }

    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
        ErrorHanding("WSAStartup() error!");

    serverSock = socket(PF_INET, SOCK_DGRAM, 0);
    if (serverSock == INVALID_SOCKET)
        ErrorHanding("socket() error!");

    memset(&serverAddr, 0, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serverAddr.sin_port = htons(atoi(argv[1]));

    if (bind(serverSock, (SOCKADDR *)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR)
        ErrorHanding("bind() error!");

    while (1)
    {
        clientAddrSize = sizeof(clientAddr);
        strLen = recvfrom(serverSock, message, BUF_SIZE, 0, (SOCKADDR *)&clientAddr, &clientAddrSize);
        printf("Message from client: %s\n", message);

        fputs("Insert message(q to quit): ", stdout);
        fgets(message, BUF_SIZE, stdin);
        if (!strcmp(message, "q\n") || !strcmp(message, "Q\n"))
            break;

        sendto(serverSock, message, strlen(message), 0, (SOCKADDR *)&clientAddr, clientAddrSize);
        printf("Message send to client: %s\n", message);
    }

    closesocket(serverSock);
    WSACleanup();

    return 0;
}

6_7_client.c：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>

#define BUF_SIZE 30

void ErrorHanding(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    SOCKET sock;
    SOCKADDR_IN serverAddr, fromAddr;
    int fromAddrSize;

    int strLen;
    char message[BUF_SIZE];

    if (argc != 3)
    {
        printf("Usage: %s <IP> <port>\n", argv[0]);
        exit(1);
    }

    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
        ErrorHanding("WSAStartup() error!");

    sock = socket(PF_INET, SOCK_DGRAM, 0);
    if (sock == INVALID_SOCKET)
        ErrorHanding("sock() error!");

    memset(&serverAddr, 0, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = inet_addr(argv[1]);
    serverAddr.sin_port = htons(atoi(argv[2]));

    while (1)
    {
        fputs("Insert message(q to quit): ", stdout);
        fgets(message, BUF_SIZE, stdin);
        if (!strcmp(message, "q\n") || !strcmp(message, "Q\n"))
            break;

        sendto(sock, message, strlen(message), 0, (SOCKADDR *)&serverAddr, sizeof(serverAddr));
        printf("Message send to server: %s\n", message);

        fromAddrSize = sizeof(fromAddr);
        strLen = recvfrom(sock, message, BUF_SIZE, 0, (SOCKADDR *)&fromAddr, &fromAddrSize);

        message[strLen] = '\0';
        printf("Message from server: %s\n", message);
    }

    closesocket(sock);
    WSACleanup();

    return 0;
}

编译：

gcc 6_7_server.c -lwsock32 -o 6_7_server
gcc 6_7_client.c -lwsock32 -o 6_7_client

运行结果：

// 服务器端
C:\Users\81228\Documents\Program\TCP IP Project\Chapter 6>6_7_server 9199
Message from client: Hi!I'm client.

Insert message(q to quit): Hello!I'm server.
Message send to client: Hello!I'm server.

Message from client: Nice to meet you.

Insert message(q to quit): Nice to meet you too.
Message send to client: Nice to meet you too.

Message from client: Good bye!
et you too.

Insert message(q to quit): Bye bye!
Message send to client: Bye bye!

// 客户端
C:\Users\81228\Documents\Program\TCP IP Project\Chapter 6>6_7_client 127.0.0.1 9199
Insert message(q to quit): Hi!I'm client.
Message send to server: Hi!I'm client.

Message from server: Hello!I'm server.

Insert message(q to quit): Nice to meet you.
Message send to server: Nice to meet you.

Message from server: Nice to meet you too.

Insert message(q to quit): Good bye!
Message send to server: Good bye!

Message from server: Bye bye!

Insert message(q to quit): q