69,371
社区成员
发帖
与我相关
我的任务
分享tcp 长连接检测客户端异常退出 keepalive使用
作为服务器端，在已客户端成功连接后要检测客户端异常断开。
使用keepalive ,在#if 0和#endif之间的东西是要放在什么地方，
它的工作机制是不是这样的： 如果客户端与之300秒没有数据交互，这发送个询问包。若没有回复则判断为断开。。
使用keepalive ,在#if 0和#endif之间的东西是要放在什么地方，
它的工作机制是不是这样的： 如果客户端与之300秒没有数据交互，这发送个询问包。若没有回复则判断为断开。。
int Init_tcp()
{
int listenfd, connectfd;
struct sockaddr_in saddr;
struct sockaddr_in caddr;
int sockopt = 1;
int len = 0;
char buf[1024] = {0};
socklen_t size = sizeof(caddr);
memset(saddr, 0, sizeof(struct sockaddr_in));
memset(caddr, 0, sizeof(struct sockaddr_in));
listenfd = socket(AF_INET, SOCK_STREAM, 0);
if(listenfd < 0)
{
perro("create socket fail!");
return ;
}
/* 设置为非阻塞*/
if (fcntl(listenfd, F_SETFL, O_NONBLOCK) < 0)
{
perror("O_NONBLOCK error!");
}
setsockopt(listenfd, SOL_SOCKET, SO_RCVTIMEO, (char *)&sockopt, sizeof(sockopt));
setsockopt(listenfd, SOL_SOCKET, SO_SNDTIMEO, (char *)&sockopt, sizeof(sockopt));
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, (char *)&sockopt, sizeof(sockopt));
setsockopt(listenfd, SOL_SOCKET, SO_REUSEPORT, (char *)&sockopt, sizeof(sockopt));
setsockopt(listenfd, SOL_SOCKET, TCP_NODELAY, (char *)&sockopt, sizeof(sockopt));
#if 0
int keepalive = 1;
setsockopt(listenfd, SOL_SOCKET, SO_KEEPALIVE, (char *)&keepalive, sizeof(keepalive));
int keepIdle = 300
setsockopt(listenfd, SOL_SOCKET, TCP_KEEPIDLE, (char *)&keepIdle, sizeof(keepIdle));
int keepInterval = 300;
setsockopt(listenfd, SOL_SOCKET, TCP_KEEPINTVL, (char *)&keepInterval, sizeof(keepInterval));
int keepCount = 3;
setsockopt(listenfd, SOL_SOCKET, TCP_KEEPCNT, (char *)&keepCount, sizeof(keepCount));
#endif
saddr.sin_family = AF_INET;
saddr.sin_port = htons(5000);
saddr.sin_addr.s_addr = INADDR_ANY;
if(bind(listenfd, (struct sockaddr *)&saddr, sizeof(saddr)) == -1)
{
perror("bind fail!");
close(listenfd);
return ;
}
if(listen(listenfd, 5) == -1)
{
perror("listen fail!");
close(listenfd);
return ;
}
while(1)
{
connectfd = accept(listenfd, (struct sockaddr *)&caddr, &size);
#if 0
int keepalive = 1;
setsockopt(connectfd, SOL_SOCKET, SO_KEEPALIVE, (char *)&keepalive, sizeof(keepalive));
int keepIdle = 300
setsockopt(connectfd, SOL_SOCKET, TCP_KEEPIDLE, (char *)&keepIdle, sizeof(keepIdle));
int keepInterval =300;
setsockopt(listenfd, SOL_SOCKET, TCP_KEEPINTVL, (char *)&keepInterval, sizeof(keepInterval));
int keepCount = 3;
setsockopt(connectfd, SOL_SOCKET, TCP_KEEPCNT, (char *)&keepCount, sizeof(keepCount));
#endif
len = recv(connectfd, buf, 1024, 0);
if(len < 0)
{
// ...
}
if(len == 0)
{
// ...
}
else
{
// ...
}
}
}
...全文
请发表友善的回复…
发表回复
要追问请引用回复 2014-06-18
- 打赏
- 举报
心跳包原理：
1、自行实现的心跳包，一般是发送一段简短的报文
2、tcp协议栈自带的keepalive心跳包，重发一个已经发送过的字节，有触发时间（即一段时间无通信后）
要追问请引用回复 2014-06-18
- 打赏
- 举报
keepalive是tcp协议栈提供的心跳包（保活）机制
以windows平台上已建立的连接为例：
用户进程（非服务）被杀死，tcp协议栈将异常断开连接，另一方可以获得通知，如recv返回-1
用户进程退出且未调用closesocket，另一方可以获得通知
系统关机（正常的），另一方可以获得通知
系统关机（异常的），另一方不一定可以获得通知
系统断电，另一方无法获得通知
网络突然故障（例如网线被拔掉），另一方无法获得通知
由此可见，断电和断网时，对方无法获得通知，recv将一直阻塞直到永远。keepalive主要就是为了应对这种情况，若干保活包不能送达，对方即认为连接丢失。
(>^ω^<)喵上树 2014-06-18
- 打赏
- 举报
表示没怎么看懂。。使用心跳包是不是会改变协议？
比如说TCP 的数据部分原来是char data[0]。
现在可能要改写成
typedef struct _t_msg
{
unsigned int type; //用来标记是否是心跳包
char data[0];
}tMsg;
而且客户端的数据部分也要是这个格式。。
mujiok2003 2014-06-18
- 打赏
- 举报
太粗暴不好吧！！！！万一别人没有想要端开，结果你给关了。。[/quote]
粗暴是相对的， 时间你可以自己调整。 心跳包也会有误杀的情况。
(>^ω^<)喵上树 2014-06-18
- 打赏
- 举报
太粗暴不好吧！！！！万一别人没有想要端开，结果你给关了。。
mujiok2003 2014-06-18
- 打赏
- 举报
服务器可以主动断开一段时间内没有通讯的连接， 虽然粗暴，但是很实用。
心跳包以下缺点：
1. 加大服务器的通讯量，会恶化网络更差的情况。
2. 客户端需要响应心跳， 客户、服务器之间耦合性更强。
(>^ω^<)喵上树 2014-06-18
- 打赏
- 举报
有没一个例子啊。。。我定时向客户端发心跳包，通过send的返回值还是recv的返回值判断。
recv的返回值好像对异常退出没有处理啊？ 貌似是说异常退出发不出来FIN包。。
while (1)
{
if ((connectfd = accept(listenfd, (struct sockaddr *)&cliaddr, (socklen_t *)& sin_size)) == -1)
{
perror("Accept() error-");
continue;
}
nrecv = recv(sockfd, recvbuf, MAXDATASIZE, 0);
if(nrecv < 0)
{
if( errno == EAGAIN || errno == EWOULDBLOCK)
{
continue;
}
else
{
//..... 客户端应用程序退出
}
}
if (nrecv == 0)
{
// 客户端主动断线
}
else
{
// 正常通信
}
close(listenfd);
}
赵4老师 2014-06-18
- 打赏
- 举报
用自行实现的心跳包，和协议无关且可根据自己实际需要灵活配置。
别用tcp协议栈自带的keepalive心跳包。
www_adintr_com 2014-06-17
- 打赏
- 举报
SO_KEEPALIVE 的检测时间可能达到 2 个小时，不适合用来判断客户端是否掉线
不过，通常情况下，客户端进程退出，客户端进程崩溃，操作系统正常关闭等等服务器都可以收到通知的。只有客户端操作系统异常崩溃的情况下服务器无法得知，需要用心跳包来检测。 而客户端断网，中间路由器崩溃造成网络不通等等，即使不处理也说得通，因为这些情况都是可以在稍后恢复的。
mujiok2003 2014-06-17
- 打赏
- 举报
推荐自己发送心跳包， 具体实现可以使用时间轮（time wheel)
赵4老师 2014-06-17
- 打赏
- 举报
不要用多线程或定时器回调直接发送心跳包，要用多线程或定时器回调将待发送心跳包插入一个待发送数据包FIFO队列中。
发送线程只管从待发送数据包FIFO队列中逐个取出数据包发送。
否则会出现类似
send(人多)，send(病少)，另一个线程或定时器回调发送(心跳)，send(财富)
recv(人多病心跳)recv(少财富)
这样的错误！
(>^ω^<)喵上树 2014-06-17
- 打赏
- 举报
心跳包这样做可以吗？？？
BOOL InitThreads()
{
if(pthread_create(&MyParam.CheckConnectedId, NULL, CheckConnectedThread, NULL))
{
write_log(LOG_SYS_ERR, "\nCreate CheckConnectedThread Failure!");
return FALSE;
}
return TRUE;
}
void * CheckConnectedThread(void * para)
{
sleep(MyParam.user_tmout); //300秒
int i = 0;
int len = 0;
char buf[] = "hello client!";
int sockfd = -1;
for(i = 0; i < FD_SETSIZE; i++)
{
if((sockfd = MyMrTb.client6[i].fd) < 0)
{
continue;
}
send(sockfd, buf, strlen(buf), 0);
//......怎么判断是否断线
}
}
赵4老师 2014-06-17
- 打赏
- 举报
心跳包怎么使用用的啊！！！
开启一个线程吗？
比如我要没5分钟检测一次。就是向所有的客户端发送心跳包，没有回应就表示已异常断开了吗?
[/quote]
所谓心跳包的意思就是在应用层甲方和乙方自己定义一个特殊的数据包，内容比如为“（甲当前时间）甲：人在吗？”，由甲方定期比如每5分钟发送给乙方，乙方收到后，发送“（甲当前时间）甲：人在吗？＋（乙当前时间）乙：在呢。”给甲方。
甲方收到乙方的对应回应，即确定此时连接可用；甲方连续多次比如三次在设定时间内比如10秒未收到乙方的对应回应，即确定此时连接已不可用，启动每隔比如15秒重新和乙方建立连接，重新连接多次比如10次不成功，想办法比如电邮、短信、报警……通知运维人员。
(>^ω^<)喵上树 2014-06-17
- 打赏
- 举报
心跳包怎么使用用的啊！！！
开启一个线程吗？
比如我要没5分钟检测一次。就是向所有的客户端发送心跳包，没有回应就表示已异常断开了吗?
赵4老师 2014-06-17
- 打赏
- 举报
不要迷信和使用keepalive
要使用心跳包
(>^ω^<)喵上树 2014-06-17
- 打赏
- 举报
主要问题是第一个？？？还未得到回复！！
赵4老师 2014-06-17
- 打赏
- 举报
不要在另外一个线程中或定时器回调函数中直接调用send函数发送心跳包，要在另外一个线程或定时器回调函数中将待发送心跳包插入一个待发送数据包FIFO队列中。
原来专管调用send函数发送数据的那个线程（如果没有就需要专门创建此线程），只管从待发送数据包FIFO队列中逐个取出数据包调用send函数发送。
否则会出现类似
发送方发送：发送数据的那个线程send(人多)，发送数据的那个线程send(病少)，另一个线程中或定时器回调函数中send(心跳)，发送数据的那个线程send(财富)
接收方接收：recv(人多病心跳)recv(少财富)
这样的错误！
多线程FIFO队列参考这个：
多线程FIFO队列参考这个：//循环向a函数每次发送200个字节长度（这个是固定的）的buffer,
//a函数中需要将循环传进来的buffer，组成240字节（也是固定的）的新buffer进行处理，
//在处理的时候每次从新buffer中取两个字节打印
#ifdef WIN32
#pragma warning(disable:4996)
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef WIN32
#include <windows.h>
#include <process.h>
#include <io.h>
#define MYVOID void
#define vsnprintf _vsnprintf
#else
#include <unistd.h>
#include <sys/time.h>
#include <pthread.h>
#define CRITICAL_SECTION pthread_mutex_t
#define MYVOID void *
#endif
//Log{
#define MAXLOGSIZE 20000000
#define MAXLINSIZE 16000
#include <time.h>
#include <sys/timeb.h>
#include <stdarg.h>
char logfilename1[]="MyLog1.log";
char logfilename2[]="MyLog2.log";
static char logstr[MAXLINSIZE+1];
char datestr[16];
char timestr[16];
char mss[4];
CRITICAL_SECTION cs_log;
FILE *flog;
#ifdef WIN32
void Lock(CRITICAL_SECTION *l) {
EnterCriticalSection(l);
}
void Unlock(CRITICAL_SECTION *l) {
LeaveCriticalSection(l);
}
void sleep_ms(int ms) {
Sleep(ms);
}
#else
void Lock(CRITICAL_SECTION *l) {
pthread_mutex_lock(l);
}
void Unlock(CRITICAL_SECTION *l) {
pthread_mutex_unlock(l);
}
void sleep_ms(int ms) {
usleep(ms*1000);
}
#endif
void LogV(const char *pszFmt,va_list argp) {
struct tm *now;
struct timeb tb;
if (NULL==pszFmt||0==pszFmt[0]) return;
vsnprintf(logstr,MAXLINSIZE,pszFmt,argp);
ftime(&tb);
now=localtime(&tb.time);
sprintf(datestr,"%04d-%02d-%02d",now->tm_year+1900,now->tm_mon+1,now->tm_mday);
sprintf(timestr,"%02d:%02d:%02d",now->tm_hour ,now->tm_min ,now->tm_sec );
sprintf(mss,"%03d",tb.millitm);
printf("%s %s.%s %s",datestr,timestr,mss,logstr);
flog=fopen(logfilename1,"a");
if (NULL!=flog) {
fprintf(flog,"%s %s.%s %s",datestr,timestr,mss,logstr);
if (ftell(flog)>MAXLOGSIZE) {
fclose(flog);
if (rename(logfilename1,logfilename2)) {
remove(logfilename2);
rename(logfilename1,logfilename2);
}
} else {
fclose(flog);
}
}
}
void Log(const char *pszFmt,...) {
va_list argp;
Lock(&cs_log);
va_start(argp,pszFmt);
LogV(pszFmt,argp);
va_end(argp);
Unlock(&cs_log);
}
//Log}
#define ASIZE 200
#define BSIZE 240
#define CSIZE 2
char Abuf[ASIZE];
char Cbuf[CSIZE];
CRITICAL_SECTION cs_HEX ;
CRITICAL_SECTION cs_BBB ;
struct FIFO_BUFFER {
int head;
int tail;
int size;
char data[BSIZE];
} BBB;
int No_Loop=0;
void HexDump(int cn,char *buf,int len) {
int i,j,k;
char binstr[80];
Lock(&cs_HEX);
for (i=0;i<len;i++) {
if (0==(i%16)) {
sprintf(binstr,"%03d %04x -",cn,i);
sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);
} else if (15==(i%16)) {
sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);
sprintf(binstr,"%s ",binstr);
for (j=i-15;j<=i;j++) {
sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');
}
Log("%s\n",binstr);
} else {
sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);
}
}
if (0!=(i%16)) {
k=16-(i%16);
for (j=0;j<k;j++) {
sprintf(binstr,"%s ",binstr);
}
sprintf(binstr,"%s ",binstr);
k=16-k;
for (j=i-k;j<i;j++) {
sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');
}
Log("%s\n",binstr);
}
Unlock(&cs_HEX);
}
int GetFromRBuf(int cn,CRITICAL_SECTION *cs,FIFO_BUFFER *fbuf,char *buf,int len) {
int lent,len1,len2;
lent=0;
Lock(cs);
if (fbuf->size>=len) {
lent=len;
if (fbuf->head+lent>BSIZE) {
len1=BSIZE-fbuf->head;
memcpy(buf ,fbuf->data+fbuf->head,len1);
len2=lent-len1;
memcpy(buf+len1,fbuf->data ,len2);
fbuf->head=len2;
} else {
memcpy(buf ,fbuf->data+fbuf->head,lent);
fbuf->head+=lent;
}
fbuf->size-=lent;
}
Unlock(cs);
return lent;
}
MYVOID thdB(void *pcn) {
char *recv_buf;
int recv_nbytes;
int cn;
int wc;
int pb;
cn=(int)pcn;
Log("%03d thdB thread begin...\n",cn);
while (1) {
sleep_ms(10);
recv_buf=(char *)Cbuf;
recv_nbytes=CSIZE;
wc=0;
while (1) {
pb=GetFromRBuf(cn,&cs_BBB,&BBB,recv_buf,recv_nbytes);
if (pb) {
Log("%03d recv %d bytes\n",cn,pb);
HexDump(cn,recv_buf,pb);
sleep_ms(1);
} else {
sleep_ms(1000);
}
if (No_Loop) break;//
wc++;
if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);
}
if (No_Loop) break;//
}
#ifndef WIN32
pthread_exit(NULL);
#endif
}
int PutToRBuf(int cn,CRITICAL_SECTION *cs,FIFO_BUFFER *fbuf,char *buf,int len) {
int lent,len1,len2;
Lock(cs);
lent=len;
if (fbuf->size+lent>BSIZE) {
lent=BSIZE-fbuf->size;
}
if (fbuf->tail+lent>BSIZE) {
len1=BSIZE-fbuf->tail;
memcpy(fbuf->data+fbuf->tail,buf ,len1);
len2=lent-len1;
memcpy(fbuf->data ,buf+len1,len2);
fbuf->tail=len2;
} else {
memcpy(fbuf->data+fbuf->tail,buf ,lent);
fbuf->tail+=lent;
}
fbuf->size+=lent;
Unlock(cs);
return lent;
}
MYVOID thdA(void *pcn) {
char *send_buf;
int send_nbytes;
int cn;
int wc;
int a;
int pa;
cn=(int)pcn;
Log("%03d thdA thread begin...\n",cn);
a=0;
while (1) {
sleep_ms(100);
memset(Abuf,a,ASIZE);
a=(a+1)%256;
if (16==a) {No_Loop=1;break;}//去掉这句可以让程序一直循环直到按Ctrl+C或Ctrl+Break或当前目录下存在文件No_Loop
send_buf=(char *)Abuf;
send_nbytes=ASIZE;
Log("%03d sending %d bytes\n",cn,send_nbytes);
HexDump(cn,send_buf,send_nbytes);
wc=0;
while (1) {
pa=PutToRBuf(cn,&cs_BBB,&BBB,send_buf,send_nbytes);
Log("%03d sent %d bytes\n",cn,pa);
HexDump(cn,send_buf,pa);
send_buf+=pa;
send_nbytes-=pa;
if (send_nbytes<=0) break;//
sleep_ms(1000);
if (No_Loop) break;//
wc++;
if (wc>3600) Log("%03d %d==wc>3600!\n",cn,wc);
}
if (No_Loop) break;//
}
#ifndef WIN32
pthread_exit(NULL);
#endif
}
int main() {
#ifdef WIN32
InitializeCriticalSection(&cs_log);
InitializeCriticalSection(&cs_HEX );
InitializeCriticalSection(&cs_BBB );
#else
pthread_t threads[2];
int threadsN;
int rc;
pthread_mutex_init(&cs_log,NULL);
pthread_mutex_init(&cs_HEX,NULL);
pthread_mutex_init(&cs_BBB,NULL);
#endif
Log("Start===========================================================\n");
BBB.head=0;
BBB.tail=0;
BBB.size=0;
#ifdef WIN32
_beginthread((void(__cdecl *)(void *))thdA,0,(void *)1);
_beginthread((void(__cdecl *)(void *))thdB,0,(void *)2);
#else
threadsN=0;
rc=pthread_create(&(threads[threadsN++]),NULL,thdA,(void *)1);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);
rc=pthread_create(&(threads[threadsN++]),NULL,thdB,(void *)2);if (rc) Log("%d=pthread_create %d error!\n",rc,threadsN-1);
#endif
if (!access("No_Loop",0)) {
remove("No_Loop");
if (!access("No_Loop",0)) {
No_Loop=1;
}
}
while (1) {
sleep_ms(1000);
if (No_Loop) break;//
if (!access("No_Loop",0)) {
No_Loop=1;
}
}
sleep_ms(3000);
Log("End=============================================================\n");
#ifdef WIN32
DeleteCriticalSection(&cs_BBB );
DeleteCriticalSection(&cs_HEX );
DeleteCriticalSection(&cs_log);
#else
pthread_mutex_destroy(&cs_BBB);
pthread_mutex_destroy(&cs_HEX);
pthread_mutex_destroy(&cs_log);
#endif
return 0;
}
(>^ω^<)喵上树 2014-06-17
- 打赏
- 举报
什么意思？？ 是------比如有一个客户端成功连接时就给它创建一个循环定时器，让它定时发送。。
typedef struct _t_mnode4 tMnode4;
struct _t_mnode4
{
// ............
tTimer * t_time_id; //定时器ID
//...........
};
inline tMnode4 * AddMrUserv4tcpTb(tMnode4 * pMrnode)
{
// ...................................................
// 创建用户TCP长连接检查机制，若已与MR服务器断线，则关闭该TCP socket
//create_ctimer 创建循环定时器函数
//MyMrTb.user_timerID 定时器组ID
//MyParam.user_tmout 定时时长 300秒
//pMrnode 传给回调函数的参数
//&pMrnode->t_time_id 用来获得返回的定时器
//MrUserv4tcp_Tm_out 回调函数
create_ctimer(MyMrTb.user_timerID, MyParam.user_tmout, pMrnode, &pMrnode->t_time_id, MrUserv4tcp_Tm_out);
//...............................
}
//回调函数
void MrUserv4tcp_Tm_out(void * para, tTimer * tid)
{
tMnode4 * pMnode4 = NULL;
int sockfd = 0;
char buf[64] = "IsAlive";
int len = 0;
pMnode4 = (tMnode4 *)para;
if(!pMnode4)
{
kill_timer(tid);
return ;
}
sockfd = pMnode4->sockfd;
len = send(sockfd, buf, strlen(buf), 0);
if(len <= 0) //用户异常断线
{
// 删除用户信息
}
}
(>^ω^<)喵上树 2014-06-17
- 打赏
- 举报
[quote=引用 9 楼 zhao4zhong1 的回复:]
不要用多线程或定时器回调直接发送心跳包，要用多线程或定时器回调将待发送心跳包插入一个待发送数据包FIFO队列中。
发送线程只管从待发送数据包FIFO队列中逐个取出数据包发送。
否则会出现类似
send(人多)，send(病少)，另一个线程或定时器回调发送(心跳)，send(财富)
recv(人多病心跳)recv(少财富)
这样的错误！
[/quote
什么意思？？ 是------比如有一个客户端成功连接时就给它创建一个循环定时器，让它定时发送。。
[/quote
什么意思？？ 是------比如有一个客户端成功连接时就给它创建一个循环定时器，让它定时发送。。
typedef struct _t_mnode4 tMnode4;
struct _t_mnode4
{
// ............
tTimer * t_time_id; //定时器ID
//...........
};
inline tMnode4 * AddMrUserv4tcpTb(tMnode4 * pMrnode)
{
// ...................................................
// 创建用户TCP长连接检查机制，若已与MR服务器断线，则关闭该TCP socket
//create_ctimer 创建循环定时器函数
//MyMrTb.user_timerID 定时器组ID
//MyParam.user_tmout 定时时长 300秒
//pMrnode 传给回调函数的参数
//&pMrnode->t_time_id 用来获得返回的定时器
//MrUserv4tcp_Tm_out 回调函数
create_ctimer(MyMrTb.user_timerID, MyParam.user_tmout, pMrnode, &pMrnode->t_time_id, MrUserv4tcp_Tm_out);
//...............................
}
//回调函数
void MrUserv4tcp_Tm_out(void * para, tTimer * tid)
{
tMnode4 * pMnode4 = NULL;
int sockfd = 0;
char buf[64] = "IsAlive";
int len = 0;
pMnode4 = (tMnode4 *)para;
if(!pMnode4)
{
kill_timer(tid);
return ;
}
sockfd = pMnode4->sockfd;
len = send(sockfd, buf, strlen(buf), 0);
if(len <= 0) //用户异常断线
{
// 删除用户信息
}
}
无证临时程序员 2014-06-16
- 打赏
- 举报
TCP不允许传输0字节，recv函数接收到0字节，就表示对方主动断开
加载更多回复（2）
