• 運用IO復用技術解決前面提到過的問題
  之前遇到的問題是: 當套接字上發生了某種事件的時候, 客戶可能阻塞于fgets呼叫. 現在將其改為阻塞于select呼叫,

  void str_cli(FILE *fp, int sockfd) {
      int maxfdp1;
      fd_set rset;
      char sendline[MAXLINE], recvline[MAXLINE];
  
      FD_ZERO(&rset);
      while(true) {
          FD_SET(fileno(fp), &rset); // 每一次都要初始化
          FD_SET(sockfd, &rset);// 每一次都要初始化
          maxfdp1 = max(fileno(fp), sockfd) + 1;
          select(maxfdp1, &rset, NULL, NULL, NULL);
  
          if(FD_ISSET(sockfd, &rset))  {
              if(readline(sockfd, recvline, MAXLINE))
                  print("server terminated permaturely");
              fputs(recvline, stdout);
          }
  
          if(FD_ISSET(fileno(fp), &rset)) {
              if(fgets(sendline, MAXLINE, fp) == NULL)
                  return;
              write(sockfd, sendline, strlen(sendline));
          }
      }
  }
  

  可是, 即使做了這個修改, 代碼仍然存在問題

  1. 因為只讀取一行stdio的快取中可能還有額外的輸入行待消費
  2. 一個讀到EOF不代表另一個已經讀完畢, 不呢個直接return

• 解決上述問題的版本

  void str_cli2(FILE * fp, int sockfd) {
      int maxfdp1;
      bool stdineof;
      fd_set rset;
      char buf[MAXLINE];
      int n;
  
      stdineof = false;
      FD_ZERO(&rset);
  
      while(true) {
          if(!stdineof)
              FD_SET(fileno(fp), &rset);
          FD_SET(sockfd, &rset);
          maxfdp1 = max(fileno(fp), sockfd) + 1;
          select(maxfdp1, &rset, NULL, NULL, NULL);
  
          if(FD_ISSET(sockfd, &rset))  { // socket is readable
              if((n = read(sockfd, buf, MAXLINE)) == 0){
                  if(stdineof)
                      return;
                  else
                      print("server terminated permaturely");
              }
              write(fileno(stdout), buf, n);
          }
          if(FD_ISSET(filenofp), &rset)) {
              if((n = read(fileno(fp), buf, MAXLINE)) == 0){
                  stdineof = true;
                  shutdown(sockfd, SHUT_WR);
                  FD_CLR(fileno(fp), &rset);
                  continue;
              }
          }
      }
  }
  

  注: 用shutdown(sockfd, SHUT_WR); 發送FIN

pselect函式

POSIX發明的, 有許多的unix變種支持他

• 用timespec結構而不是timeval
• 增加一個指向信號的掩碼的指標, 該引數允許程先序禁止遞交某些信號, 再測驗它們(這些信號)的handler設定的全域變數, 然后呼叫pselect (也就是暫時更換'信號掩碼', 例如解除某個信號的阻塞)

poll函式

poll和select類似, 只不過在處理流函式的時候能夠提供額外的資訊, 先不扯太多理論, 直接看代碼還好懂

#include "unp.h"
#include <limits.h>
#define OPEN_MAX 10

int main() {
    int     i, maxi, listenfd, connfd, sockfd;
    int     nready;
    ssize_t n;
    char    buf[MAXLINE];

    socklen_t     clilen;
    struct pollfd client[OPEN_MAX];

    struct sockaddr_in cliaddr, servaddr;

    listenfd = socket(AF_INET, SOCK_STREAM, 0);
    servaddr = makeAddr("127.0.0.1", 9988);

    bind(listenfd, (sockaddr*)&servaddr, sizeof(servaddr));
    listen(listenfd, 64);

    // initialize client array.
    client[0].fd     = listenfd;
    client[0].events = POLLRDNORM;
    for (i = 1; i < OPEN_MAX; ++i)
        client[i].fd = -1;
    maxi = 0;

    while (true) {
        nready = poll(client, maxi + 1, 0x3f3f3f3f);  // forever
        // 分兩部分處理, client[0]是用來放監聽socket的, 這個if通過說明可以accept
        if (client[0].revents && POLLRDNORM) {
            clilen = sizeof(cliaddr);
            connfd = accept(listenfd, (struct sockaddr*)&cliaddr, &clilen);

            /* insert to the client list */
            for (i = 1; i < OPEN_MAX; ++i)
                if (client[i].fd < 0) {
                    client[i].fd = connfd;
                    client[i].events = POLLRDNORM;  // read normal: 普通資料可讀
                    break;
                }
            if (i == OPEN_MAX)
                err_quit("too many clients");


            if (i > maxi)
                maxi = i;
            if (--nready <= 0)
                continue;
        }
        //別的都是client socket
        for (i = 1; i <= maxi; ++i) {
            if ((sockfd = client[i].fd) < 0)
                continue;
            if (client[i].revents && (POLLRDNORM | POLLERR)) {
                if ((n = read(sockfd, buf, MAXLINE)) < 0) {
                    if (errno == ECONNRESET) {
                        close(sockfd);
                        client[i].fd = -1;
                    }
                    else
                        perror("read error");
                }
                else if (n == 0) {
                    close(sockfd);
                    client[i].fd = -1;
                }
                else
                    write(sockfd, buf, n);
                if (--nready <= 0)
                    break;
            }
        }
    }
}

套接字選項

有很多方式來設定和影響套接字選項, 例如getsockopt, setsockopt, fcntl, ioctl

關于傳輸層的套接字選項, 請自行google或參考有關檔案和書籍

UDP編程

UDP編程模型

創建socket的時候要把SOCK_STREAM改成SOCK_DGRAM

recvfrom 和 sendto函式

類似與標準的read和write, 不過需要3個額外的引數: flags, from, addrlen, flags引數先不說, 暫時把他當成0, 后續會解釋; from和addrlen引數和accept的最后兩個引數類似

• 注: 如果from是一個空指標, 那么addrlen也一樣要是一個空指標, 表示我們不關心地址.

recvfrom和sendto都可以用于TCP, 盡管通常沒有理由那么做

void
dg_echo(int sockfd, SA* pcliaddr, socklen_t clilen) {
    int       n;
    socklen_t len;
    char      mesg[MAXLINE];

    while (1) {
        // `len` should be initialized to the size of the
        len = clilen;
        n = recvfrom(sockfd, mesg, MAXLINE, 0, pcliaddr, &len);

        sendto(sockfd, mesg, 0, pcliaddr, len);
    }
}

int
main() {
    int                sockfd;
    struct sockaddr_in servaddr, cliaddr;

    sockfd   = socket(AF_INET, SOCK_DGRAM, 0);
    servaddr = makeAddr("127.0.0.1", 6666);
    bind(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr));

    dg_echo(sockfd, (SA*)&cliaddr, sizeof(cliaddr));
    return 0;
}

代碼雖簡單, 但是有幾個細節需要注意

• 首先, 函式永不終止, 因為UDP是一個無連接的協議, 它沒有像TCP中的EOF之類的東西
• 這是一個迭代服務器, 不像TCP服務器那樣可以提供一個并發的服務器, 其中沒有fork的呼叫, 因此單個行程就得處理所有客戶
• 對于本套接字, UDP層有排隊發生, 事實上每個UDPsocket都有一個接收快取區

更多的UDP細節不在此贅述

SCTP編程

留坑.. 以后補上...
.
.
.

IPv4和IPv6的互操作性

IPv4和IPv6的互操作性

標籤：C

上一篇：設計并測驗Trapezium類 代碼參考

下一篇：如何了解一個專案？