void death_handler (int signal)
{
/*
* If we get here, somebody terminated us with a kill or a control-c.
* we call call_close on each tunnel twice to get a StopCCN out
* for each one (we can't pause to make sure it's received.
* Then we close the connections
*/
struct tunnel *st, *st2;
int sec;
log (LOG_CRIT, "%s: Fatal signal %d received\n", __FUNCTION__, signal);
st = tunnels.head;
while (st)
{
st2 = st->next;
strcpy (st->self->errormsg, "Server closing");
sec = st->self->closing;
if (st->lac)
st->lac->redial = 0;
call_close (st->self);
if (!sec)
{
st->self->closing = -1;
call_close (st->self);
}
st = st2;
}
/* erase pid file */
unlink (gconfig.pidfile);
exit (1);
}
int build_fdset (fd_set *readfds)
{
struct tunnel *tun;
struct call *call;
int max = 0;
tun = tunnels.head;
FD_ZERO (readfds);
while (tun)
{
call = tun->call_head;
while (call)
{
if (call->needclose ^ call->closing)
{
call_close (call);
call = tun->call_head;
if (!call)
break;
continue;
}
if (call->fd > -1)
{
if (!call->needclose && !call->closing)
{
if (call->fd > max)
max = call->fd;
FD_SET (call->fd, readfds);
}
}
call = call->next;
}
/* Now that call fds have been collected, and checked for
* closing, check if the tunnel needs to be closed too
*/
if (tun->self->needclose ^ tun->self->closing)
{
if (gconfig.debug_tunnel)
l2tp_log (LOG_DEBUG, "%s: closing down tunnel %d\n",
__FUNCTION__, tun->ourtid);
call_close (tun->self);
/* Reset the while loop
* and check for NULL */
tun = tunnels.head;
if (!tun)
break;
continue;
}
tun = tun->next;
}
FD_SET (server_socket, readfds);
if (server_socket > max)
max = server_socket;
FD_SET (control_fd, readfds);
if (control_fd > max)
max = control_fd;
return max;
}
void death_handler (int signal)
{
/*
* If we get here, somebody terminated us with a kill or a control-c.
* we call call_close on each tunnel twice to get a StopCCN out
* for each one (we can't pause to make sure it's received.
* Then we close the connections
*/
struct tunnel *st, *st2;
int sec;
log (LOG_CRIT, "%s: Fatal signal %d received\n", __FUNCTION__, signal);
st = tunnels.head;
while (st)
{
st2 = st->next;
strcpy (st->self->errormsg, "Server closing");
sec = st->self->closing;
if (st->lac)
st->lac->redial = 0;
/* Foxconn added start pling 08/31/2010 */
/* Disconnect the call (send CDN) tear down tunnel (StopCCN) */
call_close(st->call_head);
/* Foxconn added end pling 08/31/2010 */
call_close (st->self);
if (!sec)
{
st->self->closing = -1;
call_close (st->self);
}
st = st2;
}
/* erase pid file */
unlink (gconfig.pidfile);
#ifdef PPPOX_L2TP
extern int pox_fd;
extern int ppp_fd;
if(ppp_fd >= 0){
if (ioctl(ppp_fd, PPPIOCDETACH) < 0)
log (LOG_DEBUG, "detach ioctl(PPPIOCDETACH) failed");
}
if(pox_fd){
close(pox_fd);
}
#endif
exit (1);
}
void lac_disconnect (int tid)
{
struct tunnel *t = tunnels.head;
while (t)
{
if (t->ourtid == tid)
{
log (LOG_LOG,
"Disconnecting from %s, Local: %d, Remote: %d\n",
IPADDY (t->peer.sin_addr), t->ourtid, t->tid);
t->self->needclose = -1;
strcpy (t->self->errormsg, "Goodbye!");
call_close (t->self);
return;
}
t = t->next;
};
log (LOG_DEBUG, "No such tunnel %d to hang up.\n", tid);
return;
}
void control_xmit (void *b)
{
struct buffer *buf = (struct buffer *) b;
struct tunnel *t;
struct timeval tv;
int ns;
if (!buf)
{
l2tp_log (LOG_WARNING, "%s: called on NULL buffer!\n", __FUNCTION__);
return;
}
ns = ntohs (((struct control_hdr *) (buf->start))->Ns);
t = buf->tunnel;
if (t)
{
#ifdef DEBUG_CONTROL_XMIT
l2tp_log (LOG_DEBUG,
"trying to send control packet %d to %d\n", ns, t->ourtid);
#endif
if (ns < t->cLr)
{
#ifdef DEBUG_CONTROL_XMIT
l2tp_log (LOG_DEBUG, "%s: Tossing packet %d\n", __FUNCTION__, ns);
#endif
/* Okay, it's been received. Let's toss it now */
toss (buf);
return;
}
}
buf->retries++;
if (buf->retries > DEFAULT_MAX_RETRIES)
{
/*
* Too many retries. Either kill the tunnel, or
* if there is no tunnel, just stop retransmitting.
*/
if (t)
{
if (t->self->needclose)
{
l2tp_log (LOG_DEBUG,
"Unable to deliver closing message for tunnel %d. Destroying anyway.\n",
t->ourtid);
t->self->needclose = 0;
t->self->closing = -1;
tv.tv_sec = 1;
tv.tv_usec = 0;
schedule (tv, foo, t);
}
else
{
l2tp_log (LOG_NOTICE,
"Maximum retries exceeded for tunnel %d. Closing.\n",
t->ourtid);
strcpy (t->self->errormsg, "Timeout");
t->self->needclose = -1;
tv.tv_sec = 1;
tv.tv_usec = 0;
schedule (tv, foo, t);
}
call_close(t->self);
}
toss (buf);
}
else
{
tv.tv_sec = 1;
tv.tv_usec = 0;
if (buf->retries > 1)
{
tv.tv_sec = (time_t)((buf->retries-1) * 2);
if (tv.tv_sec > 8)
tv.tv_sec = 8;
}
schedule (tv, control_xmit, buf);
#ifdef DEBUG_CONTROL_XMIT
l2tp_log (LOG_DEBUG, "%s: Scheduling and transmitting packet %d, retries: %d\n",
__FUNCTION__, ns, buf->retries);
#endif
udp_xmit (buf, t);
}
}
void call_close (struct call *c)
{
struct buffer *buf;
struct schedule_entry *se, *ose;
struct call *tmp, *tmp2;
if (!c || !c->container)
{
l2tp_log (LOG_DEBUG, "%s: called on null call or containerless call\n",
__FUNCTION__);
return;
}
if (c == c->container->self)
{
/*
* We're actually closing the
* entire tunnel
*/
/* First deschedule any remaining packet transmissions
for this tunnel. That means Hello's and any reminaing
packets scheduled for transmission. This is a very
nasty little piece of code here. */
se = events;
ose = NULL;
while (se)
{
if ((((struct buffer *) se->data)->tunnel == c->container)
|| ((struct tunnel *) se->data == c->container))
{
#ifdef DEBUG_CLOSE
l2tp_log (LOG_DEBUG, "%s: Descheduling event\n", __FUNCTION__);
#endif
if (ose)
{
ose->next = se->next;
if ((struct tunnel *) se->data != c->container)
toss ((struct buffer *) (se->data));
free (se);
se = ose->next;
}
else
{
events = se->next;
if ((struct tunnel *) se->data != c->container)
toss ((struct buffer *) (se->data));
free (se);
se = events;
}
}
else
{
ose = se;
se = se->next;
}
}
if (c->closing)
{
/* Really close this tunnel, as our
StopCCN has been ack'd */
#ifdef DEBUG_CLOSE
l2tp_log (LOG_DEBUG, "%s: Actually closing tunnel %d\n", __FUNCTION__,
c->container->ourtid);
#endif
#ifdef USE_KERNEL
if (kernel_support)
ioctl (server_socket, L2TPIOCDELTUNNEL, c->container->ourtid);
#endif
destroy_tunnel (c->container);
return;
}
/*
* We need to close, but need to provide reliable delivery
* of the final StopCCN. We record our state to know when
* we have actually received an ACK on our StopCCN
*/
c->closeSs = c->container->control_seq_num;
buf = new_outgoing (c->container);
add_message_type_avp (buf, StopCCN);
if (c->container->hbit)
{
mk_challenge (c->container->chal_them.vector, VECTOR_SIZE);
add_randvect_avp (buf, c->container->chal_them.vector,
VECTOR_SIZE);
}
add_tunnelid_avp (buf, c->container->ourtid);
if (c->result < 0)
c->result = RESULT_CLEAR;
if (c->error < 0)
c->error = 0;
add_result_code_avp (buf, c->result, c->error, c->errormsg,
strlen (c->errormsg));
add_control_hdr (c->container, c, buf);
if (packet_dump)
do_packet_dump (buf);
#ifdef DEBUG_CLOSE
l2tp_log (LOG_DEBUG, "%s: enqueing close message for tunnel\n",
__FUNCTION__);
#endif
control_xmit (buf);
/*
* We also need to stop all traffic on any calls contained
* within us.
*/
tmp = c->container->call_head;
while (tmp)
{
tmp2 = tmp->next;
tmp->needclose = 0;
tmp->closing = -1;
call_close (tmp);
tmp = tmp2;
}
/* mf, 16.04.2003: change log message to show tunneltag */
// l2tp_log (LOG_LOG,
// "%s : Connection %d closed to %s, port %d (%s)\n", __FUNCTION__,
// c->container->tid,
// IPADDY (c->container->peer.sin_addr),
// ntohs (c->container->peer.sin_port), c->errormsg);
l2tp_log (LOG_LOG,
"%s : Connection closed with peer %s, reason: %s\n",
__FUNCTION__, c->container->tunneltag, c->errormsg);
}
else
{
/*
* Just close a call
*/
#ifdef USE_KERNEL
struct l2tp_call_opts co;
#endif
if (c->zlb_xmit)
deschedule (c->zlb_xmit);
/* if (c->dethrottle) deschedule(c->dethrottle); */
if (c->closing)
{
#ifdef DEBUG_CLOSE
l2tp_log (LOG_DEBUG, "%s: Actually closing call %d\n", __FUNCTION__,
c->ourcid);
#endif
destroy_call (c);
return;
}
#ifdef USE_KERNEL
if (kernel_support)
{
co.ourtid = c->container->ourtid;
co.ourcid = c->ourcid;
ioctl (server_socket, L2TPIOCGETCALLOPTS, &co);
co.flags = co.flags & ~L2TP_FLAG_CALL_UP;
ioctl (server_socket, L2TPIOCSETCALLOPTS, &co);
}
#endif
c->closeSs = c->container->control_seq_num;
buf = new_outgoing (c->container);
add_message_type_avp (buf, CDN);
if (c->container->hbit)
{
mk_challenge (c->container->chal_them.vector, VECTOR_SIZE);
add_randvect_avp (buf, c->container->chal_them.vector,
VECTOR_SIZE);
}
if (c->result < 0)
c->result = RESULT_CLEAR;
if (c->error < 0)
c->error = 0;
add_result_code_avp (buf, c->result, c->error, c->errormsg,
strlen (c->errormsg));
#ifdef TEST_HIDDEN
add_callid_avp (buf, c->ourcid, c->container);
#else
add_callid_avp (buf, c->ourcid);
#endif
add_control_hdr (c->container, c, buf);
if (packet_dump)
do_packet_dump (buf);
#ifdef DEBUG_CLOSE
l2tp_log (LOG_DEBUG, "%s: enqueuing close message for call %d\n",
__FUNCTION__, c->ourcid);
#endif
control_xmit (buf);
l2tp_log (LOG_LOG, "%s: Call %d to %s disconnected\n", __FUNCTION__,
c->ourcid, IPADDY (c->container->peer.sin_addr));
}
/*
* Note that we're in the process of closing now
*/
c->closing = -1;
}
void call_close (struct call *c)
{
struct buffer *buf;
struct schedule_entry *se, *ose;
struct call *tmp, *tmp2;
if (!c || !c->container)
{
l2tp_log (LOG_DEBUG, "%s: called on null call or containerless call\n",
__FUNCTION__);
return;
}
if (c == c->container->self)
{
/*
* We're actually closing the
* entire tunnel
*/
/* First deschedule any remaining packet transmissions
for this tunnel. That means Hello's and any reminaing
packets scheduled for transmission. This is a very
nasty little piece of code here. */
se = events;
ose = NULL;
while (se)
{
if ((((struct buffer *) se->data)->tunnel == c->container)
|| ((struct tunnel *) se->data == c->container))
{
#ifdef DEBUG_CLOSE
l2tp_log (LOG_DEBUG, "%s: Descheduling event\n", __FUNCTION__);
#endif
if (ose)
{
ose->next = se->next;
if ((struct tunnel *) se->data != c->container)
toss ((struct buffer *) (se->data));
free (se);
se = ose->next;
}
else
{
events = se->next;
if ((struct tunnel *) se->data != c->container)
toss ((struct buffer *) (se->data));
free (se);
se = events;
}
}
else
{
ose = se;
se = se->next;
}
}
if (c->closing)
{
/* Really close this tunnel, as our
StopCCN has been ack'd */
#ifdef DEBUG_CLOSE
l2tp_log (LOG_DEBUG, "%s: Actually closing tunnel %d\n", __FUNCTION__,
c->container->ourtid);
#endif
destroy_tunnel (c->container);
return;
}
/*
* We need to close, but need to provide reliable delivery
* of the final StopCCN. We record our state to know when
* we have actually received an ACK on our StopCCN
*/
c->closeSs = c->container->control_seq_num;
buf = new_outgoing (c->container);
add_message_type_avp (buf, StopCCN);
if (c->container->hbit)
{
mk_challenge (c->container->chal_them.vector, VECTOR_SIZE);
add_randvect_avp (buf, c->container->chal_them.vector,
VECTOR_SIZE);
}
add_tunnelid_avp (buf, c->container->ourtid);
if (c->result < 0)
c->result = RESULT_CLEAR;
if (c->error < 0)
c->error = 0;
add_result_code_avp (buf, c->result, c->error, c->errormsg,
strlen (c->errormsg));
add_control_hdr (c->container, c, buf);
if (gconfig.packet_dump)
do_packet_dump (buf);
#ifdef DEBUG_CLOSE
l2tp_log (LOG_DEBUG, "%s: enqueing close message for tunnel\n",
__FUNCTION__);
#endif
control_xmit (buf);
/*
* We also need to stop all traffic on any calls contained
* within us.
*/
tmp = c->container->call_head;
while (tmp)
{
tmp2 = tmp->next;
tmp->needclose = 0;
tmp->closing = -1;
call_close (tmp);
tmp = tmp2;
}
l2tp_log (LOG_DEBUG, "Connection %d closed to %s, port %d (%s)\n",
c->container->tid,
IPADDY (c->container->peer.sin_addr),
ntohs (c->container->peer.sin_port), c->errormsg);
if(strcmp(c->errormsg,"Server closing") )
{
if(!strcmp(c->errormsg,"goodbye!") )
l2tp_log (LOG_INFO,
"Terminated by router connect %s, cause manual disconnect.\n", IPADDY (c->container->peer.sin_addr) );
else if( c->msgtype <= 0 || c->msgtype > 16 )
l2tp_log (LOG_INFO, "Detect %s from %s, port %d \n",
c->errormsg, IPADDY (c->container->peer.sin_addr),
ntohs (c->container->peer.sin_port));
else
l2tp_log (LOG_INFO, "Detect %s %s from %s, port %d \n",
msgtypes[c->msgtype],c->errormsg, IPADDY (c->container->peer.sin_addr),
ntohs (c->container->peer.sin_port));
}
//if( (!strcmp(c->errormsg, "Timeout")) && (c->container->tid != 0) )
// l2tp_log(LOG_INFO, "Terminated by router, cause no response to echo-requests.");
}
else
{
/*
* Just close a call
*/
if (c->zlb_xmit)
deschedule (c->zlb_xmit);
/* if (c->dethrottle) deschedule(c->dethrottle); */
if (c->closing)
{
#ifdef DEBUG_CLOSE
l2tp_log (LOG_DEBUG, "%s: Actually closing call %d\n", __FUNCTION__,
c->ourcid);
#endif
destroy_call (c);
return;
}
c->closeSs = c->container->control_seq_num;
buf = new_outgoing (c->container);
add_message_type_avp (buf, CDN);
if (c->container->hbit)
{
mk_challenge (c->container->chal_them.vector, VECTOR_SIZE);
add_randvect_avp (buf, c->container->chal_them.vector,
VECTOR_SIZE);
}
if (c->result < 0)
c->result = RESULT_CLEAR;
if (c->error < 0)
c->error = 0;
add_result_code_avp (buf, c->result, c->error, c->errormsg,
strlen (c->errormsg));
#ifdef TEST_HIDDEN
add_callid_avp (buf, c->ourcid, c->container);
#else
add_callid_avp (buf, c->ourcid);
#endif
add_control_hdr (c->container, c, buf);
if (gconfig.packet_dump)
do_packet_dump (buf);
#ifdef DEBUG_CLOSE
l2tp_log (LOG_DEBUG, "%s: enqueuing close message for call %d\n",
__FUNCTION__, c->ourcid);
#endif
control_xmit (buf);
l2tp_log (LOG_DEBUG, "%s: Call %d to %s disconnected\n", __FUNCTION__,
c->ourcid, IPADDY (c->container->peer.sin_addr));
}
/*
* Note that we're in the process of closing now
*/
c->closing = -1;
}
void death_handler (int signal)
{
/*
* If we get here, somebody terminated us with a kill or a control-c.
* we call call_close on each tunnel twice to get a StopCCN out
* for each one (we can't pause to make sure it's received.
* Then we close the connections
*/
struct tunnel *st, *st2;
int sec;
l2tp_log (LOG_INFO, "%s: Fatal signal %d received\n", __FUNCTION__, signal);
#ifdef USE_KERNEL
if (kernel_support || signal != SIGTERM) {
#else
if (signal != SIGTERM) {
#endif
st = tunnels.head;
while (st)
{
st2 = st->next;
strcpy (st->self->errormsg, "Server closing");
sec = st->self->closing;
if (st->lac)
st->lac->redial = 0;
call_close (st->self);
if (!sec)
{
st->self->closing = -1;
call_close (st->self);
}
st = st2;
}
}
/* erase pid and control files */
unlink (gconfig.pidfile);
unlink (gconfig.controlfile);
free(dial_no_tmp);
close(server_socket);
close(control_fd);
closelog();
exit (1);
}
void sigterm_handler(int sig)
{
sigterm_received = 1;
}
void sigint_handler(int sig)
{
sigint_received = 1;
}
void sigchld_handler(int sig)
{
sigchld_received = 1;
}
void sigusr1_handler(int sig)
{
sigusr1_received = 1;
}
void sighup_handler(int sig)
{
sighup_received = 1;
}
void process_signal(void)
{
if (sigterm_received) { sigterm_received = 0; death_handler(SIGTERM); }
if (sigint_received) { sigint_received = 0; death_handler(SIGINT); }
if (sigchld_received) { sigchld_received = 0; child_handler(SIGCHLD); }
if (sigusr1_received) { sigusr1_received = 0; status_handler(SIGUSR1); }
if (sighup_received) { sighup_received = 0; null_handler(SIGHUP); }
}
int start_pppd (struct call *c, struct ppp_opts *opts)
{
/* char a, b; */
char tty[512];
char *stropt[80];
struct ppp_opts *p;
#ifdef USE_KERNEL
struct sockaddr_pppol2tp sax;
int flags;
#endif
int pos = 1;
int fd2 = -1;
#ifdef DEBUG_PPPD
int x;
#endif
struct termios ptyconf;
struct call *sc;
struct tunnel *st;
p = opts;
stropt[0] = strdup (PPPD);
while (p)
{
stropt[pos] = (char *) malloc (strlen (p->option) + 1);
strncpy (stropt[pos], p->option, strlen (p->option) + 1);
pos++;
p = p->next;
}
stropt[pos] = NULL;
if (c->pppd > 0)
{
l2tp_log(LOG_WARNING, "%s: PPP already started on call!\n", __FUNCTION__);
return -EINVAL;
}
if (c->fd > -1)
{
l2tp_log (LOG_WARNING, "%s: file descriptor already assigned!\n",
__FUNCTION__);
return -EINVAL;
}
#ifdef USE_KERNEL
if (kernel_support)
{
fd2 = socket(AF_PPPOX, SOCK_DGRAM, PX_PROTO_OL2TP);
if (fd2 < 0) {
l2tp_log (LOG_WARNING, "%s: Unable to allocate PPPoL2TP socket.\n",
__FUNCTION__);
return -EINVAL;
}
flags = fcntl(fd2, F_GETFL);
if (flags == -1 || fcntl(fd2, F_SETFL, flags | O_NONBLOCK) == -1) {
l2tp_log (LOG_WARNING, "%s: Unable to set PPPoL2TP socket nonblock.\n",
__FUNCTION__);
close(fd2);
return -EINVAL;
}
memset(&sax, 0, sizeof(sax));
sax.sa_family = AF_PPPOX;
sax.sa_protocol = PX_PROTO_OL2TP;
sax.pppol2tp.fd = c->container->udp_fd;
sax.pppol2tp.addr.sin_addr.s_addr = c->container->peer.sin_addr.s_addr;
sax.pppol2tp.addr.sin_port = c->container->peer.sin_port;
sax.pppol2tp.addr.sin_family = AF_INET;
sax.pppol2tp.s_tunnel = c->container->ourtid;
sax.pppol2tp.s_session = c->ourcid;
sax.pppol2tp.d_tunnel = c->container->tid;
sax.pppol2tp.d_session = c->cid;
if (connect(fd2, (struct sockaddr *)&sax, sizeof(sax)) < 0) {
l2tp_log (LOG_WARNING, "%s: Unable to connect PPPoL2TP socket.\n",
__FUNCTION__);
close(fd2);
return -EINVAL;
}
stropt[pos++] = strdup ("plugin");
stropt[pos++] = strdup ("pppol2tp.so");
stropt[pos++] = strdup ("pppol2tp");
stropt[pos] = (char *) malloc (10);
snprintf (stropt[pos], 10, "%d", fd2);
pos++;
if (c->container->lns) {
stropt[pos++] = strdup ("pppol2tp_lns_mode");
stropt[pos++] = strdup ("pppol2tp_tunnel_id");
stropt[pos] = (char *) malloc (10);
snprintf (stropt[pos], 10, "%d", c->container->ourtid);
pos++;
stropt[pos++] = strdup ("pppol2tp_session_id");
stropt[pos] = (char *) malloc (10);
snprintf (stropt[pos], 10, "%d", c->ourcid);
pos++;
}
stropt[pos] = NULL;
}
else
#endif
{
if ((c->fd = getPtyMaster (tty, sizeof(tty))) < 0)
{
l2tp_log (LOG_WARNING, "%s: unable to allocate pty, abandoning!\n",
__FUNCTION__);
return -EINVAL;
}
/* set fd opened above to not echo so we don't see read our own packets
back of the file descriptor that we just wrote them to */
tcgetattr (c->fd, &ptyconf);
ptyconf.c_cflag &= ~(ICANON | ECHO);
ptyconf.c_lflag &= ~ECHO;
tcsetattr (c->fd, TCSANOW, &ptyconf);
if(fcntl(c->fd, F_SETFL, O_NONBLOCK)!=0) {
l2tp_log(LOG_WARNING, "failed to set nonblock: %s\n", strerror(errno));
return -EINVAL;
}
fd2 = open (tty, O_RDWR);
if (fd2 < 0) {
l2tp_log (LOG_WARNING, "unable to open tty %s, cannot start pppd", tty);
return -EINVAL;
}
stropt[pos++] = strdup(tty);
stropt[pos] = NULL;
}
#ifdef DEBUG_PPPD
l2tp_log (LOG_DEBUG, "%s: I'm running: \n", __FUNCTION__);
for (x = 0; stropt[x]; x++)
{
l2tp_log (LOG_DEBUG, "\"%s\" \n", stropt[x]);
};
#endif
#ifdef __uClinux__
c->pppd = vfork ();
#else
c->pppd = fork ();
#endif
if (c->pppd < 0)
{
/* parent */
l2tp_log(LOG_WARNING,"%s: unable to fork(), abandoning!\n", __FUNCTION__);
close(fd2);
return -EINVAL;
}
else if (!c->pppd)
{
/* child */
close (0); /* redundant; the dup2() below would do that, too */
close (1); /* ditto */
/* close (2); No, we want to keep the connection to /dev/null. */
#ifdef USE_KERNEL
if (!kernel_support)
#endif
{
/* connect the pty to stdin and stdout */
dup2 (fd2, 0);
dup2 (fd2, 1);
close(fd2);
}
/* close all the calls pty fds */
st = tunnels.head;
while (st)
{
sc = st->call_head;
while (sc)
{
#ifdef USE_KERNEL
if (kernel_support) {
close(st->udp_fd); /* tunnel UDP fd */
close(st->pppox_fd); /* tunnel PPPoX fd */
} else
#endif
close (sc->fd); /* call pty fd */
sc = sc->next;
}
st = st->next;
}
/* close the UDP socket fd */
if (server_socket > 0) {
close (server_socket);
server_socket = -1;
}
/* close the control pipe fd */
if (control_fd > 0) {
close (control_fd);
control_fd = -1;
}
if( c->dialing[0] )
{
setenv( "CALLER_ID", c->dialing, 1 );
}
execv (PPPD, stropt);
l2tp_log (LOG_WARNING, "%s: Exec of %s failed!\n", __FUNCTION__, PPPD);
_exit (1);
}
close (fd2);
pos = 0;
while (stropt[pos])
{
free (stropt[pos]);
pos++;
};
return 0;
}
void network_thread ()
{
/*
* We loop forever waiting on either data from the ppp drivers or from
* our network socket. Control handling is no longer done here.
*/
int fromlen; /* Length of the address */
int tunnel, call; /* Tunnel and call */
int recvsize; /* Length of data received */
struct buffer *buf; /* Payload buffer */
struct call *c, *sc; /* Call to send this off to */
struct tunnel *st; /* Tunnel */
fd_set readfds; /* Descriptors to watch for reading */
int max; /* Highest fd */
struct timeval tv; /* Timeout for select */
/* This one buffer can be recycled for everything except control packets */
buf = new_buf (MAX_RECV_SIZE);
for (;;)
{
/*
* First, let's send out any outgoing packets that are waiting on us.
* xmit_udp should only
* contain control packets in the unthreaded version!
*/
max = 0;
FD_ZERO (&readfds);
st = tunnels.head;
while (st)
{
if (st->self->needclose ^ st->self->closing)
{
if (debug_tunnel)
log (LOG_DEBUG, "%S: closing down tunnel %d\n",
__FUNCTION__, st->ourtid);
call_close (st->self);
/* Reset the while loop
and check for NULL */
st = tunnels.head;
if (!st)
break;
continue;
}
sc = st->call_head;
while (sc)
{
if (sc->needclose ^ sc->closing)
{
call_close (sc);
sc = st->call_head;
if (!sc)
break;
continue;
}
if (sc->fd > -1)
{
/* if (!sc->throttle && !sc->needclose && !sc->closing) { */
if (!sc->needclose && !sc->closing)
{
if (sc->fd > max)
max = sc->fd;
FD_SET (sc->fd, &readfds);
}
}
sc = sc->next;
}
st = st->next;
}
FD_SET (server_socket, &readfds);
if (server_socket > max)
max = server_socket;
FD_SET (control_fd, &readfds);
if (control_fd > max)
max = control_fd;
tv.tv_sec = 1;
tv.tv_usec = 0;
schedule_unlock ();
#if 1
if(exitL2tp==1)
{
int shmid=0;
romeCfgParam_t * pRomeCfgParam;
shmid=shmget(SHM_PROMECFGPARAM,sizeof(romeCfgParam_t),0666|IPC_CREAT);
pRomeCfgParam=shmat(shmid,(void*)0,0);
pRomeCfgParam->l2tpCfgParam.dialState=L2TPCFGPARAM_DIALSTATE_OFF;
shmdt(pRomeCfgParam);
exitL2tp=0;
printf("L2TP - exit l2tp loop\n");
return;
}
#endif
select (max + 1, &readfds, NULL, NULL, NULL);
schedule_lock ();
if (FD_ISSET (control_fd, &readfds))
{
do_control ();
}
if (FD_ISSET (server_socket, &readfds))
{
/*
* Okay, now we're ready for reading and processing new data.
*/
recycle_buf (buf);
/* Reserve space for expanding payload packet headers */
buf->start += PAYLOAD_BUF;
buf->len -= PAYLOAD_BUF;
fromlen = sizeof (from);
recvsize =
recvfrom (server_socket, buf->start, buf->len, 0,
(struct sockaddr *) &from, &fromlen);
if (recvsize < MIN_PAYLOAD_HDR_LEN)
{
if (recvsize < 0)
{
if (errno != EAGAIN)
log (LOG_WARN,
"%s: recvfrom returned error %d (%s)\n",
__FUNCTION__, errno, strerror (errno));
}
else
{
log (LOG_WARN, "%s: received too small a packet\n",
__FUNCTION__);
}
}
else
{
buf->len = recvsize;
fix_hdr (buf->start);
extract (buf->start, &tunnel, &call);
if (debug_network)
{
log (LOG_DEBUG, "%s: recv packet from %s, size = %d, tunnel = %d, call = %d\n", __FUNCTION__, inet_ntoa (from.sin_addr), recvsize, tunnel, call);
}
if (packet_dump)
{
do_packet_dump (buf);
}
if (!
(c =
get_call (tunnel, call, from.sin_addr.s_addr,
from.sin_port)))
{
if ((c =
get_tunnel (tunnel, from.sin_addr.s_addr,
from.sin_port)))
{
/*
* It is theoretically possible that we could be sent
* a control message (say a StopCCN) on a call that we
* have already closed or some such nonsense. To prevent
* this from closing the tunnel, if we get a call on a valid
* tunnel, but not with a valid CID, we'll just send a ZLB
* to ack receiving the packet.
*/
if (debug_tunnel)
log (LOG_DEBUG,
"%s: no such call %d on tunnel %d. Sending special ZLB\n",
__FUNCTION__);
handle_special (buf, c, call);
}
else
log (LOG_DEBUG,
"%s: unable to find call or tunnel to handle packet. call = %d, tunnel = %d Dumping.\n",
__FUNCTION__, call, tunnel);
}
else
{
buf->peer = from;
/* Handle the packet */
c->container->chal_us.vector = NULL;
if (handle_packet (buf, c->container, c))
{
if (debug_tunnel)
log (LOG_DEBUG, "%s: bad packet\n", __FUNCTION__);
};
if (c->cnu)
{
/* Send Zero Byte Packet */
control_zlb (buf, c->container, c);
c->cnu = 0;
}
}
}
}
st = tunnels.head;
while (st)
{
sc = st->call_head;
while (sc)
{
if ((sc->fd >= 0) && FD_ISSET (sc->fd, &readfds))
{
/* Got some payload to send */
int result;
recycle_payload (buf, sc->container->peer);
#ifdef DEBUG_FLOW_MORE
log (LOG_DEBUG, "%s: rws = %d, pSs = %d, pLr = %d\n",
__FUNCTION__, sc->rws, sc->pSs, sc->pLr);
#endif
/* if ((sc->rws>0) && (sc->pSs > sc->pLr + sc->rws) && !sc->rbit) {
#ifdef DEBUG_FLOW
log(LOG_DEBUG, "%s: throttling payload (call = %d, tunnel = %d, Lr = %d, Ss = %d, rws = %d)!\n",__FUNCTION__,
sc->cid, sc->container->tid, sc->pLr, sc->pSs, sc->rws);
#endif
sc->throttle = -1;
We unthrottle in handle_packet if we get a payload packet,
valid or ZLB, but we also schedule a dethrottle in which
case the R-bit will be set
FIXME: Rate Adaptive timeout?
tv.tv_sec = 2;
tv.tv_usec = 0;
sc->dethrottle = schedule(tv, dethrottle, sc);
} else */
/* while ((result=read_packet(buf,sc->fd,sc->frame & SYNC_FRAMING))>0) { */
while ((result =
read_packet (buf, sc->fd, SYNC_FRAMING)) > 0)
{
add_payload_hdr (sc->container, sc, buf);
if (packet_dump)
{
do_packet_dump (buf);
}
sc->prx = sc->data_rec_seq_num;
if (sc->zlb_xmit)
{
deschedule (sc->zlb_xmit);
sc->zlb_xmit = NULL;
}
sc->tx_bytes += buf->len;
sc->tx_pkts++;
udp_xmit (buf);
recycle_payload (buf, sc->container->peer);
}
if (result != 0)
{
log (LOG_WARN,
"%s: tossing read packet, error = %s (%d). Closing call.\n",
__FUNCTION__, strerror (-result), -result);
strcpy (sc->errormsg, strerror (-result));
sc->needclose = -1;
}
}
sc = sc->next;
}
st = st->next;
}
}
}
void network_thread ()
{
/*
* We loop forever waiting on either data from the ppp drivers or from
* our network socket. Control handling is no longer done here.
*/
int fromlen; /* Length of the address */
int tunnel, call; /* Tunnel and call */
int recvsize; /* Length of data received */
struct buffer *buf; /* Payload buffer */
struct call *c, *sc; /* Call to send this off to */
struct tunnel *st; /* Tunnel */
fd_set readfds; /* Descriptors to watch for reading */
int max; /* Highest fd */
struct timeval tv; /* Timeout for select */
/* This one buffer can be recycled for everything except control packets */
buf = new_buf (MAX_RECV_SIZE);
for (;;)
{
/*
* First, let's send out any outgoing packets that are waiting on us.
* xmit_udp should only
* contain control packets in the unthreaded version!
*/
max = 0;
FD_ZERO (&readfds);
st = tunnels.head;
while (st)
{
if (st->self->needclose ^ st->self->closing)
{
if (debug_tunnel)
log (LOG_DEBUG, "%S: closing down tunnel %d\n",
__FUNCTION__, st->ourtid);
call_close (st->self);
/* Reset the while loop
and check for NULL */
st = tunnels.head;
if (!st)
break;
continue;
}
sc = st->call_head;
while (sc)
{
if (sc->needclose ^ sc->closing)
{
call_close (sc);
sc = st->call_head;
if (!sc)
break;
continue;
}
if (sc->fd > -1)
{
/* if (!sc->throttle && !sc->needclose && !sc->closing) { */
if (!sc->needclose && !sc->closing)
{
if (sc->fd > max)
max = sc->fd;
FD_SET (sc->fd, &readfds);
}
}
sc = sc->next;
}
st = st->next;
}
FD_SET (server_socket, &readfds);
if (server_socket > max)
max = server_socket;
FD_SET (control_fd, &readfds);
if (control_fd > max)
max = control_fd;
tv.tv_sec = 1;
tv.tv_usec = 0;
/*add start, by MJ.*/
extern int is_first_run;
if(is_first_run)
{
int lac_fp; /* to get conn_id which written by acos */
char cmd[64]={0};
char conn_id[64] = "c default";
lac_fp = fopen("/tmp/l2tp/l2tpd.info", "r");
if (lac_fp != NULL){
//fscanf(lac_fp, "%s", conn_id);
fgets(conn_id, sizeof(conn_id), lac_fp);
fclose(lac_fp);
}
else
log (LOG_DEBUG, "open /tmp/l2tp/l2tpd.info fialed\n");
log (LOG_DEBUG, "%s: -> the first run.\n", __FUNCTION__);
sprintf(cmd, "c %s", conn_id);
//do_control("c MJ.");
do_control(cmd);
//write(control_fd, cmd, strlen(cmd) );
is_first_run = 0;
}
/*add end. by MJ.*/
schedule_unlock ();
select (max + 1, &readfds, NULL, NULL, NULL);
schedule_lock ();
if (FD_ISSET (control_fd, &readfds))
{
do_control (NULL);
}
if (FD_ISSET (server_socket, &readfds))
{
/* wklin added start, 04/12/2011 */
extern void connect_pppunit(void);
connect_pppunit();
/* wklin added end, 04/12/2011 */
/*
* Okay, now we're ready for reading and processing new data.
*/
recycle_buf (buf);
/* Reserve space for expanding payload packet headers */
buf->start += PAYLOAD_BUF;
buf->len -= PAYLOAD_BUF;
fromlen = sizeof (from);
recvsize =
recvfrom (server_socket, buf->start, buf->len, 0,
(struct sockaddr *) &from, &fromlen);
/* , by MJ. for debugging.*/
//log (LOG_DEBUG, "receive %d bytes from server_scoket.\n", recvsize);
if (recvsize < MIN_PAYLOAD_HDR_LEN)
{
if (recvsize < 0)
{
if (errno != EAGAIN)
log (LOG_WARN,
"%s: recvfrom returned error %d (%s)\n",
__FUNCTION__, errno, strerror (errno));
}
else
{
log (LOG_WARN, "%s: received too small a packet\n",
__FUNCTION__);
}
}
else
{
buf->len = recvsize;
fix_hdr (buf->start);
extract (buf->start, &tunnel, &call);
if (debug_network)
{
log (LOG_DEBUG, "%s: recv packet from %s, size = %d,"
"tunnel = %d, call = %d\n", __FUNCTION__, inet_ntoa (from.sin_addr), recvsize, tunnel, call);
}
if (packet_dump)
{
do_packet_dump (buf);
}
if (!
(c =
get_call (tunnel, call, from.sin_addr.s_addr,
from.sin_port)))
{
if ((c =
get_tunnel (tunnel, from.sin_addr.s_addr,
from.sin_port)))
{
/*
* It is theoretically possible that we could be sent
* a control message (say a StopCCN) on a call that we
* have already closed or some such nonsense. To prevent
* this from closing the tunnel, if we get a call on a valid
* tunnel, but not with a valid CID, we'll just send a ZLB
* to ack receiving the packet.
*/
if (debug_tunnel)
log (LOG_DEBUG,
"%s: no such call %d on tunnel %d. Sending special ZLB\n",
__FUNCTION__);
handle_special (buf, c, call);
}
else
log (LOG_DEBUG,
"%s: unable to find call or tunnel to handle packet. call = %d, tunnel = %d Dumping.\n",
__FUNCTION__, call, tunnel);
}
else
{
buf->peer = from;
/* Handle the packet */
c->container->chal_us.vector = NULL;
if (handle_packet (buf, c->container, c))
{
if (debug_tunnel)
log (LOG_DEBUG, "%s: bad packet\n", __FUNCTION__);
};
if (c->cnu)
{
/* Send Zero Byte Packet */
control_zlb (buf, c->container, c);
c->cnu = 0;
}
}
}
};
st = tunnels.head;
while (st)
{
sc = st->call_head;
while (sc)
{
if ((sc->fd >= 0) && FD_ISSET (sc->fd, &readfds))
{
/* Got some payload to send */
int result;
recycle_payload (buf, sc->container->peer);
#ifdef DEBUG_FLOW_MORE
log (LOG_DEBUG, "%s: rws = %d, pSs = %d, pLr = %d\n",
__FUNCTION__, sc->rws, sc->pSs, sc->pLr);
#endif
/* if ((sc->rws>0) && (sc->pSs > sc->pLr + sc->rws) && !sc->rbit) {
#ifdef DEBUG_FLOW
log(LOG_DEBUG, "%s: throttling payload (call = %d, tunnel = %d, Lr = %d, Ss = %d, rws = %d)!\n",__FUNCTION__,
sc->cid, sc->container->tid, sc->pLr, sc->pSs, sc->rws);
#endif
sc->throttle = -1;
We unthrottle in handle_packet if we get a payload packet,
valid or ZLB, but we also schedule a dethrottle in which
case the R-bit will be set
FIXME: Rate Adaptive timeout?
tv.tv_sec = 2;
tv.tv_usec = 0;
sc->dethrottle = schedule(tv, dethrottle, sc);
} else */
/* while ((result=read_packet(buf,sc->fd,sc->frame & SYNC_FRAMING))>0) { */
while ((result =
read_packet (buf, sc->fd, SYNC_FRAMING)) > 0)
{
add_payload_hdr (sc->container, sc, buf);
if (packet_dump)
{
do_packet_dump (buf);
}
sc->prx = sc->data_rec_seq_num;
if (sc->zlb_xmit)
{
deschedule (sc->zlb_xmit);
sc->zlb_xmit = NULL;
}
sc->tx_bytes += buf->len;
sc->tx_pkts++;
udp_xmit (buf);
recycle_payload (buf, sc->container->peer);
}
if (result != 0)
{
log (LOG_WARN,
"%s: tossing read packet, error = %s (%d). Closing call.\n",
__FUNCTION__, strerror (-result), -result);
strcpy (sc->errormsg, strerror (-result));
sc->needclose = -1;
}
}
sc = sc->next;
}
st = st->next;
}
}
}
