月度归档： 2014 年 6 月

C/C++网络编程中的TCP保活

在默认的情况下，TCP连接是没有保活的心跳的。这就是说，当一个TCP的socket，客户端与服务端谁也不发送数据，会一直保持着连接。这其中如果有一方异常掉线，另一端永远也不可能知道。这对于一些服务型的程序来说，将是灾难性的后果。

　　所以，必须对创建的socket，启用保活心跳，即Keepalive选项。

启用Keepalive

　　对于WIN32或者Linux平台来说，设置socket的Keepalive都很简单，只需使用setsockopt设置SO_KEEPALIVE即可。

　　setsockopt的函数原型在Linux环境下为：

[cpp]
  1. #include <sys/types.h>   
  2. #include <sys/socket.h>   
  3.   
  4. int setsockopt(int s, int level, int optname,  
  5.                const void *optval,  
  6.                socklen_t optlen);  

，在WIN32平台下为

[cpp]
  1. #include <winsock2.h>   
  2.   
  3. int setsockopt(int s, int level, int optname,  
  4.                const char *optval,  
  5.                int optlen);  

　　因为const void *可以接受const char *型的参数，所以为了代码的跨平台编译考虑，可以采用以下代码来设置TCP的Keepalive选项。

[cpp]
  1. alive = 1;  
  2. if (setsockopt  
  3.     (fd, SOL_SOCKET, SO_KEEPALIVE, (const char *) &alive,  
  4.      sizeof alive) != 0)  
  5.   {  
  6.     log_warn (“Set keep alive error: %s.\n”, strerror (errno));  
  7.     return -1;  
  8.   }  

　　这样，对于TCP的连接，就启用了系统默认值的保活心跳。

Linux环境下的TCP Keepalive参数设置

　　为什么说是系统默认值的呢？因为有这样几个值，我们并没有手动设置，是采用的系统默认值。即，

  1. 多长时间发送一次保活心跳？
  2. 如果没有返回，多长时间再重试发送？
  3. 重试几次为失败？　　如果是Linux操作系统，这三个值分别为
[plain]
  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进行设置。

[cpp]
  1. #include <stdlib.h>   
  2. #include <fcntl.h>   
  3. #include <errno.h>   
  4. #include <sys/socket.h>   
  5. #include <netinet/tcp.h>   
  6. #include <netinet/in.h>   
  7. #include <netdb.h>   
  8. #include <arpa/inet.h>   
  9.   
  10. int  
  11. socket_set_keepalive (int fd)  
  12. {  
  13.   int ret, error, flag, alive, idle, cnt, intv;  
  14.   
  15.   /* Set: use keepalive on fd */  
  16.   alive = 1;  
  17.   if (setsockopt  
  18.       (fd, SOL_SOCKET, SO_KEEPALIVE, &alive,  
  19.        sizeof alive) != 0)  
  20.     {  
  21.       log_warn (“Set keepalive error: %s.\n”, strerror (errno));  
  22.       return -1;  
  23.     }  
  24.   
  25.   /* １０秒钟无数据，触发保活机制，发送保活包 */  
  26.   idle = 10;  
  27.   if (setsockopt (fd, SOL_TCP, TCP_KEEPIDLE, &idle, sizeof idle) != 0)  
  28.     {  
  29.       log_warn (“Set keepalive idle error: %s.\n”, strerror (errno));  
  30.       return -1;  
  31.     }  
  32.   
  33.   /* 如果没有收到回应，则５秒钟后重发保活包 */  
  34.   intv = 5;  
  35.   if (setsockopt (fd, SOL_TCP, TCP_KEEPINTVL, &intv, sizeof intv) != 0)  
  36.     {  
  37.       log_warn (“Set keepalive intv error: %s.\n”, strerror (errno));  
  38.       return -1;  
  39.     }  
  40.   
  41.   /* 连续３次没收到保活包，视为连接失效 */  
  42.   cnt = 3;  
  43.   if (setsockopt (fd, SOL_TCP, TCP_KEEPCNT, &cnt, sizeof cnt) != 0)  
  44.     {  
  45.       log_warn (“Set keepalive cnt error: %s.\n”, strerror (errno));  
  46.       return -1;  
  47.     }  
  48.   
  49.   return 0;  
  50. }  

WIN32环境下的TCP Keepalive参数设置

　　而WIN32环境下的参数设置，就要麻烦一些，需要使用另外的一个函数WSAIoctl和一个结构struct tcp_keepalive。

　　它们的原型分别为：

[cpp]
  1. #include <winsock2.h>   
  2. #include <mstcpip.h>   
  3.   
  4. int WSAIoctl(  
  5.              SOCKET s,  
  6.              DWORD dwIoControlCode,  
  7.              LPVOID lpvInBuffer,  
  8.              DWORD cbInBuffer,  
  9.              LPVOID lpvOutBuffer,  
  10.              DWORD cbOutBuffer,  
  11.              LPDWORD lpcbBytesReturned,  
  12.              LPWSAOVERLAPPED lpOverlapped,  
  13.              LPWSAOVERLAPPED_COMPLETION lpCompletionRoutine  
  14. );  
  15.   
  16. struct tcp_keepalive {  
  17.     u_long onoff;  
  18.     u_long keepalivetime;  
  19.     u_long keepaliveinterval;  
  20. };  

　　在这里，使用WSAIoctl的时候，dwIoControlCode要使用SIO_KEEPALIVE_VALS，lpvOutBuffer用不上，cbOutBuffer必须设置为0。

　　struct tcp_keepalive结构的参数意义为：

　　onoff，是否开启KEEPALIVE； keepalivetime，多长时间触发Keepalive报文的发送； keepaliveinterval，多长时间没有回应触发下一次发送。

　　注意：这里两个时间单位都是毫秒而不是秒。

[cpp]
  1. #include <winsock2.h>   
  2. #include <mstcpip.h>   
  3.   
  4. int  
  5. socket_set_keepalive (int fd)  
  6. {  
  7.   struct tcp_keepalive kavars[1] = {  
  8.       1,  
  9.       10 * 1000,        /* 10 seconds */  
  10.       5 * 1000          /* 5 seconds */  
  11.   };  
  12.   
  13.   /* Set: use keepalive on fd */  
  14.   alive = 1;  
  15.   if (setsockopt  
  16.       (fd, SOL_SOCKET, SO_KEEPALIVE, (const char *) &alive,  
  17.        sizeof alive) != 0)  
  18.     {  
  19.       log_warn (“Set keep alive error: %s.\n”, strerror (errno));  
  20.       return -1;  
  21.     }  
  22.   
  23.   if (WSAIoctl  
  24.       (fd, SIO_KEEPALIVE_VALS, kavars, sizeof kavars, NULL, sizeof (int), &ret, NULL,  
  25.        NULL) != 0)  
  26.     {  
  27.       log_warn (“Set keep alive error: %s.\n”, strerror (WSAGetLastError ()));  
  28.       return -1;  
  29.     }  
  30.   
  31.   return 0;  
  32. }  

位运算实现int的abs/min/max函数

论坛上两次看到不用比较计算最大/最小值了，第一次讨论时有个人有人给出了最理想的答案。那个人说在做图像运算时，比较运算会对指令流水线效率有较大影响，因而需要另外的实现。第二次讨论时找不到第一次的帖子了，于是凭着印象并查了一些资料，仔细想了想，得到了之前的答案（假定int为4个字节）：

int min(int a, int b)

{

int diff = b – a;

// b < a: a + (diff & -1)

// b > a: a + (diff & 0)

return a + (diff & (diff >> 31));

}

int max(int a, int b)

{

int diff = b – a;

// b < a: b – (diff & -1)

// b > a: b – (diff & 0)

return b – (diff & (diff >> 31));

}

int abs(int a)

{

int temp = (a >> 31);

return (a + temp) ^ temp;

}

原理上主要有两点：

1， 整数是以补码表示的

2， 有符号数的移位运算是算数移位（乘2和除2）而非物理移位

正数和0的补码同原码，负数的补码是绝对值的反码加1。-1的补码表示是0xFFFFFFFF。

任何一个非负整数（0~231-1）右移31位都是0；任何一个负整数（-231~-1）右移31位都是-1。这样min和max就比较容易理解了。

再看abs

a ^ -1 == ~a-1

a ^ 0 == a

若a非负，没有任何变化；若a为负，加-1再取反，得到绝对值。