~ubuntu-branches/ubuntu/oneiric/openvpn/oneiric

/*

 *  OpenVPN -- An application to securely tunnel IP networks

 *             over a single TCP/UDP port, with support for SSL/TLS-based

 *             session authentication and key exchange,

 *             packet encryption, packet authentication, and

 *             packet compression.

 *

 *  Copyright (C) 2002-2010 OpenVPN Technologies, Inc. <sales@openvpn.net>

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License version 2

 *  as published by the Free Software Foundation.

 *

 *  This program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program (see the file COPYING included with this

 *  distribution); if not, write to the Free Software Foundation, Inc.,

 *  59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

#include "syshead.h"

#include "init.h"

#include "forward.h"

#include "multi.h"

#include "win32.h"

#include "memdbg.h"

#include "forward-inline.h"

#define P2P_CHECK_SIG() EVENT_LOOP_CHECK_SIGNAL (c, process_signal_p2p, c);

static bool

process_signal_p2p (struct context *c)

{

  remap_signal (c);

  return process_signal (c);

}

static void

tunnel_point_to_point (struct context *c)

{

  context_clear_2 (c);

  /* set point-to-point mode */

  c->mode = CM_P2P;

  /* initialize tunnel instance */

  init_instance_handle_signals (c, c->es, CC_HARD_USR1_TO_HUP);

  if (IS_SIG (c))

    return;

  /* main event loop */

  while (true)

    {

      perf_push (PERF_EVENT_LOOP);

      /* process timers, TLS, etc. */

      pre_select (c);

      P2P_CHECK_SIG();

      /* set up and do the I/O wait */

      io_wait (c, p2p_iow_flags (c));

      P2P_CHECK_SIG();

      /* timeout? */

      if (c->c2.event_set_status == ES_TIMEOUT)

	{

	  perf_pop ();

	  continue;

	}

      /* process the I/O which triggered select */

      process_io (c);

      P2P_CHECK_SIG();

      perf_pop ();

    }

  uninit_management_callback ();

  /* tear down tunnel instance (unless --persist-tun) */

  close_instance (c);

}

#undef PROCESS_SIGNAL_P2P

int

main (int argc, char *argv[])

{

  struct context c;

#if PEDANTIC

  fprintf (stderr, "Sorry, I was built with --enable-pedantic and I am incapable of doing any real work!\n");

  return 1;

#endif

  CLEAR (c);

  /* signify first time for components which can

     only be initialized once per program instantiation. */

  c.first_time = true;

  /* initialize program-wide statics */

  if (init_static ())

    {

      /*

       * This loop is initially executed on startup and then

       * once per SIGHUP.

       */

      do

	{

	  /* enter pre-initialization mode with regard to signal handling */

	  pre_init_signal_catch ();

	  /* zero context struct but leave first_time member alone */

	  context_clear_all_except_first_time (&c);

	  /* static signal info object */

	  CLEAR (siginfo_static);

	  c.sig = &siginfo_static;

	  /* initialize garbage collector scoped to context object */

	  gc_init (&c.gc);

	  /* initialize environmental variable store */

	  c.es = env_set_create (NULL);

#ifdef WIN32

	  env_set_add_win32 (c.es);

#endif

#ifdef ENABLE_MANAGEMENT

	  /* initialize management subsystem */

	  init_management (&c);

#endif

	  /* initialize options to default state */

	  init_options (&c.options, true);

	  /* parse command line options, and read configuration file */

	  parse_argv (&c.options, argc, argv, M_USAGE, OPT_P_DEFAULT, NULL, c.es);

#ifdef ENABLE_PLUGIN

	  /* plugins may contribute options configuration */

	  init_verb_mute (&c, IVM_LEVEL_1);

	  init_plugins (&c);

	  open_plugins (&c, true, OPENVPN_PLUGIN_INIT_PRE_CONFIG_PARSE);

#endif

	  /* init verbosity and mute levels */

	  init_verb_mute (&c, IVM_LEVEL_1);

	  /* set dev options */

	  init_options_dev (&c.options);

	  /* openssl print info? */

	  if (print_openssl_info (&c.options))

	    break;

	  /* --genkey mode? */

	  if (do_genkey (&c.options))

	    break;

	  /* tun/tap persist command? */

	  if (do_persist_tuntap (&c.options))

	    break;

	  /* sanity check on options */

	  options_postprocess (&c.options);

	  /* show all option settings */

	  show_settings (&c.options);

	  /* print version number */

	  msg (M_INFO, "%s", title_string);

	  /* misc stuff */

	  pre_setup (&c.options);

	  /* test crypto? */

	  if (do_test_crypto (&c.options))

	    break;

#ifdef ENABLE_MANAGEMENT

	  /* open management subsystem */

	  if (!open_management (&c))

	    break;

#endif

	  /* set certain options as environmental variables */

	  setenv_settings (c.es, &c.options);

	  /* finish context init */

	  context_init_1 (&c);

	  do

	    {

	      /* run tunnel depending on mode */

	      switch (c.options.mode)

		{

		case MODE_POINT_TO_POINT:

		  tunnel_point_to_point (&c);

		  break;

#if P2MP_SERVER

		case MODE_SERVER:

		  tunnel_server (&c);

		  break;

#endif

		default:

		  ASSERT (0);

		}

	      /* indicates first iteration -- has program-wide scope */

	      c.first_time = false;

	      /* any signals received? */

	      if (IS_SIG (&c))

		print_signal (c.sig, NULL, M_INFO);

	      /* pass restart status to management subsystem */

	      signal_restart_status (c.sig);

	    }

	  while (c.sig->signal_received == SIGUSR1);

	  uninit_options (&c.options);

	  gc_reset (&c.gc);

	}

      while (c.sig->signal_received == SIGHUP);

    }

  context_gc_free (&c);

  env_set_destroy (c.es);

#ifdef ENABLE_MANAGEMENT

  /* close management interface */

  close_management ();

#endif

  /* uninitialize program-wide statics */

  uninit_static ();

  openvpn_exit (OPENVPN_EXIT_STATUS_GOOD);  /* exit point */

  return 0;			            /* NOTREACHED */

}