Chinaunix首页 | 论坛 | 博客

信仰年轻

首页　| 　博文目录　| 　关于我

Garfield_Trump

  • 博客访问： 1861887
  • 博文数量： 317
  • 博客积分： 1557
  • 博客等级： 上尉
  • 技术积分： 1208
  • 用 户 组： 普通用户
  • 注册时间： 2008-02-26 23:38
个人简介

如果想出发，就不要等到明天！

文章分类

全部博文（317）

文章存档

2016年（1）

2015年（41）

2014年（152）

2013年（114）

2012年（4）

2011年（1）

2009年（4）

我的朋友
最近访客
推荐博文
相关博文
tcp_socket 多异常情况的 简易demo

分类： 其他平台

2013-05-07 16:35:25

原文地址：tcp_socket 多异常情况的 简易demo 作者：iibull

标签：
     keepalive机制的自定义    远端socket关闭造成send操作崩溃  非阻塞式的connect操作  实时检测socket上是否有错误


server.c 

点击(此处)折叠或打开

  1. /*
  2. * 监听， 收到内容变大写后回写
  3. */
  4. #include <stdio.h>
  5. #include <sys/types.h>
  6. #include <sys/socket.h>
  7. #include <sys/un.h>
  8. #include <errno.h>
  9. #include <unistd.h>
  10. #include <signal.h>
  11. #include <sys/wait.h>
  12. #include <netdb.h>

  14. void sig_handler(int signo)
  15. {
  16.  pid_t pid;
  17.  int stat;

  19.  pid=waitpid(-1,&stat,WNOHANG);
  20.  while(pid>0){
  21.   printf("child process terminated (PID: %ld)\n",(long)getpid());
  22.   pid=waitpid(-1,&stat,WNOHANG);
  23.  }

  25.  return;
  26. }


  29. int main(int argc,char *argv[])
  30. {
  31.  socklen_t clt_addr_len;
  32.  int listen_fd;
  33.  int com_fd;
  34.  int ret;
  35.  int i;
  36.  static char recv_buf[1024];
  37.  int len;
  38.  int port;
  39.  int sleep_cnt;
  40.  pid_t pid;

  42.  char sys_cmd[20];

  44.  struct sockaddr_in clt_addr;
  45.  struct sockaddr_in srv_addr;


  48.  port=5000;

  50.  if(signal(SIGCHLD,sig_handler)<0){
  51.   perror("cannot set the signal");
  52.   return 1;
  53.  }

  55.  listen_fd=socket(PF_INET,SOCK_STREAM,0);
  56.  if(listen_fd<0){
  57.   perror("cannot create listening socket");
  58.   return 1;
  59.  }

  61.  int flag=1;
  62.  len=sizeof(int);
  63.  setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &flag, len);

  65.  memset(&srv_addr,0,sizeof(srv_addr));
  66.  srv_addr.sin_family=AF_INET;
  67.  srv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
  68.  srv_addr.sin_port=htons(port);

  70.  ret=bind(listen_fd,(struct sockaddr*)&srv_addr,sizeof(srv_addr));
  71.  if(ret==-1){
  72.   perror("cannot bind server socket");
  73.   close(listen_fd);
  74.   return 1;
  75.  }

  77.  ret=listen(listen_fd,5);
  78.  if(ret==-1){
  79.   perror("cannot listen the client connect request");
  80.   close(listen_fd);
  81.   return 1;
  82.  }
  83.  
  84.    
  85.  while(1)
  86.  {

  88.   len=sizeof(clt_addr);
  89.   com_fd=accept(listen_fd,(struct sockaddr*)&clt_addr,&len);
  90.   if(com_fd<0){
  91.    if(errno==EINTR){
  92.     continue;
  93.    }else{
  94.     perror("cannot accept client connect request");
  95.     close(listen_fd);
  96.     return 1;
  97.    }
  98.   }

  100.   pid=fork();
  101.   if(pid<0){
  102.    perror("cannot create the child process");
  103.    close(listen_fd);
  104.    return 1;
  105.   }else if(pid==0)
  106.   {
  107.  
  108.    printf("the child child process is %ld \n",(long)getpid());
  109.    while((len=recv(com_fd,recv_buf,1024,0))>0)
  110.    {
  111.     printf("Message from client(%d): %s\n",len,recv_buf);
  112.     if(recv_buf[0]=='@')
  113.     {
  114.      close(com_fd);
  115.      return 0;
  116.     }
  117.     for(i=0;i<len;i++)
  118.      recv_buf[i]=toupper(recv_buf[i]);
  119.     write(com_fd,recv_buf,len);
  120.    }

  122.    close(com_fd);
  123.    printf("return while(1) \n");
  124.    return 0;

  126.   }else
  127.   {
  128.    close(com_fd);
  129.    printf("the child parent process is %ld \n",(long)getpid());

  131.   }
  132.  }
  133.  
  134.  return 0;
  135. }
client.c 
使用非阻塞式的connect操作， 对网络异常和对端socket断开的情况有简单的处理。

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include <unistd.h>
  5. #include <errno.h>
  6. #include <sys/types.h>
  7. #include <sys/ioctl.h>
  8. #include <fcntl.h>
  9. #include <sys/select.h>
  10. #include <arpa/inet.h>
  11. #include <sys/socket.h>
  12. #include <netinet/tcp.h>
  13. #include <signal.h>

  15. int sockfd = -1;

  17. static int SockSelect(int sockfd, fd_set *readfs, fd_set *writefs, fd_set *excepfs, struct timeval *vtimeout)
  18. {
  19.     int iret;
  20.     while ((iret=select(sockfd+1, readfs, writefs, excepfs, vtimeout)) < 0)
  21.     {
  22.         if (errno==EINTR) continue;
  23.         else break;
  24.     }

  26.     return iret;
  27. }

  29. int check_sock_error(int s)
  30. {/*
  31.     fd_set exceptSet;
  32.     struct timeval vtimeout;
  33.     
  34.     FD_ZERO(&exceptSet);
  35.     FD_SET(s, &exceptSet);
  36.     
  37.     vtimeout.tv_sec = 0;
  38.     vtimeout.tv_usec = 100*1000;
  39.     
  40.     int iRet =SockSelect(s , NULL, NULL, &exceptSet, &vtimeout);
  41.     if (iRet <= 0) return iRet;

  43.     if (FD_ISSET(s, &exceptSet)) return 1;
  44. */
  45.     int error;
  46.     int len = sizeof(int);
  47.     getsockopt(s, SOL_SOCKET, SO_ERROR, &error, (socklen_t *)&len);
  48.     if(error != 0) {
  49.         fprintf(stderr, "check_sock_error = [%d] \n", error);
  50.     }

  52.     return error;
  53. }

  55. int check_sock_send(int s)
  56. {
  57.     fd_set sendSet;
  58.     struct timeval vtimeout;
  59.     
  60.     FD_ZERO(&sendSet);
  61.     FD_SET(s, &sendSet);
  62.     
  63.     vtimeout.tv_sec = 1;
  64.     vtimeout.tv_usec = 0;
  65.     
  66.     int iRet =SockSelect(s , NULL, &sendSet, NULL, &vtimeout);
  67.     if (iRet <= 0) return iRet;

  69.     if (FD_ISSET(s, &sendSet))
  70.         return 1;
  71. }

  73. int check_sock_recv(int s)
  74. {
  75.     fd_set sendSet;
  76.     struct timeval vtimeout;
  77.     
  78.     FD_ZERO(&sendSet);
  79.     FD_SET(s, &sendSet);
  80.     
  81.     vtimeout.tv_sec = 5;
  82.     vtimeout.tv_usec = 0;
  83.     
  84.     int iRet =SockSelect(s , &sendSet, NULL, NULL, &vtimeout);
  85.     if (iRet <= 0) return iRet;

  87.     if (FD_ISSET(s, &sendSet))
  88.         return 1;
  89. }

  91. int set_keepalive(int s)
  92. {
  93.     int keepAlive = 1;//设定KeepAlive
  94.     int keepIdle = 1;//开始首次KeepAlive探测前的TCP空闭时间
  95.     int keepInterval = 1;//两次KeepAlive探测间的时间间隔
  96.     int keepCount = 1;//判定断开前的KeepAlive探测次数    
  97.     int flag=1;
  98.     int len=sizeof(int);
  99.     setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &flag, len);            
  100.     struct timeval timeout={3,0};//3s            
  101.     setsockopt(s,SOL_SOCKET,SO_SNDTIMEO,&timeout,sizeof(timeout));            
  102.     setsockopt(s,SOL_SOCKET,SO_RCVTIMEO,&timeout,sizeof(timeout));    

  104.     if(setsockopt(s,SOL_SOCKET,SO_KEEPALIVE,(void*)&keepAlive,sizeof(keepAlive)) == -1)
  1.     {
  2.         fprintf(stderr, " SO_KEEPALIVE failed .\n");
  3.     }

  5.     if(setsockopt(s,SOL_TCP,TCP_KEEPIDLE,(void *)&keepIdle,sizeof(keepIdle)) == -1)
  6.     {
  7.         fprintf(stderr, " TCP_KEEPIDLE failed .\n");
  8.     }

  10.     if(setsockopt(s,SOL_TCP,TCP_KEEPINTVL,(void *)&keepInterval,sizeof(keepInterval)) == -1)
  11.     {
  12.         fprintf(stderr, " TCP_KEEPINTVL failed .\n");
  13.     }

  15.     if(setsockopt(s,SOL_TCP,TCP_KEEPCNT,(void *)&keepCount,sizeof(keepCount)) == -1)
  16.     {
  17.         fprintf(stderr, " TCP_KEEPCNT failed .\n");
  18.     }
  19. }

  21. void closesocket(int s)
  22. {
  23.     if (s != -1) {
  24.         shutdown(s, SHUT_RDWR);
  25.         close(s);
  26.     }
  27. }
  28. static void proc_sig_pipe(int signo)
  29. {
  30.     fprintf(stderr, "*** maybe Opposite Side socket closed. ***\n");
  31.     //closesocket(sockfd);
  32.     //sockfd = -1;
  33. }

  35. /*初始化信号句柄*/
  36. void regSigProcHandle(void)
  37. {
  38.     struct sigaction sigact;
  39.     sigset_t block_mask;

  41.     //屏蔽本App之外所有的信号
  42.     sigfillset(&block_mask);
  43.     sigdelset(&block_mask, SIGPIPE);
  44.     sigprocmask(SIG_BLOCK, &block_mask, NULL);

  46.     //信号处理
  47.     sigfillset(&sigact.sa_mask);
  48.     sigact.sa_handler=proc_sig_pipe;
  49.     sigaction(SIGPIPE, &sigact, NULL);
  50. }

  52. int main()
  53. {
  54.     struct sockaddr_in servaddr;
  55.     int ret;

  57.     /*register some signals */
  58.     regSigProcHandle();

  60.     while (1) {
  61.         if (sockfd == -1) {
  62. //1. 连接服务器
  63. //此处不应当使用阻塞式调用，因为当网络持续不通时，此处可能会变得无限长时间( <= 2 * MSL = (1-4分钟))的阻塞。
  64. //建议使用 sockfd 设置成非阻塞状态。
  65. //然后connect 调用完毕后，使用select检测sockfd的可发送状态，
  66. //若如select超时，则说明connect超时，
  67. //若成功，则把sockfd从新设置成阻塞状态，进行下一步操作。

  69.             fprintf(stderr, "------- reconnected.-------------- \n");
  70.             if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) < 0)
  71.             {
  72.                 fprintf(stderr, "socket create error. \n");
  73.                 sleep(1);
  74.                 continue;
  75.             }

  77.             //set non-blocking
  78.             int flags;
  79.             flags = fcntl(sockfd, F_GETFL); //if (flags<0) { error();}
  80.             flags |= O_NONBLOCK;
  81.             fcntl(sockfd, F_SETFL, flags);
  82.             /*
  83.             int nonblock = 1;
  84.             if (ioctl(sockfd, FIONBIO, &nonblock) < 0) {
  85.                 close(sockfd);
  86.                 perror("ioctl FIONBIO");
  87.             }
  88.             */
  89.             servaddr.sin_family = AF_INET;
  90.             servaddr.sin_addr.s_addr = inet_addr("192.168.10.147");
  91.             servaddr.sin_port = htons(5000);

  93.             if ((ret = connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr))) == -1) {
  94.                 if (errno == EINPROGRESS) {
  95.                     int error;
  96.                     int len = sizeof(int);
  97.                     fd_set set;
  98.                     struct timeval tv_timeout;
  99.                     tv_timeout.tv_sec = 10;
  100.                     tv_timeout.tv_usec = 0;
  101.                     FD_ZERO(&set);
  102.                     FD_SET(sockfd, &set);
  103.                     if(select(sockfd + 1, NULL, &set, NULL, &tv_timeout) > 0) {
  104.                         getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, (socklen_t *)&len);
  105.                         if(error != 0) {
  106.                             fprintf(stderr, "socket error. [%d] \n", error);
  107.                             closesocket(sockfd);
  108.                             sockfd = -1;
  109.                             sleep(1);
  110.                             continue;
  111.                         }
  112.                     } else { //timeout or select error
  113.                         fprintf(stderr, "connect timeout. \n");
  114.                         closesocket(sockfd);
  115.                         sockfd = -1;
  116.                         sleep(1);
  117.                         continue;
  118.                     }
  119.                 }
  120.                 else { //exception
  121.                     fprintf(stderr, "connect exception. \n");
  122.                     sockfd = -1;
  123.                     sleep(1);
  124.                     continue;
  125.                 }
  126.             }
  127.             else if (ret == 0) { // connect success.
  128.                 fprintf(stderr, "connect success. \n");
  129.             }

  131.             // reconfig to block mode
  132.             int nonblock = 0;
  133.             if (ioctl(sockfd, FIONBIO, &nonblock) < 0) {
  134.                 closesocket(sockfd);
  135.                 perror("ioctl FIONBIO");
  136.             }

  138.             set_keepalive(sockfd);
  139.         }
  140.         
  141. //2. 发送数据
  142.         //此处应当先判断当前连接是否有异常。
  143.         //1. 异常判断 getsockopt(s, SOL_SOCKET, SO_ERROR, &error, (socklen_t *)&len);
  144.         //2. 规避远程对端的sock关闭，此处会跑出 SIGPIPE异常造成崩溃。
  145.         //3. 尽量改用select方式先进行超时处理。
  146. /*
  147. //error
  148.         //fprintf(stderr, "socket check error. \n");
  149.         //getc(stdin);
  150.         ret = check_sock_error(sockfd);
  151.         if (ret > 0) {
  152.                 fprintf(stderr, "socket has error. \n");
  153.                 closesocket(sockfd);
  154.                 sockfd = -1;
  155.                 sleep(1);
  156.                 continue;
  157.         }
  158.         else {
  159.             fprintf(stderr, "socket is OK.\n");
  160.         }
  161. //*/
  162. //send
  163.         //fprintf(stderr, "socket send check. \n");
  164.         //getc(stdin);
  165.         ret = check_sock_send(sockfd);
  166.         if (ret <= 0) {
  167.                 fprintf(stderr, "socket has error for send. \n");
  168.                 closesocket(sockfd);
  169.                 sockfd = -1;
  170.                 sleep(1);
  171.                 continue;
  172.         }
  173.         else {
  174.             fprintf(stderr, "socket no error for send. \n");
  175.         }

  177.         const char pSend[]="iibull";
  178.         char pRecv[256];

  180.         ret = send(sockfd, pSend, strlen(pSend), 0);
  181.         if (ret <= 0) {
  182.                 fprintf(stderr, "send error. [%d]\n", ret);
  183.                 closesocket(sockfd);
  184.                 sockfd = -1;
  185.                 sleep(1);
  186.                 continue;
  187.         }
  188.         else {
  189.             fprintf(stderr, "send success. [%d]\n", ret);
  190.         }

  192. //3. 收取数据
  193.         //1. 首先当检测socket上是否有错误。
  194.         //2. 尽量改用select方式先进行分段超时处理，以节省系统资源。
  195. /*
  196. //error
  197.         fprintf(stderr, "socket error check. \n");
  198.         getc(stdin);
  199.         ret = check_sock_error(sockfd);
  200.         if (ret > 0) {
  201.                 fprintf(stderr, "socket has error. \n");
  202.                 closesocket(sockfd);
  203.                 sockfd = -1;
  204.                 sleep(1);
  205.                 continue;
  206.         }
  207.         else {
  208.             fprintf(stderr, "socket no error for recv. \n");
  209.         }
  210. //*/
  211. //recv        
  212.         //fprintf(stderr, "socket recv check. \n");
  213.         //getc(stdin);
  214.         ret = check_sock_recv(sockfd);
  215.         if (ret <= 0) {
  216.                 fprintf(stderr, "socket has error for recv. \n");
  217.                 closesocket(sockfd);
  218.                 sockfd = -1;
  219.                 sleep(1);
  220.                 continue;
  221.         }
  222.         else {
  223.             fprintf(stderr, "socket is OK for recv. \n");
  224.         }

  226.         memset(pRecv, sizeof(pRecv), 0);
  227.         ret = recv(sockfd, pRecv, sizeof(pRecv)-1, 0);
  228.         if (ret <= 0) {
  229.                 fprintf(stderr, "recv error. [%d]\n", ret);
  230.                 closesocket(sockfd);
  231.                 sockfd = -1;
  232.                 sleep(1);
  233.                 continue;
  234.         }
  235.         else {
  236.             fprintf(stderr, "### recv OK [%s]###\n", pRecv);
  237.         }

  239.         sleep(1);
  240.     }
  241. }

参考:
http://blog.patpig.com/2012/06/c-socket-%E5%85%B3%E4%BA%8Econnect%E8%B6%85%E6%97%B6%E8%AE%BE%E7%BD%AE/
http://www.cnblogs.com/jason-jiang/archive/2006/11/03/549337.html


linux和windows下用setsockopt设置SO_SNDTIMEO,SO_RCVTIMEO的参数的一点区别

linux和windows下用setsockopt设置SO_SNDTIMEO,SO_RCVTIMEO的参数的一点区别  


UDP的socket在某些情况：如对方关闭时，本地可能sendto不出去数据，然后recvfrom就会被阻塞，这时就需要设置 这两个参数的值提高程序质量。

linux:

    struct timeval timeout={3,0};//3s
    int ret=setsockopt(sock_fd,SOL_SOCKET,SO_SNDTIMEO,&timeout,sizeof(timeout));
    int ret=setsockopt(sock_fd,SOL_SOCKET,SO_RCVTIMEO,&timeout,sizeof(timeout));

    如果ret==0 则为成功,-1为失败,这时可以查看errno来判断失败原因
    int recvd=recv(sock_fd,buf,1024,0);
    if(recvd==-1&&errno==EAGAIN)
   {
        printf("timeout\n");
   }


windows:
int timeout = 3000; //3s
   int ret=setsockopt(sock_fd,SOL_SOCKET,SO_SNDTIMEO,&timeout,sizeof(timeout));

   int ret=setsockopt(sock_fd,SOL_SOCKET,SO_RCVTIMEO,&timeout,sizeof(timeout));


而solaris，则不支持。


阅读(1908) | 评论(0) | 转发(0) |
0

上一篇：浅谈MAC、MII、PHY

下一篇：VLC源码分析

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6