static int
sasyncd_run(pid_t ppid)
{
struct timeval *timeout, tv;
fd_set *rfds, *wfds;
size_t fdsetsize;
int maxfd, n;
n = getdtablesize();
fdsetsize = howmany(n, NFDBITS) * sizeof(fd_mask);
rfds = (fd_set *)malloc(fdsetsize);
if (!rfds) {
log_err("malloc(%lu) failed", (unsigned long)fdsetsize);
return -1;
}
wfds = (fd_set *)malloc(fdsetsize);
if (!wfds) {
log_err("malloc(%lu) failed", (unsigned long)fdsetsize);
free(rfds);
return -1;
}
control_setrun();
signal(SIGINT, sasyncd_stop);
signal(SIGTERM, sasyncd_stop);
timer_add("carp_undemote", CARP_DEMOTE_MAXTIME,
monitor_carpundemote, NULL);
while (!daemon_shutdown) {
memset(rfds, 0, fdsetsize);
memset(wfds, 0, fdsetsize);
maxfd = net_set_rfds(rfds);
n = net_set_pending_wfds(wfds);
if (n > maxfd)
maxfd = n;
pfkey_set_rfd(rfds);
pfkey_set_pending_wfd(wfds);
if (cfgstate.pfkey_socket + 1 > maxfd)
maxfd = cfgstate.pfkey_socket + 1;
carp_set_rfd(rfds);
if (cfgstate.route_socket + 1 > maxfd)
maxfd = cfgstate.route_socket + 1;
timeout = &tv;
timer_next_event(&tv);
n = select(maxfd, rfds, wfds, 0, timeout);
if (n == -1) {
if (errno != EINTR) {
log_err("select()");
sleep(1);
}
} else if (n) {
net_handle_messages(rfds);
net_send_messages(wfds);
pfkey_read_message(rfds);
pfkey_send_message(wfds);
carp_read_message(rfds);
}
timer_run();
/* Mostly for debugging. */
if (getppid() != ppid) {
log_msg(0, "sasyncd: parent died");
daemon_shutdown++;
}
}
free(rfds);
free(wfds);
return 0;
}
int
main(int argc, char *argv[])
{
printf("ISAKMP: main : <<<START>>> \n");
fd_set *rfds, *wfds;
int n, m;
size_t mask_size;
struct timeval tv, *timeout;
// closefrom(STDERR_FILENO + 1);
/*
* Make sure init() won't alloc fd 0, 1 or 2, as daemon() will close
* them.
*/
/*
for (n = 0; n <= 2; n++)
if (fcntl(n, F_GETFL, 0) == -1 && errno == EBADF)
(void) open("/dev/null", n ? O_WRONLY : O_RDONLY, 0);
*/
/* Log cmd line parsing and initialization errors to stderr. */
log_to(stderr);
parse_args(argc, argv);
log_init(debug);
/* Open protocols and services databases. */
setprotoent(1);
setservent(1);
/* Open command fifo */
ui_init();
set_slave_signals();
/* Daemonize before forking unpriv'ed child */
if (!debug)
if (daemon(0, 0))
log_fatal("main: daemon (0, 0) failed");
/* Set timezone before priv'separation */
tzset();
write_pid_file();
/*
if (monitor_init(debug)) {
// The parent, with privileges enters infinite monitor loop.
//monitor_loop(debug);
//exit(0); // Never reached.
}*/
/* Child process only from this point on, no privileges left. */
init();
/* If we wanted IKE packet capture to file, initialize it now. */
if (pcap_file != 0)
log_packet_init(pcap_file);
/* Allocate the file descriptor sets just big enough. */
// we change here
//n = getdtablesize();
n = 1000;
mask_size = howmany(n, NFDBITS) * sizeof(fd_mask);
rfds = (fd_set *) malloc(mask_size);
if (!rfds)
log_fatal("main: malloc (%lu) failed",
(unsigned long)mask_size);
wfds = (fd_set *) malloc(mask_size);
if (!wfds)
log_fatal("main: malloc (%lu) failed",
(unsigned long)mask_size);
//monitor_init_done();
while (1) {
/* If someone has sent SIGHUP to us, reconfigure. */
if (sighupped) {
sighupped = 0;
log_print("SIGHUP received");
reinit();
}
/* and if someone sent SIGUSR1, do a state report. */
if (sigusr1ed) {
sigusr1ed = 0;
log_print("SIGUSR1 received");
report();
}
/*
* and if someone set 'sigtermed' (SIGTERM, SIGINT or via the
* UI), this indicates we should start a controlled shutdown
* of the daemon.
*
* Note: Since _one_ message is sent per iteration of this
* enclosing while-loop, and we want to send a number of
* DELETE notifications, we must loop atleast this number of
* times. The daemon_shutdown() function starts by queueing
* the DELETEs, all other calls just increments the
* 'sigtermed' variable until it reaches a "safe" value, and
* the daemon exits.
*/
if (sigtermed)
daemon_shutdown();
/* Setup the descriptors to look for incoming messages at. */
bzero(rfds, mask_size);
n = transport_fd_set(rfds);
FD_SET(ui_socket, rfds);
if (ui_socket + 1 > n)
n = ui_socket + 1;
/*
* XXX Some day we might want to deal with an abstract
* application class instead, with many instantiations
* possible.
*/
if (!app_none && app_socket >= 0) {
FD_SET(app_socket, rfds);
if (app_socket + 1 > n)
n = app_socket + 1;
}
/* Setup the descriptors that have pending messages to send. */
bzero(wfds, mask_size);
m = transport_pending_wfd_set(wfds);
printf(" m = %d , n = %d \n", m,n);
if (m > n)
n = m;
/* Find out when the next timed event is. */
timeout = &tv;
timer_next_event(&timeout);
printf(" select (n n= %d )\n ",n );
n = select(n, rfds, wfds, 0, timeout);
if (n == -1) {
if (errno != EINTR) {
log_error("main: select");
/*
* In order to give the unexpected error
* condition time to resolve without letting
* this process eat up all available CPU
* we sleep for a short while.
*/
sleep(1);
}
} else if (n) {
transport_handle_messages(rfds);
transport_send_messages(wfds);
if (FD_ISSET(ui_socket, rfds))
ui_handler();
if (!app_none && app_socket >= 0 &&
FD_ISSET(app_socket, rfds))
app_handler();
}
timer_handle_expirations();
}
}
int
main (int argc, char *argv[])
{
fd_set *rfds, *wfds;
int n, m;
size_t mask_size;
struct timeval tv, *timeout;
/* Make sure init() won't alloc fd 0, 1 or 2, as daemon() will close them. */
for (n = 0; n <= 2; n++)
if (fcntl (n, F_GETFL, 0) == -1 && errno == EBADF)
(void)open ("/dev/null", n ? O_WRONLY : O_RDONLY, 0);
/* Log cmd line parsing and initialization errors to stderr. */
log_to (stderr);
parse_args (argc, argv);
log_init ();
/* Do a clean daemon shutdown on TERM reception. (Needed by monitor). */
signal (SIGTERM, daemon_shutdown_now);
if (debug) signal (SIGINT, daemon_shutdown_now);
#if defined (USE_PRIVSEP)
if (monitor_init ())
{
/* The parent, with privileges. */
if (!debug)
if (daemon (0, 0))
log_fatal ("main [priv]: daemon (0, 0) failed");
/* Enter infinite monitor loop. */
monitor_loop (debug);
exit (0); /* Never reached. */
}
/* Child process only from this point on, no privileges left. */
#endif
init ();
if (!debug)
{
if (daemon (0, 0))
log_fatal ("main: daemon (0, 0) failed");
/* Switch to syslog. */
log_to (0);
}
write_pid_file ();
/* Reinitialize on HUP reception. */
signal (SIGHUP, sighup);
/* Report state on USR1 reception. */
signal (SIGUSR1, sigusr1);
/* Rehash soft expiration timers on USR2 reception. */
signal (SIGUSR2, sigusr2);
#if defined (USE_DEBUG)
/* If we wanted IKE packet capture to file, initialize it now. */
if (pcap_file != 0)
log_packet_init (pcap_file);
#endif
/* Allocate the file descriptor sets just big enough. */
n = getdtablesize ();
mask_size = howmany (n, NFDBITS) * sizeof (fd_mask);
rfds = (fd_set *)malloc (mask_size);
if (!rfds)
log_fatal ("main: malloc (%lu) failed", (unsigned long)mask_size);
wfds = (fd_set *)malloc (mask_size);
if (!wfds)
log_fatal ("main: malloc (%lu) failed", (unsigned long)mask_size);
while (1)
{
/* If someone has sent SIGHUP to us, reconfigure. */
if (sighupped)
{
log_print ("SIGHUP received");
reinit ();
sighupped = 0;
}
/* and if someone sent SIGUSR1, do a state report. */
if (sigusr1ed)
{
log_print ("SIGUSR1 received");
report ();
}
/* and if someone sent SIGUSR2, do a timer rehash. */
if (sigusr2ed)
{
log_print ("SIGUSR2 received");
rehash_timers ();
}
/*
* and if someone set 'sigtermed' (SIGTERM or via the UI), this
* indicated we should start a shutdown of the daemon.
*
* Note: Since _one_ message is sent per iteration of this enclosing
* while-loop, and we want to send a number of DELETE notifications,
* we must loop atleast this number of times. The daemon_shutdown()
* function starts by queueing the DELETEs, all other calls just
* increments the 'sigtermed' variable until it reaches a "safe"
* value, and the daemon exits.
*/
if (sigtermed)
daemon_shutdown ();
/* Setup the descriptors to look for incoming messages at. */
memset (rfds, 0, mask_size);
n = transport_fd_set (rfds);
FD_SET (ui_socket, rfds);
if (ui_socket + 1 > n)
n = ui_socket + 1;
/*
* XXX Some day we might want to deal with an abstract application
* class instead, with many instantiations possible.
*/
if (!app_none && app_socket >= 0)
{
FD_SET (app_socket, rfds);
if (app_socket + 1 > n)
n = app_socket + 1;
}
/* Setup the descriptors that have pending messages to send. */
memset (wfds, 0, mask_size);
m = transport_pending_wfd_set (wfds);
if (m > n)
n = m;
/* Find out when the next timed event is. */
timeout = &tv;
timer_next_event (&timeout);
n = select (n, rfds, wfds, 0, timeout);
if (n == -1)
{
if (errno != EINTR)
{
log_error ("select");
/*
* In order to give the unexpected error condition time to
* resolve without letting this process eat up all available CPU
* we sleep for a short while.
*/
sleep (1);
}
}
else if (n)
{
transport_handle_messages (rfds);
transport_send_messages (wfds);
if (FD_ISSET (ui_socket, rfds))
ui_handler ();
if (!app_none && app_socket >= 0 && FD_ISSET (app_socket, rfds))
app_handler ();
}
timer_handle_expirations ();
}
}