在 TCP/IP 协议中，"IP地址 + TCP或UDP端口号" 可以唯一标识网络通讯中的一个进程，"IP地址+端口号" 就称为 socket。本文以一个简单的 TCP 协议为例，介绍如何创建基于 TCP 协议的网络程序。

TCP 协议通讯流程

下图描述了 TCP 协议的通讯流程(此图来自互联网)：

下图则描述 TCP 建立连接的过程(此图来自互联网)：

服务器调用 socket()、bind()、listen() 函数完成初始化后，调用 accept() 阻塞等待，处于监听端口的状态，客户端调用 socket() 初始化后，调用 connect() 发出 SYN 段并阻塞等待服务器应答，服务器应答一个SYN-ACK 段，客户端收到后从 connect() 返回，同时应答一个 ACK 段，服务器收到后从 accept() 返回。

TCP 连接建立后数据传输的过程：

建立连接后，TCP 协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，服务器被动处理请求，一问一答的方式。因此，服务器从 accept() 返回后立刻调用 read()，读 socket 就像读管道一样，如果没有数据到达就阻塞等待，这时客户端调用 write() 发送请求给服务器，服务器收到后从 read() 返回，对客户端的请求进行处理，在此期间客户端调用 read() 阻塞等待服务器的应答，服务器调用 write() 将处理结果发回给客户端，再次调用 read() 阻塞等待下一条请求，客户端收到后从 read() 返回，发送下一条请求，如此循环下去。

下图描述了关闭 TCP 连接的过程：

如果客户端没有更多的请求了，就调用 close() 关闭连接，就像写端关闭的管道一样，服务器的 read() 返回 0，这样服务器就知道客户端关闭了连接，也调用 close() 关闭连接。注意，任何一方调用 close() 后，连接的两个传输方向都关闭，不能再发送数据了。如果一方调用 shutdown() 则连接处于半关闭状态，仍可接收对方发来的数据。

在学习 socket 编程时要注意应用程序和 TCP 协议层是如何交互的：

• 应用程序调用某个 socket 函数时 TCP 协议层完成什么动作，比如调用 connect() 会发出 SYN 段

• 应用程序如何知道 TCP 协议层的状态变化，比如从某个阻塞的 socket 函数返回就表明 TCP 协议收到了某些段，再比如 read() 返回 0 就表明收到了 FIN 段

下面通过一个简单的 TCP 网络程序来理解相关概念。程序分为服务器端和客户端两部分，它们之间通过 socket 进行通信。

服务器端程序

下面是一个非常简单的服务器端程序，它从客户端读字符，然后将每个字符转换为大写并回送给客户端：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>

#define MAXLINE 80
#define SERV_PORT 8000

int main(void)
{
    struct sockaddr_in servaddr, cliaddr;
    socklen_t cliaddr_len;
    int listenfd, connfd;
    char buf[MAXLINE];
    char str[INET_ADDRSTRLEN];
    int i, n;

    // socket() 打开一个网络通讯端口，如果成功的话，
    // 就像 open() 一样返回一个文件描述符，
    // 应用程序可以像读写文件一样用 read/write 在网络上收发数据。
    listenfd = socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(SERV_PORT);
    
    // bind() 的作用是将参数 listenfd 和 servaddr 绑定在一起，
    // 使 listenfd 这个用于网络通讯的文件描述符监听 servaddr 所描述的地址和端口号。
    bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

    // listen() 声明 listenfd 处于监听状态，
    // 并且最多允许有 20 个客户端处于连接待状态，如果接收到更多的连接请求就忽略。
    listen(listenfd, 20);

    printf("Accepting connections ...\n");
    while (1)
    {
        cliaddr_len = sizeof(cliaddr);
        // 典型的服务器程序可以同时服务于多个客户端，
        // 当有客户端发起连接时，服务器调用的 accept() 返回并接受这个连接，
        // 如果有大量的客户端发起连接而服务器来不及处理，尚未 accept 的客户端就处于连接等待状态。
        connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);
      
        n = read(connfd, buf, MAXLINE);
        printf("received from %s at PORT %d\n",
               inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
               ntohs(cliaddr.sin_port));
    
        for (i = 0; i < n; i++)
        {
            buf[i] = toupper(buf[i]);
        }
            
        write(connfd, buf, n);
        close(connfd);
    }
}

把上面的代码保存到文件 server.c 文件中，并执行下面的命令编译：

$ gcc server.c -o server

然后运行编译出来的 server 程序：

$ ./server

此时我们可以通过 ss 命令来查看主机上的端口监听情况：

如上图所示，server 程序已经开始监听主机的 8000 端口了。

下面让我们介绍一下这段程序中用到的 socket 相关的 API。

int socket(int family, int type, int protocol);

socket() 打开一个网络通讯端口，如果成功的话，就像 open() 一样返回一个文件描述符，应用程序可以像读写文件一样用 read/write 在网络上收发数据。对于IPv4，family 参数指定为 AF_INET。对于 TCP 协议，type 参数指定为 SOCK_STREAM，表示面向流的传输协议。如果是 UDP 协议，则 type 参数指定为 SOCK_DGRAM，表示面向数据报的传输协议。protocol 指定为 0 即可。

int bind(int sockfd, const struct sockaddr *myaddr, socklen_t addrlen);

服务器需要调用 bind 函数绑定一个固定的网络地址和端口号。bind() 的作用是将参数 sockfd 和 myaddr 绑定在一起，使 sockfd 这个用于网络通讯的文件描述符监听 myaddr 所描述的地址和端口号。struct sockaddr *是一个通用指针类型，myaddr 参数实际上可以接受多种协议的 sockaddr 结构体，而它们的长度各不相同，所以需要第三个参数 addrlen 指定结构体的长度。
程序中对 myaddr 参数的初始化为：

bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);

首先将整个结构体清零，然后设置地址类型为 AF_INET，网络地址为 INADDR_ANY，这个宏表示本地的任意 IP 地址，因为服务器可能有多个网卡，每个网卡也可能绑定多个 IP 地址，这样设置可以在所有的 IP 地址上监听，直到与某个客户端建立了连接时才确定下来到底用哪个 IP 地址，端口号为 SERV_PORT，我们定义为 8000。

int listen(int sockfd, int backlog);

listen() 声明 sockfd 处于监听状态，并且最多允许有 backlog 个客户端处于连接待状态，如果接收到更多的连接请求就忽略。

int accept(int sockfd, struct sockaddr *cliaddr, socklen_t *addrlen);

三方握手完成后，服务器调用 accept() 接受连接，如果服务器调用 accept() 时还没有客户端的连接请求，就阻塞等待直到有客户端连接上来。cliaddr 是一个传出参数，accept() 返回时传出客户端的地址和端口号。addrlen 参数是一个传入传出参数(value-result argument)，传入的是调用者提供的缓冲区 cliaddr 的长度以避免缓冲区溢出问题，传出的是客户端地址结构体的实际长度(有可能没有占满调用者提供的缓冲区)。如果给 cliaddr 参数传 NULL，表示不关心客户端的地址。
服务器程序的主要结构如下：

while (1)
{
    cliaddr_len = sizeof(cliaddr);
    connfd = accept(listenfd,
            (struct sockaddr *)&cliaddr, &cliaddr_len);
    n = read(connfd, buf, MAXLINE);
    ......
    close(connfd);
}

整个是一个 while 死循环，每次循环处理一个客户端连接。由于 cliaddr_len 是传入传出参数，每次调用 accept( ) 之前应该重新赋初值。accept() 的参数 listenfd 是先前的监听文件描述符，而 accept() 的返回值是另外一个文件描述符 connfd，之后与客户端之间就通过这个 connfd 通讯，最后关闭 connfd 断开连接，而不关闭 listenfd，再次回到循环开头 listenfd 仍然用作 accept 的参数。

客户端程序

下面是客户端程序，它从命令行参数中获得一个字符串发给服务器，然后接收服务器返回的字符串并打印：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define MAXLINE 80
#define SERV_PORT 8000

int main(int argc, char *argv[])
{
    struct sockaddr_in servaddr;
    char buf[MAXLINE];
    int sockfd, n;
    char *str;
    
    if (argc != 2)
    {
        fputs("usage: ./client message\n", stderr);
        exit(1);
    }
    str = argv[1];
    
    sockfd = socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
    servaddr.sin_port = htons(SERV_PORT);
    
    // 由于客户端不需要固定的端口号，因此不必调用 bind()，客户端的端口号由内核自动分配。
    // 注意，客户端不是不允许调用 bind()，只是没有必要调用 bind() 固定一个端口号，
    // 服务器也不是必须调用 bind()，但如果服务器不调用 bind()，内核会自动给服务器分配监听端口，
    // 每次启动服务器时端口号都不一样，客户端要连接服务器就会遇到麻烦。
    connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

    write(sockfd, str, strlen(str));

    n = read(sockfd, buf, MAXLINE);
    printf("Response from server:\n");
    write(STDOUT_FILENO, buf, n);
    printf("\n");
    close(sockfd);
    return 0;
}

把上面的代码保存到文件 client.c 文件中，并执行下面的命令编译：

$ gcc client.c -o client

然后运行编译出来的 client 程序：

$ ./client hello

此时服务器端会收到请求并返回转换为大写的字符串，并输出相应的信息：

而客户端在发送请求后会收到转换过的字符串：

在客户端的代码中有两点需要注意：
    1. 由于客户端不需要固定的端口号，因此不必调用 bind()，客户端的端口号由内核自动分配。
    2. 客户端需要调用 connect() 连接服务器，connect 和 bind 的参数形式一致，区别在于 bind 的参数是自己的地址，而 connect 的参数是对方的地址。
至此我们已经使用 socket 技术完成了一个最简单的客户端服务器程序，虽然离实际应用还非常遥远，但就学习而言已经足够了。

提升服务器端的响应能力

虽然我们的服务器程序可以响应客户端的请求，但是这样的效率太低了。一般情况下服务器程序需要能够同时处理多个客户端的请求。可以通过 fork 系统调用创建子进程来处理每个请求，下面是大体的实现思路：

listenfd = socket(...);
bind(listenfd, ...);
listen(listenfd, ...);
while (1)
{
    connfd = accept(listenfd, ...);
    n = fork();
    if (n == -1)
    {
        perror("call to fork");
        exit(1);
    }
    else if (n == 0)
    {
        // 在子进程中处理客户端的请求。
        close(listenfd);
        while (1)
        {
            read(connfd, ...);
            ...
            write(connfd, ...);
        }
        close(connfd);
        exit(0);
    }
    else
    {
        close(connfd);
    }    
}

此时父进程的任务就是不断的创建子进程，而由子进程去响应客户端的具体请求。通过这种方式，可以极大的提升服务器端的响应能力。

总结

本文通过一个简单的建基于 TCP 协议的网络程序介绍了 linux socket 编程中的基本概念。通过它我们可以了解到 socket 程序工作的基本原理，以及一些解决性能问题的思路。