第5章 基于 TCP 的服务端/客户端（2）

5.1 回声客户端的完美实现

        先回顾一下服务器端的 I/O 相关代码：

//持续接收客户端发送的数据，并将数据原样发送回客户端，直到客户端关闭连接。
while ((str_len = read(clnt_sock, message, BUF_SIZE)) != 0)//read函数从clnt_sock套接字中读取数据，并将其存储在message缓冲区中。BUF_SIZE是缓冲区的大小，用于指定每次最大读取的字节数。read函数返回读取的字节数。
    write(clnt_sock, message, str_len);//从客户端接收到的消息写入clnt_sock套接字，将其发送回客户端。

        接着是客户端代码:

//将message字符串中的数据写入到sock套接字中，发送给服务器。strlen(message)计算了消息的长度，确保将整个消息发送给服务器。
write(sock, message, strlen(message));
//从sock套接字中读取服务器的响应，并将其存储在message缓冲区中。
str_len = read(sock, message, BUF_SIZE - 1);

        二者都在循环调用 read 和 write 函数。实际上之前的回声客户端将 100% 接受字节传输的数据，只不过接收数据时的单位有些问题。扩展客户端代码回顾范围，下面是，客户端的代码:

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

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

    write(sock, message, strlen(message));
    str_len = read(sock, message, BUF_SIZE - 1);
    message[str_len] = 0;
    printf("Message from server: %s", message);
}

        回声客户端使用write()函数一次性发送整个消息字符串，然后使用read()函数尝试接收数据。但是，read()函数的工作方式是按照字节流来接收数据，它没有办法知道服务器端发送的消息的边界。

        这个问题其实很容易解决，因为可以提前接受数据的大小。若之前传输了20字节长的字符串，则再接收时循环调用 read 函数读取 20 个字节即可。既然有了解决办法，那么代码如下：

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

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

int main(int argc, char *argv[])
{
    int sock;
    char message[BUF_SIZE];
    int str_len, recv_len, recv_cnt;
    struct sockaddr_in serv_adr;

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

    sock = socket(PF_INET, SOCK_STREAM, 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]));

    if (connect(sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) == -1)
        error_handling("connect() error!");
    else
        puts("Connected...........");

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

        if (!strcmp(message, "q\n") || !strcmp(message, "Q\n"))
            break;
        str_len = write(sock, message, strlen(message));

        recv_len = 0;
        //接收所有传输数据而循环调用 read 函数
        while (recv_len < str_len)
        {
            recv_cnt = read(sock, &message[recv_len], BUF_SIZE - 1);
            if (recv_cnt == -1)
                error_handling("read() error");
            recv_len += recv_cnt;
        }
        message[recv_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);
}

                如果问题不在于回声客户端：定义应用层协议

回声客户端可以提前知道接收数据的长度，这在大多数情况下是不可能的。那么此时无法预知接收数据长度时应该如何收发数据？这时需要的是应用层协议的定义。在收发过程中定好规则（协议）以表示数据边界，或者提前告知需要发送的数据的大小。服务端/客户端实现过程中逐步定义的规则集合就是应用层协议。

现在写一个小程序来体验应用层协议的定义过程。要求：

1. 服务器从客户端获得多个数组和运算符信息。
2. 服务器接收到数字候对齐进行加减乘运算，然后把结果传回客户端。

例：

1. 向服务器传递3,5,9的同事请求加法运算，服务器返回3+5+9的结果
2. 请求做乘法运算，客户端会收到3*5*9的结果
3. 如果向服务器传递4,3,2的同时要求做减法，则返回4-3-2的运算结果。

实现代码：

        服务器代码：

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

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

char res[10];
//解析该字符串并进行加法、乘法或减法运算，并将结果存储在全局变量res中。最后，返回指向res的指针。
char *calc(char *s)
{
    int len = strlen(s), i;
    int n = 0;
    for (i = 0; i < len; i++)
        if (s[i] == ' ')
        {
            i++;
            break;
        }
        else
            n = n * 10 + (s[i] - '0');
    int *num = malloc(sizeof(int) * n);
    int tot = 0, x = 0;

    for (; i < len; i++)
    {
        if (s[i] == '+' || s[i] == '*' || s[i] == '-')
            break;
        if (s[i] == ' ')
        {
            num[tot++] = x;
            x = 0;
        }
        else
            x = x * 10 + (s[i] - '0');
    }
    int ans = 0;
    if (s[i] == '+')
    {
        for (int i = 0; i < tot; i++)
            ans += num[i];
    }
    else if (s[i] == '*')
    {
        ans = 1;
        for (int i = 0; i < tot; i++)
            ans *= num[i];
    }
    else if (s[i] == '-')
    {
        ans = num[0];
        for (int i = 1; i < tot; i++)
            ans -= num[i];
    }
    free(num);
    sprintf(res, "%d", ans);
    return res;
}

int main(int argc, char *argv[])
{
    int serv_sock, clnt_sock;
    char message[BUF_SIZE];
    int str_len;

    struct sockaddr_in serv_adr, clnt_adr;
    socklen_t clnt_adr_sz;

    if (argc != 2)
    {
        printf("Usage : %s <port>\n", argv[0]);
        exit(1);
    }
    //创建一个套接字serv_sock
    serv_sock = socket(PF_INET, SOCK_STREAM, 0);
    if (serv_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 = 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");
    //调用listen()函数将套接字设置为监听状态，指定等待连接的队列长度为5。
    if (listen(serv_sock, 5) == -1)
        error_handling("listen() error");

    clnt_adr_sz = sizeof(clnt_adr);
    //使用accept()函数等待客户端连接。一旦有客户端连接请求到达，它将创建一个新的套接字clnt_sock来处理该连接，并获取客户端地址信息。
    clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_adr, &clnt_adr_sz);
    if (clnt_sock == -1)
        error_handling("accept() error");
    //使用read()函数从clnt_sock读取客户端发送的消息，并将其存储在message缓冲区中。
    str_len = read(clnt_sock, message, BUF_SIZE);
    //调用calc()函数对接收到的消息进行计算，并将结果使用write()函数发送回客户端。
    write(clnt_sock, calc(message), str_len);
    close(clnt_sock);
    close(serv_sock);
    return 0;
}

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

        客户端代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#define BUF_SIZE 10240
void error_handling(char *message);

int main(int argc, char *argv[])
{
    int sock;
    char message[BUF_SIZE];
    int str_len;
    struct sockaddr_in serv_adr;
    if (argc != 3)
    {
        printf("Usage : %s <IP> <port>\n", argv[0]);
        exit(1);
    }
    //创建一个套接字sock，并使用socket()函数来创建一个TCP套接字。
    sock = socket(PF_INET, SOCK_STREAM, 0);
    if (sock == -1)
        error_handling("socket() error");
    //设置服务器地址serv_adr的相关信息，包括地址族、服务器IP地址和端口号。
    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()函数连接到服务器。如果连接成功，打印"连接成功"的提示信息。
    if (connect(sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) == -1)
        error_handling("connect() error");
    else
        printf("连接成功!\n");
    int n, i;
    char temp[20];
    //获取要进行计算的数字个数n，并将其转换为字符串形式，然后将其添加到message字符串中。
    puts("请输入你要计算的数字个数:");
    scanf("%d", &n);
    sprintf(temp, "%d", n);
    strcat(temp, " ");
    strcat(message, temp);
    for (i = 0; i < n; i++)
    {
        printf("请输入第 %d 个数字:", i + 1);
        scanf("%s", temp);
        strcat(temp, " ");
        strcat(message, temp);
    }
    puts("请输入你要进行的运算符(+,-,*):");
    scanf("%s", temp);
    strcat(message, temp);
    //使用write()函数将message字符串发送到服务器，发送的长度为strlen(message)。
    write(sock, message, strlen(message));
    str_len = read(sock, message, BUF_SIZE - 1);
    message[str_len] = 0;
    printf("运算的结果是: %s\n", message);
    return 0;
}
void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

        运行结果：

 5.2 TCP 原理

TCP 套接字中的 I/O 缓冲：

        TCP 套接字的数据收发无边界。服务器即使调用 1 次 write 函数传输 40 字节的数据，客户端也有可能通过 4 次 read 函数调用每次读取 10 字节。但此处也有一些疑问，服务器一次性传输了 40 字节，而客户端竟然可以缓慢的分批接受。客户端接受 10 字节后，剩下的 30 字节在何处等候呢？

        实际上，write 函数调用后并非立即传输数据， read 函数调用后也并非马上接收数据。如图所示，write 函数调用瞬间，数据将移至输出缓冲；read 函数调用瞬间，从输入缓冲读取数据。

I/O 缓冲特性可以整理如下：

• I/O 缓冲在每个 TCP 套接字中单独存在
• I/O 缓冲在创建套接字时自动生成
• 即使关闭套接字也会继续传递输出缓冲中遗留的数据
• 关闭套接字将丢失输入缓冲中的数据

TCP 不会发生超过输入缓冲大小的数据传输，因为 TCP 会控制数据流。TCP 中有滑动窗口（Sliding Window）协议，用对话方式如下：

• A：你好，最多可以向我传递 50 字节
• B：好的
• A：我腾出了 20 字节的空间，最多可以接受 70 字节
• B：好的

 数据收发也是如此，因此 TCP 中不会因为缓冲溢出而丢失数据。

TCP 内部工作原理 1：与对方套接字的连接 

TCP 套接字从创建到消失所经过的过程分为如下三步：

• 与对方套接字建立连接
• 与对方套接字进行数据交换
• 断开与对方套接字的连接

首先讲解与对方套接字建立连接的过程。连接过程中，套接字的对话如下：

• 套接字A：你好，套接字 B。我这里有数据给你，建立连接吧
• 套接字B：好的，我这边已就绪
• 套接字A：谢谢你受理我的请求

        TCP 在实际通信中也会经过三次对话过程，因此，该过程又被称为 Three-way handshaking（三次握手）。接下来给出连接过程中实际交换的信息方式：

套接字是全双工方式工作的。也就是说，它可以双向传递数据。因此，收发数据前要做一些准备。首先请求连接的主机 A 要给主机 B 传递以下信息：

[SYN] SEQ : 1000 , ACK:-

         SEQ的含义为：现在传递的数据包的序号为 1000，如果接收无误，请通知我向您传递 1001 号数据包。

        这是首次请求连接时使用的消息，又称为 SYN。SYN 是 Synchronization 的简写，表示收发数据前传输的同步消息。接下来主机 B 向 A 传递以下信息：

[SYN+ACK] SEQ: 2000, ACK: 1001

        SEQ 为 2000 、ACK 1001 的含义如下：

SEQ: 现传递的数据包号为 2000 ，如果接受无误，请通知我向您传递 2001 号数据包。

ACK: 刚才传输的 SEQ 为 1000 的数据包接受无误，现在请传递 SEQ 为 1001 的数据包。

        对于主机 A 首次传输的数据包的确认消息（ACK 1001）和为主机 B 传输数据做准备的同步消息（SEQ 2000）捆绑发送。因此，此种类消息又称为 SYN+ACK。 

        收发数据前向数据包分配序号，并向对方通报此序号，这都是为了防止数据丢失做的准备。通过向数据包分配序号并确认，可以在数据包丢失时马上查看并重传丢失的数据包。因此 TCP 可以保证可靠的数据传输。

        最后，主机A向主机B传输消息：

[ACK] SEQ : 1001 , ACK:2001

        此时数据包传递以下信息：已正确接收到SEQ为2000的数据包，现在可以传输SEQ为2001的数据包。 

        至此，主机A和主机B确认了彼此均就绪。

---

TCP 内部工作原理 2：与对方主机的数据交换

        通过第一步三次握手过程完成了数据交换准备，下面就开始正式收发数据，其默认方式如图所示：

        图上给出了主机 A 分成 2 个数据包向主机 B 传输 200 字节的过程。首先，主机 A 通过 1 个数据包发送 100 个字节的数据，数据包的 SEQ 为 1200 。主机 B 为了确认这一点，向主机 A 发送 ACK 1301 消息。

        此时的 ACK 号为 1301 而不是 1201，原因在于 ACK 号的增量为传输的数据字节数。假设每次 ACK 号不加传输的字节数，这样虽然可以确认数据包的传输，但无法明确 100 个字节全都正确传递还是丢失了一部分，比如只传递了 80 字节。因此按照如下公式传递 ACK 信息：

ACK 号 = SEQ 号 + 传递的字节数 + 1

         与三次握手协议相同，最后 + 1 是为了告知对方下次要传递的 SEQ 号。下面分析传输过程中数据包丢失的情况：

        上图表示了通过 SEQ 1301 数据包向主机 B 传递 100 字节数据。但中间发生了错误，主机 B 未收到，经过一段时间后，主机 A 仍然未收到对于 SEQ 1301 的 ACK 的确认，因此试着重传该数据包。为了完成该数据包的重传，TCP 套接字启动计时器以等待 ACK 应答。若相应计时器发生超时（Time-out!）则重传。

---

TCP 内部工作原理 3：断开套接字的连接 

        TCP 套接字的结束过程也非常优雅。如果对方还有数据需要传输时直接断掉该连接会出问题，所以断开连接时需要双方协商，断开连接时双方的对话如下：

• 套接字A：我希望断开连接
• 套接字B：哦，是吗？请稍后。
• 套接字A：我也准备就绪，可以断开连接。
• 套接字B：好的，谢谢合作。

        先由套接字 A 向套接字 B 传递断开连接的信息，套接字 B 发出确认收到的消息，然后向套接字 A 传递可以断开连接的消息，套接字 A 同样发出确认消息。 

        图中数据包内的 FIN 表示断开连接。也就是说，双方各发送 1 次 FIN 消息后断开连接。此过过程经历 4 个阶段，因此又称四次握手（Four-way handshaking）。SEQ 和 ACK 的含义与之前讲解的内容一致，省略。图中，主机 A 传递了两次 ACK 5001，也许这里会有困惑。其实，第二次 FIN 数据包中的 ACK 5001 只是因为接收了 ACK 消息后未接收到的数据重传的。

---

习题：

1、请说明 TCP 套接字连接设置的三次握手过程。尤其是 3 次数据交换过程每次收发的数据内容。

        TCP套接字的生命周期主要可分为3个部分: ①与对方套接字建立连接 ②与对方套接字进行数据交换 ③断开与对方套接字的连接。

        其中,在第一步建立连接的阶段,又可细分为3个步骤(即三次握手)：①由主机1给主机2发送初始的SEQ，首次连接请求是关键字是SYN，表示收发数据前同步传输的消息,此时报文的ACK一般为空。②主机2收到报文以后，给主机 1 传递信息，用一个新的SEQ表示自己的序号，然后ACK代表已经接受到主机1的消息，希望接受下一个消息③主机1收到主机2的确认以后，还需要给主机2给出确认，此时再发送一次SEQ和ACK。

2、TCP 是可靠的数据传输协议，但在通过网络通信的过程中可能丢失数据。请通过 ACK 和 SEQ 说明 TCP 通过和何种机制保证丢失数据的可靠传输。

        序列号用于对发送的每个字节进行编号，接收方通过确认号告知发送方已成功接收的字节。通过序列号和确认号的配对，TCP可以跟踪数据的传输和确认情况，并在需要时进行重传。此外，TCP还使用滑动窗口机制、超时重传、流量控制和拥塞控制等机制来进一步确保数据的可靠传输。这些机制使得TCP在面对网络不稳定性和丢包时能够有效地保证数据的正确性、完整性和可达性。

3、TCP 套接字中调用 write 和 read 函数时数据如何移动？结合 I/O 缓冲进行说明。

        TCP 套接字调用 write 函数时，数据将移至输出缓冲，在适当的时候，传到对方输入缓冲。这时对方将调用 read 函数从输入缓冲中读取数据。

4、对方主机的输入缓冲剩余 50 字节空间时，若本主机通过 write 函数请求传输 70 字节，请问 TCP 如何处理这种情况？

        TCP 中有滑动窗口控制协议，所以传输的时候会保证传输的字节数小于等于自己能接受的字节数。