Linux 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);
  }
}

$ gcc server.c -o server

$ ./server

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

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

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

int listen(int sockfd, int backlog);

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

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

#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;
}

$ gcc client.c -o client

$ ./client hello

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);
  }  
}