網絡編程中的TCP保活

在默認的情況下，TCP連接是沒有保活的心跳的。這就是說，當一個TCP的socket，客戶端與服務端誰也不發送數據，會一直保持着連接。這其中如果有一方異常掉線，另一端永遠也不可能知道。這對於一些服務型的程序來說，將是災難性的後果。

　　所以，必須對創建的socket，啓用保活心跳，即Keepalive選項。

啓用Keepalive

　　對於WIN32或者Linux平臺來說，設置socket的Keepalive都很簡單，只需使用setsockopt設置SO_KEEPALIVE即可。

　　setsockopt的函數原型在Linux環境下爲：

[html]view
plaincopy

#include <sys/types.h>    

#include <sys/socket.h>    

int setsockopt(int s, int level, int optname,    

               const void *optval,    

               socklen_t optlen);

，在WIN32平臺下爲

[html]view
plaincopy

#include <winsock2.h>    

int setsockopt(int s, int level, int optname,    

               const char *optval,    

               int optlen);

　　因爲const void *可以接受const char *型的參數，所以爲了代碼的跨平臺編譯考慮，可以採用以下代碼來設置TCP的Keepalive選項。

[html]view
plaincopy

alive = 1;  

if (setsockopt  

    (fd, SOL_SOCKET, SO_KEEPALIVE, (const char *) &alive,  

     sizeof alive) != 0)  

  {  

    log_warn ("Set keep alive error: %s.\n", strerror (errno));  

    return -1;  

  }

　　這樣，對於TCP的連接，就啓用了系統默認值的保活心跳。

Linux環境下的TCP Keepalive參數設置

　　爲什麼說是系統默認值的呢？因爲有這樣幾個值，我們並沒有手動設置，是採用的系統默認值。即，

多長時間發送一次保活心跳？
如果沒有返回，多長時間再重試發送？
重試幾次爲失敗？
　　如果是Linux操作系統，這三個值分別爲
[html] view plain copy
1. # cat /proc/sys/net/ipv4/tcp_keepalive_time
2. 7200
3. # cat /proc/sys/net/ipv4/tcp_keepalive_intvl
4. 75
5. # cat /proc/sys/net/ipv4/tcp_keepalive_probes
6. 9

　　這就是說，在Linux系統下，如果對於TCP的socket啓用了Keepalive選項，則會在7200秒（即兩個小時）沒有數據後，發起KEEPALIVE報文。如果沒有迴應，則會在75秒後再次重試。如果重試9次均失敗，則認定連接已經失效。TCP的讀取操作，將返回0。

　　這對於我們大多數應用來說，前兩個時間值都有點太長了。

　　我們可以通過重設上面三個值，來使得操作系統上運行的所有啓用了Keepalive選項的TCP的socket的行爲更改。

　　我們也可以只針對我們自己創建的socket，重設這三個值。它們分別對應TCP_KEEPIDLE、TCP_KEEPINTL和TCP_KEEPCNT的選項值，同樣可以使用setsockopt進行設置。

[html]view
plaincopy

#include <stdlib.h>    

#include <fcntl.h>    

#include <errno.h>    

#include <sys/socket.h>    

#include <netinet/tcp.h>    

#include <netinet/in.h>    

#include <netdb.h>    

#include <arpa/inet.h>    

int    

socket_set_keepalive (int fd)    

{    

  int ret, error, flag, alive, idle, cnt, intv;    

  /* Set: use keepalive on fd */    

  alive = 1;    

  if (setsockopt    

      (fd, SOL_SOCKET, SO_KEEPALIVE, &alive,    

       sizeof alive) != 0)    

    {    

      log_warn ("Set keepalive error: %s.\n", strerror (errno));    

      return -1;    

    }    

  /* １０秒鐘無數據，觸發保活機制，發送保活包 */    

  idle = 10;    

  if (setsockopt (fd, SOL_TCP, TCP_KEEPIDLE, &idle, sizeof idle) != 0)    

    {    

      log_warn ("Set keepalive idle error: %s.\n", strerror (errno));    

      return -1;    

    }    

  /* 如果沒有收到迴應，則５秒鐘後重發保活包 */    

  intv = 5;    

  if (setsockopt (fd, SOL_TCP, TCP_KEEPINTVL, &intv, sizeof intv) != 0)    

    {    

      log_warn ("Set keepalive intv error: %s.\n", strerror (errno));    

      return -1;    

    }    

  /* 連續３次沒收到保活包，視爲連接失效 */    

  cnt = 3;    

  if (setsockopt (fd, SOL_TCP, TCP_KEEPCNT, &cnt, sizeof cnt) != 0)    

    {    

      log_warn ("Set keepalive cnt error: %s.\n", strerror (errno));    

      return -1;    

    }    

  return 0;    

}

WIN32環境下的TCP Keepalive參數設置

　　而WIN32環境下的參數設置，就要麻煩一些，需要使用另外的一個函數WSAIoctl和一個結構struct tcp_keepalive。

　　它們的原型分別爲：

[html]view
plaincopy

#include <winsock2.h>    

#include <mstcpip.h>    

int WSAIoctl(    

             SOCKET s,    

             DWORD dwIoControlCode,    

             LPVOID lpvInBuffer,    

             DWORD cbInBuffer,    

             LPVOID lpvOutBuffer,    

             DWORD cbOutBuffer,    

             LPDWORD lpcbBytesReturned,    

             LPWSAOVERLAPPED lpOverlapped,    

             LPWSAOVERLAPPED_COMPLETION lpCompletionRoutine    

);    

struct tcp_keepalive {    

    u_long onoff;    

    u_long keepalivetime;    

    u_long keepaliveinterval;    

};

　　在這裏，使用WSAIoctl的時候，dwIoControlCode要使用SIO_KEEPALIVE_VALS，lpvOutBuffer用不上，cbOutBuffer必須設置爲0。

　　struct tcp_keepalive結構的參數意義爲：

　　onoff，是否開啓KEEPALIVE； keepalivetime，多長時間觸發Keepalive報文的發送； keepaliveinterval，多長時間沒有迴應觸發下一次發送。

　　注意：這裏兩個時間單位都是毫秒而不是秒。

[html]view
plaincopy

#include <winsock2.h>    

#include <mstcpip.h>    

int    

socket_set_keepalive (int fd)    

{    

  struct tcp_keepalive kavars[1] = {    

      1,    

      10 * 1000,        /* 10 seconds */    

      5 * 1000          /* 5 seconds */    

  };    

  /* Set: use keepalive on fd */    

  alive = 1;    

  if (setsockopt    

      (fd, SOL_SOCKET, SO_KEEPALIVE, (const char *) &alive,    

       sizeof alive) != 0)    

    {    

      log_warn ("Set keep alive error: %s.\n", strerror (errno));    

      return -1;    

    }    

  if (WSAIoctl    

      (fd, SIO_KEEPALIVE_VALS, kavars, sizeof kavars, NULL, sizeof (int), &ret, NULL,    

       NULL) != 0)    

    {    

      log_warn ("Set keep alive error: %s.\n", strerror (WSAGetLastError ()));    

      return -1;    

    }    

  return 0;    

}

http://blog.csdn.net/weiwangchao_/article/details/7225338

一、問題起因：
a》
在文章：http://tldp.org/HOWTO/html_single/TCP-Keepalive-HOWTO/ 寫到：
There are also three other socket options you can set for keepalive when you write your application.
They all use the SOL_TCP level instead of SOL_SOCKET, and they override system-wide variables
only for the current socket. If you read without writing first,
the current system-wide parameters will be returned.

TCP_KEEPCNT:    overrides tcp_keepalive_probes
TCP_KEEPIDLE:    overrides tcp_keepalive_time
TCP_KEEPINTVL:    overrides tcp_keepalive_intvl

上面說：設置 socket 的keepalive 屬性選項, 只對當前socket起作用
-----they override system-wide variables only for the current socket。

b》
可是：《TCP/IP詳解卷1：協議》page 252 中寫到：
“一個被人們不斷討論的關於保活選項的問題就是兩個小時的空閒時間是否可以改
變。通常他們希望該數值可以小得多，處在分鐘的數量級。正如我們在附錄E看到的，
這個值通常可以改變，但是在該附錄所描述的所有系統中，保活間隔時間是系統級的
變量，因此改變它會影響到所有使用該功能的用戶。
Host Requirements RFC提到一個實現可提供保活的功能，但是除非應用程序指明
要這樣，否則就不能使用該功能。而且，保活間隔必須是可配置的，但是其默認值必
須不小於兩個小時。”

我的理解是：這裏兩處的描述，有些矛盾。
到底 keepalive 屬性是隻對單個socket起作用，還是會影響其他socket？
爲此，用來下面的程序來測試。

在下面的程序中，在服務器端使用TCP保活選項，客戶端沒有使用。
客戶端也可以使用這個選項，但通常都是服務器設置這個功能。
如果雙方都特別需要了解對方是否已經消失，則雙方都可以使用這個選項。

這個程序寫的比較簡單：
沒有考慮服務器效率，只是爲了測試 keepalive 屬性。
錯誤處理也都非常簡單。

說明：本文只是測試客戶主機崩潰或者網絡異常斷開，比如拔掉網線或中間路由器崩潰等情況。
正常關機或重啓本文不予考慮。

思路:
在程序中表現爲,當tcp檢測到對端socket不再可用時(TCP發出保活探查報文，但是沒有收到客戶端對其保活探查報文的響應), select會返回socket可讀, 並且在 recv 或 read 時返回-1,
同時設置errno爲 ETIMEDOUT。

服務器端：

#include <stdio.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>

#define SRV_PORT 12345
#define LISTEN_QUEUE 20

#define CONN_MAX 1024

/* 存放已連接的客戶端描述符 */

int conn[CONN_MAX];

/* 當前已連接客戶端的總數 */
int conn_amount;

int init_socket_tcp(unsigned short port, int backlog);
void active_keepalive(int sockfd);
void set_keepalive_params(int sockfd, int idle, int count, int intvl);

static int firstclient = 1;

int main(int argc, char *argv[])
{
    int sockfd, cltfd = -1;
    struct sockaddr_in clt_addr;
    socklen_t addrlen;

    int i, n;
    char buf[1024];
    int len;

    int maxfd;
    fd_set readfds;

    sockfd = init_socket_tcp(SRV_PORT, LISTEN_QUEUE);
    if (sockfd < 0) {
        perror("init socket failed!");
        exit(EXIT_FAILURE);
    }

    for (i = 0; i < CONN_MAX; i++) {
            conn[i] = -1;
    }

    maxfd = sockfd;
    conn_amount = 0;

    while (1) {
        FD_ZERO(&readfds);
        FD_SET(sockfd, &readfds);

        for (i = 0; i < CONN_MAX; i++) {
            if (conn[i] != -1) {
                FD_SET(conn[i], &readfds);
                if (conn[i] > maxfd)
                    maxfd = conn[i];
            }
        }

        printf("start select............\n");
        if ((n = select(maxfd + 1, &readfds, NULL, NULL, NULL)) < 0) {
            perror("select faield");
            continue;
        }

        for (i = 0; i < CONN_MAX; i++) {
            if ((conn[i] != -1) && FD_ISSET(conn[i], &readfds)) {
                len = read(conn[i], buf, sizeof(buf) - 1);
                if (len < 0) {
                    if (errno == EINTR) {
                        printf("errno == EINTR\n");
                        continue;
                    }
                    if (errno == ETIMEDOUT)
                        printf("ETIMEDOUT..............., client: %d\n", i + 1);
                    perror("read error");
                    close(conn[i]);
                    conn[i] = -1;
                    conn_amount--;
                } else if (len == 0) {
                        printf("client close socket.\n");
                        close(conn[i]);
                        conn[i] = -1;
                        conn_amount--;
                } else
                    printf("read from client: %s\n", buf);
            }
        } /* for (i = 0; i < CONN_MAX; i++)*/

        if (FD_ISSET(sockfd, &readfds)) {
            addrlen = sizeof(struct sockaddr_in);
            cltfd = accept(sockfd, (struct sockaddr *)&clt_addr, &addrlen);
            if (cltfd < 0) {
                perror("accept failed");
                continue;
            }

            if (conn_amount < CONN_MAX) {
                conn_amount++;
                printf("*********** conn_amount = %d\n", conn_amount);

                /* set tcp_keepalive_* options */
                /* 設置第一個客戶端socket keepalive 屬性 */

if (firstclient) {

                    /* 開啓 keepalive 選項 */
                    active_keepalive(cltfd);
                    /* 設置 keepalive 相關參數 */

                    set_keepalive_params(cltfd, 60, 3, 2);
                    firstclient = 0;
                } else { /* 設置其他客戶端socket keepalive 屬性 */

/* 開啓 keepalive 選項 */

active_keepalive(cltfd);

                    /* 設置 keepalive 相關參數 */
                    set_keepalive_params(cltfd, 20, 3, 5);
                }

                for (i = 0; i < CONN_MAX; i++) {
                    if (conn[i] == -1) {
                        conn[i] = cltfd;
                        break;
                    }
                }
            } else { /* 到達 CONN_MAX後，不處理其他客戶端連接請求 */
                printf("max connection arrived, I will close the client socket!\n");
                close(cltfd);
            }
        }

    } /* while (1) */

    close(sockfd);
    exit(EXIT_SUCCESS);
}

int init_socket_tcp(unsigned short port, int backlog)
{
    int sockfd;
    struct sockaddr_in srv_addr;
    socklen_t addrlen;

    sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sockfd < 0) {
        perror("create socket failed!");
        return -1;
    }

    addrlen = sizeof(struct sockaddr_in);
    memset(&srv_addr, 0, sizeof(struct sockaddr_in));
    srv_addr.sin_family = AF_INET;
    srv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    srv_addr.sin_port = htons(port);

    int reuse = 1;
    if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(int)) < 0) {
        perror("setsockopt SO_REUSEADDR");
        close(sockfd);
        return -1;
    }

    if (bind(sockfd, (struct sockaddr *)&srv_addr, addrlen) < 0) {
        perror("bind errror");
        close(sockfd);
        return -1;
    }

    if (listen(sockfd, backlog) < 0) {
        perror("listen error");
        close(sockfd);
        return -1;
    }

    return sockfd;
}

void active_keepalive(int sockfd)
{
    int optval;
    socklen_t optlen = sizeof(optval);

    /* check the status for the keepalive option */
    if (getsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &optval, &optlen) < 0) {
        perror("getsockopt SO_KEEPALIVE failed");
        close(sockfd);
        exit(EXIT_FAILURE);
    }
    printf("SO_KEEPALIVE is %s\n", optval ? "ON" : "OFF");

    /* set the option active */
    optval = 1;
    optlen = sizeof(optval);
    if (setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &optval, optlen) < 0) {
        printf("setsockopt SO_KEEPALIVE failed，reason: %m\n");
        close(sockfd);
        exit(EXIT_FAILURE);
    }
    printf("SO_KEEPALIVE on socket\n");

    /* check the status again */
    if (getsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &optval, &optlen) < 0) {
        perror("getsockopt SO_KEEPALIVE again failed");
        close(sockfd);
        exit(EXIT_FAILURE);
    }
    printf("SO_KEEPALIVE is %s\n", (optval ? "ON" : "OFF"));
}

void set_keepalive_params(int sockfd, int idle, int count, int intvl)
{
    int keepalive_time = idle;
    int keepalive_probes = count;
    int keepalive_intvl = intvl;

    if (setsockopt(sockfd, SOL_TCP, TCP_KEEPIDLE, &keepalive_time, sizeof(int)) < 0) {
        perror("TCP_KEEPIDLE failed");
        return;
    }

    if (setsockopt(sockfd, SOL_TCP, TCP_KEEPCNT, &keepalive_probes, sizeof(int)) < 0) {
        perror("TCP_KEEPCNT failed");
        return;
    }

    if (setsockopt(sockfd, SOL_TCP, TCP_KEEPINTVL, &keepalive_intvl, sizeof(int)) < 0) {
        perror("TCP_KEEPINTVL failed");
        return;
    }

    return;
}

客戶端：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>

#define SRV_IP "192.168.1.4"
#define SRV_PORT 12345

#define errexit(msg) do {perror(msg); exit(EXIT_FAILURE);} while(0)

int main(int argc, char *argv[])
{
    int sockfd;
    struct sockaddr_in srvaddr;

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
        errexit("socket");

    memset(&srvaddr, 0, sizeof(struct sockaddr_in));
    srvaddr.sin_family = AF_INET;
    srvaddr.sin_addr.s_addr = inet_addr(SRV_IP);
    srvaddr.sin_port = htons(SRV_PORT);

    if (connect(sockfd, (struct sockaddr *)&srvaddr, sizeof(struct sockaddr_in)) != 0)
        errexit("connect");
    else
        printf("connect to server succeeded!\n");

    /* 連接成功後，什麼也不做 */
    pause();

    close(sockfd);
    exit(0);
}

測試過程簡單描述：
1.啓動服務器端程序
2.啓動 2 個客戶端
3.在2個客戶端都成功連接服務器後，斷開服務器主機的網線
4.似乎在 20+/-10 秒後，成功檢測出客戶端 2 斷開了，然後似乎再經過 30+/- 10 秒左右, 檢測到客戶端 1 斷開連接。（自己口頭數的秒，具體時間很不準確，但不影響結論

）。

最後的結論：
they override system-wide variables only for the current socket 應該是對的。
也就是，keepalive 屬性只對單個socket 起作用，
對其他 socket 的 keepalive 屬性沒有影響.

http://blog.chinaunix.net/uid-15084954-id-190356.html

網絡編程中的TCP保活

啓用Keepalive

Linux環境下的TCP Keepalive參數設置

WIN32環境下的TCP Keepalive參數設置

工作中用到的腳本合集

24-5-18 X

Unknown symbol gpio_direction_input解決方法

SPIflash

ＳＰＩ總線

STM32 SPI DMA 的使用

Android/Linux驅動開發之使用dev_dbg調試設備驅動

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結