select連線以及使用方式

select用於監視和操作檔案描述符，通過管理程序的fd_set來通知是否可以進行I/O有關的操作。

       int select(int nfds, fd_set *readfds, fd_set *writefds,
                  fd_set *exceptfds, struct timeval *timeout);

nfds是當前程序中檔案描述符最大的一個，一般設定max + 1。出錯返回-1，時間到返回0，具體參考手冊和程式碼例項。

具體參考：http://man7.org/linux/man-pages/man2/select.2.html

程式碼例項

程式設計環境：Ubuntu 18.04 LTS
編譯器：G++ 7.2

序列的select例子，伺服器接受客戶端的請求，並返回客戶端傳送來的資料。

伺服器

#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
 


#define TRUE 1
#define FALSE 0

int main(int argc, char* argv[]) {
  if (2 != argc) {
    printf("Usage: %s <port of serve>\n", argv[0]);
    return -1;
  }

  int len, rc, on = 1;
  int listen_sd, max_sd, new_sd;
  int desc_ready, end_server = FALSE;
  int close_conn;
  char buffer[80];
  struct
 
 sockaddr_in addr;
  struct timeval timeout;
  fd_set master_set, working_set;

  listen_sd = socket(AF_INET, SOCK_STREAM, 0);
  if (listen_sd < 0) {
    perror("socket() falied\n");
    return -1;
  }

  rc = setsockopt(listen_sd, SOL_SOCKET, SO_REUSEADDR,
                  (char*)&on, sizeof(on));
  if (rc < 0) {
    perror("setsockopt() failed\n");
    close(listen_sd);
    return -1;
  }
  
  // 這裡設定為非阻塞的listen模式，這樣accpet函式在
  // 接收不到連線的時候，不會發生阻塞。
  rc = ioctl(listen_sd, FIONBIO, (char*)&on);
  if (rc < 0) {
    perror("ioctl() failed\n");
    close(listen_sd);
    return -1;
  }

  memset(&addr, 0, sizeof(addr));
  int port = atoi(argv[1]);
  if (port <= 1024) {
    perror("port error\n");
    return -1;
  }

  addr.sin_family = AF_INET;
  addr.sin_port = htons(port);
  addr.sin_addr.s_addr = htonl(INADDR_ANY);

  rc = bind(listen_sd, (struct sockaddr*)&addr, sizeof(addr));
  if (rc < 0) {
    perror("bind() error\n");
    close(listen_sd);
    return -1;
  }

  rc = listen(listen_sd, 32);
  if (rc < 0) {
    perror("listen() error\n");
    close(listen_sd);
    return -1;
  }

  FD_ZERO(&master_set);
  max_sd = listen_sd;
  FD_SET(listen_sd, &master_set);

  timeout.tv_sec = 3 * 60; // 3分鐘的時間
  timeout.tv_usec = 0;

  do {
    memcpy(&working_set, &master_set, sizeof(master_set));
    printf("Waiting on select()...\n");
    rc = select(max_sd + 1, &working_set, NULL, NULL, &timeout);
    
    if (rc < 0) {
      perror("select() failed\n");
      break;
    }
    if (rc == 0) {
      printf("select() timed out. End program.\n");
      break;
    }

    desc_ready = rc;  // 就緒的個數
    for (int i = 0; i <= max_sd && desc_ready > 0; ++i) {
      if (FD_ISSET(i, &working_set)) {
        desc_ready -= 1;
        if(i == listen_sd) {  // 有新的連線到來
          printf("Listening socket is readable.\n");
          do {  // 這裡的死迴圈是為了接收完監聽佇列中所有的連線
            new_sd = accept(listen_sd, NULL, NULL);
            if (new_sd < 0) {
              if (errno != EWOULDBLOCK) {
                perror("accept() failed.\n");
                end_server = TRUE;
              }
              break;
            }

            printf("New coming connection - %d\n", new_sd);
            FD_SET(new_sd, &master_set);  // 新連線加入任務佇列，注意是master
            if(new_sd > max_sd) {  // 更新最大的fd
              max_sd = new_sd;
            }
          } while(new_sd != -1);
        } else {  // 已經建立的連線收到資料
          printf("Descriptor %d readable\n", i);
          close_conn = FALSE;

          do {
            // 這裡處理接收到客戶端的資訊，死迴圈是為了接收完所有可能的資料
            // 注意這裡，recv本身是一個阻塞的函式，所以只要客戶端不主動關閉連線，
            // 那麼伺服器會一直阻塞在這裡，又因為使用了while(TRUE)方式迴圈接收，
            // 因此出現瞭如果使用多個客戶端進行連線，只有當前面的關閉連線後，
            // 後面的才會收到資料。在高效能的伺服器程式設計中，客戶端的連線應該使用
            // 多執行緒或者多程序的方式處理。如果資源充足，應該給每個客戶端一個程序
            // 或者執行緒，當然這樣可能也會出現資源不足的情況。更好的方式是多執行緒(程序)結合
            // 心跳檢測機制，把下面的send傳送資料替換成心跳函式。如果收不到心跳，
            // 就認定已經斷線，此時把客戶端的連線剔除即可。本例子中客戶端主動斷開
            // 連線也會被剔除，因為send函式收不到回覆了。
            // 當然，這個例子只是一個示範select的作用，沒有那麼複雜。
            rc = recv(i, buffer, sizeof(buffer), 0);
            if (rc < 0) {
              if (errno != EWOULDBLOCK) {
                perror("recv() failed");
                close_conn = TRUE;
              }
              break;
            }
            if (rc == 0) {
              printf("Connection closed\n");
              close_conn = TRUE;
              break;
            }

            len = rc;
            printf("%d bytes received\n", len);
            rc = send(i, buffer, len, 0);  // 在這裡把客戶端的資料重新發回去
            if (rc < 0) {
              perror("send() failed");
              close_conn = TRUE;
              break;
            }
          } while(TRUE);

          if (close_conn) {
            close(i);
            FD_CLR(i, &master_set);
            if (i == max_sd) {
              // 在這裡迴圈關掉所有的未連線socket
              while (FD_ISSET(max_sd, &master_set) == FALSE) {
                max_sd -= 1;
              }
            }
          }
        }
      }
    }
  } while(end_server == FALSE);

  // 關閉所有連線
  for (int i = 0; i <= max_sd; ++i) {
    if (FD_ISSET(i, &master_set)) {
      close(i);
    }
  }

  return 0;
}

客戶端

間隔2秒傳送一次資料包

#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char* argv[]) {
  if (argc != 3) {
    printf("Usage: %s <ip of server> <port of server>\n", argv[0]);
    return -1;
  }

  int port = 0;
  int socketfd = 0;
  struct sockaddr_in serv_addr;
  char buffer[80];

  bzero(&serv_addr, sizeof(serv_addr));
  bzero(buffer, sizeof(buffer));
  
  if (inet_pton(AF_INET, argv[1], &serv_addr.sin_addr.s_addr) < 0) {
    printf("IP error\n");
    return -1;
  }
  
  port = atoi(argv[2]);
  if (port <= 1024) {
    printf("Port error\n");
    return -1;
  }

  serv_addr.sin_port = htons(port);
  serv_addr.sin_family = AF_INET;

  socketfd = socket(AF_INET, SOCK_STREAM, 0);
  if (socketfd < 0) {
    printf("socket() error");
    return -1;
  }

  if (connect(socketfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
    printf("connect() error\n");
    return -1;
  }
  
  int i = 0;
  int rc = 0;
  while (1) {
    sprintf(buffer, "%dth message\n", i);
    ++i;
    rc = send(socketfd, buffer, sizeof(buffer), 0);
    if (rc < 0) {
      printf("send() error\n");
      return -1;
    } else if (rc == 0) {
      printf("send nothing to server\n");
      return -1;
    } else {
      printf("send successfully\n");
    }

    rc = recv(socketfd, buffer, sizeof(buffer), 0);
    if (rc < 0) {
      printf("recv() error\n");
      return -1;
    } else if (rc == 0) {
      printf("receive nothing from server\n");
      return -1;
    } else {
      printf("received data: %s", buffer);
    }

    sleep(2);
  }

  return 0;
}

參考

• https://www.ibm.com/support/knowledgecenter/ssw_ibm_i_72/rzab6/xnonblock.htm
• Linux高效能伺服器程式設計