/* process command to relay udp traffic
*
*/
static int
udp_relay( int sockfd, const char* param, size_t plen,
const struct in_addr* mifaddr,
struct server_ctx* ctx )
{
char mcast_addr[ IPADDR_STR_SIZE ];
struct sockaddr_in addr;
uint16_t port;
pid_t new_pid;
int rc = 0, flags;
int msockfd = -1, sfilefd = -1,
dfilefd = -1, srcfd = -1;
char dfile_name[ MAXPATHLEN ];
size_t rcvbuf_len = 0;
assert( (sockfd > 0) && param && plen && ctx );
TRACE( (void)tmfprintf( g_flog, "udp_relay : new_socket=[%d] param=[%s]\n",
sockfd, param) );
do {
rc = parse_udprelay( param, plen, mcast_addr, IPADDR_STR_SIZE, &port );
if( 0 != rc ) {
(void) tmfprintf( g_flog, "Error [%d] parsing parameters [%s]\n",
rc, param );
break;
}
if( 1 != inet_aton(mcast_addr, &addr.sin_addr) ) {
(void) tmfprintf( g_flog, "Invalid address: [%s]\n", mcast_addr );
rc = ERR_INTERNAL;
break;
}
addr.sin_family = AF_INET;
addr.sin_port = htons( (short)port );
} while(0);
if( 0 != rc ) {
(void) send_http_response( sockfd, 500, "Service error" );
return rc;
}
/* start the (new) process to relay traffic */
if( 0 != (new_pid = fork()) ) {
rc = add_client( ctx, new_pid, mcast_addr, port, sockfd );
return rc; /* parent returns */
}
/* child process:
*/
TRACE( (void)tmfprintf( g_flog, "Client process=[%d] started "
"for socket=[%d]\n", getpid(), sockfd) );
(void) get_pidstr( PID_RESET, "c" );
(void)close( ctx->lsockfd );
/* close the reading end of the comm. pipe */
(void)close( ctx->cpipe[0] );
ctx->cpipe[0] = -1;
do {
/* make write end of pipe non-blocking (we don't want to
* block on pipe write while relaying traffic)
*/
if( -1 == (flags = fcntl( ctx->cpipe[1], F_GETFL )) ||
-1 == fcntl( ctx->cpipe[1], F_SETFL, flags | O_NONBLOCK ) ) {
mperror( g_flog, errno, "%s: fcntl", __func__ );
rc = -1;
break;
}
if( NULL != g_uopt.dstfile ) {
(void) snprintf( dfile_name, MAXPATHLEN - 1,
"%s.%d", g_uopt.dstfile, getpid() );
dfilefd = creat( dfile_name, S_IRUSR | S_IWUSR | S_IRGRP );
if( -1 == dfilefd ) {
mperror( g_flog, errno, "%s: g_uopt.dstfile open", __func__ );
rc = -1;
break;
}
TRACE( (void)tmfprintf( g_flog,
"Dest file [%s] opened as fd=[%d]\n",
dfile_name, dfilefd ) );
}
else dfilefd = -1;
if( NULL != g_uopt.srcfile ) {
sfilefd = open( g_uopt.srcfile, O_RDONLY | O_NOCTTY );
if( -1 == sfilefd ) {
mperror( g_flog, errno, "%s: g_uopt.srcfile open", __func__ );
rc = -1;
}
else {
TRACE( (void) tmfprintf( g_flog, "Source file [%s] opened\n",
g_uopt.srcfile ) );
srcfd = sfilefd;
}
}
else {
rc = calc_buf_settings( NULL, &rcvbuf_len );
if (0 == rc ) {
rc = setup_mcast_listener( &addr, mifaddr, &msockfd,
(g_uopt.nosync_sbuf ? 0 : rcvbuf_len) );
srcfd = msockfd;
}
}
if( 0 != rc ) break;
rc = relay_traffic( srcfd, sockfd, ctx, dfilefd, mifaddr );
if( 0 != rc ) break;
} while(0);
if( msockfd > 0 ) {
close_mcast_listener( msockfd, mifaddr );
}
if( sfilefd > 0 ) {
(void) close( sfilefd );
TRACE( (void) tmfprintf( g_flog, "Source file [%s] closed\n",
g_uopt.srcfile ) );
}
if( dfilefd > 0 ) {
(void) close( dfilefd );
TRACE( (void) tmfprintf( g_flog, "Dest file [%s] closed\n",
dfile_name ) );
}
if( 0 != rc ) {
(void) send_http_response( sockfd, 500, "Service error" );
}
(void) close( sockfd );
free_server_ctx( ctx );
closelog();
TRACE( (void)tmfprintf( g_flog, "Child process=[%d] exits with rc=[%d]\n",
getpid(), rc) );
if( g_flog && (stderr != g_flog) ) {
(void) fclose(g_flog);
}
free_uopt( &g_uopt );
rc = ( 0 != rc ) ? ERR_INTERNAL : rc;
exit(rc); /* child exits */
return rc;
}
/* process client requests */
int
srv_loop( const char* ipaddr, int port,
const char* mcast_addr )
{
int rc, maxfd, err, nrdy, i;
fd_set rset;
struct timeval tmout, idle_tmout, *ptmout = NULL;
tmfd_t *asock = NULL;
size_t n = 0, nasock = 0, max_nasock = LQ_BACKLOG;
sigset_t oset, bset;
static const long IDLE_TMOUT_SEC = 30;
assert( (port > 0) && mcast_addr && ipaddr );
(void)tmfprintf( g_flog, "Server is starting up, max clients = [%u]\n",
g_uopt.max_clients );
asock = calloc (max_nasock, sizeof(*asock));
if (!asock) {
mperror (g_flog, ENOMEM, "%s: calloc", __func__);
return ERR_INTERNAL;
}
init_server_ctx( &g_srv, g_uopt.max_clients,
(ipaddr[0] ? ipaddr : "0.0.0.0") , (uint16_t)port, mcast_addr );
g_srv.rcv_tmout = (u_short)g_uopt.rcv_tmout;
g_srv.snd_tmout = RLY_SOCK_TIMEOUT;
/* NB: server socket is non-blocking! */
if( 0 != (rc = setup_listener( ipaddr, port, &g_srv.lsockfd,
g_uopt.lq_backlog )) ) {
return rc;
}
sigemptyset (&bset);
sigaddset (&bset, SIGINT);
sigaddset (&bset, SIGQUIT);
sigaddset (&bset, SIGCHLD);
sigaddset (&bset, SIGTERM);
(void) sigprocmask (SIG_BLOCK, &bset, &oset);
TRACE( (void)tmfprintf( g_flog, "Entering server loop [%s]\n",
SLOOP_TAG) );
while (1) {
FD_ZERO( &rset );
FD_SET( g_srv.lsockfd, &rset );
FD_SET( g_srv.cpipe[0], &rset );
maxfd = (g_srv.lsockfd > g_srv.cpipe[0] ) ? g_srv.lsockfd : g_srv.cpipe[0];
for (i = 0; (size_t)i < nasock; ++i) {
assert (asock[i].fd >= 0);
FD_SET (asock[i].fd, &rset);
if (asock[i].fd > maxfd) maxfd = asock[i].fd;
}
/* if there are accepted sockets - apply specified time-out
*/
tmout.tv_sec = g_uopt.ssel_tmout;
tmout.tv_usec = 0;
idle_tmout.tv_sec = IDLE_TMOUT_SEC;
idle_tmout.tv_usec = 0;
/* enforce *idle* select(2) timeout to alleviate signal contention */
ptmout = ((nasock > 0) && (g_uopt.ssel_tmout > 0)) ? &tmout : &idle_tmout;
TRACE( (void)tmfprintf( g_flog, "Waiting for input from [%ld] fd's, "
"%s timeout\n", (long)(2 + nasock), (ptmout ? "with" : "NO")));
if (ptmout && ptmout->tv_sec) {
TRACE( (void)tmfprintf (g_flog, "select() timeout set to "
"[%ld] seconds\n", ptmout->tv_sec) );
}
(void) sigprocmask (SIG_UNBLOCK, &bset, NULL);
if( must_quit() ) {
TRACE( (void)tmfputs( "Must quit now\n", g_flog ) );
rc = 0; break;
}
nrdy = select (maxfd + 1, &rset, NULL, NULL, ptmout);
err = errno;
(void) sigprocmask (SIG_BLOCK, &bset, NULL);
if( must_quit() ) {
TRACE( (void)tmfputs( "Must quit now\n", g_flog ) );
rc = 0; break;
}
wait_terminated( &g_srv );
if( nrdy < 0 ) {
if (EINTR == err) {
TRACE( (void)tmfputs ("INTERRUPTED, yet "
"will continue.\n", g_flog) );
rc = 0; continue;
}
mperror( g_flog, err, "%s: select", __func__ );
break;
}
TRACE( (void)tmfprintf (g_flog, "Got %ld requests\n", (long)nrdy) );
if (0 == nrdy) { /* time-out */
tmout_requests (asock, &nasock);
rc = 0; continue;
}
if( FD_ISSET(g_srv.cpipe[0], &rset) ) {
(void) tpstat_read( &g_srv );
if (--nrdy <= 0) continue;
}
if ((0 < nasock) &&
(0 < (nrdy - (FD_ISSET(g_srv.lsockfd, &rset) ? 1 : 0)))) {
process_requests (asock, &nasock, &rset, &g_srv);
/* n now contains # (yet) unprocessed accepted sockets */
}
if (FD_ISSET(g_srv.lsockfd, &rset)) {
if (nasock >= max_nasock) {
(void) tmfprintf (g_flog, "Cannot accept sockets beyond "
"the limit [%ld/%ld], skipping\n",
(long)nasock, (long)max_nasock);
}
else {
n = max_nasock - nasock; /* append asock */
accept_requests (g_srv.lsockfd, &(asock[nasock]), &n);
nasock += n;
}
}
} /* server loop */
TRACE( (void)tmfprintf( g_flog, "Exited server loop [%s]\n", SLOOP_TAG) );
for (i = 0; (size_t)i < nasock; ++i) {
if (asock[i].fd > 0) (void) close (asock[i].fd);
}
free (asock);
/* receive additional (blocked signals) */
(void) sigprocmask (SIG_SETMASK, &oset, NULL);
wait_terminated( &g_srv );
terminate_all_clients( &g_srv );
wait_all( &g_srv );
if (0 != close( g_srv.lsockfd )) {
mperror (g_flog, errno, "server socket close");
}
free_server_ctx( &g_srv );
(void)tmfprintf( g_flog, "Server exits with rc=[%d]\n", rc );
return rc;
}
