TCP/IP网络编程之基于TCP的服务端/客户端（一）

理解TCP和UDP

根据数据传输方式的不同，基于网络协议的套接字一般分为TCP套接字和UDP套接字。因为TCP套接字是面向连接的，因此又称为基于流（stream）的套接字。TCP是Transmission Control Protocol（传输控制协议）的简写，意为“对数据传输过程的控制”。因此，学习控制方法及范围有助于正确理解TCP套接字

TCP/IP协议栈

讲解TCP前先介绍TCP所属的TCP/IP协议栈（Stack，层），如图1-1所示：

图1-1   TCP/IP协议栈

从图1-1可以看出，TCP/IP协议栈共分为四层，可以理解为数据收发分成了四个层次化过程。也就是说，面对“基于互联网的有效数据传输”的命题，并非通过一个庞大的协议解决问题，而是通过层次化方案——TCP/IP协议栈解决，通过TCP套接字收发数据需要借助四层，如图1-2所示：

图1-2   TCP协议栈

反之，通过UDP套接字收发数据时，利用图1-2的四层协议栈来完成：

图1-3   UDP协议栈

各层可能通过操作系统等软件实现，也可能通过类似NIC的硬件设备实现

TCP/IP协议的诞生背景

“通过因特网完成有效数据传输”这个课题让许多专家聚集到一起，不同人负责不同模块，如：硬件、系统、路由。为什么要这样做呢？因为编写软件前需要构建硬件系统，在此基础上需要通过软件实现各种算法，所以才需要众多领域的专家进行讨论，以形成各种规定。把“通过因特网完成有效数据传输”问题按照不同领域划分成小问题后，出现了多种协议，它们通过层级结构建立紧密联系

把协议分成多个层次具有哪些优点？协议设计更容易？这是优点之一，但更重要的原因是：为了通过标准化操作设计开放式系统。标准本身就在于对外公开，引导更多人遵循。以多个标准为依据所设计的系统称为开放式系统，我们现在学习的TCP/IP协议栈也属于其中之一。那么开放式系统具有哪些优点呢？比方：路由器用来完成IP层交互任务，某公司原先使用A路由器，可将其替换成B路由器，即便A、B这两种路由器并非同一产商也可以顺利替换，因为所有的路由器生产产商都会按照IP层标准制造

再举个例子，大家的计算机一般都装有网卡（网络接口卡），即便没安装也没关系，网卡很容易买到，因为所有的网卡制造商都会遵守链路层的协议标准，这就是开放式系统的优点

链路层

接下来逐层了解TCP/IP协议栈，先讲链路层。链路层是物理链接领域标准化的结果，也是最基本的领域，专门定义LAN、WAN、MAN等网络标准。若两台主机通过网络进行数据进行交换，则需要图1-4所示的物理连接，链路层就负责这些标准：

图1-4   网络连接结构

IP层

准备好物理连接后就要传输数据，为了在复杂的网络中传输数据，首先需要考虑路径的选择。向目标传输数据需要经过哪条路径？解决此问题就是IP层，该层使用的协议就是IP。IP本身是面向消息的、不可靠的协议。每次传输数据时会帮我们选择路径，但每次传输时的路径并不一致。如果传输中发生路径错误，则选择其他路径；但如果发生数据丢失或损坏，则无法解决。换言之，IP协议无法应对数据错误

TCP/UDP层

IP层解决数据传输中的路径选择问题，只需照此路径传输数据即可。TCP和UDP层以IP层提供的路径信息为基础完成实际的数据传输，故该层又称传输层。UDP比TCP简单，我们后面还会在讨论，现在只解释TCP。TCP可以保证可靠的数据传输，但它发送数据时以IP层为基础，IP层是面向消息的，是不可靠的，那TCP又是如何保证消息的可靠传输呢？

IP层只关注一个数据包（数据传输的基本单位）的传输过程。因此，即使传输多个数据包，每个数据包也是由IP层实际传输的，也就是说传输顺序及传输本身都是不可靠的。若只利用IP层传输数据，则有可能后发送的数据包比早发生的数据包先到达目标主机。另外，传输的数据包A、B、C中可能只收到A和C，B可能丢失或接收到时已损坏。但若添加TCP协议则会按照如图1-5的方式进行数据传输：

图1-5   传输控制协议

我们可以看到，当主机A发送1号数据包给主机B时，必须等到主机B确认1号数据包接收成功，才会接着发送2号数据包，如果主机A发送1号数据包却迟迟收不到主机B回复的接收成功，则会认为是超时，并重新发送一个1号数据包

实现基于TCP的服务端/客户端

图1-6给出了TCP服务器端默认的函数调用顺序，大部分TCP服务器端都按照该顺序调用

图1-6   TCP服务端函数调用顺序

调用socket函数创建套接字，声明并初始化地址信息结构体变量，调用bind函数向套接字分配地址。这两个阶段之前都讨论过了，下面讲解之后的几个过程

进入等待连接请求状态

我们已调用bind函数给套接字分配了地址，接下来就要通过调用listen函数进入等待连接请求状态。只有调用了listen函数，服务端套接字才能进入可接收连接的状态，换言之，这时，客户端才能调用connect函数（若提前调用则会发生错误）

#include <sys/socket.h>
int listen(int sockfd, int backlog);//成功时返回0，失败时返回-1

　　

• sock：希望进入等待连接请求状态的套接字文件描述符，传递的描述符套接字参数成为服务端套接字（监听套接字）
• backlog：连接请求等待队列（Queue）的长度，若为5，则队列长度为5，表示最多使5个连接请求进入队列

先解释一下等待连接请求状态的含义和连接请求等待队列。“服务器端处于等待连接请求状态”是指，客户端请求连接时，服务器端受理连接前一直处于等待状态，当有多个客户端一起发送连接请求时，服务器端套接字只能处理一个连接请求，而其他的连接请求，只能暂时放在请求队列，即listen函数的第二个参数

受理客户端连接请求

调用listen函数后，若有新的连接请求，则应按序受理。受理请求意味着进入可接收数据的状态，这里进入这种状态的所需部件当然还是套接字，可能有人会想使用服务器端套接字，但服务器端套接字已经用于监听，如果将其用于与客户端交换数据，那么谁来监听客户端的连接请求呢？因此需要另外一个套接字，但没必要亲自创建，accept函数将自动创建套接字，并连接到发起请求的客户端

#include <sys/socket.h>
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);//成功时返回创建的套接字文件描述符，失败时返回-1

　　

• sock：服务器套接字的文件描述符
• addr：保存发起连接请求的客户端地址信息的变量地址值，调用函数后向传递来的地址变量参数填充客户端地址信息
• addrlen：第二个参数addr结构体的长度，但是存有长度的变量地址。函数调用完成后，该变量即被填入客户端地址长度

accept函数受理连接请求等待队列中待处理的客户端连接请求，函数调用成功时，accept函数内部将产生用于数据I/O的套接字，并返回其文件描述符。需要强调的是，套接字是自动创建的，并自动与发起连接请求的客户端建立连接

这里，我们重新回顾TCP/IP网络编程之网络编程和套接字这一章中的hello_server.c

hello_server.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
 
void error_handling(char *message);
 
int main(int argc, char *argv[])
{
    int serv_sock;
    int clnt_sock;
 
    struct sockaddr_in serv_addr;
    struct sockaddr_in clnt_addr;
    socklen_t clnt_addr_size;
 
    char message[] = "Hello world!";
 
    if (argc != 2)
    {
        printf("Usage: %s <port>\n", argv[0]);
        exit(1);
    }
 
    serv_sock = socket(AF_INET, SOCK_STREAM, 0); 
    if (serv_sock == -1)
        error_handling("sock() error");
 
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(atoi(argv[1]));
 
    if (bind(serv_sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1) 
        error_handling("bind() error");
 
    if (listen(serv_sock, 5) == -1) 
        error_handling("listen() error");
 
    clnt_addr_size = sizeof(clnt_addr);
    clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_addr, &clnt_addr_size); 
    if (clnt_sock == -1)
        error_handling("accept() error");
 
    write(clnt_sock, message, sizeof(message)); 
    close(clnt_sock);
    close(serv_sock);
 
    return 0;
}
 
void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

　　

• 第27行：服务器端实现过程中先要创建套接字，但此时的套接字尚未是真正的服务器端套接字
• 第31~37行：为了完成套接字地址分配，初始化结构体变量并调用bind函数
• 第39行：调用accept函数从队列的顶部取出一个连接请求与客户端建立连接，并返回创建的套接字文件描述符。另外，调用accept函数时若等待队列为空，则accept函数不会返回，直到队列中出现新的客户端连接
• 第47~49行：调用write函数向客户端传输数据，调用close函数关闭连接

TCP客户端的默认函数调用顺序

接下来讲解客户端的实现顺序，我们前面说过，客户端的套接字实现比服务器端要简单的多，因为创建套接字和请求连接就是客户端的全部内容，如图1-7：

图1-7   TCP客户端函数调用顺序

与服务器端相比，区别就在于“请求连接”，它是创建客户端套接字后向服务器端发起的连接请求。服务器端调用listen函数后创建连接请求等待队列，之后客户端即可请求连接。那如何发起连接请求呢？通过connect函数完成：

#include <sys/socket.h>
int connect(int sock_fd, struct sockaddr *serv_addr, socklen_t addrlen);//成功时返回0，失败时返回-1

　　

•  sock：客户端套接字文件描述符
• serv_addr：保存目标服务器端地址信息的变量地址值
• addrlen：以字节为单位传递已传递给第二个结构体参数serv_addr的地址变量长度

客户端调用connect函数后，发生以下情况之一才会返回：

• 服务器端接收连接请求
• 发生断网等异常情况而中断连接请求

需要注意，所谓的“接收连接”并不意味着服务器端调用accept函数，其实是服务器端把连接请求信息记录到等待队列，因此connect函数返回后并不立即进行数据交换

这里，我们再回顾之前的hello_client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
 
void error_handling(char *message);
 
int main(int argc, char *argv[])
{
    int sock;
    struct sockaddr_in serv_addr;
    char message[30];
    int str_len;
 
    if (argc != 3)
    {
        printf("Usage: %s <IP> <port>\n", argv[0]);
        exit(1);
    }
 
    sock = socket(AF_INET, SOCK_STREAM, 0); 
    if (sock == -1)
        error_handling("sock() error");
 
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = inet_addr(argv[1]);
    serv_addr.sin_port = htons(atoi(argv[2]));
 
    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1) 
        error_handling("connect() error!");
 
    str_len = read(sock, message, sizeof(message) - 1);
    if (str_len == -1)
        error_handling("read() error!");
 
    printf("Message from server: %s\n", message);
    close(sock);
 
    return 0;
}
 
void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

　　

•  第23行：创建准备连接服务器端的套接字，此时创建的是TCP套接字
• 第27~30行：结构体变量serv_addr中初始化IP和端口信息。初始化值为目标服务器端套接字的IP和端口信息
• 第32行：调用connect函数向服务器端发送连接请求
• 第35行：完成连接后，接收服务器端传输的数据
• 第40行：接收数据后调用close函数关闭套接字，结束与服务器端的连接

基于TCP的服务器端/客户端函数调用关系

前面讲解了TCP服务器端/客户端的实现顺序，实际上二者并非相互独立，让我们画一下它们之间的交互过程，如图1-8所示

图1-8   函数调用关系

图1-8的总体流程如下：服务器端创建套接字后联系调用bind、listen函数进入等待状态，客户端通过调用connect函数发起连接请求，需要注意的是，客户端只能等到服务器端调用listen函数后才能调用connect函数。同时要清楚，客户端调用connect前，服务器端可能先调用了accept函数。当然，此时服务器端在调用accept函数时进入了阻塞状态，直到客户端调用connect函数为止

实现迭代服务器端/客户端

现在，让我们来编写一个回声服务器端/客户端，所谓回声，就是服务器端将客户端传输的字符串数据原封不动地回传给客户端，不过在此之前，需要解释一下何为迭代服务器端。之前我们所看到的Hello world服务器端处理完一个客户端连接请求则退出程序，连接请求等待队列是实际上没太大意义，这并非我们所需的服务器端，设置好等待队列后，应向所有客户端提供服务，如果在受理完一个客户端请求连接后，还需要再受理其他的请求连接，改怎么扩展代码？最简单的办法就是通过循环语句返回调动accept函数，如图1-9

图1-9   迭代服务器端的函数调用顺序

图1-9可以看出，调用accept函数后，紧接着调用I/O相关的read、write函数，然后调用close函数。这并非针对服务器端套接字，而是针对accept函数调用时所创建的套接字。调用close函数就意味着结束了针对某一客户端的服务，此时如果还想服务于其他客户端，就要重新调用accept函数。目前，我们的服务器端套接字同一时刻只能服务于一个客户端连接，将来学完进程和线程后，就可以编写同时服务多个客户端的服务器端了

迭代回声服务器端/客户端

即时服务器端以迭代方式运转，客户端代码亦无太大区别，接下来创建迭代回声服务器端及与之配套的回声客户端，首先整理一下程序的基本运行方式：

• 服务器端在同一时刻只与一个客户端相连，并提供回声服务
• 服务器端依次向五个客户端提供服务并退出
• 客户端接收用户输入的字符串并发送到服务器端
• 服务器端将接收到的字符串回传给客户端，即“回声”
• 服务器端与客户端之间的字符串回声一直执行到客户端输入Q为止

echo_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　1024
void error_handling(char *message);

int main(int argc, char *argv[])
{
    int serv_sock, clnt_sock;
    char messag[1024];
    int str_len, i;

    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 = 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");
    if (listen(serv_sock, 5) == -1)
        error_handling("listen()error");
    clnt_adr_sz = sizeof(clnt_adr);
    for (i = 0; i < 5; i++)
    {
        clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_adr, &clnt_adr_sz);
        if (clnt_sock == -1)
            error_handling("accept()error");
        else
            printf("Connected client %d \n", i + 1);
        while ((str_len = read(clnt_sock, messag, 1024)) != 0)
            write(clnt_sock, messag, str_len);
        close(clnt_sock);
    }
    close(serv_sock);
    return 0;
}
void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

　　

• 第37~40行：为处理5个客户端连接而添加的循环语句。共调用五次accept函数，依次向五个客户端提供服务
• 第44、45行：实际完后回声服务的代码，原封不动地传输读取的字符串
• 第46行：针对连接客户端的套接字调用close函数，向连接的相应套接字发送EOF。换言之，客户端套接字若调用close函数，则第44行的循环条件变为false，因此执行第46行代码
• 第48行：向5个客户端提供服务后关闭服务器端套接字并终止程序

echo_client.c

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

void error_handling(char *message);
int main(int argc, char *argv[])
{
    int sock;
    char message[1024];
    int str_len;
    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, 1024, stdin);
        if (!strcmp(message, "q\n") || !strcmp(message, "Q\n"))
            break;
        write(sock, message, strlen(message));
        str_len = read(sock, message, 1024 - 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);
}

　　

• 第27行：调用connect函数。若调用该函数引起的连接请求被注册到服务器端等待队列，则connect函数将完成正常调用。因此，即使通过第30行代码输出了连接提示字符串，如果服务器尚未调用accept函数，也不会真正建立服务关系
• 第42行：调用close函数向相应套接字发送EOF（EOF即意味着中断连接）

编译echo_server.c并运行，服务器端套接字将等待客户端连接请求

# gcc echo_server.c -o echo_server
# ./echo_server 8500

　　

编译echo_client.c并分三次运行

# gcc echo_client.c -o echo_client
# ./echo_client 127.0.0.1 8500
Connected..........
Input message(Q to quit):Hello ^H
Message from server:Hello 
Input message(Q to quit):world
Message from server:world
Input message(Q to quit):Q
# ./echo_client 127.0.0.1 8500
Connected..........
Input message(Q to quit):Java
Message from server:Java
Input message(Q to quit):Python
Message from server:Python
Input message(Q to quit):Golang
Message from server:Golang
Input message(Q to quit):Q
# ./echo_client 127.0.0.1 8500
Connected..........
Input message(Q to quit):Spring
Message from server:Spring
Input message(Q to quit):Flask
Message from server:Flask
Input message(Q to quit):Gin
Message from server:Gin
Input message(Q to quit):Q

　　

最后可看到服务器端套接字程序打印如下：

# ./echo_server 8500
Connected client 1 
Connected client 2 
Connected client 3

　　

可以看到，服务器端套接字共处理了3次客户端连接请求