精华内容
下载资源
问答
  • linux socket tcp 断开检测
                   

    经过实际测试,根据测试结果做的socket断开检测。目前应用在项目中正常。有更好的方法,期待交流。

    1、send非阻塞

    client/server端send: 
    ①对端close(fd)检测:send 返回-1,错误errno == EPIPE,说明对端进程被kill掉,即正常close(fd)的效果
    ②网线断开/断电关机检测(超时检测):send 返回-1,errno == EWOULDBLOCK,意为“套接字设置为非阻塞式,但所请求的操作需要阻塞”
    但该错误码,除了指网线断开,也发生在socket内核缓冲区满。
    所以我们通过加超时检测或者计数来判断。select超时,则判定为网络连接失败,关闭本地端socket fd

    2、recv非阻塞
    client/server端recv:
    ①对端close(fd)检测(超时检测):recv 返回0,说明缓存区数据被读完,实测两种情况,对端没有再发数据,对端fd被关闭了。
    通过select超时来检测,当超时如2s,我们认为对端连接断开,应关闭本地的fd。
    ②网线断开/断电关机检测(超时检测):recv 返回-1,errno == EAGAIN,意为“没有可读写数据,缓冲区无数据”。
    所以此时需要select超时检测,若超时,要么对端没有再发数据,要么对端的网线断了或者直接断电了。

    超过我们判定为对端不在线,关闭本地的fd。

     /**  *设置为非阻塞方式  *@return -1 failure, 0 success.**/int set_socket_nonblock(int sockfd){          int block_flag = fcntl(sockfd, F_GETFL, 0);      if(block_flag < 0){        err_msg("get socket fd flag error:%s\n", strerror(errno));        return -1;      }      else{        if(fcntl(sockfd, F_SETFL, block_flag | O_NONBLOCK) < 0){            err_msg("set socket fd non block error:%s\n", strerror(errno));            return -1;        }      }      return 0; }

    /**  *@return   * 0 success,  *-1 failure,errno==EPIPE, 对端进程fd被关掉  *-2 failure,网络断开或者对端超时未再发送数据  *-3 failure,other errno**/int socket_nonblock_send(int fd, unsigned char* buffer,  unsigned int length, unsigned long timeout){    if(length == 0 || buffer == NULL){        err_msg("buffer point is NULL or length is zero\n");        return 0;    }    unsigned int bytes_left;  //无符号    long long written_bytes;  //有符号    unsigned char* ptr;    ptr = buffer;    bytes_left = length;    fd_set writefds;    struct timeval tv;    int ret = 0;    while(bytes_left > 0){        written_bytes = send(fd, ptr, bytes_left, MSG_NOSIGNAL);        if(written_bytes < 0){            if(errno == EINTR )     //由于信号中断,没写成功任何数据                written_bytes = 0;            else if(errno == EWOULDBLOCK){    //即EAGAIN,socket内核缓存区满,或者网线断开                FD_ZERO(&writefds);                FD_SET(fd, &writefds);                tv.tv_sec = timeout/1000000;                tv.tv_usec = timeout%1000000;                ret = select(fd+1, NULL, &writefds, NULL, &tv); //阻塞,err:0 timeout err:-1 错误见errno                if(ret == 0){    //超时,判定为网线断开                    err_msg("select error:%s\n", strerror(errno));                    return -2;                }                else if(ret < 0 && errno != EINTR) {                    err_msg("select error:%s\n", strerror(errno));                    return -2;;                }                written_bytes = 0;  //未超时,判定为socket缓冲区满导致的网络阻塞            }            else if(errno == EPIPE){     //连接套接字的本地端已关闭.(如对端被kill掉)                err_msg("write socket error %d:%s\n", errno, strerror(errno));                return -1;            }            else{       //其他错误                err_msg("write socket error %d:%s\n", errno, strerror(errno));                return -3;            }        }        bytes_left -= written_bytes;        ptr += written_bytes;    }    return 0;}

    /**  *@return     the number of bytes read success,    -1 failure, 对端进程fd被关掉或者对端超时未再发送数据    -2 failure,网络断开或者对端超时未再发送数据    -3 failure,other errno**/long long socket_nonblock_recv(int fd, unsigned char* buffer, unsigned int length, unsigned long timeout){    unsigned int bytes_left;    long long read_bytes;    unsigned char* ptr;    ptr = buffer;    bytes_left = length;    fd_set readfds;    int ret = 0;    struct timeval tv;    while(bytes_left > 0){        read_bytes = recv(fd, ptr, bytes_left, 0);        if(read_bytes < 0){            if(errno == EINTR)      //由于信号中断                read_bytes = 0;            else if(errno == EAGAIN){    //EAGAIN 没有可读写数据,缓冲区无数据                if(length > bytes_left)    //说明上一循环把缓冲区数据读完,继续读返回-1,应返回已读取的长度                    return (length - bytes_left);                else{    //length == bytes_left,说明第一次调用该函数就无数据可读,可能是对端无数据发来,可能是对端网线断了                    FD_ZERO(&readfds);                    FD_SET(fd, &readfds);                    tv.tv_sec = timeout/1000000;                    tv.tv_usec = timeout%1000000;                    ret = select(fd+1, &readfds, NULL, NULL, &tv); //阻塞,err:0 timeout err:-1 错误见errno                    if(ret == 0){    //超时,判定为网线断开                        err_msg("select error:%s\n", strerror(errno));                        return -2;                    }                    else if(ret < 0 && errno != EINTR) {                        err_msg("select error:%s\n", strerror(errno));                        return -2;                    }                    //未超时,有数据到来,继续读                    continue;               }            }            else {      //其他错误                err_msg("read socket buf error:%s\n", strerror(errno));                return -3;            }          }        else if(read_bytes == 0){    //缓冲区数据读完,对端fd 关闭或对端没有发数据了,超时10s后判定为连接已断            FD_ZERO(&readfds);            FD_SET(fd, &readfds);            tv.tv_sec = timeout/1000000;            tv.tv_usec = timeout%1000000;            ret = select(fd+1, NULL, NULL, &readfds, &tv); //阻塞,err:0 timeout err:-1 错误见errno            if(ret == 0){   //超时,对端fd关闭,或对端没有再发数据                err_msg("select error:%s\n", strerror(errno));                return -1;            }            else if(ret < 0 && errno != EINTR){                err_msg("select error:%s\n", strerror(errno));                return -1;            }            //未超时,有数据到来,继续读            continue;        }        bytes_left -= read_bytes;        ptr += read_bytes;    }    return (length - bytes_left);}

    3、对端close掉socket fd,send导致程序终止问题。

    问题描述:

    当服务器close一个连接时,若client端接着发数据。根据TCP协议的规定,会收到一个RST响应,client再往这个服务器发送数据时,系统会发出一个SIGPIPE信号给进程,告诉进程这个连接已经断开了,不要再写了。

    又或者当一个进程向某个已经收到RST的socket执行写操作是,内核向该进程发送一个SIGPIPE信号。该信号的缺省学位是终止进程,因此进程必须捕获它以免不情愿的被终止。

    问题原因:
    根据信号的默认处理规则SIGPIPE信号的默认执行动作是terminate(终止、退出),所以进程会退出。
    系统里边定义了三种处理方法: 
        1)SIG_DFL     
        2)SIG_IGN     
        3)SIG_ERR     
    若不想客户端退出,需要把 SIGPIPE默认执行动作屏蔽。


    问题解决:

    使用send的第四个参数MSG_NOSIGNAL,禁止send()函数向系统发送异常信息,此时将屏蔽SIGPIPE信号。

    send(fd, ptr, bytes_left, MSG_NOSIGNAL);

    以下是网络找到的方法,未测试:

    http://blog.sina.com.cn/s/blog_6f7c07a00101g7u3.html

    用signal(SIGCHLD,SIG_IGN)或者重载其处理方法。个人选了后者。两者区别在于signal设置的信号句柄只能起一次作用,信号被捕获一次后,信号句柄就会被还原成默认 值了;sigaction设置的信号句柄,可以一直有效,值到你再次改变它的设置。具体代码如下:
    struct sigaction action;
    action.sa_handler = handle_pipe;
    sigemptyset(&action.sa_mask);
    action.sa_flags = 0;
    sigaction(SIGPIPE, &action, NULL);
    void handle_pipe(int sig)
    {//不做任何处理即可}
    在源文件中要添加signal.h头文件:#include <signal.h>。

               

    再分享一下我老师大神的人工智能教程吧。零基础!通俗易懂!风趣幽默!希望你也加入到我们人工智能的队伍中来!http://www.captainbed.net

    这里写图片描述
    展开全文
  • Linuxsocket超时(connect超时/recv超时)  connect超时: 目前各平台通用的设置socket connect超时的办法是通过select(),具体方法如下: 1.建立socket; 2.将该socket设置为非阻塞模式; 3....
     

    Linux 下socket超时(connect超时/recv超时)



     connect超时:

    目前各平台通用的设置socket connect超时的办法是通过select(),具体方法如下:

    1.建立socket;

    2.将该socket设置为非阻塞模式;

    3.调用connect();

    4.使用select()检查该socket描述符是否可写;

    5.根据select()返回的结果判断connect()结果;

    6.将socket设回阻塞模式。

     

    下面给出的是我写的client程序(已经编译通过):

    #include <stdio.h>
    #include <stdlib.h>
    #include <errno.h>
    #include <string.h>
    #include <sys/types.h>
    #include <netdb.h>
    #include <netinet/in.h>
    #include <sys/socket.h>
    #include <sys/wait.h>
    #include <sys/time.h>
    #include <unistd.h>
    #include <asm/ioctls.h>
     
    #define MAXDATASIZE 4926

    int detect_imap(const char *server ,char *protocol,unsigned short port)
    {
        int sockfd,numbytes;
        char buf[MAXDATASIZE];
        struct hostent *he;
        struct sockaddr_in their_addr;

        if ((he = gethostbyname(server)) == NULL)
        {
            herror("gethostbyname");
            return 0; 
        } 
        
        if ((sockfd=socket(AF_INET,SOCK_STREAM,0)) == -1)
        {
            perror("socket");
            return 0;
        }
        
        unsigned long ul=1;
        int rm=ioctl(sockfd,FIONBIO,&ul); 
        if(rm==-1)
        {
          close(sockfd); 
          return 0;   
        }
        
        their_addr.sin_family = AF_INET;
        their_addr.sin_port = htons(port);
        their_addr.sin_addr = *((struct in_addr *)he->h_addr);
        bzero(&(their_addr.sin_zero), 8);
       
        if (connect(sockfd, (struct sockaddr *)&their_addr, sizeof(struct sockaddr)) == 0)
        {
         printf("connected/n");
        } 
        if(errno!=EINPROGRESS) 
        {
         perror("connect");
          printf("cannot connect:%s/n",server);
          return 0;
        }     
     
        struct timeval timeout; 
        fd_set r;          
        FD_ZERO(&r);
        FD_SET(sockfd,&r); 
        timeout.tv_sec=0;    
        timeout.tv_usec=100;
        int retval = select(sockfd+1,NULL,&r,NULL,&timeout);
        if(retval==-1)
        {
          perror("select");
          return 0;
        }
        else if(retval == 0)
        {
          fprintf(stderr,"timeout/n");
          return 0;
        }
        printf("%sconnected/n",server);

        unsigned long ul1=0;
        rm=ioctl(sockfd,FIONBIO,(unsigned long*)&ul1); 
        if(rm==-1)
        {
          close(sockfd);
          return 0;      
        }
      
        if ((numbytes=recv(sockfd,buf,MAXDATASIZE,0)) == -1)
        {
          perror("recv");
          return 0; 
        }
        
        buf[numbytes] = '/0';
        if (0 == strncmp(buf,"* OK",4))
        {
          printf("Received: %s",buf);
          close(sockfd);
          return 1;
        }
        else
        {
          printf("Error protocol!");
          close(sockfd);
          return 0;  
        }
    }

    int 
    main(int argc,char *argv[])
    {
       int i;
       if (argc!=2)
        {
           fprintf(stderr,"usage:client hostname/n");
           exit(1);
        }

       i = detect_imap(argv[1] ,argv[2],143);
       printf ("%d",i);
    }

     

     

    以上代码工作的很好,并且也可以通过getsockopt()获得连接发生错误的确切信息,但这总方法难免觉得有些复杂,因为要涉及到阻塞状态的解除和回置。

    这里有个简单的操作方法,同样可以设置连接超时:即通过SO_SNDTIMO套节字参数让超时操作跳过select。

    原因是:Linux内核源码中connect的超时参数和SO_SNDTIMO操作的参数一致。

    因此,在linux平台下,可以通过connect之前设置SO_SNDTIMO来达到控制连接超时的目的。

    部分修正代码如下:

        struct timeval timeo;
        socklen_t len = sizeof(timeo);
        timeo.tv_sec = overtime;


         if (setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, &timeo, len) == -1)
        {
            strcpy(reason,strerror(errno));
            perror("setsockopt");
           return 0;
        }
        
        their_addr.sin_family = AF_INET;
        their_addr.sin_port = htons(serverStruct->port);
        their_addr.sin_addr = *((struct in_addr *)he->h_addr);
        bzero(&(their_addr.sin_zero), 8);
      
        if (connect(sockfd, (struct sockaddr *)&their_addr, sizeof(struct sockaddr)) == -1)
        {  
          if (errno == EINPROGRESS) 
           {
              strcpy(reason,"timeout");
              return 0;
            }  
           strcpy(reason,strerror(errno));
           perror("connect");
            return 0;
        }  

     

    编译运行:gcc client_select.c -o client_select

                        ./client_select imap.21cn.com

    ps:列子是对imap协议进行分析时的代码。

     

    recv超时:

    如果要设置接收超时,可以用setsockopt()和send超时一样,只需将如下代码添加在connect之后就可以了。

     timeout.tv_sec=0;    
        timeout.tv_usec=500;
        int result = setsockopt(sockfd,SOL_SOCKET,SO_RCVTIMEO,(char *)&timeout.tv_sec,sizeof(struct timeval));
        if (result < 0)
        {
          perror("setsockopt"); 
        }

    展开全文
  • 当服务器监听并接受一个客户端链接的时候, 可以不断向客户端发送数据, 这时如果客户端断开socket链接, 服务器继续向一个关闭的socket 发送数据(send, write)的时候, 系统会默认对服务器进程发送一个SIGPIPE信号, 这...

    当服务器监听并接受一个客户端链接的时候, 可以不断向客户端发送数据, 这时如果客户端断开socket链接, 服务器继续向一个关闭的socket 发送数据(send, write)的时候, 系统会默认对服务器进程发送一个SIGPIPE信号, 这个信号的默认动作就是终止当前服务器进程.

    所以为了解决客户端断开后导致服务器进程结束的问题, 使用如下方法忽略SIGPIPE信号.

    struct sigaction sa;
    sa.sa_handler = SIG_IGN;
    sigaction( SIGPIPE, &sa, 0 );


    然后对发送函数的返回值做监测, 如果返回-1, 那么跳出持续发送数据的循环, 继续监听端口, 并等待新的连接.达到了持续监听客户端的目的.

    展开全文
  • linuxsocket connect超时设置

    万次阅读 2016-01-20 10:34:38
    今天发现自己的系统存在很严重缺陷,当前台关闭的时候后台就无法正常工作,原因很好定位,后台的socket连接超时时间过长,系统默认...如何设置socket的Connect超时(linux) [From]http://dev.cbw.com/c/c/20051019
     今天发现自己的系统存在很严重缺陷,当前台关闭的时候后台就无法正常工作,原因很好定位,后台的socket连接超时时间过长,系统默认时间好像是75秒,于是找资料,根据下边文章中的内容解决了,把超时时间设为5秒后,感觉好多了。看来还有好多东西需要慢慢挖掘阿!

    如何设置socket的Connect超时(linux)
    [From]http://dev.cbw.com/c/c/200510195601_4292587.shtml
    1.首先将标志位设为Non-blocking模式,准备在非阻塞模式下调用connect函数
    2.调用connect,正常情况下,因为TCP三次握手需要一些时间;而非阻塞调用只要不能立即完成就会返回错误,所以这里会返回EINPROGRESS,表示在建立连接但还没有完成。
    3.在读套接口描述符集(fd_set rset)和写套接口描述符集(fd_set wset)中将当前套接口置位(用FD_ZERO()、FD_SET()宏),并设置好超时时间(struct timeval *timeout)
    4.调用select( socket, &rset, &wset, NULL, timeout )
    返回0表示connect超时
    如果你设置的超时时间大于75秒就没有必要这样做了,因为内核中对connect有超时限制就是75秒。

    [From]http://www.ycgczj.com.cn/34733.html
    网络编程中socket的分量我想大家都很清楚了,socket也就是套接口,在套接口编程中,提到超时的概念,我们一下子就能想到3个:发送超时,接收超时,以及select超时(注: select函数并不是只用于套接口的,但是套接口编程中用的比较多),在connect到目标主机的时候,这个超时是不由我们来设置的。不过正常情况下这个超时都很长,并且connect又是一个阻塞方法,一个主机不能连接,等着connect返回还能忍受,你的程序要是要试图连接多个主机,恐怕遇到多个不能连接的主机的时候,会塞得你受不了的。我也废话少说,先说说我的方法,如果你觉得你已掌握这种方法,你就不用再看下去了,如果你还不了解,我愿意与你分享。本文是已在Linux下的程序为例子,不过拿到Windows中方法也是一样,无非是换几个函数名字罢了。
    Linux中要给connect设置超时,应该是有两种方法的。一种是该系统的一些参数,这个方法我不讲,因为我讲不清楚:P,它也不是编程实现的。另外一种方法就是变相的实现connect的超时,我要讲的就是这个方法,原理上是这样的:
    1.建立socket
    2.将该socket设置为非阻塞模式
    3.调用connect()
    4.使用select()检查该socket描述符是否可写(注意,是可写)
    5.根据select()返回的结果判断connect()结果
    6.将socket设置为阻塞模式(如果你的程序不需要用阻塞模式的,这步就省了,不过一般情况下都是用阻塞模式的,这样也容易管理)
    如果你对网络编程很熟悉的话,其实我一说出这个过程你就知道怎么写你的程序了,下面给出我写的一段程序,仅供参考。
    /******************************
    * Time out for connect()
    * Write by Kerl W
    ******************************/
    #include <sys/socket.h>
    #include <sys/types.h>
    #define TIME_OUT_TIME 20 //connect超时时间20秒
    int main(int argc , char **argv)
    {
      ………………
      int sockfd = socket(AF_INET, SOCK_STREAM, 0);
      if(sockfd < 0) exit(1);
      struct sockaddr_in serv_addr;
      ………//以服务器地址填充结构serv_addr
      int error=-1, len;
      len = sizeof(int);
      timeval tm;
      fd_set set;
      unsigned long ul = 1;
      ioctl(sockfd, FIONBIO, &ul); //设置为非阻塞模式
      bool ret = false;
      if( connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1)
      {
      tm.tv_set = TIME_OUT_TIME;
      tm.tv_uset = 0;
      FD_ZERO(&set);
      FD_SET(sockfd, &set);
      if( select(sockfd+1, NULL, &set, NULL, &tm) > 0)
      {
        getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, (socklen_t *)&len);
        if(error == 0) ret = true;
    else ret = false;
      } else ret = false;
    }
    else ret = true;
    ul = 0;
    ioctl(sockfd, FIONBIO, &ul); //设置为阻塞模式
    if(!ret)
    {
    close( sockfd );
    fprintf(stderr , "Cannot Connect the server!n");
      return;
      }
    fprintf( stderr , "Connected!n");
    //下面还可以进行发包收包操作
    ……………
    }
    以上代码片段,仅供参考,也是为初学者提供一些提示,主要用到的几个函数,select, ioctl, getsockopt都可以找到相关资料,具体用法我这里就不赘述了,你只需要在linux中轻轻的敲一个man <函数名>就能够看到它的用法。
    此外我需要说明的几点是,虽然我们用ioctl把套接口设置为非阻塞模式,不过select本身是阻塞的,阻塞的时间就是其超时的时间由调用select 的时候的最后一个参数timeval类型的变量指针指向的timeval结构变量来决定的,timeval结构由一个表示秒数的和一个表示微秒数(long类型)的成员组成,一般我们设置了秒数就行了,把微妙数设为0(注:1秒等于100万微秒)。而select函数另一个值得一提的参数就是上面我们用到的fd_set类型的变量指针。调用之前,这个变量里面存了要用select来检查的描述符,调用之后,针对上面的程序这里面是可写的描述符,我们可以用宏FD_ISSET来检查某个描述符是否在其中。由于我这里只有一个套接口描述符,我就没有使用FD_ISSET宏来检查调用select之后这个sockfd是否在set里面,其实是需要加上这个判断的。不过我用了getsockopt来检查,这样才可以判断出这个套接口是否是真的连接上了,因为我们只是变相的用select来检查它是否连接上了,实际上select检查的是它是否可写,而对于可写,是针对以下三种条件任一条件满足时都表示可写的:
    1)套接口发送缓冲区中的可用控件字节数大于等于套接口发送缓冲区低潮限度的当前值,且或者i)套接口已连接,或者ii)套接口不要求连接(UDP方式的)
    2)连接的写这一半关闭。
    3)有一个套接口错误待处理。
    这样,我们就需要用getsockopt函数来获取套接口目前的一些信息来判断是否真的是连接上了,没有连接上的时候还能给出发生了什么错误,当然我程序中并没有标出那么多状态,只是简单的表示可连接/不可连接。
    下面我来谈谈对这个程序测试的结果。我针对3种情形做了测试:
    1. 目标机器网络正常的情况
    可以连接到目标主机,并能成功以阻塞方式进行发包收包作业。
    2. 目标机器网络断开的情况
    在等待设置的超时时间(上面的程序中为20秒)后,显示目标主机不能连接。
    3. 程序运行前断开目标机器网络,超时时间内,恢复目标机器的网络
    在恢复目标主机网络连接之前,程序一只等待,恢复目标主机后,程序显示连接目标主机成功,并能成功以阻塞方式进行发包收包作业。
    以上各种情况的测试结果表明,这种设置connect超时的方法是完全可行的。我自己是把这种设置了超时的connect封装到了自己的类库,用在一套监控系统中,到目前为止,运行还算正常。这种编程实现的connect超时比起修改系统参数的那种方法的有点就在于它只用于你的程序之中而不影响系统。
    本文来自CSDN博客,转载请标明出处: http://blog.csdn.net/wangyifei0822/archive/2008/03/11/2171314.aspx
    展开全文
  • 本文详细介绍了目前各平台通用的设置套接字(Socket)连接超时的办法,介绍了Linux环境下的Socket连接超时的一种实现方法。
  • Linux设置socket连接超时

    千次阅读 2013-01-26 17:21:58
    Linux设置socket连接超时(异步连接)   转载▼ 标签:  linux   socket   connect   超时   it 分类: Linux & C 1.首先将标志位设为Non-blocking模式,...
  • linux TCP超时重传

    万次阅读 2013-06-04 11:16:48
    TCP超时重传是保证TCP可靠性传输的机制之一,当超时后...linux TCP超时重传是通过设置重传超时时钟icsk_retransmit_timer来实现的。 零窗探测超时时钟与重传超时时钟共用icsk_retransmit_timer,根据icsk_pending是IC
  • linux socket的connect 超时

    千次阅读 2016-05-17 10:55:46
    1.将打开的socket设为非阻塞的,可以用fcntl(socket, F_SETFL, O_NDELAY)完成(有的系统用FNEDLAY也可). 2.发connect调用,这时返回-1,但是errno被设为EINPROGRESS,意即connect仍旧在进行还没有完成. 3.在读套接口...
  • Linux 建立 TCP 连接的超时时间分析

    万次阅读 2018-01-28 20:22:27
    Linux 建立 TCP 连接的超时时间分析 Linux 建立 TCP 连接的超时时间分析 概述 超时分析 超时验证 如何改进 概述 Linux 系统默认的建立 TCP 连接的超时时间为 127 秒,对于许多客户端来说,这个时间都...
  • linux tcp select 超时 自查文档

    千次阅读 2016-05-19 17:06:30
    tcp.c#include #include #include #include <unistd.h>#include #include <sys/socket.h> #include #include <arpa/inet.h>#include #inclu
  • linux下的tcp超时机制

    2014-01-14 13:09:55
    在windows下,会在10秒后退出telnet````````````经过若干的百度,google后证实,原来linux 内核对于tcp的链路检测这块,果然存在一个很大的不和谐的地方,就是它默认的情况下,是不会频发性的去探测链路的链接状况,而是要...
  • linux socket select(tcp)

    2020-01-23 10:58:24
    该demo主要实现了linux下通过select(tcp)方式的socket并发通讯,相关接口介绍可以参考环境高级编程>> ![在这里插入图片描述](https://img-blog.csdnimg.cn/20200123105617236.png)![在这里插入图片描述]...
  • 在网上没找到资料,索性用getsockopt把一个默认的socket超时值读出来看看。我原来写的代码是设置接收超时,所以现在读取的时候也读的是接收超时。 // get.c #include /* See NOTES */ #include #include #...
  • linux socket编程之TCP与UDP

    千次阅读 2012-02-15 21:41:37
    TCP/IP协议叫做传输控制/网际协议,又叫网络通信协议 TCP/IP虽然叫传输控制协议(TCP)和网际协议(IP),但是实际上是一组协议,包含ICMP, RIP, TELENET, FTP, SMTP, ARP, TFTP等。 从协议分层模型方面来讲...
  • linux socket编程以及简单的tcp,udp的例子通过socket编程大致对网路编程的脉络有个大致的了解,如果有不太懂的地方, 咱们可以到网络上查找手册socket的基本操作创建socketint socket(int domain, int type, int ...
  • 根据数据报文发现,每次tcp ack keep-alive数据报文请求发送后如果发送别的数据,就会出现socket超时, 判断是内核处理tcp keepalive出现问题导致的。 问题重现 我根据这种情况,实现了一个类似的socket,发送keep-...
  • Linux 系统默认的建立 TCP 连接的超时时间为 127 秒,对于许多客户端来说,这个时间都太长了, 特别是当这个客户端实际上是一个服务的时候,更希望能够尽早失败,以便能够选择其它的可用服务重新尝试。 socket 是 ...
  • Tcp超时修改

    2018-01-24 17:35:00
    Linux 建立 TCP 连接的超时时间分析 tags: linux | network Linux 系统默认的建立 TCP 连接的超时时间为 127 秒,对于许多客户端来...socketLinux 下实现的传输控制层协议,包括 TCP 和 UDP,一个 socket 端...
  • linux下的tcp连接超时

    2016-05-19 09:02:00
    最近需要写一个linux下的通信程序, 通信模块用的是Qt的QTcpSocket. ...调试+google后, 定位问题应该不是Qt的问题, 而是windows和linux下对tcp超时的设置不同导致的, 也找到一些解决方案, 大致可以归纳为...
  • 在[上一篇【阻塞的TCP server&client】](https://blog.csdn.net/xb_2015/article/details/102993083)中,介绍了如何使用socket函数编写第一个socket通信小程序。这篇文章在第一个demo的基础上,将使用select函数实现...
  • Socket连接超时

    千次阅读 2012-07-03 10:54:35
    Socket.connect连接超时有二种情况: 1.由于网络的问题,TCP/IP三次握手时间>timeout的设置时间。这在国外访问weibo时,并且网络环境极差的情况下有可能发生。 解决的办法:调大socket.connect方法中的timeout参数...
  • linux socket套接字超时之setsockopt

    万次阅读 2014-12-11 16:37:11
    超时一些注意事项. 这里只是记录测试的一些结果,仅供参考和探讨.不附加测试代码了. 测试环境:系统debian 6,内核版本:2.6.32-5-686 设置/获取超时代码 struct timeval ti;... setsockopt(sock,SOL_SOCKET,SO_
  • 嵌入式linux TCP socket编程

    千次阅读 2017-03-08 17:19:05
    一、利用内核编程的API ...sendto()_Linux C函数 sendto(经socket传送数据) 相关函数  send , sendmsg,recv , recvfrom , socket 表头文件  #include  #include 定义函数  int sendto
  • linux c实现超时、非阻塞socket的函数select Select在Socket编程中还是比较重要的,可是对于初学Socket的人来 说都不太爱用Select写程序,他们只是习惯写诸如 connect、accept、recv或recvfrom这样的阻塞程序...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 39,848
精华内容 15,939
关键字:

linuxsockettcp超时

linux 订阅