/*********************************************************************************
|
* Copyright: (C) 2020 LingYun IoT System Studio
|
* All rights reserved.
|
*
|
* Filename: socket.c
|
* Description: This file is for socket API
|
*
|
* Version: 1.0.0(2020年04月16日)
|
* Author: Guo Wenxue <guowenxue@gmail.com>
|
* ChangeLog: 1, Release initial version on "2020年04月16日 13时43分28秒"
|
*
|
********************************************************************************/
|
|
#include "socket.h"
|
#include "logger.h"
|
|
static int proc_sock_connect(socket_t *sock);
|
|
/* description: initialise socket context and create socket fd
|
* input args: $sock: socket context
|
* $type: SOCK_TYPE_LISTEN, SOCK_TYPE_ACCEPT or SOCK_TYPE_CONNEC
|
* $create: call socket() create or not
|
* return value: <0: failure 0: successfully
|
*/
|
int socket_ctx_init(socket_t *sock, uint8_t type, int create)
|
{
|
int fd = -1;
|
|
if( !sock )
|
{
|
log_err("Invalid input arguments\n");
|
return -1;
|
}
|
|
memset(sock, 0, sizeof(*sock));
|
sock->type = type;
|
|
sock->keepintvl=600;
|
sock->keepcnt = 3;
|
|
if( create )
|
{
|
fd = socket(AF_INET, SOCK_STREAM, 0);
|
if( fd < 0 )
|
{
|
log_err("Create socket failure: %s\n", strerror(errno));
|
return -2;
|
}
|
|
sock->fd = fd;
|
}
|
else
|
{
|
sock->fd = -1;
|
}
|
|
sock->status = SOCK_STAT_INIT;
|
|
return 0;
|
}
|
|
/* description: close socket
|
* input args: $sock: socket context
|
* return value: <0: failure 0: successfully
|
*/
|
int socket_close(socket_t *sock)
|
{
|
int force = 0;
|
|
if( !sock )
|
{
|
log_err("Invalid input arguments\n");
|
return -1;
|
}
|
|
if(sock->fd < 0)
|
{
|
log_nrml("socket already closed\n");
|
return 0;
|
}
|
|
log_nrml("start close socket[%d] on port[%d] to [%s:%d]\n", sock->fd, sock->lport, sock->raddr, sock->rport);
|
|
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( SOCK_TYPE_ACCEPT==sock->type || SOCK_TYPE_CONNECT==sock->type )
|
{
|
shutdown(sock->fd, SHUT_RDWR);
|
}
|
|
close(sock->fd);
|
|
sock->fd = -1;
|
sock->status = SOCK_STAT_INIT;
|
|
return 0;
|
}
|
|
/* description: create socket and listen on port $port
|
* input args: $sock: socket context
|
* $ipaddr: listen IP address, NULL for any address
|
* $port: listen port
|
* return value: <0: failure 0: successfully
|
*/
|
int socket_listen(socket_t *sock, char *ipaddr, int port)
|
{
|
int rv = 0;
|
int fd = -1;
|
struct sockaddr_in addr;
|
int backlog = 13;
|
|
if( !sock )
|
{
|
log_err("Invalid input arguments\n");
|
return -1;
|
}
|
|
if( sock->status != SOCK_STAT_INIT )
|
{
|
socket_close(sock);
|
}
|
|
/* initial listen socket bind address */
|
memset(&addr, 0, sizeof(addr));
|
addr.sin_family = AF_INET;
|
addr.sin_port = htons(port);
|
if( !ipaddr )
|
{
|
addr.sin_addr.s_addr = htons(INADDR_ANY);
|
}
|
else
|
{
|
if( !inet_pton(AF_INET, ipaddr, &addr.sin_addr) )
|
{
|
log_err("Listen IP address '%s' not valid\n");
|
return -2;
|
}
|
}
|
|
/* initial socket context and create socket fd */
|
if( socket_ctx_init(sock, SOCK_TYPE_LISTEN, SOCK_CREATE) < 0)
|
{
|
log_err("socket context initial failure\n");
|
return -2;
|
}
|
|
strncpy(sock->laddr, (!ipaddr?"0.0.0.0":ipaddr), sizeof(sock->laddr));
|
sock->lport = port;
|
memset(&sock->raddr, 0, sizeof(sock->raddr));
|
sock->rport = 0;
|
|
log_dbg("initial listen socket context ok\n");
|
|
/* set listen port reuseable */
|
socket_set_reuseaddr(sock->fd);
|
|
if( bind(sock->fd, (struct sockaddr*)&addr, sizeof(addr)) < 0)
|
{
|
log_err("bind listen socket failure: %s\n", strerror(errno));
|
rv = -3;
|
goto cleanup;
|
}
|
|
if( listen(sock->fd, backlog) < 0 )
|
{
|
log_err("Listen on socket[%d] failed: %s\n", sock->fd, strerror(errno));
|
rv = -4;
|
goto cleanup;
|
}
|
|
log_nrml("create socket and listen on [%s:%d] already\n", sock->laddr, sock->lport);
|
|
cleanup:
|
if( rv )
|
{
|
log_err("Create socket listen on [%s:%d] failed\n", sock->laddr, sock->lport);
|
socket_close(sock);
|
}
|
else
|
{
|
sock->status = SOCK_STAT_LISTENED;
|
log_nrml("Create socket[%p:%d] listen [%s:%d] ok\n", sock, sock->fd, sock->laddr, sock->lport);
|
}
|
|
return rv;
|
}
|
|
|
|
/* description: create socket and connect to server
|
* input args: $sock: socket context
|
* $host: IP address and port, format as "host:port", such as "127.0.0.1:8000"
|
* $block: block mode(1) or non-block(0)
|
*return value: <0: error 0: connecing in non-block mode 1:connected
|
*/
|
int socket_connect(socket_t *sock, int lport, char *host, int block)
|
{
|
int rv = 0;
|
char service[20];
|
struct addrinfo hints, *rp;
|
struct addrinfo *res = NULL;
|
struct in_addr inaddr;
|
struct sockaddr_in addr;
|
int len = sizeof(addr);
|
|
if( !sock )
|
{
|
log_err("Invalid input arguments\n");
|
return -1;
|
}
|
|
/* socket already connected */
|
if( SOCK_STAT_CONNECTED == sock->status )
|
{
|
return 1;
|
}
|
/* socket connecting in none-block mode */
|
else if( SOCK_STAT_CONNECTING == sock->status )
|
{
|
log_dbg("socket continue connect to remote server [%s:%d]\n", sock->raddr, sock->rport);
|
rv = proc_sock_connect(sock);
|
goto out;
|
}
|
|
/* socket not initial before */
|
if( SOCK_STAT_UNINIT== sock->status )
|
{
|
if( socket_ctx_init(sock, SOCK_TYPE_LISTEN, SOCK_NOT_CREATE) < 0)
|
{
|
log_err("ERROR: initial socket context failure\n");
|
return -2;
|
}
|
|
if( parser_host_port(sock, host)<0 || sock->rport<=0 )
|
{
|
log_err("parser connect server hostname and port [%s] failure\n", host);
|
return -3;
|
}
|
|
if( lport>0 )
|
{
|
sock->lport = lport;
|
}
|
|
log_dbg("initial socket context ok\n");
|
}
|
|
log_nrml("start create socket connect to server [%s:%d] now\n", sock->raddr, sock->rport);
|
|
|
/*+--------------------------------------------------+
|
*| use getaddrinfo() to do domain name translation |
|
*+--------------------------------------------------+*/
|
|
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 */
|
|
/* If 'raddr' is a valid IP address, then don't use name resolution */
|
if( inet_aton(sock->raddr, &inaddr) )
|
{
|
log_info("%s is a valid IP address, don't use domain name resolution.\n", sock->raddr);
|
hints.ai_flags |= AI_NUMERICHOST;
|
}
|
|
/* Obtain address(es) matching host/port */
|
snprintf(service, sizeof(service), "%d", sock->rport);
|
if( (rv=getaddrinfo(sock->raddr, service, &hints, &res)) )
|
{
|
log_err("getaddrinfo() parser [%s:%s] failed: %s\n", sock->raddr, service, gai_strerror(rv));
|
return -3;
|
}
|
|
/* close any opened socket on it */
|
socket_close(sock);
|
|
/* 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)
|
{
|
char ipaddr[INET_ADDRSTRLEN];
|
struct sockaddr_in *sp = (struct sockaddr_in *) rp->ai_addr;
|
|
|
/* check and print domain name translation result */
|
memset( ipaddr, 0, sizeof(ipaddr) );
|
if( inet_ntop(AF_INET, &sp->sin_addr, ipaddr, sizeof(ipaddr)) )
|
{
|
log_nrml("domain name resolution [%s->%s]\n", sock->raddr, ipaddr);
|
}
|
|
memcpy(&sock->saddr, rp->ai_addr, sizeof(sock->saddr));
|
|
/* Create the socket */
|
sock->fd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
|
if( sock->fd < 0)
|
{
|
log_err("socket() create failed: %s\n", strerror(errno));
|
rv = -3;
|
continue;
|
}
|
|
log_info("socket[%d] for connect create ok\n", sock->fd);
|
|
/* bind local port to socket if needed */
|
if(sock->lport > 0)
|
{
|
memset(&addr, 0, len);
|
addr.sin_family = AF_INET;
|
addr.sin_port = htons ((u_short) sock->lport);
|
|
if ( bind(sock->fd, (struct sockaddr *)&addr, len) )
|
{
|
rv = -4;
|
close(sock->fd);
|
log_err("Bind port[%d] to connect socket [%d] failed: %s\n", sock->lport, sock->fd, strerror(errno));
|
continue;
|
}
|
else
|
{
|
rv = 0;
|
log_dbg("Bind local port[%d] to connect socket [%d] OK\n", lport, sock->fd);
|
}
|
}
|
|
/* Set socket options */
|
if( !block )
|
{
|
socket_set_nonblock(sock->fd);
|
}
|
socket_set_keepalive(sock->fd, sock->keepintvl, sock->keepcnt);
|
|
if( (rv=proc_sock_connect(sock)) >= 0 )
|
{
|
/* connecting or connected already */
|
break;
|
}
|
else
|
{
|
/* socket connect get error, try another IP address */
|
close(sock->fd);
|
continue;
|
}
|
}
|
|
freeaddrinfo(res);
|
|
out:
|
return rv;
|
}
|
|
/* description: connect() server and check the connect result
|
* input args: $sock: socket context
|
*return value: <0: Error 0: Connecing in non-block mode 1:Connected
|
*/
|
static int proc_sock_connect(socket_t *sock)
|
{
|
int rv;
|
int len = sizeof(struct sockaddr);
|
|
if( !sock || sock->fd<0 )
|
{
|
log_err("Invalid input arguments\n");
|
return -1;
|
}
|
|
log_nrml("socket[%d] try to connect to server [%s:%d] now...\n", sock->fd, sock->raddr, sock->rport);
|
|
rv = connect(sock->fd, &sock->saddr, len);
|
if( 0 == rv )
|
{
|
sock->status = SOCK_STAT_CONNECTED;
|
rv = 1;
|
goto out;
|
}
|
|
/* rv < 0, connect failure will continue to check */
|
switch (errno)
|
{
|
case EISCONN:
|
sock->status = SOCK_STAT_CONNECTED;
|
rv = 1;
|
break;
|
|
case EALREADY:
|
case EINPROGRESS:
|
sock->status = SOCK_STAT_CONNECTING;
|
rv = 0;
|
break;
|
|
default:
|
sock->status = SOCK_STAT_UNINIT;
|
rv = -7;
|
break;
|
}
|
|
out:
|
if( rv > 0 )
|
{
|
log_nrml("socket[%d] connected to remote server [%s:%d]\n", sock->fd, sock->raddr, sock->rport);
|
}
|
else if ( rv == 0 )
|
{
|
log_nrml("socket[%d] connect to remote server [%s:%d] in progressing\n", sock->fd, sock->raddr, sock->rport);
|
}
|
else
|
{
|
log_err("socket[%d] connect to remote [%s:%d] failed: %s\n", sock->fd, sock->raddr, sock->rport, strerror(errno));
|
socket_close(sock);
|
}
|
|
return rv;
|
}
|
|
|
/* description: accept a new client socket
|
* input args: $sock: socket context
|
* $listenfd: listen socket fd
|
* return value: <0: failure 0: successfully
|
*/
|
int socket_accept(socket_t *sock, int listenfd)
|
{
|
if( !sock )
|
{
|
log_err("Invalid input arguments\n");
|
return -1;
|
}
|
|
}
|
|
|
/* description: send data to the socket, make sure all data send over.
|
* input args: $sock: socket context
|
* $data: send data
|
* $bytes: data size
|
* return value: <0: failure 0: successfully
|
*/
|
int socket_send(socket_t *sock, char *data, int bytes)
|
{
|
int rv = 0;
|
int i = 0;
|
int left_bytes = bytes;
|
|
if( !sock || !data || bytes<=0 )
|
{
|
log_err("Invalid input arguments\n");
|
return -1;
|
}
|
|
while( left_bytes > 0 )
|
{
|
rv=write(sock->fd, &data[i], left_bytes);
|
if( rv < 0 )
|
{
|
log_info("socket[%d] write() failure: %s, close socket now\n", sock->fd, strerror(errno));
|
socket_close(sock);
|
return -2;
|
}
|
else if( rv == left_bytes )
|
{
|
log_info("socket send %d bytes data over\n", bytes);
|
return 0;
|
}
|
else
|
{
|
/* not send over this time, continue to send left data */
|
i += rv;
|
left_bytes -= rv;
|
continue;
|
}
|
}
|
}
|
|
/* description: receive data from the socket in some time
|
* input args: $sock: socket context
|
* $data: send data
|
* $bytes: data size
|
* $timeout: receive data time, <=0 will don't timeout
|
* return value: <0: error >=0: receive data bytes;
|
*/
|
int socket_recv(socket_t *sock, char *buf, int size, int timeout)
|
{
|
int rv = 0;
|
int i = 0;
|
fd_set fdsr;
|
int maxsock;
|
|
if( !sock || sock->fd<0 || !buf ||size<=0 )
|
{
|
log_err("Invalid input arguments\n");
|
return -1;
|
}
|
|
memset(buf, 0, size);
|
|
maxsock = sock->fd;
|
|
FD_ZERO(&fdsr);
|
FD_SET(sock->fd, &fdsr);
|
|
if( timeout <= 0 ) /* no timeout */
|
{
|
rv=select(maxsock+1, &fdsr, NULL, NULL, NULL);
|
}
|
else
|
{
|
struct timeval tv;
|
|
tv.tv_sec = timeout;
|
tv.tv_usec = 0;
|
rv=select(maxsock+1, &fdsr, NULL, NULL, &tv);
|
}
|
|
|
if( rv < 0 )
|
{
|
log_err("select() read from socket[%d] failure: %s\n", sock->fd, strerror(errno));
|
return -2;
|
}
|
else if( rv == 0 )
|
{
|
log_err("select() read from socket[%d] get timeout\n", sock->fd);
|
return 0;
|
}
|
else
|
{
|
rv = read(sock->fd, buf, size);
|
if( rv < 0 )
|
{
|
log_err("socket[%d] read() failure: %s, close socket now\n", sock->fd, strerror(errno));
|
socket_close(sock);
|
return -2;
|
}
|
else if( rv == 0 )
|
{
|
log_err("socket[%d] read() get peer disconnect, close socket now\n", sock->fd);
|
socket_close(sock);
|
return -2;
|
}
|
else
|
{
|
log_dbg("socket[%d] receive %d bytes data\n", sock->fd, rv);
|
logger_dump(LOG_LEVEL_INFO, buf, rv);
|
return rv;
|
}
|
}
|
}
|
|
|
|
/* description: parser hostname and port from $host and set it into $sock
|
* input args: $sock: socket context
|
* $host: connect hostname, format as "hostname:port"
|
*/
|
int parser_host_port(socket_t *sock, char *host)
|
{
|
char *ptr = NULL;
|
int len = 0;
|
|
if( !sock || !host )
|
{
|
log_err("Invalid input arguments\n");
|
return -1;
|
}
|
|
ptr = strchr(host, ':');
|
|
if( !ptr )
|
{
|
log_err("Invalid arguments for host, format should be 'hostname:port'\n");
|
return -1;
|
}
|
|
len = ptr-host;
|
if( len > sizeof(sock->raddr) )
|
len = sizeof(sock->raddr);
|
|
memcpy(sock->raddr, host, ptr-host);
|
sock->rport = atoi(ptr+1);
|
|
log_info("paser host[%s] to '%s:%d'\n", host, sock->raddr, sock->rport);
|
|
return 0;
|
}
|
|
|
int socket_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;
|
}
|
|
|
int socket_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 socket_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;
|
}
|
|
/*
|
* 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 socket_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;
|
}
|
