/*********************************************************************************
 *      Copyright:  (C) 2012 Guo Wenxue<guowenxue@gmail.com>  
 *                  All rights reserved.
 *
 *       Filename:  cp_sock.c
 *    Description:  This file is the Linux TCP socket basic library.
 *                 
 *        Version:  1.0.0(10/26/2012~)
 *         Author:  Guo Wenxue <guowenxue@gmail.com>
 *      ChangeLog:  1, Release initial version on "10/26/2012 01:20:41 PM"
 *                 
 ********************************************************************************/

#include "cp_sock.h"
#include "cp_logger.h"
#include "cp_common.h"
#include "cp_time.h"

CP_SOCK *cp_sock_init(CP_SOCK *sock, unsigned int rsize, unsigned int ssize, int keepintvl, int keepcnt)
{
    if(!sock)
    {
        if( !(sock=(CP_SOCK *)t_malloc(sizeof(*sock))) )
        {
            log_err("socket context malloc failed: %s\n", strerror(errno));
            goto failed;
        }
        else
        {
            memset(sock, 0, sizeof(*sock));
            sock->flag |= FLAG_SOCK_MALLOC;
        }
    }
    else
    {
        memset(sock, 0, sizeof(*sock));
    }

    if( !(sock->rbuf=cp_string_create_empty(CP_DEF_RCVBUF_SIZE)) )
    {
        log_err("socket context create recv buffer failed\n");
        cp_sock_term(sock);
        goto failed;
    }

    if( !(sock->sbuf=cp_string_create_empty(CP_DEF_SNDBUF_SIZE)) )
    {
        log_err("socket context create send buffer failed\n");
        cp_sock_term(sock);
        goto failed;
    }

    log_dbg("socket context [%p] initialise ok\n", sock);
    sock->rsize = rsize;
    sock->ssize = ssize;
    sock->keepintvl = keepintvl;
    sock->keepcnt = keepcnt;
    sock->idle_timeout = CP_SOCK_DEF_IDLE_TIMEOUT;
    sock->msg_timeout = CP_SOCK_DEF_MSG_TIMEOUT;
    sock->fd = -1;
    sock->index = -1;
    sock->actv_time = time_now();

    sock->flag |= FLAG_SOCK_INIT;

    return sock;

failed:
    log_err("socket context initialize failed\n");
    return NULL;
}

void cp_sock_term(CP_SOCK *sock)
{
    if(!sock)
        return;

    log_dbg("terminate socket [%p:%d] now\n", sock, sock->fd);

    if(sock->flag & FLAG_SOCK_INIT)
        cp_sock_close(sock);

    if(sock->rbuf)
    {
        cp_string_destroy(sock->rbuf);
    } 

    if(sock->privt && sock->privt_free)
    {
        sock->privt_free();
    }

    if(sock->sbuf)
    {
        cp_string_destroy(sock->sbuf);
    }

    if(sock->flag & FLAG_SOCK_MALLOC)
    {
        //memset(sock, 0, sizeof(*sock));
        t_free(sock);
        return ;
    }
    
    //memset(sock, 0, sizeof(*sock));
    sock->fd = -1;  

    return ;
}

int cp_sock_close(CP_SOCK *sock)
{
    int        rv = 0;
    int        force = 0;

    if(!sock)
        return -1;

    if(sock->fd>0)
    {
        log_dbg("Close socket[%d] bind [%s:%d]\n", sock->fd, sock->laddr, sock->lport);
        if(force)
        {
            /*
             * If l_onoff is nonzero and l_linger is zero, TCP aborts the connection when it is closed.  
             * That is, TCP discards any data still remaining in the socket send buffer and sends an RST 
             * to the peer, not the normal four-packet connection termination sequence.
             */
            struct linger so_linger;

            so_linger.l_onoff = 1;  /* Turn on linger */
            so_linger.l_linger = 0; /* Set the timeout to 0  */

            setsockopt (sock->fd, SOL_SOCKET, SO_LINGER, (char *) &so_linger, sizeof (struct linger));
        } 
        
        if(CP_SOCK_MODE_ACCEPT == sock->mode || CP_SOCK_MODE_CONNECT == sock->mode)
        {
            shutdown (sock->fd, SHUT_RDWR);
        }

        if( (rv=close(sock->fd)) )
        {
            return -2;
        }
    }

    sock->fd = -1;
    return rv;
}


int cp_sock_listen(CP_SOCK *sock, char *laddr, int lport, int backlog)
{
    int                 rv = 0;
    int                 fd = -1;
    char                service[20];
    struct addrinfo     hints, *rp;
    struct addrinfo     *res = NULL;
    struct in_addr      inaddr;

    if(!sock || !(sock->flag&FLAG_SOCK_INIT) || lport<=0 || backlog <=0)
    {
        log_err("Invalide input arguments\n");
        rv = -1;
        goto cleanup;
    }

    strncpy(sock->laddr, (!laddr?"0.0.0.0":laddr), sizeof(sock->laddr));
    log_dbg("Create socket listen on [%s:%d] now\n", sock->laddr, lport);

    cp_sock_close(sock);

    memset(&hints, 0, sizeof(struct addrinfo));
    hints.ai_family = AF_INET; /*  Only support IPv4 */
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP; /*  TCP protocol */ 
    hints.ai_flags = AI_PASSIVE;

    /* If 'laddr' is a valid IP address, then don't use name resolution */
    if(laddr && inet_aton(laddr, &inaddr))
    {
        log_info("%s is a valid IP address, don't use name resolution.\n", laddr);
        hints.ai_flags |= AI_NUMERICHOST;
    }

    /* Obtain address(es) matching host/port */
    snprintf(service, sizeof(service), "%d", lport);
    if( (rv=getaddrinfo(laddr, service, &hints, &res)) )
    {
        log_err("getaddrinfo() parser [%s:%s] failed: %s\n", laddr, service, gai_strerror(rv));
        rv = -2;
        goto cleanup;
    }


    /*  getaddrinfo() returns a list of address structures. Try each 
     *  address until we successfully connect or bind*/
    sock->fd = -1;
    for (rp=res; rp!=NULL; rp=rp->ai_next) 
    {
        /* Create the socket */
        if( (fd=socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol)) < 0)
        {
            log_err("socket() create failed: %s\n", strerror(errno));
            rv = -3;
            continue;
        }

        cp_sock_set_reuseaddr(fd);
        cp_sock_set_keepalive(fd, sock->keepintvl, sock->keepcnt);
        cp_sock_set_nonblock(fd); 
        
        if( 0==bind(fd, rp->ai_addr, rp->ai_addrlen) ) 
        { 
            struct sockaddr_in    *saddr = (struct sockaddr_in *)rp->ai_addr;
            sock->fd = fd;
            sock->lport = lport;

            strncpy (sock->laddr, inet_ntoa (saddr->sin_addr), sizeof(sock->laddr)-1);
            log_dbg("Bind socket[%d] ok\n", fd);
            rv = 0;
            break;
        }
        else
        {
            rv = -4;
            log_err("Bind socket[%d] failed: %s\n", fd, strerror(errno));
        }

        close(fd);
    } /* for (rp=res; rp!=NULL; rp=rp->ai_next)  */


    if(sock->fd < 0)
    {
        close(fd);
        goto cleanup;
    }

    if(listen(sock->fd, backlog))
    {
        log_err("Listen on socket[%d] failed: %s\n", sock->fd, strerror(errno));
        rv = -6;
        goto cleanup;
    }

    sock->mode = CP_SOCK_MODE_LISTEN;
    sock->rport = 0;
    memset(&sock->raddr, 0, sizeof(sock->raddr));

cleanup:
    if( rv )
    {
        log_err("Create socket listen on [%s:%d] failed\n", sock->laddr, lport);
        if(sock->fd > 0)
            close(sock->fd);
    }
    else
    {
        sock->actv_time = time_now();
        sock->status = SOCK_STAT_LISTENED;
        log_nrml("Create socket[%p:%d] listen [%s:%d] ok\n", sock, sock->fd, sock->laddr, lport);
    }

    if(res)
        freeaddrinfo(res);  /* No longer needed */
    return rv;
}


int cp_sock_accept(CP_SOCK *serv_sock, CP_SOCK *new_sock)
{
    struct sockaddr_in       saddr;
    socklen_t                len = sizeof(saddr);
    int                      fd = -1;
    int                      rv = 0;

    if(!serv_sock || !new_sock || serv_sock->fd<0 )
    {
        log_err("Invalide input arguments\n");
        rv = -1;
        goto cleanup;
    }

    log_dbg("accept new client from server [fd=%d %s:%d] now\n", serv_sock->fd, serv_sock->laddr, serv_sock->lport);

    if( (fd=accept(serv_sock->fd, (struct sockaddr *)&saddr, &len)) < 0 )
    {
        log_err("Accept new client from server [fd=%d %s:%d] failed: %s\n", 
                serv_sock->fd, serv_sock->laddr, serv_sock->lport, strerror(errno));
        rv = -2;
        goto cleanup;
    }

    /* Set socket buffer size  */
    cp_sock_set_buffer(fd, new_sock->rsize, new_sock->ssize);
    /* Enable socket keepalive to detect network  */
    cp_sock_set_keepalive(fd, new_sock->keepintvl, new_sock->keepcnt);
    cp_sock_set_nonblock(fd); 

    new_sock->fd = fd;
    new_sock->mode = CP_SOCK_MODE_ACCEPT;
    /* get remote address */
    strncpy (new_sock->raddr, inet_ntoa(saddr.sin_addr), sizeof(new_sock->raddr)-1);
    new_sock->rport = ntohs(saddr.sin_port);

    /* Get local address */
    len = sizeof(saddr);
    if (getsockname (new_sock->fd, (struct sockaddr *) &saddr, (socklen_t *) &len)) 
    {
        strncpy(new_sock->laddr, serv_sock->laddr, sizeof(new_sock->laddr)-1);
        new_sock->lport = serv_sock->lport;
    }
    else
    {
        strncpy (new_sock->laddr, inet_ntoa (saddr.sin_addr), sizeof (new_sock->laddr) - 1);
        new_sock->lport = ntohs (saddr.sin_port);
    }

cleanup:
    if(!rv)
    {
        new_sock->status = SOCK_STAT_ACCEPTED;
        new_sock->actv_time = time_now();
        log_nrml("Accept new client socket [%d %s:%d] <== [%s:%d]\n", 
                new_sock->fd, new_sock->laddr, new_sock->lport, new_sock->raddr, new_sock->rport);
    }
    else
    {
        log_err("Accept new client from server [%d] on [%s:%d] failed\n", 
                serv_sock->fd, serv_sock->raddr, serv_sock->rport);
        close(fd);
    }

    return rv;
}


/*
 *  Description:  Create a socket connect to the remove server
 *   Input args:  $sock: The socket contex   $raddr: Remote server address  
 *                $rport: Remote server listened port     
 *                $lport: Use this local port connect to remote server
 *  Output args:  None
 * Return value:  <0:connect failed  ==0:connect ok  >0:connect in progress
 *
 */
int cp_sock_connect(CP_SOCK *sock, char *raddr, int rport, int lport)
{
    int                 rv = 0;
    int                 fd = -1;
    char                service[20];
    struct addrinfo     hints, *rp;
    struct addrinfo     *res = NULL;
    struct in_addr      inaddr;
    struct sockaddr_in  saddr;
    int                 len = sizeof(saddr); 

    if(!sock || !(sock->flag&FLAG_SOCK_INIT) || !raddr || rport<=0)
    {
        log_err("Invalide input arguments\n");
        rv = -1;
        goto failed;
    }

    if(SOCK_STAT_CONNECTED == sock->status)
    {
        return 0;
    }
    else if(SOCK_STAT_CONNECTING == sock->status)
    {
        goto connecting;
    }

    log_dbg("create socket connect to remote server [%s:%d] now\n", raddr, rport);

    memset(&hints, 0, sizeof(struct addrinfo));
    hints.ai_family = AF_INET; /*  Only support IPv4 */
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP; /*  TCP protocol */ 
    hints.ai_flags = AI_PASSIVE;

    /* If 'raddr' is a valid IP address, then don't use name resolution */
    if(raddr && inet_aton(raddr, &inaddr))
    {
        log_info("%s is a valid IP address, don't use name resolution.\n", raddr);
        hints.ai_flags |= AI_NUMERICHOST;
    }

    /* Obtain address(es) matching host/port */
    snprintf(service, sizeof(service), "%d", rport);
    if( (rv=getaddrinfo(raddr, service, &hints, &res)) )
    {
        log_err("getaddrinfo() parser [%s:%s] failed: %s\n", raddr, service, gai_strerror(rv));
        rv = -2;
        goto failed;
    }

    cp_sock_close(sock); /* close any opened socket on it */
    sock->fd = -1;

    /*  getaddrinfo() returns a list of address structures. Try each 
     *  address until we successfully connect or bind*/
    for (rp=res; rp!=NULL; rp=rp->ai_next) 
    {
        fd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);

        /* Create the socket */
        if( fd < 0)
        {
            log_err("socket() create failed: %s\n", strerror(errno));
            rv = -3;
            continue;
        }
        log_trace("create socket[%p:%d] with connect mode ok\n", sock, fd); 
        
        /* We need bind lport to this socket */
        if(lport > 0)
        { 
            memset(&saddr, 0, len);
            saddr.sin_family = AF_INET;
            saddr.sin_port = htons ((u_short) lport); 
            
            if ( bind(fd, (struct sockaddr *)&saddr, len) )
            {
                rv = -4;
                close(fd);
                log_err("Bind port[%d] to connect socket [%d] failed: %s\n", lport, fd, strerror(errno));
                continue;
            }
            else
            {
                sock->lport = lport; 
                rv = 0;
                log_dbg("Bind port[%d] to connect socket [%d] OK\n", lport, fd);
            }
        }

        /* Set socket options */
        cp_sock_set_buffer(fd, sock->rsize, sock->ssize);
        cp_sock_set_keepalive(fd, sock->keepintvl, sock->keepcnt);
        cp_sock_set_nonblock(fd);

        /* Nono block Connect to the remote server */
        if(0==connect(fd, rp->ai_addr, rp->ai_addrlen))
        { 
            /* Conenct to server successfully */
            sock->fd = fd;
            sock->status = SOCK_STAT_CONNECTING; 

            memcpy(&sock->saddr, &rp->ai_addr, sizeof(sock->saddr));
            
            rv = 0;
            goto connected;
        }
        else
        {
            if(EINPROGRESS == errno)
            {
                /* Connect to server now in progress  */
                sock->fd = fd;
                sock->status = SOCK_STAT_CONNECTING; 
                memcpy(&sock->saddr, &rp->ai_addr, sizeof(sock->saddr));

                rv = 0;
                goto connecting;
            }
            else
            {
                /* Connect to server failed. */
                close(fd);
                rv = -5;
                log_err("connect() to server failed: %s\n", strerror(errno));
                goto failed;
            }
        } 

        close(fd);
    }  /* for (rp=res; rp!=NULL; rp=rp->ai_next)  */


    if(sock->fd < 0)
    {
        close(fd);
        goto failed;
    }


connecting: 
    if(SOCK_STAT_CONNECTING == sock->status)
    { 

        len = sizeof(sock->saddr); 

        errno = 0;
        if( !connect(sock->fd, &sock->saddr, len) )
        {
            /* connect() return 0 means it already connected */
            sock->status = SOCK_STAT_CONNECTED; 
            rv = 0;
            goto connected;
        }

        /* Connect failure will continue to check */
        switch (errno)
        {
            case EISCONN: 
                sock->status = SOCK_STAT_CONNECTED; 
                rv = 0;
                goto connected;

            case EALREADY: 
            case EINPROGRESS:
                log_dbg("socket[%d] connect to remote [%s:%d] in progress\n", sock->fd, raddr, rport);
                rv = 0;
                goto cleanup;

            default:
                log_err("socket[%d] connect to remote [%s:%d] failed: %s\n", sock->fd, raddr, rport, strerror(errno));
                sock->status = SOCK_STAT_DISCONNECT; 
                rv = -7;
                break;
        }
    }

connected:
    if(SOCK_STAT_CONNECTED == sock->status)
    { 
        rv = 0;

        log_nrml("socket[%d] connected to remote server [%s:%d]\n", sock->fd, raddr, rport);
        /* Set remote address */ 
        sock->rport=rport; 
        strncpy (sock->raddr, raddr, sizeof(sock->raddr)-1); 
        sock->actv_time = time_now();
        
        /* Get local address */ 
        memset(&saddr, 0, len);
        len = sizeof(saddr); 

        if (!getsockname (sock->fd, (struct sockaddr *) &saddr, (socklen_t *) &len)) 
        {
            strncpy (sock->laddr, inet_ntoa (saddr.sin_addr), sizeof (sock->laddr) - 1);
            sock->lport = ntohs (saddr.sin_port);
        }
        else
        {
            memset(&sock->laddr, 0, sizeof(sock->laddr));
            sock->lport = lport;
        }
        goto cleanup;
    }


failed:
    log_err("Create socket connect to [%s:%d] failed\n", raddr, rport);
    if(sock && sock->fd >= 0)
        close(sock->fd);

cleanup:
    if(res)
        freeaddrinfo(res);  /* No longer needed */

    return rv;
}


int cp_sock_recv(CP_SOCK *sock)
{
    int               rv, left;
    int               flag;
    cp_string         *rbuf;

    if(!sock || !sock->rbuf || !sock->rbuf->data || sock->fd<0)
    {
        log_err("Invalide input arguments\n");
        return -1;
    }

    rbuf = sock->rbuf;
    left = rbuf->size-rbuf->len;
    flag = left ? 0 : MSG_PEEK; 

    if(left <= 0)
        return 0;
    
    rv=recv(sock->fd, &rbuf->data[rbuf->len], left, flag);
    if( rv > 0)
    {
        rbuf->len += rv;
    }
    else if(rv<0)
    {
        if(EAGAIN==errno || EINPROGRESS==errno)
        { 
            log_warn("socket [%d] please recv data again: %s\n", sock->fd, strerror(errno));
            rv = 0;
        }
        else
        {
            log_err("socket [%d] recv data failed: %s\n", sock->fd, strerror(errno));
            rv = -2;
        }
    }

    if(rv > 0)
    {
        sock->actv_time = sock->msg_time = time_now();
    }
    return rv;
}

int cp_sock_send(CP_SOCK *sock)
{
    int                      rv;
    struct pollfd            sock_poll;

    if(!sock || sock->fd<0 || !sock->sbuf->data || sock->sbuf->len<=0)
    {
        log_err("Invalide input arguments\n");
        return -1;
    }

    sock_poll.events = POLLOUT;
    sock_poll.fd = sock->fd;

    if( (rv=poll(&sock_poll, 1, 0)) > 0 )
    {
        if( !(POLLOUT &sock_poll.events) )
        {
            return -2;
        }

        if ( (rv=send(sock->fd, sock->sbuf->data, sock->sbuf->len, MSG_NOSIGNAL)) < 0) 
        {
            if (EAGAIN == errno) 
            {
                log_warn("socket [%d] please send data again: %s\n", sock->fd, strerror(errno));
                return 0;
            }
            else
            {
                log_err("socket [%d] send data failed: %s\n", sock->fd, strerror(errno));
                return -4;
            }
        }
        else
        {
            sock->sbuf->len -= rv;
            sock->actv_time = time_now();
            memmove (sock->sbuf->data, sock->sbuf->data+rv, sock->sbuf->len);
            return rv;
        }
    }
    else /* poll()<0 means failed, poll()==0 means timeout */
    {
        log_err("send data from socket [%d] poll failed: %s\n", sock->fd, strerror(errno));
        return 0;
    }

    return 0;
}

int cp_sock_set_nonblock(int sockfd)
{
    int opts;
    /*
     * fcntl may set: 
     *
     * EACCES, EAGAIN: Operation is prohibited by locks held by other 
     *          processes. Or, operation is prohibited because the file has 
     *          been memory-mapped by another process. 
     * EBADF:   fd is not an open file descriptor, or the command was F_SETLK 
     *          or F_SETLKW and the file descriptor open mode doesn't match 
     *          with the type of lock requested.
     * EDEADLK: It was detected that the specified F_SETLKW command would 
     *          cause a deadlock.
     * EFAULT:  lock is outside your accessible address space.
     * EINTR:   For F_SETLKW, the command was interrupted by a signal. For 
     *          F_GETLK and F_SETLK, the command was interrupted by a signal 
     *          before the lock was checked or acquired. Most likely when 
     *          locking a remote file (e.g. locking over NFS), but can 
     *          sometimes happen locally.
     * EINVAL:  For F_DUPFD, arg is negative or is greater than the maximum 
     *          allowable value. For F_SETSIG, arg is not an allowable signal 
     *          number.
     * EMFILE:  For F_DUPFD, the process already has the maximum number of 
     *          file descriptors open. 
     * ENOLCK:  Too many segment locks open, lock table is full, or a remote 
     *          locking protocol failed (e.g. locking over NFS).
     * EPERM:   Attempted to clear the O_APPEND flag on a file that has the 
     *          append-only attribute set.
     */
    opts = fcntl(sockfd, F_GETFL);
    if (opts < 0)
    {
        log_warn("fcntl() get socket options failure: %s\n", strerror(errno));
        return -1;
    } 

    opts |= O_NONBLOCK;

    if (fcntl(sockfd, F_SETFL, opts) < 0)
    {
        log_warn("fcntl() set socket options failure: %s\n", strerror(errno));
        return -1;
    }

    log_dbg("Set socket[%d] none blocking\n", sockfd);
    return opts;
}

int cp_sock_set_buffer(int sockfd, int rsize, int ssize)
{
    int        opt;
    socklen_t  optlen = sizeof(opt);

    if(sockfd < 0)
        return -1;

    /* Get system default receive buffer size, Linux X86: 85K */
    if (getsockopt (sockfd, SOL_SOCKET, SO_RCVBUF, (char *) &opt, &optlen)) 
    {
        log_warn("getsockopt() get receive buffer failure: %s\n", strerror(errno));
        return -2;
    }

    /* Only when current receive buffer size larger than the default one will change it  */
    if(rsize > opt)
    {
        opt = (int) rsize;
        if (setsockopt (sockfd, SOL_SOCKET, SO_RCVBUF, (char *) &opt, optlen)) 
        {
            log_warn("setsockopt() set receive buffer to %d failure: %s\n", opt, strerror(errno));
            return -2;
        }
    }

    /* Get system default send buffer size, Linux X86: 16K */
    if (getsockopt (sockfd, SOL_SOCKET, SO_SNDBUF, (char *) &opt, &optlen)) 
    {
        log_warn("getsockopt() get send buffer failure: %s\n", strerror(errno));
        return -3;
    }

    /* Only when current receive buffer size larger than the default one will change it  */
    if(ssize > opt)
    {
        opt = (int) ssize;
        if (setsockopt (sockfd, SOL_SOCKET, SO_SNDBUF, (char *) &opt, optlen)) 
        {
            log_warn("setsockopt() set send buffer to %d failure: %s\n", opt, strerror(errno));
            return -3;
        }
    }

    log_info("Set socket[%d] RCVBUF size:%d  SNDBUF size:%d\n", sockfd, rsize, ssize);
    return 0;
}

int cp_sock_set_reuseaddr(int sockfd)
{
    int opt = 1;
    int len = sizeof (int);

    if (setsockopt (sockfd, SOL_SOCKET, SO_REUSEADDR, (void *) &opt, len)) 
    {
        log_err("Set socket[%d] option SO_REUSEADDR failed:%s\n", sockfd, strerror(errno));
        return -1;
    } 
    log_dbg("Set socket[%d] option SO_REUSEADDR ok\n", sockfd);

    return 0;
}

/*
 * Enable socket SO_KEEPALIVE, if the connection disconnected, any system call on socket
 * will return immediately and errno will be set to "WSAENOTCONN"
 *
 * keepalive is not program related, but socket related, * so if you have multiple sockets, 
 * you can handle keepalive for each of them separately.
 *
 * Reference: http://tldp.org/HOWTO/html_single/TCP-Keepalive-HOWTO/
 */
int cp_sock_set_keepalive(int sockfd, int keepintvl, int keepcnt)
{
    int  opt;

    if(sockfd < 0)
        return -1;

    /* Enable the KEEPALIVE flag */
    opt = 1;
    if (setsockopt (sockfd, SOL_SOCKET, SO_KEEPALIVE, (char *) &opt, sizeof (opt))) 
    {
        log_warn("setsockopt() enable SO_KEEPALIVE failure: %s\n", strerror(errno));
        return -2;
    }

    if(keepintvl || keepcnt)
    {
        /*
         *  The tcp_keepidle parameter specifies the interval between the last data packet sent 
         *  (simple ACKs are not considered data) and the first keepalive probe; after the 
         *  connection is marked to need keepalive, this counter is not used any further. 
         *  ~ >: cat /proc/sys/net/ipv4/tcp_keepalive_time 
         *  7200
         */
        opt = 3; /* 3 seconds  */
        if (setsockopt (sockfd, SOL_TCP, TCP_KEEPIDLE, (char *) &opt, sizeof (opt))) 
        {
            log_err("setsockopt() set TCP_KEEPIDLE to %d seconds failure: %s\n", opt, strerror(errno));
            return -3;
        }

        if((opt=keepintvl) > 0)
        {
            /*
             * The tcp_keepintvl parameter specifies the interval between subsequential keepalive 
             * probes, regardless of what the connection has exchanged in the meantime.
             * ~ >: cat /proc/sys/net/ipv4/tcp_keepalive_intvl 
             * 75
             */
            if (setsockopt (sockfd, SOL_TCP, TCP_KEEPINTVL, (char *) &opt, sizeof (opt))) 
            {
                log_err("setsockopt() set TCP_KEEPINTVL to %d failure: %s\n", opt, strerror(errno));
                return -4;
            }
        }

        if((opt=keepcnt) > 0)
        {
            /*
             * The TCP_KEEPCNT option specifies the maximum number of unacknowledged probes to 
             * send before considering the connection dead and notifying the application layer
             * probes to be sent. The value of TCP_KEEPCNT is an integer value between 1 and n, 
             * where n is the value of the systemwide tcp_keepcnt parameter. 
             * ~ >: cat /proc/sys/net/ipv4/tcp_keepalive_probes 
             * 9
             */
            if (setsockopt (sockfd, SOL_TCP, TCP_KEEPCNT, (char *) &opt, sizeof (opt)))
            {
                log_err("setsockopt() set TCP_KEEPCNT to %d failure: %s\n", opt, strerror(errno));
                return -5;
            }
        }
    }

    log_dbg("Set socket[%d] KEEPINTVL:%d  KEEPCNT:%d\n", sockfd, keepintvl, keepcnt);
    return 0;
}