C++博客- C++ 技术中心-随笔分类-Windows 网络编程

套接字read/write返回值

C++技术中心 — Tue, 12 Dec 2017 02:32:00 GMT

1、阻塞模式与非阻塞模式下recv的返回值各代表什么意思？有没有区别？（就我目前了解阻塞与非阻塞recv返回值没有区分，都是 <0：出错，=0：连接关闭，>0接收到数据大小，特别：返回值 <0时并且(errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)的情况下认为连接是正常的，继续接收。只是阻塞模式下recv会阻塞着接收数据，非阻塞模式下如果没有数据会返回，不会阻塞着读，因此需要循环读取

2、阻塞模式与非阻塞模式下write的返回值各代表什么意思？有没有区别？

阻塞与非阻塞write返回值没有区分，都是 <0：出错，=0：连接关闭，>0发送数据大小，特别：返回值 <0时并且(errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)的情况下认为连接是正常的，继续发送。只是阻塞模式下write会阻塞着发送数据，非阻塞模式下如果暂时无法发送数据会返回，不会阻塞着 write，因此需要循环发送

3、阻塞模式下read返回值 < 0 && errno != EINTR && errno != EWOULDBLOCK && errno != EAGAIN时，连接异常，需要关闭，read返回值 < 0 && (errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)时表示没有数据，需要继续接收，如果返回值大于0表示接送到数据。

非阻塞模式下read返回值 < 0表示没有数据，= 0表示连接断开，> 0表示接收到数据。

这2种模式下的返回值是不是这么理解，有没有跟详细的理解或跟准确的说明？

4、阻塞模式与非阻塞模式下是否send返回值 < 0 && (errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)表示暂时发送失败，需要重试，如果send返回值 <= 0, && errno != EINTR && errno != EWOULDBLOCK && errno != EAGAIN时，连接异常，需要关闭，如果send返回值 > 0则表示发送了数据？send的返回值是否这么理解，阻塞模式与非阻塞模式下send返回值=0是否都是发送失败，还是那个模式下表示暂时不可发送，需要重发？

1. send函数

int send( SOCKET s, const char FAR *buf, int len, int flags );

不论是客户端还是服务器端应用程序都用send函数来向TCP连接的另一端发送数据。

客户端程序一般用send函数向服务器发送请求，而服务器则通常用send函数来向客户程序发送应答。

该函数的：

第一个参数指定发送端套接字描述符；

第二个参数指明一个存放应用程序要发送数据的缓冲区；

第三个参数指明实际要发送的数据的字节数；

第四个参数一般置0。

这里只描述同步Socket的send函数的执行流程。当调用该函数时，send先比较待发送数据的长度len和套接字s的发送缓冲的长度，如果len大于s的发送缓冲区的长度，该函数返回SOCKET_ERROR；如果len小于或者等于s的发送缓冲区的长度，那么send先检查协议是否正在发送s的发送缓冲中的数据，如果是就等待协议把数据发送完，如果协议还没有开始发送s的发送缓冲中的数据或者s的发送缓冲中没有数据，那么 send就比较s的发送缓冲区的剩余空间和len，如果len大于剩余空间大小send就一直等待协议把s的发送缓冲中的数据发送完，如果len小于剩余空间大小send就仅仅把buf中的数据copy到剩余空间里（注意并不是send把s的发送缓冲中的数据传到连接的另一端的，而是协议传的，send仅仅是把buf中的数据copy到s的发送缓冲区的剩余空间里）。如果send函数copy数据成功，就返回实际copy的字节数，如果send在copy数据时出现错误，那么send就返回SOCKET_ERROR；如果send在等待协议传送数据时网络断开的话，那么send函数也返回SOCKET_ERROR。

要注意send函数把buf中的数据成功copy到s的发送缓冲的剩余空间里后它就返回了，但是此时这些数据并不一定马上被传到连接的另一端。如果协议在后续的传送过程中出现网络错误的话，那么下一个Socket函数就会返回SOCKET_ERROR。（每一个除send外的Socket函数在执行的最开始总要先等待套接字的发送缓冲中的数据被协议传送完毕才能继续，如果在等待时出现网络错误，那么该Socket函数就返回 SOCKET_ERROR）

注意：在Unix系统下，如果send在等待协议传送数据时网络断开的话，调用send的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。

Send函数的返回值有三类：

（1）返回值=0：

（2）返回值<0：发送失败，错误原因存于全局变量errno中

（3）返回值>0：表示发送的字节数（实际上是拷贝到发送缓冲中的字节数）

错误代码：

EBADF 参数s 非合法的socket处理代码。
EFAULT 参数中有一指针指向无法存取的内存空间
ENOTSOCK 参数s为一文件描述词，非socket。
EINTR 被信号所中断。
EAGAIN 此操作会令进程阻断，但参数s的socket为不可阻断。
ENOBUFS 系统的缓冲内存不足
ENOMEM 核心内存不足
EINVAL 传给系统调用的参数不正确。

2. recv函数

int recv( SOCKET s, char FAR *buf, int len, int flags );

不论是客户端还是服务器端应用程序都用recv函数从TCP连接的另一端接收数据。

该函数的：

第一个参数指定接收端套接字描述符；

第二个参数指明一个缓冲区，该缓冲区用来存放recv函数接收到的数据；

第三个参数指明buf的长度；

第四个参数一般置0。

这里只描述同步Socket的recv函数的执行流程。当应用程序调用recv函数时，recv先等待s的发送缓冲中的数据被协议传送完毕，如果协议在传送s的发送缓冲中的数据时出现网络错误，那么recv函数返回SOCKET_ERROR，如果s的发送缓冲中没有数据或者数据被协议成功发送完毕后，recv先检查套接字s的接收缓冲区，如果s接收缓冲区中没有数据或者协议正在接收数据，那么recv就一直等待，只到协议把数据接收完毕。当协议把数据接收完毕，recv函数就把s的接收缓冲中的数据copy到buf中（注意协议接收到的数据可能大于buf的长度，所以在这种情况下要调用几次recv函数才能把s的接收缓冲中的数据copy完。recv函数仅仅是copy数据，真正的接收数据是协议来完成的），recv函数返回其实际copy的字节数。如果recv在copy时出错，那么它返回SOCKET_ERROR；如果recv函数在等待协议接收数据时网络中断了，那么它返回0。

注意：在Unix系统下，如果recv函数在等待协议接收数据时网络断开了，那么调用recv的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。

默认情况下socket是阻塞的。

阻塞与非阻塞recv返回值没有区别，都是：

<0 出错

=0 对方调用了close API来关闭连接

>0 接收到的数据大小，

特别地：返回值<0时并且(errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)的情况下认为连接是正常的，继续接收。

只是阻塞模式下recv会一直阻塞直到接收到数据，非阻塞模式下如果没有数据就会返回，不会阻塞着读，因此需要循环读取）。

返回说明：

（1）成功执行时，返回接收到的字节数。

（2）若另一端已关闭连接则返回0，这种关闭是对方主动且正常的关闭

（3）失败返回-1，errno被设为以下的某个值

EAGAIN：套接字已标记为非阻塞，而接收操作被阻塞或者接收超时

EBADF：sock不是有效的描述词

ECONNREFUSE：远程主机阻绝网络连接

EFAULT：内存空间访问出错

EINTR：操作被信号中断

EINVAL：参数无效

ENOMEM：内存不足

ENOTCONN：与面向连接关联的套接字尚未被连接上

ENOTSOCK：sock索引的不是套接字

C++技术中心 2017-12-12 10:32 发表评论

Echo Server based on libevent

C++技术中心 — Sun, 03 May 2015 12:28:00 GMT

出处：Blog of Felix021

时间：Sat, 25 Feb 2012 00:43:26 +0000

作者：felix021

地址：http://www.felix021.com/blog/read.php?2068

内容：

花了两天的时间在libevent上，想总结下，就以写简单tutorial的方式吧，貌似没有一篇简单的说明，让人马上就能上手用的。

首先给出官方文档吧： http://libevent.org ，首页有个Programming with Libevent，里面是一节一节的介绍libevent，但是感觉信息量太大了，而且还是英文的-。-（当然，如果想好好用libevent，看看还是很有必要的），还有个Reference，大致就是对各个版本的libevent使用doxgen生成的文档，用来查函数原型和基本用法什么的。

下面假定已经学习过基本的socket编程（socket,bind,listen,accept,connect,recv,send,close），并且对异步/callback有基本认识。

基本的socket编程是阻塞/同步的，每个操作除非已经完成或者出错才会返回，这样对于每一个请求，要使用一个线程或者单独的进程去处理，系统资源没法支撑大量的请求（所谓c10k problem?），例如内存：默认情况下每个线程需要占用2～8M的栈空间。posix定义了可以使用异步的select系统调用，但是因为其采用了轮询的方式来判断某个fd是否变成active，效率不高[O(n)]，连接数一多，也还是撑不住。于是各系统分别提出了基于异步/callback的系统调用，例如Linux的epoll，BSD的kqueue，Windows的IOCP。由于在内核层面做了支持，所以可以用O(1)的效率查找到active的fd。基本上，libevent就是对这些高效IO的封装，提供统一的API，简化开发。

libevent大概是这样的：

默认情况下是单线程的（可以配置成多线程，如果有需要的话），每个线程有且只有一个event_base，对应一个struct event_base结构体（以及附于其上的事件管理器），用来schedule托管给它的一系列event，可以和操作系统的进程管理类比，当然，要更简单一点。当一个事件发生后，event_base会在合适的时间（不一定是立即）去调用绑定在这个事件上的函数（传入一些预定义的参数，以及在绑定时指定的一个参数），直到这个函数执行完，再返回schedule其他事件。//创建一个event_base

struct event_base *base = event_base_new();

assert(base != NULL);

event_base内部有一个循环，循环阻塞在epoll/kqueue等系统调用上，直到有一个/一些事件发生，然后去处理这些事件。当然，这些事件要被绑定在这个event_base上。每个事件对应一个struct event，可以是监听一个fd或者POSIX信号量之类（这里只讲fd了，其他的看manual吧）。struct event使用event_new来创建和绑定，使用event_add来启用：//创建并绑定一个event

struct event *listen_event;

//参数：event_base, 监听的fd，事件类型及属性，绑定的回调函数，给回调函数的参数

listen_event = event_new(base, listener, EV_READ|EV_PERSIST, callback_func, (void*)base);

//参数：event，超时时间(struct timeval *类型的，NULL表示无超时设置)

event_add(listen_event, NULL);

注：libevent支持的事件及属性包括(使用bitfield实现，所以要用 | 来让它们合体)

(a) EV_TIMEOUT: 超时

(b) EV_READ: 只要网络缓冲中还有数据，回调函数就会被触发

(d) EV_SIGNAL: POSIX信号量，参考manual吧

(e) EV_PERSIST: 不指定这个属性的话，回调函数被触发后事件会被删除

(f) EV_ET: Edge-Trigger边缘触发，参考EPOLL_ET

然后需要启动event_base的循环，这样才能开始处理发生的事件。循环的启动使用event_base_dispatch，循环将一直持续，直到不再有需要关注的事件，或者是遇到event_loopbreak()/event_loopexit()函数。//启动事件循环

event_base_dispatch(base);

接下来关注下绑定到event的回调函数callback_func：传递给它的是一个socket fd、一个event类型及属性bit_field、以及传递给event_new的最后一个参数（去上面几行回顾一下，把event_base给传进来了，实际上更多地是分配一个结构体，把相关的数据都撂进去，然后丢给event_new，在这里就能取得到了）。其原型是：typedef void(* event_callback_fn)(evutil_socket_t sockfd, short event_type, void *arg)

对于一个服务器而言，上面的流程大概是这样组合的：

1. listener = socket()，bind()，listen()，设置nonblocking(POSIX系统中可使用fcntl设置，windows不需要设置，实际上libevent提供了统一的包装evutil_make_socket_nonblocking)

2. 创建一个event_base

3. 创建一个event，将该socket托管给event_base，指定要监听的事件类型，并绑定上相应的回调函数(及需要给它的参数)。对于listener socket来说，只需要监听EV_READ|EV_PERSIST

4. 启用该事件

5. 进入事件循环

---------------

6. (异步) 当有client发起请求的时候，调用该回调函数，进行处理。

问题：为什么不在listen完马上调用accept，获得客户端连接以后再丢给event_base呢？这个问题先想想噢。

回调函数要做什么事情呢？当然是处理client的请求了。首先要accept，获得一个可以与client通信的sockfd，然后……调用recv/send吗？错！大错特错！如果直接调用recv/send的话，这个线程就阻塞在这个地方了，如果这个客户端非常的阴险（比如一直不发消息，或者网络不好，老是丢包），libevent就只能等它，没法处理其他的请求了——所以应该创建一个新的event来托管这个sockfd。

在老版本libevent上的实现，比较罗嗦[如果不想详细了解的话，看下一部分]。

对于服务器希望先从client获取数据的情况，大致流程是这样的：

1. 将这个sockfd设置为nonblocking

2. 创建2个event:

event_read，绑上sockfd的EV_READ|EV_PERSIST，设置回调函数和参数（后面提到的struct）

event_write，绑上sockfd的EV_WRITE|EV_PERSIST，设置回调函数和参数（后面提到的struct）

3. 启用event_read事件

------

4. (异步) 等待event_read事件的发生, 调用相应的回调函数。这里麻烦来了：回调函数用recv读入的数据，不能直接用send丢给sockfd了事——因为sockfd是nonblocking的，丢给它的话，不能保证正确（为什么呢？）。所以需要一个自己管理的缓存用来保存读入的数据中（在accept以后就创建一个struct，作为第2步回调函数的arg传进来），在合适的时间（比如遇到换行符）启用event_write事件【event_add(event_write, NULL)】，等待EV_WRITE事件的触发

------

5. (异步) 当event_write事件的回调函数被调用的时候，往sockfd写入数据，然后删除event_write事件【event_del(event_write)】，等待event_read事件的下一次执行。

以上步骤比较晦涩，具体代码可参考官方文档里面的【Example: A low-level ROT13 server with Libevent】

由于需要自己管理缓冲区，且过程晦涩难懂，并且不兼容于Windows的IOCP，所以libevent2开始，提供了bufferevent这个神器，用来提供更加优雅、易用的API。struct bufferevent内建了两个event(read/write)和对应的缓冲区【struct evbuffer *input, *output】，并提供相应的函数用来操作缓冲区（或者直接操作bufferevent）。每当有数据被读入input的时候，read_cb函数被调用；每当output被输出完的时候，write_cb被调用；在网络IO操作出现错误的情况（连接中断、超时、其他错误），error_cb被调用。于是上一部分的步骤被简化为：

1. 设置sockfd为nonblocking

2. 使用bufferevent_socket_new创建一个struct bufferevent *bev，关联该sockfd，托管给event_base

3. 使用bufferevent_setcb(bev, read_cb, write_cb, error_cb, (void *)arg)将EV_READ/EV_WRITE对应的函数

4. 使用bufferevent_enable(bev, EV_READ|EV_WRITE|EV_PERSIST)来启用read/write事件

------

5. (异步)

在read_cb里面从input读取数据，处理完毕后塞到output里(会被自动写入到sockfd)

在write_cb里面（需要做什么吗？对于一个echo server来说，read_cb就足够了）

在error_cb里面处理遇到的错误

*. 可以使用bufferevent_set_timeouts(bev, struct timeval *READ, struct timeval *WRITE)来设置读写超时, 在error_cb里面处理超时。

*. read_cb和write_cb的原型是

void read_or_write_callback(struct bufferevent *bev, void *arg)

error_cb的原型是

void error_cb(struct bufferevent *bev, short error, void *arg) //这个是event的标准回调函数原型

可以从bev中用libevent的API提取出event_base、sockfd、input/output等相关数据，详情RTFM~

于是代码简化到只需要几行的read_cb和error_cb函数即可：

void read_cb(struct bufferevent *bev, void *arg) {

char line[256];

int n;

evutil_socket_t fd = bufferevent_getfd(bev);

while (n = bufferevent_read(bev, line, 256), n > 0)

bufferevent_write(bev, line, n);

}

void error_cb(struct bufferevent *bev, short event, void *arg) {

bufferevent_free(bev);

}

于是一个支持大并发量的echo server就成型了！下面附上无注释的echo server源码，110行，多抄几遍，就能完全弄懂啦！更复杂的例子参见官方文档里面的【Example: A simpler ROT13 server with Libevent】

#include

#define LISTEN_PORT 9999

#define LISTEN_BACKLOG 32

void do_accept(evutil_socket_t listener, short event, void *arg);

void read_cb(struct bufferevent *bev, void *arg);

void error_cb(struct bufferevent *bev, short event, void *arg);

void write_cb(struct bufferevent *bev, void *arg);

int main(int argc, char *argv[])

{

int ret;

evutil_socket_t listener;

listener = socket(AF_INET, SOCK_STREAM, 0);

assert(listener > 0);

evutil_make_listen_socket_reuseable(listener);

struct sockaddr_in sin;

sin.sin_family = AF_INET;

sin.sin_addr.s_addr = 0;

sin.sin_port = htons(LISTEN_PORT);

if (bind(listener, (struct sockaddr *)&sin, sizeof(sin)) < 0) {

perror("bind");

return 1;

}

if (listen(listener, LISTEN_BACKLOG) < 0) {

perror("listen");

return 1;

}

printf ("Listening...\n");

evutil_make_socket_nonblocking(listener);

struct event_base *base = event_base_new();

assert(base != NULL);

struct event *listen_event;

listen_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base);

event_add(listen_event, NULL);

event_base_dispatch(base);

printf("The End.");

return 0;

}

void do_accept(evutil_socket_t listener, short event, void *arg)

{

struct event_base *base = (struct event_base *)arg;

evutil_socket_t fd;

struct sockaddr_in sin;

socklen_t slen = sizeof(sin);

fd = accept(listener, (struct sockaddr *)&sin, &slen);

if (fd < 0) {

perror("accept");

return;

}

if (fd > FD_SETSIZE) { //这个if是参考了那个ROT13的例子，貌似是官方的疏漏，从select-based例子里抄过来忘了改

perror("fd > FD_SETSIZE\n");

return;

}

printf("ACCEPT: fd = %u\n", fd);

struct bufferevent *bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);

bufferevent_setcb(bev, read_cb, NULL, error_cb, arg);

bufferevent_enable(bev, EV_READ|EV_WRITE|EV_PERSIST);

}

void read_cb(struct bufferevent *bev, void *arg)

{

#define MAX_LINE 256

char line[MAX_LINE+1];

int n;

evutil_socket_t fd = bufferevent_getfd(bev);

while (n = bufferevent_read(bev, line, MAX_LINE), n > 0) {

line[n] = '\0';

printf("fd=%u, read line: %s\n", fd, line);

bufferevent_write(bev, line, n);

}

void write_cb(struct bufferevent *bev, void *arg) {}

void error_cb(struct bufferevent *bev, short event, void *arg)

{

evutil_socket_t fd = bufferevent_getfd(bev);

printf("fd = %u, ", fd);

if (event & BEV_EVENT_TIMEOUT) {

printf("Timed out\n"); //if bufferevent_set_timeouts() called

}

else if (event & BEV_EVENT_EOF) {

printf("connection closed\n");

}

else if (event & BEV_EVENT_ERROR) {

printf("some other error\n");

}

bufferevent_free(bev);

}

C++技术中心 2015-05-03 20:28 发表评论

libevent windows编译

C++技术中心 — Sun, 15 Feb 2015 05:14:00 GMT

1. 下载libevent库
2.本人用vs2013编译，所有需要修改

在以下3个文件开头修改“#define _WIN32_WINNT 0x0603”

libevent-2.0.22-stable\event_iocp.c

libevent-2.0.22-stable\evthread_win32.c

libevent-2.0.22-stable\listener.c

3.设置nmake的环境
VC6 prefix\Microsoft Visual Studio\VC98\Bin\VCVARS32.BAT
VC8 prefix\Microsoft Visual Studio 8\VC\bin\vcvars32.bat
VC9 prefix\Microsoft Visual Studio 9.0\VC\bin\vcvars32.bat
我这里是vs2013，执行D:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\vcvars32.bat
注意：这些批处理文件只会在当前进程中设置（局部的）环境变量，也就是说：
1. 用cmd（或者command）打开的命令行窗口中，运行某个vcvar32.bat一次。
那么当前命令行窗口中就可以正常使用cl，直到关闭。

4.使用VC的nmake -f Makefile.nmake即可编译32位release模式。
如果要求编译64位的版本，需要在Makefile.nmake中添加一个LIBFLAGS选项 /MACHINE:X64
如果要加调试信息，可以在 CFLAGS中加入/Zi，32位加调试选项是 CFLAGS中加/ZI，当然要调整优化选项/Ox

C++技术中心 2015-02-15 13:14 发表评论

tcp连接探测Keepalive和心跳包

C++技术中心 — Tue, 13 Aug 2013 01:03:00 GMT

     采用TCP连接的C/S模式软件，连接的双方在连接空闲状态时，如果任意一方意外崩溃、当机、网线断开或路由器故障，另一方无法得知TCP连接已经失效，除非继续在此连接上发送数据导致错误返回。很多时候，这不是我们需要的。我们希望服务器端和客户端都能及时有效地检测到连接失效，然后优雅地完成一些清理工作并把错误报告给用户。
      如何及时有效地检测到一方的非正常断开，一直有两种技术可以运用。一种是由TCP协议层实现的Keepalive，另一种是由应用层自己实现的心跳包。
      TCP默认并不开启Keepalive功能，因为开启Keepalive功能需要消耗额外的宽带和流量，尽管这微不足道，但在按流量计费的环境下增加了费用，另一方面，Keepalive设置不合理时可能会因为短暂的网络波动而断开健康的TCP连接。并且，默认的Keepalive超时需要7,200,000 milliseconds，即2小时，探测次数为5次。
      对于Win2K/XP/2003，可以从下面的注册表项找到影响整个系统所有连接的keepalive参数：
       [HKEY_LOCAL_MACHINE/SYSTEM/CurrentControlSet/Services/Tcpip/Parameters]
        "KeepAliveTime”=dword:006ddd00
        "KeepAliveInterval"=dword:000003e8
        "MaxDataRetries"="5"

      对于实用的程序来说，2小时的空闲时间太长。因此，我们需要手工开启Keepalive功能并设置合理的Keepalive参数。

// 开启KeepAlive
BOOL bKeepAlive = TRUE;
int nRet = ::setsockopt(socket_handle, SOL_SOCKET, SO_KEEPALIVE, (char*)&bKeepAlive, sizeof(bKeepAlive));

if (nRet == SOCKET_ERROR)
{
return FALSE;
}

// 设置KeepAlive参数
tcp_keepalive alive_in = {0};
tcp_keepalive alive_out = {0};
alive_in.keepalivetime = 5000; // 开始首次KeepAlive探测前的TCP空闭时间

alive_in.keepaliveinterval = 1000; // 两次KeepAlive探测间的时间间隔

alive_in.onoff = TRUE;
unsigned long ulBytesReturn = 0;

nRet = WSAIoctl(socket_handle, SIO_KEEPALIVE_VALS, &alive_in, sizeof(alive_in),
&alive_out, sizeof(alive_out), &ulBytesReturn, NULL, NULL);
if (nRet == SOCKET_ERROR)
{
return FALSE;

}

开启Keepalive选项之后，对于使用IOCP模型的服务器端程序来说，一旦检测到连接断开，GetQueuedCompletionStatus函数将立即返回FALSE，使得服务器端能及时清除该连接、释放该连接相关的资源。对于使用select模型的客户端来说，连接断开被探测到时，以recv目的阻塞在socket上的select方法将立即返回SOCKET_ERROR，从而得知连接已失效，客户端程序便有机会及时执行清除工作、提醒用户或重新连接。

另一种技术，由应用程序自己发送心跳包来检测连接的健康性。客户端可以在一个Timer中或低级别的线程中定时向发服务器发送一个短小精悍的包，并等待服务器的回应。客户端程序在一定时间内没有收到服务器回应即认为连接不可用，同样，服务器在一定时间内没有收到客户端的心跳包则认为客户端已经掉线。

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

　windows下此处的”非正常断开”指TCP连接不是以优雅的方式断开,如网线故障等物理链路的原因,还有突然主机断电等原因.

有两种方法可以检测:

1.TCP连接双方定时发握手消息

2.利用TCP协议栈中的KeepAlive探测
第二种方法简单可靠,只需对TCP连接两个Socket设定KeepAlive探测,
所以本文只讲第二种方法在Linux,Window2000下的实现(在其它的平台上没有作进一步的测试)

Windows 2000平台下头文件
#include <mstcpip.h>
//定义结构及宏
/*
struct TCP_KEEPALIVE {
u_longonoff;
u_longkeepalivetime;
u_longkeepaliveinterval;
} ;
*/

    tcp_keepalive live,liveout;
    live.keepaliveinterval=5000; //每5秒发一次探测报文,发5次没有回应，就断开
    live.keepalivetime=30000;//超过30s没有数据，就发送控测包

    live.onoff=TRUE;
    int Opt = 1;
    int iRet = setsockopt(Accept,SOL_SOCKET,SO_KEEPALIVE,(char *)&Opt,sizeof(int));
    if(iRet == 0){
     DWORD dw;
     if(::WSAIoctl(Accept,SIO_KEEPALIVE_VALS,
      &live,sizeof(live),&liveout,sizeof(liveout),
      &dw,NULL,NULL)== SOCKET_ERROR){
     }
    }

ACE下代码 //by rainfish blog.csdn.net/bat603

int Opt = 1;
//在测试过程中，发现检测的次数是5次，即下面的设置中，从最近一次消息开始计算的10秒后，每次间隔5秒，连续发送5次，即35秒发现网络断了
tcp_keepalive live,liveout;
live.keepaliveinterval=5000; //每次检测的间隔（单位毫秒）
live.keepalivetime=10000; //第一次开始发送的时间（单位毫秒）
live.onoff=TRUE;
int iRet = stream.set_option(SOL_SOCKET,SO_KEEPALIVE,&Opt,sizeof(int));
if(iRet == 0){
DWORD dw;
//此处显示了在ACE下获取套接字的方法，即句柄的(SOCKET)化就是句柄
if(WSAIoctl((SOCKET)h,SIO_KEEPALIVE_VALS,&live,sizeof(live),
&liveout,sizeof(liveout),&dw,NULL,NULL)== SOCKET_ERROR){
//Delete Client
return;
}
}

Linux平台下

#include "/usr/include/linux/tcp.h"
#include "/usr/include/linux/socket.h"
////KeepAlive实现，单位秒
//下面代码要求有ACE,如果没有包含ACE,则请把用到的ACE函数改成linux相应的接口
int keepAlive = 1;//设定KeepAlive
int keepIdle = 5;//开始首次KeepAlive探测前的TCP空闭时间
int keepInterval = 5;//两次KeepAlive探测间的时间间隔
int keepCount = 3;//判定断开前的KeepAlive探测次数
if(setsockopt(s,SOL_SOCKET,SO_KEEPALIVE,(void*)&keepAlive,sizeof(keepAlive)) == -1)
{
ACE_DEBUG ((LM_INFO,
ACE_TEXT ("(%P|%t) setsockopt SO_KEEPALIVE error!/n")));
}

if(setsockopt(s,SOL_TCP,TCP_KEEPIDLE,(void *)&keepIdle,sizeof(keepIdle)) == -1)
{
ACE_DEBUG ((LM_INFO,
ACE_TEXT ("(%P|%t) setsockopt TCP_KEEPIDLE error!/n")));
}

if(setsockopt(s,SOL_TCP,TCP_KEEPINTVL,(void *)&keepInterval,sizeof(keepInterval)) == -1)
{
ACE_DEBUG ((LM_INFO,
ACE_TEXT ("(%P|%t) setsockopt TCP_KEEPINTVL error!/n")));
}

if(setsockopt(s,SOL_TCP,TCP_KEEPCNT,(void *)&keepCount,sizeof(keepCount)) == -1)
{
ACE_DEBUG ((LM_INFO,
ACE_TEXT ("(%P|%t)setsockopt TCP_KEEPCNT error!/n")));
}

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

C++技术中心 2013-08-13 09:03 发表评论