我們知道，一個基於TCP/IP的客戶端-伺服器的程式中，正常情況下，我會是啟動伺服器使其在一個埠上監聽請求，等待客戶端的連線；通過TCP的三次握手，客戶端能夠通過socket建立一個到伺服器的連線；然後，兩者就可以基於這個socket連線通訊了。連線結束後，客戶端（程序）會退出；在不需要繼續處理客戶請求的情況下，伺服器（程序）也將退出。而且，當一個程序退出的時候，核心會關閉所有由這個程序開啟的套接字，這裡將觸發TCP的四次揮手進而關閉一個socket連線。但是，在一些異常的情況下，譬如：伺服器程序終止、伺服器主機奔潰/奔潰後重啟、伺服器關機的情況下，客戶端向伺服器發起請求的時候，將會發生什麼呢？下邊，我們來看看這幾種情況。

        注意：一下描述的各種情況所使用的示例程式在文章的最後貼出

     一、伺服器程序終止

        我們啟動客戶/伺服器對，然後殺死子程序（模擬伺服器程序崩潰的情形，我們可從中檢視客戶端將發生什麼）。

        1：在同一個主機上啟動伺服器和客戶，並在客戶上輸入一行文字，以驗證一切正常。正常情況下，改行文字將由伺服器回射給客戶。

        2：找到伺服器子程序的ID，通過kill命令殺死它。作為程序終止處理的部分工作，子程序中所有開啟著的描述字都被關閉。這就導致向客戶傳送一個FIN，而客戶TCP則響應以一個ACK。這就是TCP連線終止的前一半工作。

        3：子程序終止時，核心將給父程序遞交SIGCHLD訊號。

        4：客戶上沒有發生任何特殊之事。客戶TCP接受來自伺服器TCP的FIN並響應一個ACK，然後問題是客戶程序此時阻塞在fgets呼叫上，等待從終端接受一行文字。它是看不到這個FIN的。

        5：此時我們如果執行netstat命令，可以看到如下的套介面的狀態：

        FIN_WAIT2即為我們殺掉的那個子程序的，因為我們知道主動關閉的那端在傳送完fin並接受對端的ack後將進入fin_wait2狀態，此時它在等待對端的fin。

        6：現在我們在客戶上在輸入一行文字，我們可以看到如下的輸出：

        當我們輸入“after server close”時，客戶TCP接著把資料傳送給伺服器，TCP允許這麼做，因為客戶TCP接受到FIN只是表示伺服器程序已關閉了連線的服務端，從而不再往其中傳送任何資料而已。FIN的接受並沒有告知客戶TCP伺服器程序已經終止（在這個例子中它缺失是終止了）。當伺服器TCP接收到來自客戶的資料時，既然先前開啟那個套介面的程序已經終止，於是響應一個RST。

        7：然而客戶程序看不到這個RST，因為它在呼叫write後立即呼叫read，並且由於第2步中接收到FIN，所呼叫的read立即返回0（表示）EOF。我們的客戶此時並未預期收到EOF，於是以出錯資訊“server term prematurely.”（伺服器過早終止）退出。

        8：當客戶終止時，它所有開啟著的描述字都被關閉。

        我們的上述討論還取決於程式的時序。客戶呼叫read既可能發生在伺服器的RST被客戶收到之前，也可能發生在收到之後。如果read發生在收到RST之前（如本例子所示），那麼結果是客戶得到一個未預期的EOF；否則結果是由readline返回一個ECONNRESET（“connection reset by peer”對方復位連線）錯誤。

        本例子的問題在於：當FIN到達套介面時，客戶正阻塞在fgets呼叫上。客戶實際上在應對兩個描述字——套介面和使用者輸入，它不能單純阻塞在這兩個源中某個特定源的輸入上，而是應該阻塞在其任何一個源的輸入上。（可用select等io複用的函式實現）

   二、伺服器主機崩潰

        我們接著檢視當伺服器主機崩潰時會發生什麼。為了模擬這種情形，我們需要在不同的機器上執行客戶與伺服器，在首次確認客戶伺服器能正常工作後，我們從網路上斷開伺服器主機，並在客戶上再輸入一行文字。這裡同時也模擬了當客戶傳送資料時伺服器主機不可達的情形（機建立連線後某些中間路由器不工作）

         1：當伺服器主機崩潰時，已有的網路連線上發不出任何東西。這裡我們假設的是主機崩潰，而不是執行了關機命令。

         2：我們在客戶上輸入一行文字，它由write寫入核心，再由客戶TCP作為一個數據分節送出。客戶隨後阻塞於read呼叫，等待伺服器的應答。

         3：這種情況下，客戶TCP持續重傳資料分節，試圖從伺服器上接受一個ACK。（源自Berkeley的實現重傳該資料分節12次，共等待約9分鐘才放棄重傳。）當客戶TCP最終放棄時（假設這段時間內，伺服器主機沒有重新啟動或者如果是伺服器主機為崩潰但從網路上不可達的情況，那麼假設主機仍然不可達），返回客戶程序一個錯誤。既然客戶阻塞在readline呼叫上，該呼叫將返回一個錯誤。假設伺服器已崩潰，從而對客戶的資料分節根本沒有響應，那麼所返回的錯誤是ETIMEDOUT。然而如果某個中間路由器判定伺服器主機已不可達，從而響應以一個“destination unreachable”，那麼所返回的錯誤是EHOSTUNREACH或ENETUNREACH。

         儘管我們的客戶最後還是發現對端主機已崩潰或不可達，不過有時候我們需要更快地檢測出這種情況，而不是不得不等待9分鐘。所用的方法就是對read呼叫設定一個超時。

         另外我們剛討論的情形只有在向伺服器主機發送資料時，才能檢測出它已經崩潰，如果我們不主動傳送主句也想檢測出伺服器主機的崩潰，那麼就需要用到SO_KEEPALIVE這個套介面選項。        

     三、伺服器主機崩潰後重啟

        在前一節的分析中，當我們傳送資料時，伺服器主機仍然處於崩潰狀態；這節，我們將在傳送資料前重新啟動崩潰了的伺服器主機。模擬這種情況的簡單方法就是：建立連線，再從網路上埠伺服器主機，將它關機後再重啟，最後把它重新連線到網路中。

        如前一節所述，如果在伺服器主機崩潰時客戶不主動給伺服器傳送資料，那麼客戶不會知道伺服器主機已經崩潰。所發生的步驟如下：

        1：啟動客戶伺服器，在客戶上輸入一行文字已確認連線已建立。

        2：伺服器主機崩潰並重啟。

        3：在客戶上輸入一行文字，它將作為一個TCP資料分節傳送到伺服器主機。

        4：當伺服器主機崩潰後重啟時，它的TCP丟失了崩潰前的所有連線資訊，因此伺服器TCP對於所收到的來自客戶的資料分節響應以一個RST。

        5：當客戶TCP收到該RST時，客戶正阻塞於read呼叫，導致該呼叫返回ECONNRESET錯誤。

    四、伺服器主機關機

        這節我們看看當伺服器關機時將會發生什麼。

        Unix系統關機時，init程序通常先給所有程序傳送SIGTERM訊號（該訊號可被捕獲），再等待一段固定的時間（一般在5~20秒之間），然後給所有仍在執行的程序傳送SIGKILL訊號（該訊號不能被捕獲）。這麼做是留給所有執行中的程序一小段時間來清除和終止。如果我們不捕獲SIGTERM訊號並終止，我們的伺服器將由SIGKILL訊號終止。當伺服器程序終止時，它的所有開啟著的描述字都被關閉，隨後發生的步驟與第一節中討論過的一樣。正如第一節中所述的情形，我們必須在客戶中使用select或poll函式，使得伺服器程序的終止已經發生，客戶馬上檢測到。

    五、示例程式

//client.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <errno.h>
#include <error.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <string.h>
#include <signal.h>

void str_cli(FILE *fp, int sfd ) {
    char sendline[1024], recvline[2014];
    memset(recvline, 0, sizeof(sendline));
    memset(sendline, 0, sizeof(recvline));
    while( fgets(sendline, 1024, fp) != NULL ) {
        write(sfd, sendline, strlen(sendline)); 
        if( read(sfd, recvline, 1024) == 0 ) {
            printf("server term prematurely.\n"); 
        }
        fputs(recvline, stdout);
        memset(recvline, 0, sizeof(sendline));
        memset(sendline, 0, sizeof(recvline));
    }
}

int main() {
    int s;
    if( (s = socket(AF_INET, SOCK_STREAM, 0)) < 0 ) {
        int e = errno; 
        perror("create socket fail.\n");
        exit(0);
    }
    
    struct sockaddr_in server_addr, child_addr; 
    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(9998);
    inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr);
    
    if( connect(s, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0 ) {
        perror("connect fail."); 
        exit(0);
    }
    str_cli(stdin, s);
    exit(0);
}

//server.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <errno.h>
#include <error.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <string.h>
#include <signal.h>
#include <sys/wait.h>

//using namespace std;


typedef void sigfunc(int);

void func_wait(int signo) {
    pid_t pid;
    int stat;
    pid = wait(&stat);    
    printf( "child %d exit\n", pid );
    return;
}
void func_waitpid(int signo) {
    pid_t pid;
    int stat;
    while( (pid = waitpid(-1, &stat, WNOHANG)) > 0 ) {
        printf( "child %d exit\n", pid );
    }
    return;
}

sigfunc* signal( int signo, sigfunc *func ) {
    struct sigaction act, oact;
    act.sa_handler = func;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    if ( signo == SIGALRM ) {
#ifdef            SA_INTERRUPT
        act.sa_flags |= SA_INTERRUPT;    /* SunOS 4.x */
#endif
    } else {
#ifdef           SA_RESTART
        act.sa_flags |= SA_RESTART;    /* SVR4, 4.4BSD */
#endif
    }
    if ( sigaction(signo, &act, &oact) < 0 ) {
        return SIG_ERR;
    }
    return oact.sa_handler;
} 


void str_echo( int cfd ) {
    ssize_t n;
    char buf[1024];
    //char t[] = "SERVER ECHO: ";
again:
    memset(buf, 0, sizeof(buf));
    while( (n = read(cfd, buf, 1024)) > 0 ) {
        write(cfd, buf, n); 
    }
    if( n <0 && errno == EINTR ) {
        goto again; 
    } else {
        printf("str_echo: read error\n");
    }
}

int main() {

    signal(SIGCHLD, &func_waitpid);    

    int s, c;
    pid_t child;
    if( (s = socket(AF_INET, SOCK_STREAM, 0)) < 0 ) {
        int e = errno; 
        perror("create socket fail.\n");
        exit(0);
    }
    
    struct sockaddr_in server_addr, child_addr; 
    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(9998);
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);

    if( bind(s, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0 ) {
        int e = errno; 
        perror("bind address fail.\n");
        exit(0);
    }
    
    if( listen(s, 1024) < 0 ) {
        int e = errno; 
        perror("listen fail.\n");
        exit(0);
    }
    while(1) {
        socklen_t chilen = sizeof(child_addr); 
        if ( (c = accept(s, (struct sockaddr *)&child_addr, &chilen)) < 0 ) {
            perror("listen fail.");
            exit(0);
        }

        if( (child = fork()) == 0 ) {
            close(s); 
            str_echo(c);
            exit(0);
        }
        close(c);
    }
}