Windows 环境下的 Socket 编程 4 - 基于 UDP 的服务器/客户端

在 TCP 中，套接字之间应该是一对一的关系。若向 10 个客户端提供服务，则除了守门的服务器套接字外，还需要 10 个服务器端套接字。但在 UDP 中，不管是服务器端还是客户端都只需要 1 个套接字。

基于 UDP 的数据 I/O 函数

UDP 套接字不会保持连接状态，因此每次传输数据都要添加目标地址信息。

1. sendto 函数

//发送数据函数，成功返回传输的字节数，失败时返回 -1
int sendto(SOCKET s,const char *buf,int len,int flags,const struct sockaddr *to,int tolen);
1
2

• s：套接字
• buf：指向待传输数据的缓冲区
• len：待传输数据的长度
• flags：可选参数，若没有则传递 0
• to：指向包含目的地址信息的 sockaddr 结构体变量
• tolen：变量 to 的长度

2. recvfrom 函数

//接收数据函数，成功时返回接收的字节数，失败时返回 -1
int WSAAPI recvfrom(SOCKET s,char *buf,int len,int flags,struct sockaddr *from,int *fromlen);
1
2

• s：套接字
• buff：指向保存接收数据的缓冲区
• len：可接收的最大字节数
• flags：可选参数，若没有则传入 0
• from：指向包含发送端地址信息的 sockaddr 结构体变量
• fromlen：指向保存变量 from 长度的变量

什么时候调用 recvfrom ，当操作系统接收到 UDP 数据， 会自动通知（回调）应用程序吗？
如果 len 很小，对方又发送大数据包，如何知道接收缓冲区的数据大小，以方便多次读取？
如果 len 很大，recvfrom 函数会一直等待吗？

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

UDP 不同于 TCP，不存在请求连接和受理过程，因此在某种意义上无法明确区分服务器端和客户端。只是因其提供服务而称为服务器端。
服务器端实现：

#include 
#include 
#include 

void ErrorHandler(char *message);

#define BUF_SIZE 1024
int main(int argc, char *argv[])
{
    WSADATA wsaData;
    SOCKET hServSock, hClntSock;
    struct sockaddr_in servAddr, clntAddr;
    int szClntAddr;
    char message[BUF_SIZE];
    int strLen, i;
    if(argc != 2)
    {
        printf ("Usage: %s \n", argv[0]);
        exit(1);
    }

    if(WSAStartup(MAKEWORD(2,2), &wsaData) != 0)
        ErrorHandler("WSAStartup failed");

    hServSock = socket(PF_INET, SOCK_DGRAM, 0);
    if(hServSock == INVALID_SOCKET)
        ErrorHandler("socket error");
    
    memset(&servAddr, 0, sizeof(servAddr));
    servAddr.sin_family = AF_INET;
    servAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servAddr.sin_port = htons(atoi(argv[1]));

    if(bind(hServSock, (struct sockaddr *)&servAddr, sizeof(servAddr)) == SOCKET_ERROR)
        ErrorHandler("bind socket error");
    
    while(1)
    {
        strLen = recvfrom(hServSock, message, BUF_SIZE, 0, (struct sockaddr *)&clntAddr, &szClntAddr);
        sendto(hServSock, message, strLen, 0, (struct sockaddr *)&clntAddr, sizeof(clntAddr));
    }
    closesocket(hServSock);
    WSACleanup();
    return 0;
}

void ErrorHandler(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

客户端实现：

#include 
#include 
#include 
#include 

#define BUF_SIZE    1024
void ErrorHandler(char *message);

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    SOCKET hClntSock;
    struct sockaddr_in servAddr,fromAddr;
    char message[BUF_SIZE];
    int strLen;
    int adr_sz;
    if(argc != 3)
    {
        printf ("Usage: %s  \n", argv[0]);
        exit(1);
    }

    if(WSAStartup(MAKEWORD(2,2), &wsaData) != 0)
        ErrorHandler("WSAStartup failed");

    hClntSock = socket(PF_INET, SOCK_DGRAM, 0);
    if(hClntSock == INVALID_SOCKET)
        ErrorHandler("socket error");
    
    memset(&servAddr, 0, sizeof(servAddr));
    servAddr.sin_family = AF_INET;
    servAddr.sin_addr.s_addr = inet_addr(argv[1]);
    servAddr.sin_port = htons(atoi(argv[2]));


    while(1)
    {
        fputs("Input message(Q to quit): ",stdout);
        fgets(message, BUF_SIZE, stdin);

        if(!strcmp(message, "q\n") ||!strcmp(message, "Q\n"))
            break;

        sendto(hClntSock, message, strlen(message), 0, (struct sockaddr *)&servAddr, sizeof(servAddr));
        strLen = recvfrom(hClntSock, message, BUF_SIZE, 0, (struct sockaddr *)&fromAddr, &adr_sz);
        message[strLen] = 0;
        printf("Message from server: %s", message);
    }
    
    closesocket(hClntSock);
    WSACleanup();
    return 0;
}

void ErrorHandler(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

UDP 套接字存在数据边界

TCP 数据传输不存在边界，这表示数据传输过程中调用 I/O 函数的次数不具有任何意义。但是，UDP 是具有数据边界的协议，传输中调用 I/O 函数的次数非常重要。调用 3 次 sendto 发送的函数要调用 3 次 recvfrom 函数才能接收完。

已连接的 UDP 套接字

使用 sendto 函数，每次都要传入目标地址信息，这在某些场合会低效且繁琐，已连接的 UDP 套接字可以解决这个问题。

1. connect 函数：创建已连接的 UDP 套接字

/*成功返回 0 ，失败返回 SOCKET_ERROR */
int connect(SOCKET s, const struct sockaddr *name, int namelen);
1
2

这个函数参数与 TCP 相同，但是结果不同，TCP 调用这个函数会进行 3 次握手，UDP 调用这个函数只是注册目标 IP 和端口信息。
一旦调用 connect 函数后，就不必使用 sendto 和 recvfrom 函数发送和接收数据，取而代之的是和 TCP 相同的 API 函数：send 和 recv 。