TCP 协议

socket 概述

在一个典型的 C\S 场景中，应用程序使用 socket 进行通信的方式如下：

• 各个应用程序创建一个 socket。socket 是一个允许通信的“设备”，两个应用程序都需要用到它
• 服务器将自己的 socket 绑定到一个众所周知的地址上使得客户端能够定位到它的位置

通信 domain

识别出一个socket 的方法（即 socket “地址” 的格式）

• UNIX domain
  • UNIX domain socket 使用路径名
  • UNIX domain 用：sockaddr_un
• Internet domain
  • Internet domain socket 使用IP地址和端口号
  • Internet domain 使用 sockaddr_in

Internet Domain Socket

Internet domain socket用于实现不同主机上的进程间通信，要做到不同主机跨进程通信，第一个要解决的问题就是怎么唯一标识一个进程。我们知道主机上每个进程都有一个唯一的pid，通过pid可以解决同一台主机上的跨进程通信进程的识别问题。但是如果2个进程不在一台主机上的话，pid是有可能重复的，所以在这个场景下不适用，那有什么其他的方式吗？我们知道通过主机IP可以唯一锁定主机，而通过端口可以定位到程序，而进程间通信我们还需要知道通信用的什么协议。这样一来“IP+端口+协议”的组合就可以唯一标识网络中一台主机上的一个进程。这也是生成socket的主要参数。

在 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 <ctype.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define MAXLINE 80
#define SERV_PORT 8000

int main(void)
{
struct sockaddr_in server_addr, client_addr;
int server_fd, client_fd;
socklen_t client_addr_len;
char buf[MAXLINE];
char str[INET_ADDRSTRLEN];   // 存储 IPv4 地址

// 创建socket
server_fd = socket(AF_INET, SOCK_STREAM, 0);

// socket bind server_addr
bzero(&server_addr, sizeof(server_addr));
server_addr.sin_family = AF_INET;
// IP + port
server_addr.sin_addr.s_addr = htonl(INADDR_ANY); // 将服务器地址结构体中的IP地址字段设置为“任意”IP地址，并将其从主机字节序转换为网络字节序。
server_addr.sin_port = htons(SERV_PORT);
bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr));

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

printf("Accepting connections ...\n");

while(1)
{
    // accpet
    // 典型的服务器程序可以同时服务于多个客户端, 当有客户端发起连接时，服务器调用的 accept() 返回并接受这个连接，
    // 如果有大量的客户端发起连接而服务器来不及处理，尚未 accept 的客户端就处于连接等待状态。
    client_addr_len = sizeof(client_addr);
    client_fd =accept(server_fd, (struct sockaddr *)&client_addr, &client_addr_len);

    // read data from client_fd to buf
    // inet_ntop()将二进制的IP地址转换成可读的字符串形式存储到str
    // ntohs()将网络字节序的端口号转换为主机字节序
    int stream = read(client_fd, buf, MAXLINE);
    printf("received from %s at PORT %d\n",
            inet_ntop(AF_INET, &client_addr.sin_addr, str, sizeof(str)),
            ntohs(client_addr.sin_port));

    // 字符转换
    for(int i = 0; i < stream; i++)
    {
        buf[i] = toupper(buf[i]);
    }

    // write data of buf to client_fd
    write(client_fd, buf, stream);
    close(client_fd);
}

}

简单介绍一下这段代码：
此时我们可以通过 ss 命令来查看主机上的端口监听情况：ss -tnl sport = :8000
如上图所示，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(&server_addr, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
server_addr.sin_port = htons(SERV_PORT);

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

int listen(int server_fd, int backlog);

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

int accept(int server_fd, struct sockaddr *client_addr, socklen_t *addrlen);

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

while (1)
{
    client_addr_len = sizeof(client_addr);
    client_fd =accept(server_fd, (struct sockaddr *)&client_addr, &client_addr_len);
    int stream = read(client_fd, buf, MAXLINE);
    ......
    close(client_fd);
}

整个是一个 while 死循环，每次循环处理一个客户端连接。由于 client_addr_len 是传入传出参数，每次调用 accept( ) 之前应该重新赋初值。accept() 的参数 server_fd 是先前的监听文件描述符，而 accept() 的返回值是另外一个文件描述符 client_fd，之后与客户端之间就通过这个 client_fd 通讯，最后关闭 client_fd 断开连接，而不关闭 server_fd，再次回到循环开头 server_fd 仍然用作 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[])
{
    int client_fd;
    struct sockaddr_in client_addr;
    char buf[MAXLINE];
    char *str;

    if (argc != 2)
    {
        fputs("usage: ./client message\n", stderr);
        exit(1);
    }
    str = argv[1];

    // 创建socket
    client_fd = socket(AF_INET, SOCK_STREAM, 0);

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

    // write data to server
    write(client_fd, str, strlen(str));

    // read data from server to buf
    int stream = read(client_fd, buf, MAXLINE);
    printf("Response from server:\n");
    write(STDOUT_FILENO, buf, stream);
    printf("\n");
    close(client_fd);
    return 0;
}

运行

gcc client.c -o client
gcc server.c -o server

结果

在客户端的代码中有两点需要注意：

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

提升服务器端的响应能力

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

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

总结

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

待做

• 每次都需要linux重启运行

reference

Unix Domain Socket