static bool recdirectory(void)
{
    static const struct opt_items names[] = {
        { rec_base_directory, -1 },
        { STR(LANG_RECORD_CURRENT_DIR) }
    };
    return set_option(str(LANG_RECORD_DIRECTORY),
                      &global_settings.rec_directory, INT,
                      names, 2, NULL );
}

static bool recchannels(void)
{
    static const struct opt_items names[] = {
        { STR(LANG_CHANNEL_STEREO) },
        { STR(LANG_CHANNEL_MONO) }
    };
    return set_option(str(LANG_RECORDING_CHANNELS),
                      &global_settings.rec_channels, INT,
                      names, 2, NULL );
}

int main(int argc, char *argv[])
{
	int i=1;
	for (;i<argc; ++i)
		set_option(argv[i]);

	load_configure();
	nodenet_startup();
	return 0;
}

int imap_wait_keepalive (pid_t pid)
{
  struct sigaction oldalrm;
  struct sigaction act;
  sigset_t oldmask;
  int rc;

  short imap_passive = option (OPTIMAPPASSIVE);

  set_option (OPTIMAPPASSIVE);
  set_option (OPTKEEPQUIET);

  sigprocmask (SIG_SETMASK, NULL, &oldmask);

  sigemptyset (&act.sa_mask);
  act.sa_handler = alrm_handler;
#ifdef SA_INTERRUPT
  act.sa_flags = SA_INTERRUPT;
#else
  act.sa_flags = 0;
#endif

  sigaction (SIGALRM, &act, &oldalrm);

  alarm (ImapKeepalive);
  while (waitpid (pid, &rc, 0) < 0 && errno == EINTR)
  {
    alarm (0); /* cancel a possibly pending alarm */
    imap_keepalive ();
    alarm (ImapKeepalive);
  }

  alarm (0);	/* cancel a possibly pending alarm */

  sigaction (SIGALRM, &oldalrm, NULL);
  sigprocmask (SIG_SETMASK, &oldmask, NULL);

  unset_option (OPTKEEPQUIET);
  if (!imap_passive)
    unset_option (OPTIMAPPASSIVE);

  return rc;
}

//{{{
void options_menu(void)
{
	int choice;
	int old_value, new_value;
	int change_made = 0;
	
	setTabStops(options_menu_tabs);
	UI_Menu_Set_Persist(1);
	while(1) {
#ifdef OPTIONS_SUBMENUS
		choice = UI_Menu_Pick(options_rect, count_options()+OPTIONS_SUBMENUS,
		                      &cb_options_menu);
		if(choice>=0 && choice<OPTIONS_SUBMENUS) {
			pick_submenu(choice);
			change_made = 1;
			continue;
		} else {
			choice -= OPTIONS_SUBMENUS;
		}
#else
		choice = UI_Menu_Pick(options_rect, count_options(), &cb_options_menu);
#endif
		
		if(choice<0)
			break;
		old_value = get_option(options[choice].key);
		new_value = (old_value+1) % count_choices(options[choice].choices);
		set_option(options[choice].key, new_value);
		change_made = 1;
		
#ifdef IS_CALCULATOR
		if(options[choice].key == OPTION_GRAYSCALE)
		{
			if(get_option(OPTION_GRAYSCALE) == OPTION_GRAY_ON)
				GrayOnThrow();
			else
				GrayOff();
			if(w->level) // Only if game is started
				full_redraw();
		}
#endif
#ifdef PALMOS
		if(options[choice].key == OPTION_INVERSE)
			init_colors();
#endif
#ifdef REALCOMPUTER
		if(options[choice].key == OPTION_COLOR)
			init_colors();
#endif
	}
	UI_Menu_Set_Persist(0);
	
	if(change_made)
		save_options();
}

static void start_civetweb(int argc, char *argv[]) {
  struct mg_callbacks callbacks;
  char *options[MAX_OPTIONS];
  int i;

  // Edit passwords file if -A option is specified
  if (argc > 1 && !strcmp(argv[1], "-A")) {
    if (argc != 6) {
      show_usage_and_exit();
    }
    exit(mg_modify_passwords_file(argv[2], argv[3], argv[4], argv[5]) ?
         EXIT_SUCCESS : EXIT_FAILURE);
  }

  // Show usage if -h or --help options are specified
  if (argc == 2 && (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help"))) {
    show_usage_and_exit();
  }

  options[0] = NULL;
  set_option(options, "document_root", ".");

  // Update config based on command line arguments
  process_command_line_arguments(argv, options);

  // Make sure we have absolute paths for files and directories
  set_absolute_path(options, "document_root", argv[0]);
  set_absolute_path(options, "put_delete_auth_file", argv[0]);
  set_absolute_path(options, "cgi_interpreter", argv[0]);
  set_absolute_path(options, "access_log_file", argv[0]);
  set_absolute_path(options, "error_log_file", argv[0]);
  set_absolute_path(options, "global_auth_file", argv[0]);
  set_absolute_path(options, "ssl_certificate", argv[0]);

  // Make extra verification for certain options
  verify_existence(options, "document_root", 1);
  verify_existence(options, "cgi_interpreter", 0);
  verify_existence(options, "ssl_certificate", 0);

  // Setup signal handler: quit on Ctrl-C
  signal(SIGTERM, signal_handler);
  signal(SIGINT, signal_handler);

  // Start Civetweb
  memset(&callbacks, 0, sizeof(callbacks));
  callbacks.log_message = &log_message;
  ctx = mg_start(&callbacks, NULL, (const char **) options);
  for (i = 0; options[i] != NULL; i++) {
    free(options[i]);
  }

  if (ctx == NULL) {
    die("%s", "Failed to start Civetweb.");
  }
}

/* Examines any relevant environment variables.  Must be called when in
 * single-thread mode.
 */
static void read_environment ()
{
  Option *o;

  for (o = vars; o->env; o++)
  {
    char *val;
    if ((val = (char *) getenv (o->env)))
      set_option (o, val, "Environment variable", o->env);
  }
}

 void bind_and_listen(const std::string& port,bool reuse_addr) {
     boost::asio::ip::tcp::resolver resolver(get_io_service());
     boost::asio::ip::tcp::resolver::query query(boost::asio::ip::tcp::v4(),port);
     boost::asio::ip::tcp::endpoint endpoint = *resolver.resolve(query);
     open(endpoint.protocol());
     if(reuse_addr) {
         set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
     }
     bind(endpoint);
     listen(boost::asio::socket_base::max_connections);
 }

static bool autoloadbookmark(void)
{
    static const struct opt_items names[] = {
        { STR(LANG_SET_BOOL_NO) },
        { STR(LANG_SET_BOOL_YES) },
        { STR(LANG_RESUME_SETTING_ASK) }
    };
    return set_option( str(LANG_BOOKMARK_SETTINGS_AUTOLOAD),
                       &global_settings.autoloadbookmark, INT,
                       names, 3, NULL );
}

int
dotogglepickup(void)
{
    union nh_optvalue val;

    val.b = !flags.pickup;
    set_option("autopickup", val, FALSE);

    pline("Autopickup: %s.", flags.pickup ? "ON" : "OFF");
    return 0;
}

static void set_parameters (struct _options *opts, int flags,
			    int argc, const char **argv)
{
    opts->opt_silent                = flags & PAM_SILENT;
    opts->opt_disallow_null_authtok = flags & PAM_DISALLOW_NULL_AUTHTOK;

    while (argc-- > 0) {
	set_option (opts, *argv);
	++argv;
    }
}

static bool useMRB(void)
{
    static const struct opt_items names[] = {
        { STR(LANG_SET_BOOL_NO) },
        { STR(LANG_SET_BOOL_YES) },
        { STR(LANG_BOOKMARK_SETTINGS_UNIQUE_ONLY) }
    };
    return set_option( str(LANG_BOOKMARK_SETTINGS_MAINTAIN_RECENT_BOOKMARKS),
                       &global_settings.usemrb, INT,
                       names, 3, NULL );
}

boolean nh_set_option(const char *name, union nh_optvalue value, boolean isstring)
{
	boolean rv;
	
	if (!api_entry_checkpoint())
	    return FALSE;
	
	rv = set_option(name, value, isstring);
	
	api_exit();
	return rv;
}

/*
 * Process any command-line switches and any additional GUC variable
 * settings passed in the startup packet.
 */
static void process_startup_options(struct session *port, bool am_superuser)
{
	enum guc_ctx gucctx;
	struct list_cell* gucopts;

	gucctx = am_superuser ? PGC_SUSET : PGC_BACKEND;

	/*
	 * First process any command-line switches that were included in the
	 * startup packet, if we are in a regular backend.
	 */
	if (port->cmdline_options != NULL) {
		/*
		 * The maximum possible number of commandline arguments that could
		 * come from port->cmdline_options is (strlen + 1) / 2; see
		 * pg_split_opts().
		 */
		char **av;
		int maxac;
		int ac;

		maxac = 2 + (strlen(port->cmdline_options) + 1) / 2;
		av = (char**) palloc(maxac * sizeof(char *));
		ac = 0;
		av[ac++] = "postgres";

		/* Note this mangles port->cmdline_options */
		pg_split_opts(av, &ac, port->cmdline_options);
		av[ac] = NULL;

		ASSERT(ac < maxac);

		(void) process_postgres_switches(ac, av, gucctx);
	}

	/*
	 * Process any additional GUC variable settings passed in startup packet.
	 * These are handled exactly like command-line variables.
	 */
	gucopts = list_head(port->guc_options);
	while (gucopts) {
		char *name;
		char *value;

		name = lfirst(gucopts);
		gucopts = lnext(gucopts);

		value = lfirst(gucopts);
		gucopts = lnext(gucopts);

		set_option(name, value, gucctx, PGC_S_CLIENT);
	}
}

static bool avc(void)
{
    static const struct opt_items names[] = {
        { STR(LANG_OFF) },
        { "20ms", TALK_ID(20, UNIT_MS) },
        { "2s", TALK_ID(2, UNIT_SEC) },
        { "4s", TALK_ID(4, UNIT_SEC) },
        { "8s", TALK_ID(8, UNIT_SEC) }
    };
    return set_option(str(LANG_DECAY), &global_settings.avc, INT,
                      names, 5, set_avc);
}

UnixSocketAcceptor<Protocol, Dispatcher>::UnixSocketAcceptor(Dispatcher &dispatcher,
                                                 UnixEndpoint<Protocol> const &ep,
                                                 UnixSocketBase::ReuseAddress reuse)
    : _dispatcher(dispatcher), _fd(-1)
{
  Error err;

  open(ep.protocol(), err);
  set_option(reuse, err);
  bind(ep, err);
  listen(SOMAXCONN, err);
}

static bool backlight_fade_in(void)
{
    static const struct opt_items names[] = {
        { STR(LANG_OFF) },
        { "500ms", TALK_ID(500, UNIT_MS) },
        { "1s", TALK_ID(1, UNIT_SEC) },
        { "2s", TALK_ID(2, UNIT_SEC) },
    };
    return set_option(str(LANG_BACKLIGHT_FADE_IN),
                      &global_settings.backlight_fade_in,
                      INT, names, 4, backlight_set_fade_in );
}

static bool dir_filter(void)
{
    static const struct opt_items names[] = {
        { STR(LANG_FILTER_ALL) },
        { STR(LANG_FILTER_SUPPORTED) },
        { STR(LANG_FILTER_MUSIC) },
        { STR(LANG_FILTER_PLAYLIST) },
        { STR(LANG_FILTER_ID3DB) }
    };
    return set_option( str(LANG_FILTER), &global_settings.dirfilter, INT,
                       names, 5, NULL );
}

boolean
nh_set_option(const char *name, union nh_optvalue value)
{
    boolean rv;

    API_ENTRY_CHECKPOINT_RETURN_ON_ERROR(FALSE);

    rv = set_option(name, value, NULL);

    API_EXIT();
    return rv;
}

int main(int argc, char *const argv[])
{
  int opt;
  char *srvaddr = "127.0.0.1";
  int id = 11;
  int tag = 1;

  /* the id and server address don't really matter,
   * as we don't register to the server. */

  while ((opt = getopt(argc, argv, "i:S:nf:t:h:d:")) != -1) {
    switch (opt) {
      case 'i':
        id = atoi(optarg);
        break;
      case 'S':
        srvaddr = optarg;
        break;
      case 'n':
        nonblock = 1;
        break;
      case 'f':
        rate = atoi(optarg);
        break;
      case 't':
        tag = atoi(optarg);
        break;
      case 'h':
        hold = atoi(optarg);
        break;
      case 'd':
        parse_sockaddr_in(&dest_addr, optarg);
        /* default send to the xcast's port if not set. */
        if( dest_addr.sin_port == 0 )
          dest_addr.sin_port = htons(MIX_CAST_PORT);
        break;
    }
  }

  open_audio_out();

  set_option(OPT_ACCESS_RAW_AUDIO_PACK, 1);

  set_event_callback(on_event);

  id |= (tag<<16); //wrap tag and id
  client_init(id, DEVTYPE_NETPLAY, srvaddr, AUDIO_PORT);

  while(1) sleep(10000);

  return 0;
}