Example #1
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();
	}
}
Example #2
0
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 ();
    }
}