在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 
#include 
#include 
#include 
#include 
#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 %dn",
        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所描述的地址和端标语。structsockaddr*是一个通用表针类型，myaddr参数实际上可以接受多种合同的sockaddr结构体查看linux是什么系统，而它们的宽度各不相同，所以须要第三个参数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处于窃听状态linux定时器，而且最多容许有backlog个顾客端处于连接待状态，假如接收到更多的联接恳求就忽视。

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

复制

三方握手完成后，服务器调用accept()接受联接，假如服务器调用accept()时还没有顾客端的联接恳求，就阻塞等待直至有顾客端联接上来。cliaddr是一个传出参数，accept()返回时传出顾客端的地址和端标语。addrlen参数是一个传入传出参数(value-resultargument)，传入的是调用者提供的缓冲区cliaddr的厚度以防止缓冲区溢出问题，传出的是顾客端地址结构体的实际宽度(有可能没有占满调用者提供的缓冲区)。假如给cliaddr参数传NULLlinux socket，表示不关心顾客端的地址。

服务器程序的主要结构如下：

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

复制

整个是一个while死循环linux socket，每次循环处理一个顾客端联接。因为cliaddr_len是传入传出参数，每次调用accept()之前应当重新赋年率。accept()的参数listenfd是以前的窃听文件描述符，而accept()的返回值是另外一个文件描述符connfd，然后与顾客端之间就通过这个connfd通信，最后关掉connfd断掉联接，而不关掉listenfd，再度回到循环开头listenfd一直用作accept的参数。

顾客端程序

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

#include 
#include 
#include 
#include 
#include 
#include 
#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 messagen", 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合同的网路程序介绍了linuxsocket编程中的基本概念。通过它我们可以了解到socket程序工作的基本原理，以及一些解决性能问题的思路。

本文原创地址：https://www.linuxprobe.com/rhcjjytxydwl.html编辑：刘遄，审核员：暂无