/*! \brief handles io from a "generic" ser process (get fd or new_fd from a tcp_send)
*
* \param p - pointer in the ser processes array (pt[]), to the entry for
* which an io event was detected
* \param fd_i - fd index in the fd_array (usefull for optimizing
* io_watch_deletes)
* \return handle_* return convention:
* - -1 on error reading from the fd,
* - 0 on EAGAIN or when no more io events are queued
* (receive buffer empty),
* - >0 on successfull reads from the fd (the receive buffer might
* be non-empty).
*/
inline static int handle_ser_child(struct process_table* p, int fd_i)
{
struct tcp_connection* tcpconn;
long response[2];
int cmd;
int bytes;
int ret;
int fd;
ret=-1;
if (p->unix_sock<=0){
/* (we can't have a fd==0, 0 is never closed )*/
LM_CRIT("fd %d for %d (pid %d)\n",
p->unix_sock, (int)(p-&pt[0]), p->pid);
goto error;
}
/* get all bytes and the fd (if transmitted)
* (this is a SOCK_STREAM so read is not atomic) */
bytes=receive_fd(p->unix_sock, response, sizeof(response), &fd,
MSG_DONTWAIT);
if (bytes<(int)sizeof(response)){
/* too few bytes read */
if (bytes==0){
/* EOF -> bad, child has died */
LM_DBG("dead child %d, pid %d"
" (shutting down?)\n", (int)(p-&pt[0]), p->pid);
/* don't listen on it any more */
io_watch_del(&io_h, p->unix_sock, fd_i, 0);
goto error; /* child dead => no further io events from it */
}else if (bytes<0){
/* EAGAIN is ok if we try to empty the buffer
* e.g: SIGIO_RT overflow mode or EPOLL ET */
if ((errno!=EAGAIN) && (errno!=EWOULDBLOCK)){
LM_CRIT("read from child %d (pid %d): %s [%d]\n",
(int)(p-&pt[0]), p->pid, strerror(errno), errno);
ret=-1;
}else{
ret=0;
}
/* try to ignore ? */
goto end;
}else{
/* should never happen */
LM_CRIT("too few bytes received (%d)\n", bytes );
ret=0; /* something was read so there is no error; otoh if
receive_fd returned less then requested => the receive
buffer is empty => no more io queued on this fd */
goto end;
}
}
ret=1; /* something was received, there might be more queued */
LM_DBG("read response= %lx, %ld, fd %d from %d (%d)\n",
response[0], response[1], fd, (int)(p-&pt[0]), p->pid);
cmd=response[1];
tcpconn=(struct tcp_connection*)response[0];
if (tcpconn==0){
LM_CRIT("null tcpconn pointer received from child %d (pid %d)"
"%lx, %lx\n", (int)(p-&pt[0]), p->pid, response[0], response[1]) ;
goto end;
}
switch(cmd){
case CONN_ERROR:
if (!(tcpconn->flags & F_CONN_REMOVED) && (tcpconn->s!=-1)){
io_watch_del(&io_h, tcpconn->s, -1, IO_FD_CLOSING);
tcpconn->flags|=F_CONN_REMOVED;
}
tcpconn_destroy(tcpconn); /* will close also the fd */
break;
case CONN_GET_FD:
/* send the requested FD */
/* WARNING: take care of setting refcnt properly to
* avoid race condition */
if (send_fd(p->unix_sock, &tcpconn, sizeof(tcpconn),
tcpconn->s)<=0){
LM_ERR("send_fd failed\n");
}
break;
case CONN_NEW:
/* update the fd in the requested tcpconn*/
/* WARNING: take care of setting refcnt properly to
* avoid race condition */
if (fd==-1){
LM_CRIT(" cmd CONN_NEW: no fd received\n");
break;
}
tcpconn->s=fd;
/* add tcpconn to the list*/
tcpconn_add(tcpconn);
/* update the timeout*/
tcpconn->timeout=get_ticks()+tcp_con_lifetime;
io_watch_add(&io_h, tcpconn->s, F_TCPCONN, tcpconn);
tcpconn->flags&=~F_CONN_REMOVED;
break;
default:
LM_CRIT("unknown cmd %d\n", cmd);
}
end:
return ret;
error:
return -1;
}
/*! \brief tcp main loop */
void tcp_main_loop(void)
{
struct socket_info* si;
int r;
/* init io_wait (here because we want the memory allocated only in
* the tcp_main process) */
/*! \todo FIXME: TODO: make tcp_max_fd_no a config param */
if (init_io_wait(&io_h, tcp_max_fd_no, tcp_poll_method)<0)
goto error;
/* init: start watching all the fds*/
/* add all the sockets we listens on for connections */
for (si=tcp_listen; si; si=si->next){
if ((si->proto==PROTO_TCP) &&(si->socket!=-1)){
if (io_watch_add(&io_h, si->socket, F_SOCKINFO, si)<0){
LM_CRIT("failed to add listen socket to the fd list\n");
goto error;
}
}else{
LM_CRIT("non tcp address in tcp_listen\n");
}
}
#ifdef USE_TLS
if (!tls_disable){
for (si=tls_listen; si; si=si->next){
if ((si->proto==PROTO_TLS) && (si->socket!=-1)){
if (io_watch_add(&io_h, si->socket, F_SOCKINFO, si)<0){
LM_CRIT("failed to add tls listen socket to the fd list\n");
goto error;
}
}else{
LM_CRIT("non tls address in tls_listen\n");
}
}
}
#endif
/* add all the unix sockets used for communcation with other opensips
* processes (get fd, new connection a.s.o) */
for (r=1; r<counted_processes; r++){
/* skip myslef (as process) and -1 socks (disabled)
(we can't have 0, we never close it!) */
if (r!=process_no && pt[r].unix_sock>0)
if (io_watch_add(&io_h, pt[r].unix_sock, F_PROC, &pt[r])<0){
LM_CRIT("failed to add process %d (%s) unix socket "
"to the fd list\n", r, pt[r].desc);
goto error;
}
}
/* add all the unix sokets used for communication with the tcp childs */
for (r=0; r<tcp_children_no; r++){
if (tcp_children[r].unix_sock>0)/*we can't have 0, we never close it!*/
if (io_watch_add(&io_h, tcp_children[r].unix_sock, F_TCPCHILD,
&tcp_children[r]) <0){
LM_CRIT("failed to add tcp child %d unix socket to "
"the fd list\n", r);
goto error;
}
}
/* main loop */
switch(io_h.poll_method){
case POLL_POLL:
while(1){
/* wait and process IO */
io_wait_loop_poll(&io_h, TCP_MAIN_SELECT_TIMEOUT, 0);
/* remove old connections */
tcpconn_timeout(0);
}
break;
#ifdef HAVE_SELECT
case POLL_SELECT:
while(1){
io_wait_loop_select(&io_h, TCP_MAIN_SELECT_TIMEOUT, 0);
tcpconn_timeout(0);
}
break;
#endif
#ifdef HAVE_SIGIO_RT
case POLL_SIGIO_RT:
while(1){
io_wait_loop_sigio_rt(&io_h, TCP_MAIN_SELECT_TIMEOUT);
tcpconn_timeout(0);
}
break;
#endif
#ifdef HAVE_EPOLL
case POLL_EPOLL_LT:
while(1){
io_wait_loop_epoll(&io_h, TCP_MAIN_SELECT_TIMEOUT, 0);
tcpconn_timeout(0);
}
break;
case POLL_EPOLL_ET:
while(1){
io_wait_loop_epoll(&io_h, TCP_MAIN_SELECT_TIMEOUT, 1);
tcpconn_timeout(0);
}
break;
#endif
#ifdef HAVE_KQUEUE
case POLL_KQUEUE:
while(1){
io_wait_loop_kqueue(&io_h, TCP_MAIN_SELECT_TIMEOUT, 0);
tcpconn_timeout(0);
}
break;
#endif
#ifdef HAVE_DEVPOLL
case POLL_DEVPOLL:
while(1){
io_wait_loop_devpoll(&io_h, TCP_MAIN_SELECT_TIMEOUT, 0);
tcpconn_timeout(0);
}
break;
#endif
default:
LM_CRIT("no support for poll method %s (%d)\n",
poll_method_name(io_h.poll_method), io_h.poll_method);
goto error;
}
error:
destroy_io_wait(&io_h);
LM_CRIT("exiting...");
exit(-1);
}
/*! \brief handles io from a tcp child process
* \param tcp_c - pointer in the tcp_children array, to the entry for
* which an io event was detected
* \param fd_i - fd index in the fd_array (usefull for optimizing
* io_watch_deletes)
* \return handle_* return convention: -1 on error, 0 on EAGAIN (no more
* io events queued), >0 on success. success/error refer only to
* the reads from the fd.
*/
inline static int handle_tcp_child(struct tcp_child* tcp_c, int fd_i)
{
struct tcp_connection* tcpconn;
long response[2];
int cmd;
int bytes;
if (tcp_c->unix_sock<=0){
/* (we can't have a fd==0, 0 is never closed )*/
LM_CRIT("fd %d for %d (pid %d, ser no %d)\n", tcp_c->unix_sock,
(int)(tcp_c-&tcp_children[0]), tcp_c->pid, tcp_c->proc_no);
goto error;
}
/* read until sizeof(response)
* (this is a SOCK_STREAM so read is not atomic) */
bytes=recv_all(tcp_c->unix_sock, response, sizeof(response), MSG_DONTWAIT);
if (bytes<(int)sizeof(response)){
if (bytes==0){
/* EOF -> bad, child has died */
LM_DBG("dead tcp child %d (pid %d, no %d)"
" (shutting down?)\n", (int)(tcp_c-&tcp_children[0]),
tcp_c->pid, tcp_c->proc_no );
/* don't listen on it any more */
io_watch_del(&io_h, tcp_c->unix_sock, fd_i, 0);
goto error; /* eof. so no more io here, it's ok to return error */
}else if (bytes<0){
/* EAGAIN is ok if we try to empty the buffer
* e.g.: SIGIO_RT overflow mode or EPOLL ET */
if ((errno!=EAGAIN) && (errno!=EWOULDBLOCK)){
LM_CRIT("read from tcp child %ld (pid %d, no %d) %s [%d]\n",
(long)(tcp_c-&tcp_children[0]), tcp_c->pid,
tcp_c->proc_no, strerror(errno), errno );
}else{
bytes=0;
}
/* try to ignore ? */
goto end;
}else{
/* should never happen */
LM_CRIT("too few bytes received (%d)\n", bytes );
bytes=0; /* something was read so there is no error; otoh if
receive_fd returned less then requested => the receive
buffer is empty => no more io queued on this fd */
goto end;
}
}
LM_DBG("reader response= %lx, %ld from %d \n",
response[0], response[1], (int)(tcp_c-&tcp_children[0]));
cmd=response[1];
tcpconn=(struct tcp_connection*)response[0];
if (tcpconn==0){
/* should never happen */
LM_CRIT("null tcpconn pointer received from tcp child %d (pid %d):"
"%lx, %lx\n", (int)(tcp_c-&tcp_children[0]), tcp_c->pid,
response[0], response[1]) ;
goto end;
}
switch(cmd){
case CONN_RELEASE:
tcp_c->busy--;
if (tcpconn->state==S_CONN_BAD){
tcpconn_destroy(tcpconn);
break;
}
/* update the timeout (lifetime) */
set_tcp_timeout( tcpconn );
tcpconn_put(tcpconn);
/* must be after the de-ref*/
io_watch_add(&io_h, tcpconn->s, F_TCPCONN, tcpconn);
tcpconn->flags&=~F_CONN_REMOVED;
LM_DBG("cmd CONN_RELEASE %p refcnt= %d\n",
tcpconn, tcpconn->refcnt);
break;
case CONN_ERROR:
case CONN_DESTROY:
case CONN_EOF:
/* WARNING: this will auto-dec. refcnt! */
tcp_c->busy--;
/* main doesn't listen on it => we don't have to delete it
if (tcpconn->s!=-1)
io_watch_del(&io_h, tcpconn->s, -1, IO_FD_CLOSING);
*/
tcpconn_destroy(tcpconn); /* closes also the fd */
break;
default:
LM_CRIT("unknown cmd %d from tcp reader %d\n",
cmd, (int)(tcp_c-&tcp_children[0]));
}
end:
return bytes;
error:
return -1;
}
void tcp_receive_loop(int unix_sock)
{
/* init */
tcpmain_sock=unix_sock; /* init com. socket */
if (init_io_wait(&io_w, tcp_max_fd_no, tcp_poll_method)<0)
goto error;
/* add the unix socket */
if (io_watch_add(&io_w, tcpmain_sock, F_TCPMAIN, 0)<0){
LM_CRIT("failed to add socket to the fd list\n");
goto error;
}
/* main loop */
switch(io_w.poll_method){
case POLL_POLL:
while(1){
io_wait_loop_poll(&io_w, TCP_CHILD_SELECT_TIMEOUT, 0);
tcp_receive_timeout();
}
break;
#ifdef HAVE_SELECT
case POLL_SELECT:
while(1){
io_wait_loop_select(&io_w, TCP_CHILD_SELECT_TIMEOUT, 0);
tcp_receive_timeout();
}
break;
#endif
#ifdef HAVE_SIGIO_RT
case POLL_SIGIO_RT:
while(1){
io_wait_loop_sigio_rt(&io_w, TCP_CHILD_SELECT_TIMEOUT);
tcp_receive_timeout();
}
break;
#endif
#ifdef HAVE_EPOLL
case POLL_EPOLL_LT:
while(1){
io_wait_loop_epoll(&io_w, TCP_CHILD_SELECT_TIMEOUT, 0);
tcp_receive_timeout();
}
break;
case POLL_EPOLL_ET:
while(1){
io_wait_loop_epoll(&io_w, TCP_CHILD_SELECT_TIMEOUT, 1);
tcp_receive_timeout();
}
break;
#endif
#ifdef HAVE_KQUEUE
case POLL_KQUEUE:
while(1){
io_wait_loop_kqueue(&io_w, TCP_CHILD_SELECT_TIMEOUT, 0);
tcp_receive_timeout();
}
break;
#endif
#ifdef HAVE_DEVPOLL
case POLL_DEVPOLL:
while(1){
io_wait_loop_devpoll(&io_w, TCP_CHILD_SELECT_TIMEOUT, 0);
tcp_receive_timeout();
}
break;
#endif
default:
LM_CRIT("no support for poll method %s (%d)\n",
poll_method_name(io_w.poll_method), io_w.poll_method);
goto error;
}
error:
destroy_io_wait(&io_w);
LM_CRIT("exiting...");
exit(-1);
}
/*! \brief
* handle io routine, based on the fd_map type
* (it will be called from io_wait_loop* )
* params: fm - pointer to a fd hash entry
* idx - index in the fd_array (or -1 if not known)
* return: -1 on error, or when we are not interested any more on reads
* from this fd (e.g.: we are closing it )
* 0 on EAGAIN or when by some other way it is known that no more
* io events are queued on the fd (the receive buffer is empty).
* Usefull to detect when there are no more io events queued for
* sigio_rt, epoll_et, kqueue.
* >0 on successfull read from the fd (when there might be more io
* queued -- the receive buffer might still be non-empty)
*/
inline static int handle_io(struct fd_map* fm, int idx)
{
int ret;
int n;
struct tcp_connection* con;
int s;
long resp;
switch(fm->type){
case F_TCPMAIN:
again:
ret=n=receive_fd(fm->fd, &con, sizeof(con), &s, 0);
LM_DBG("received n=%d con=%p, fd=%d\n", n, con, s);
if (n<0){
if (errno == EWOULDBLOCK || errno == EAGAIN){
ret=0;
break;
}else if (errno == EINTR) goto again;
else{
LM_CRIT("read_fd: %s \n", strerror(errno));
abort(); /* big error*/
}
}
if (n==0){
LM_WARN("0 bytes read\n");
break;
}
if (con==0){
LM_CRIT("null pointer\n");
break;
}
con->fd=s;
if (s==-1) {
LM_ERR("read_fd:no fd read\n");
goto con_error;
}
if (con==tcp_conn_lst){
LM_CRIT("duplicate"
" connection received: %p, id %d, fd %d, refcnt %d"
" state %d (n=%d)\n", con, con->id, con->fd,
con->refcnt, con->state, n);
release_tcpconn(con, CONN_ERROR, tcpmain_sock);
break; /* try to recover */
}
/* reset the per process TCP req struct */
init_tcp_req(¤t_req);
/* 0 attempts so far for this SIP MSG */
con->msg_attempts = 0;
/* must be before io_watch_add, io_watch_add might catch some
* already existing events => might call handle_io and
* handle_io might decide to del. the new connection =>
* must be in the list */
tcpconn_listadd(tcp_conn_lst, con, c_next, c_prev);
con->timeout=get_ticks()+TCP_CHILD_MAX_MSG_TIME;
if (io_watch_add(&io_w, s, F_TCPCONN, con)<0){
LM_CRIT("failed to add new socket to the fd list\n");
tcpconn_listrm(tcp_conn_lst, con, c_next, c_prev);
goto con_error;
}
break;
case F_TCPCONN:
con=(struct tcp_connection*)fm->data;
resp=tcp_read_req(con, &ret);
if (resp<0) {
ret=-1; /* some error occured */
io_watch_del(&io_w, con->fd, idx, IO_FD_CLOSING);
tcpconn_listrm(tcp_conn_lst, con, c_next, c_prev);
con->state=S_CONN_BAD;
release_tcpconn(con, resp, tcpmain_sock);
}
break;
case F_NONE:
LM_CRIT("empty fd map %p (%d): "
"{%d, %d, %p}\n", fm, (int)(fm-io_w.fd_hash),
fm->fd, fm->type, fm->data);
goto error;
default:
LM_CRIT("uknown fd type %d\n", fm->type);
goto error;
}
return ret;
con_error:
con->state=S_CONN_BAD;
release_tcpconn(con, CONN_ERROR, fm->fd);
return ret;
error:
return -1;
}
void tcp_receive_loop(int unix_sock)
{
/* init */
tcpmain_sock=unix_sock; /* init com. socket */
if (init_io_wait(&io_w, get_max_open_fds(), tcp_poll_method)<0)
goto error;
tcp_reader_prev_ticks=get_ticks_raw();
if (init_local_timer(&tcp_reader_ltimer, get_ticks_raw())!=0)
goto error;
/* add the unix socket */
if (io_watch_add(&io_w, tcpmain_sock, POLLIN, F_TCPMAIN, 0)<0){
LM_CRIT("failed to add socket to the fd list\n");
goto error;
}
/* initialize the config framework */
if (cfg_child_init()) goto error;
/* main loop */
switch(io_w.poll_method){
case POLL_POLL:
while(1){
io_wait_loop_poll(&io_w, TCP_CHILD_SELECT_TIMEOUT, 0);
tcp_reader_timer_run();
}
break;
#ifdef HAVE_SELECT
case POLL_SELECT:
while(1){
io_wait_loop_select(&io_w, TCP_CHILD_SELECT_TIMEOUT, 0);
tcp_reader_timer_run();
}
break;
#endif
#ifdef HAVE_SIGIO_RT
case POLL_SIGIO_RT:
while(1){
io_wait_loop_sigio_rt(&io_w, TCP_CHILD_SELECT_TIMEOUT);
tcp_reader_timer_run();
}
break;
#endif
#ifdef HAVE_EPOLL
case POLL_EPOLL_LT:
while(1){
io_wait_loop_epoll(&io_w, TCP_CHILD_SELECT_TIMEOUT, 0);
tcp_reader_timer_run();
}
break;
case POLL_EPOLL_ET:
while(1){
io_wait_loop_epoll(&io_w, TCP_CHILD_SELECT_TIMEOUT, 1);
tcp_reader_timer_run();
}
break;
#endif
#ifdef HAVE_KQUEUE
case POLL_KQUEUE:
while(1){
io_wait_loop_kqueue(&io_w, TCP_CHILD_SELECT_TIMEOUT, 0);
tcp_reader_timer_run();
}
break;
#endif
#ifdef HAVE_DEVPOLL
case POLL_DEVPOLL:
while(1){
io_wait_loop_devpoll(&io_w, TCP_CHILD_SELECT_TIMEOUT, 0);
tcp_reader_timer_run();
}
break;
#endif
default:
LM_CRIT("no support for poll method %s (%d)\n",
poll_method_name(io_w.poll_method), io_w.poll_method);
goto error;
}
error:
destroy_io_wait(&io_w);
LM_CRIT("exiting...");
exit(-1);
}
/* handle io routine, based on the fd_map type
* (it will be called from io_wait_loop* )
* params: fm - pointer to a fd hash entry
* idx - index in the fd_array (or -1 if not known)
* return: -1 on error, or when we are not interested any more on reads
* from this fd (e.g.: we are closing it )
* 0 on EAGAIN or when by some other way it is known that no more
* io events are queued on the fd (the receive buffer is empty).
* Usefull to detect when there are no more io events queued for
* sigio_rt, epoll_et, kqueue.
* >0 on successfull read from the fd (when there might be more io
* queued -- the receive buffer might still be non-empty)
*/
inline static int handle_io(struct fd_map* fm, short events, int idx)
{
int ret;
int n;
int read_flags;
struct tcp_connection* con;
int s;
long resp;
ticks_t t;
/* update the local config */
cfg_update();
switch(fm->type){
case F_TCPMAIN:
again:
ret=n=receive_fd(fm->fd, &con, sizeof(con), &s, 0);
LM_DBG("received n=%d con=%p, fd=%d\n", n, con, s);
if (unlikely(n<0)){
if (errno == EWOULDBLOCK || errno == EAGAIN){
ret=0;
break;
}else if (errno == EINTR) goto again;
else{
LM_CRIT("read_fd: %s \n", strerror(errno));
abort(); /* big error*/
}
}
if (unlikely(n==0)){
LM_ERR("0 bytes read\n");
goto error;
}
if (unlikely(con==0)){
LM_CRIT("null pointer\n");
goto error;
}
con->fd=s;
if (unlikely(s==-1)) {
LM_ERR("read_fd: no fd read\n");
goto con_error;
}
con->reader_pid=my_pid();
if (unlikely(con==tcp_conn_lst)){
LM_CRIT("duplicate connection received: %p, id %d, fd %d, refcnt %d"
" state %d (n=%d)\n", con, con->id, con->fd,
atomic_get(&con->refcnt), con->state, n);
goto con_error;
break; /* try to recover */
}
if (unlikely(con->state==S_CONN_BAD)){
LM_WARN("received an already bad connection: %p id %d refcnt %d\n",
con, con->id, atomic_get(&con->refcnt));
goto con_error;
}
/* if we received the fd there is most likely data waiting to
* be read => process it first to avoid extra sys calls */
read_flags=((con->flags & (F_CONN_EOF_SEEN|F_CONN_FORCE_EOF)) &&
!(con->flags & F_CONN_OOB_DATA))? RD_CONN_FORCE_EOF
:0;
#ifdef USE_TLS
repeat_1st_read:
#endif /* USE_TLS */
resp=tcp_read_req(con, &n, &read_flags);
if (unlikely(resp<0)){
/* some error occured, but on the new fd, not on the tcp
* main fd, so keep the ret value */
if (unlikely(resp!=CONN_EOF))
con->state=S_CONN_BAD;
LM_WARN("%s:%d %s releasing\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
release_tcpconn(con, resp, tcpmain_sock);
break;
}
#ifdef USE_TLS
/* repeat read if requested (for now only tls might do this) */
if (unlikely(read_flags & RD_CONN_REPEAT_READ))
goto repeat_1st_read;
#endif /* USE_TLS */
/* must be before io_watch_add, io_watch_add might catch some
* already existing events => might call handle_io and
* handle_io might decide to del. the new connection =>
* must be in the list */
tcpconn_listadd(tcp_conn_lst, con, c_next, c_prev);
t=get_ticks_raw();
con->timeout=t+S_TO_TICKS(TCP_CHILD_TIMEOUT);
/* re-activate the timer */
con->timer.f=tcpconn_read_timeout;
local_timer_reinit(&con->timer);
local_timer_add(&tcp_reader_ltimer, &con->timer,
S_TO_TICKS(TCP_CHILD_TIMEOUT), t);
if (unlikely(io_watch_add(&io_w, s, POLLIN, F_TCPCONN, con)<0)){
LM_CRIT("io_watch_add failed for %p id %d fd %d, state %d, flags %x,"
" main fd %d, refcnt %d\n",
con, con->id, con->fd, con->state, con->flags,
con->s, atomic_get(&con->refcnt));
tcpconn_listrm(tcp_conn_lst, con, c_next, c_prev);
local_timer_del(&tcp_reader_ltimer, &con->timer);
goto con_error;
}
break;
case F_TCPCONN:
con=(struct tcp_connection*)fm->data;
if (unlikely(con->state==S_CONN_BAD)){
resp=CONN_ERROR;
if (!(con->send_flags.f & SND_F_CON_CLOSE))
LM_WARN("F_TCPCONN connection marked as bad: %p id %d refcnt %d\n",
con, con->id, atomic_get(&con->refcnt));
goto read_error;
}
read_flags=((
#ifdef POLLRDHUP
(events & POLLRDHUP) |
#endif /* POLLRDHUP */
(events & (POLLHUP|POLLERR)) |
(con->flags & (F_CONN_EOF_SEEN|F_CONN_FORCE_EOF)))
&& !(events & POLLPRI))? RD_CONN_FORCE_EOF: 0;
#ifdef USE_TLS
repeat_read:
#endif /* USE_TLS */
resp=tcp_read_req(con, &ret, &read_flags);
if (unlikely(resp<0)){
read_error:
ret=-1; /* some error occured */
if (unlikely(io_watch_del(&io_w, con->fd, idx,
IO_FD_CLOSING) < 0)){
LM_CRIT("io_watch_del failed for %p id %d fd %d,"
" state %d, flags %x, main fd %d, refcnt %d\n",
con, con->id, con->fd, con->state,
con->flags, con->s, atomic_get(&con->refcnt));
}
tcpconn_listrm(tcp_conn_lst, con, c_next, c_prev);
local_timer_del(&tcp_reader_ltimer, &con->timer);
if (unlikely(resp!=CONN_EOF))
con->state=S_CONN_BAD;
LM_WARN("%s:%d %s releasing\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
release_tcpconn(con, resp, tcpmain_sock);
}else{
#ifdef USE_TLS
if (unlikely(read_flags & RD_CONN_REPEAT_READ))
goto repeat_read;
#endif /* USE_TLS */
/* update timeout */
con->timeout=get_ticks_raw()+S_TO_TICKS(TCP_CHILD_TIMEOUT);
/* ret= 0 (read the whole socket buffer) if short read &
* !POLLPRI, bytes read otherwise */
ret&=(((read_flags & RD_CONN_SHORT_READ) &&
!(events & POLLPRI)) - 1);
}
break;
case F_NONE:
LM_CRIT("empty fd map %p (%d): {%d, %d, %p}\n",
fm, (int)(fm-io_w.fd_hash),
fm->fd, fm->type, fm->data);
goto error;
default:
LM_CRIT("uknown fd type %d\n", fm->type);
goto error;
}
return ret;
con_error:
con->state=S_CONN_BAD;
LM_WARN("%s:%d %s releasing\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
release_tcpconn(con, CONN_ERROR, tcpmain_sock);
return ret;
error:
return -1;
}
