X-Git-Url: http://git.silcnet.org/gitweb/?p=silc.git;a=blobdiff_plain;f=apps%2Fsilcd%2Fsilcd.c;h=d367328c6578fdb15942f922e108a2fc7525e4de;hp=c2318925f06e52c9596e32555e6f5360bc14199b;hb=b2d306dde2ce3eae11b4729eca5f3242b2109861;hpb=1f2f026d0f1bafcdbdffd5861502eddda0b876c3

diff --git a/apps/silcd/silcd.c b/apps/silcd/silcd.c
index c2318925..d367328c 100644
--- a/apps/silcd/silcd.c
+++ b/apps/silcd/silcd.c
@@ -4,12 +4,11 @@
 
   Author: Pekka Riikonen <priikone@silcnet.org>
 
-  Copyright (C) 1997 - 2002 Pekka Riikonen
+  Copyright (C) 1997 - 2007 Pekka Riikonen
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2 of the License, or
-  (at your option) any later version.
+  the Free Software Foundation; version 2 of the License.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -33,18 +32,15 @@
 static SilcServer silcd;
 
 static void silc_usage(void);
-static char *silc_server_create_identifier(void);
-static int silc_server_create_key_pair(char *pkcs_name, int bits, char *path,
-				       char *identifier,
-				       SilcPublicKey *ret_pub_key,
-				       SilcPrivateKey *ret_prv_key);
 
+#ifdef HAVE_GETOPT_LONG
 /* Long command line options */
 static struct option long_opts[] =
 {
   { "config-file", 1, NULL, 'f' },
   { "passphrase", 1, NULL, 'p' },
   { "debug", 2, NULL, 'd' },
+  { "debug-level", 1, NULL, 'D' },
   { "hexdump", 0, NULL, 'x' },
   { "help", 0, NULL, 'h' },
   { "foreground", 0, NULL, 'F' },
@@ -58,13 +54,13 @@ static struct option long_opts[] =
 
   { NULL, 0, NULL, 0 }
 };
+#endif /* HAVE_GETOPT_LONG */
 
 /* Command line option variables */
-static bool opt_create_keypair = FALSE;
 static char *opt_keypath = NULL;
 static char *opt_pkcs = "rsa";
 static char *opt_identifier = NULL;
-static int opt_bits = 1024;
+static int opt_bits = 2048;
 
 /* Prints out the usage of silc client */
 
@@ -76,6 +72,7 @@ static void silc_usage(void)
 "  Generic Options:\n"
 "  -f  --config-file=FILE        Alternate configuration file\n"
 "  -d  --debug=string            Enable debugging (Implies --foreground)\n"
+"  -D  --debug-level=level       Enable debugging (Implies --foreground)\n"
 "  -x  --hexdump                 Enable hexdumps (Implies --debug)\n"
 "  -h  --help                    Display this message\n"
 "  -F  --foreground              Dont fork\n"
@@ -102,7 +99,7 @@ static void silc_usage(void)
   exit(0);
 }
 
-/* Dies if a *valid* pid file exists already */
+/* Die if a *valid* pid file exists already */
 
 static void silc_server_checkpid(SilcServer silcd)
 {
@@ -130,35 +127,432 @@ static void silc_server_checkpid(SilcServer silcd)
   }
 }
 
-static void signal_handler(int sig)
+/* Drop root privileges. If some system call fails, die. */
+
+static void silc_server_drop_privs(SilcServer server)
+{
+  /* Are we executing silcd as root or a regular user? */
+  if (geteuid()) {
+    SILC_LOG_DEBUG(("Server started as user"));
+  }
+  else {
+    struct passwd *pw;
+    struct group *gr;
+    char *user, *group;
+
+    SILC_LOG_DEBUG(("Server started as root. Dropping privileges."));
+
+    /* Get the values given for user and group in configuration file */
+    user = server->config->server_info->user;
+    group = server->config->server_info->group;
+
+    if (!user || !group) {
+      fprintf(stderr, "Error:"
+       "\tSILC server must not be run as root.  For the security of your\n"
+       "\tsystem it is strongly suggested that you run SILC under dedicated\n"
+       "\tuser account.  Modify the ServerInfo configuration section to run\n"
+       "\tthe server as non-root user.\n");
+      exit(1);
+    }
+
+    /* Check whether the user/group does not begin with a number */
+    if (isdigit(user[0]) || isdigit(group[0])) {
+      SILC_LOG_DEBUG(("User and/or group starts with a number"));
+      fprintf(stderr, "Invalid user and/or group information\n");
+      fprintf(stderr, "Please assign them as names, not numbers\n");
+      exit(1);
+    }
+
+    if (!(pw = getpwnam(user))) {
+      fprintf(stderr, "Error: No such user %s found.\n", user);
+      exit(1);
+    }
+    if (!(gr = getgrnam(group))) {
+      fprintf(stderr, "Error: No such group %s found.\n", group);
+      exit(1);
+    }
+
+    /* Check whether user and/or group is set to root. If yes, exit
+       immediately. Otherwise, setgid and setuid server to user.group */
+    if ((gr->gr_gid == 0) || (pw->pw_uid == 0)) {
+      fprintf(stderr, "Error:"
+       "\tSILC server must not be run as root.  For the security of your\n"
+       "\tsystem it is strongly suggested that you run SILC under dedicated\n"
+       "\tuser account.  Modify the ServerInfo configuration section to run\n"
+       "\tthe server as non-root user.\n");
+      exit(1);
+    }
+
+    SILC_LOG_DEBUG(("Changing to group %s (gid=%u)", group, gr->gr_gid));
+    if (setgid(gr->gr_gid) != 0) {
+      fprintf(stderr, "Error: Failed setgid() to %s (gid=%u). Exiting.\n",
+	      group, gr->gr_gid);
+      exit(1);
+    }
+#if defined HAVE_SETGROUPS && defined HAVE_INITGROUPS
+    SILC_LOG_DEBUG(("Removing supplementary groups"));
+    if (setgroups(0, NULL) != 0) {
+      fprintf(stderr, "Error: Failed setgroups() to NULL. Exiting.\n");
+      exit(1);
+    }
+    SILC_LOG_DEBUG(("Setting supplementary groups for user %s", user));
+    if (initgroups(user, gr->gr_gid) != 0) {
+      fprintf(stderr, "Error: Failed initgroups() for user %s (gid=%u). "
+	      "Exiting.\n", user, gr->gr_gid);
+      exit(1);
+    }
+#endif
+    SILC_LOG_DEBUG(("Changing to user %s (uid=%u)", user, pw->pw_uid));
+    if (setuid(pw->pw_uid) != 0) {
+      fprintf(stderr, "Error: Failed to setuid() to %s (gid=%u). Exiting.\n",
+              user, pw->pw_uid);
+      exit(1);
+    }
+  }
+}
+
+/* Fork server to background */
+
+static void silc_server_daemonise(SilcServer server)
 {
-  /* Mark the signal to be caller after this signal is over. */
-  silc_schedule_signal_call(silcd->schedule, sig);
+  int i;
+
+  SILC_LOG_DEBUG(("Forking SILC server to background"));
+
+  if ((i = fork()) < 0) {
+    fprintf(stderr, "Error: fork() failed: %s\n", strerror(errno));
+    exit(1);
+  }
+
+  if (i) /* Kill the parent */
+    exit(0);
+
+  server->background = TRUE;
+  setsid();
+
+  /* XXX close stdin, stdout, stderr -- before this, check that all writes
+     to stderr are changed to SILC_SERVER_LOG_ERROR() */
 }
 
 SILC_TASK_CALLBACK(got_hup)
 {
   /* First, reset all log files (they might have been deleted) */
-  /* XXX this may be redundant with the silc_server_config_setlogfiles() call.
-   * merge these two with the appropriate checking. */
   silc_log_reset_all();
+
   /* Rehash the configuration file */
   silc_server_rehash(silcd);
 }
 
 SILC_TASK_CALLBACK(stop_server)
 {
-  /* Stop scheduler, the program will stop eventually after noticing
-     that the scheduler is down. */
-  silc_schedule_stop(silcd->schedule);
+  silc_server_stop(silcd);
 }
 
-void silc_server_stderr(char *message)
+/* Dump server statistics into a file into /tmp directory */
+
+SILC_TASK_CALLBACK(dump_stats)
 {
-  if (silcd->background)
-    silc_log_output(SILC_LOG_ERROR, message);
+  FILE *fdd;
+  int fild;
+  char filename[256];
+
+  memset(filename, 0, sizeof(filename));
+  snprintf(filename, sizeof(filename) - 1, "/tmp/silcd.%d.stats-XXXXXX", getpid());
+  fild = mkstemp(filename);
+  if (fild == -1)
+    return;
+
+  fdd = fdopen(fild, "w");
+  if (fdd == NULL) {
+    close(fild);
+    unlink(filename);
+    return;
+  }
+
+#define STAT_OUTPUT(fmt, stat) fprintf(fdd, fmt "\n", (int)stat);
+
+  fprintf(fdd, "SILC Server %s Statistics\n\n", silcd->server_name);
+  fprintf(fdd, "Local Stats:\n");
+  STAT_OUTPUT("  My clients              : %d", silcd->stat.my_clients);
+  STAT_OUTPUT("  My servers              : %d", silcd->stat.my_servers);
+  STAT_OUTPUT("  My routers              : %d", silcd->stat.my_routers);
+  STAT_OUTPUT("  My channels             : %d", silcd->stat.my_channels);
+  STAT_OUTPUT("  My joined users         : %d", silcd->stat.my_chanclients);
+  STAT_OUTPUT("  My aways                : %d", silcd->stat.my_aways);
+  STAT_OUTPUT("  My detached clients     : %d", silcd->stat.my_detached);
+  STAT_OUTPUT("  My server operators     : %d", silcd->stat.my_server_ops);
+  STAT_OUTPUT("  My router operators     : %d", silcd->stat.my_router_ops);
+  fprintf(fdd, "\nGlobal Stats:\n");
+  STAT_OUTPUT("  Cell clients            : %d", silcd->stat.cell_clients);
+  STAT_OUTPUT("  Cell servers            : %d", silcd->stat.cell_servers);
+  STAT_OUTPUT("  Cell channels           : %d", silcd->stat.cell_channels);
+  STAT_OUTPUT("  Cell joined users       : %d", silcd->stat.cell_chanclients);
+  STAT_OUTPUT("  All clients             : %d", silcd->stat.clients);
+  STAT_OUTPUT("  All servers             : %d", silcd->stat.servers);
+  STAT_OUTPUT("  All routers             : %d", silcd->stat.routers);
+  STAT_OUTPUT("  All channels            : %d", silcd->stat.channels);
+  STAT_OUTPUT("  All joined users        : %d", silcd->stat.chanclients);
+  STAT_OUTPUT("  All aways               : %d", silcd->stat.aways);
+  STAT_OUTPUT("  All detached clients    : %d", silcd->stat.detached);
+  STAT_OUTPUT("  All server operators    : %d", silcd->stat.server_ops);
+  STAT_OUTPUT("  All router operators    : %d", silcd->stat.router_ops);
+  fprintf(fdd, "\nGeneral Stats:\n");
+  STAT_OUTPUT("  Connection attempts     : %d", silcd->stat.conn_attempts);
+  STAT_OUTPUT("  Connection failures     : %d", silcd->stat.conn_failures);
+  STAT_OUTPUT("  Authentication attempts : %d", silcd->stat.auth_attempts);
+  STAT_OUTPUT("  Authentication failures : %d", silcd->stat.auth_failures);
+  STAT_OUTPUT("  Packets sent            : %d", silcd->stat.packets_sent);
+  STAT_OUTPUT("  Packets received        : %d", silcd->stat.packets_received);
+  STAT_OUTPUT("  Commands sent           : %d", silcd->stat.commands_sent);
+  STAT_OUTPUT("  Commands received       : %d", silcd->stat.commands_received);
+  STAT_OUTPUT("  Connections             : %d", silcd->stat.conn_num);
+
+#undef STAT_OUTPUT
+
+#ifdef SILC_DEBUG
+  /* Dump internal flags */
+  fprintf(fdd, "\nDumping internal flags\n");
+  fprintf(fdd, "  server_type            : %d\n", silcd->server_type);
+  fprintf(fdd, "  standalone             : %d\n", silcd->standalone);
+  fprintf(fdd, "  listenning             : %d\n", silcd->listenning);
+  fprintf(fdd, "  background             : %d\n", silcd->background);
+  fprintf(fdd, "  backup_router          : %d\n", silcd->backup_router);
+  fprintf(fdd, "  backup_primary         : %d\n", silcd->backup_primary);
+  fprintf(fdd, "  backup_noswitch        : %d\n", silcd->backup_noswitch);
+  fprintf(fdd, "  backup_closed          : %d\n", silcd->backup_closed);
+  fprintf(fdd, "  wait_backup            : %d\n", silcd->wait_backup);
+  if (silcd->router)
+    fprintf(fdd, "  primary router         : %s\n",
+      silcd->router->server_name ? silcd->router->server_name : "");
+
+  /* Dump connections */
+  {
+    SilcPacketStream s;
+    SilcDList conns = silc_packet_engine_get_streams(silcd->packet_engine);
+
+    fprintf(fdd, "\nDumping connections\n");
+    silc_dlist_start(conns);
+    while ((s = silc_dlist_get(conns))) {
+      const char *hostname, *ip;
+      SilcUInt16 port;
+      SilcSocket sock;
+      SilcIDListData idata = silc_packet_get_context(s);
+      if (!silc_socket_stream_get_info(silc_packet_stream_get_stream(s),
+				       &sock, &hostname, &ip, &port))
+	continue;
+      fprintf(fdd, "  %d: host %s ip %s port %d type %d\n",
+	      sock, hostname ? hostname : "N/A",
+	      ip ? ip : "N/A", port, idata ? idata->conn_type : 0);
+    }
+    silc_dlist_uninit(conns);
+  }
+
+  /* Dump lists */
+  {
+    SilcList list;
+    SilcIDCacheEntry id_cache = NULL;
+    SilcServerEntry server_entry;
+    SilcClientEntry client_entry;
+    SilcChannelEntry channel_entry;
+    int c;
+
+    fprintf(fdd, "\nDumping databases\n");
+
+    if (silc_idcache_get_all(silcd->local_list->servers, &list)) {
+      c = 1;
+      fprintf(fdd, "\nServers in local-list:\n");
+      while ((id_cache = silc_list_get(list))) {
+	  server_entry = (SilcServerEntry)id_cache->context;
+	  fprintf(fdd, "  %d: name %s id %s status 0x%x\n", c,
+		  server_entry->server_name ? server_entry->server_name :
+		  "N/A", server_entry->id ?
+		  silc_id_render(server_entry->id, SILC_ID_SERVER) : "N/A",
+		  server_entry->data.status);
+	  c++;
+      }
+    }
+    if (silc_idcache_get_all(silcd->global_list->servers, &list)) {
+	fprintf(fdd, "\nServers in global-list:\n");
+	c = 1;
+        while ((id_cache = silc_list_get(list))) {
+	  server_entry = (SilcServerEntry)id_cache->context;
+	  fprintf(fdd, "  %d: name %s id %s status 0x%x\n", c,
+		  server_entry->server_name ? server_entry->server_name :
+		  "N/A", server_entry->id ?
+		  silc_id_render(server_entry->id, SILC_ID_SERVER) : "N/A",
+		  server_entry->data.status);
+	  c++;
+        }
+    }
+    if (silc_idcache_get_all(silcd->local_list->clients, &list)) {
+	fprintf(fdd, "\nClients in local-list:\n");
+	c = 1;
+        while ((id_cache = silc_list_get(list))) {
+	  client_entry = (SilcClientEntry)id_cache->context;
+	  server_entry = client_entry->router;
+	  fprintf(fdd, "  %d: name %s id %s status 0x%x from %s\n", c,
+		  client_entry->nickname ? client_entry->nickname :
+		  (unsigned char *)"N/A", client_entry->id ?
+		  silc_id_render(client_entry->id, SILC_ID_CLIENT) : "N/A",
+		  client_entry->data.status, server_entry ?
+		  server_entry->server_name ? server_entry->server_name :
+		  "N/A" : "local");
+	  c++;
+	}
+    }
+    if (silc_idcache_get_all(silcd->global_list->clients, &list)) {
+	fprintf(fdd, "\nClients in global-list:\n");
+	c = 1;
+        while ((id_cache = silc_list_get(list))) {
+	  client_entry = (SilcClientEntry)id_cache->context;
+	  server_entry = client_entry->router;
+	  fprintf(fdd, "  %d: name %s id %s status 0x%x from %s\n", c,
+		  client_entry->nickname ? client_entry->nickname :
+		  (unsigned char *)"N/A", client_entry->id ?
+		  silc_id_render(client_entry->id, SILC_ID_CLIENT) : "N/A",
+		  client_entry->data.status, server_entry ?
+		  server_entry->server_name ? server_entry->server_name :
+		  "N/A" : "local");
+	  c++;
+	}
+    }
+    if (silc_idcache_get_all(silcd->local_list->channels, &list)) {
+	fprintf(fdd, "\nChannels in local-list:\n");
+	c = 1;
+        while ((id_cache = silc_list_get(list))) {
+	  channel_entry = (SilcChannelEntry)id_cache->context;
+	  fprintf(fdd, "  %d: name %s id %s\n", c,
+		  channel_entry->channel_name ? channel_entry->channel_name :
+		  "N/A", channel_entry->id ?
+		  silc_id_render(channel_entry->id, SILC_ID_CHANNEL) : "N/A");
+	  c++;
+	}
+    }
+    if (silc_idcache_get_all(silcd->global_list->channels, &list)) {
+	fprintf(fdd, "\nChannels in global-list:\n");
+	c = 1;
+        while ((id_cache = silc_list_get(list))) {
+	  channel_entry = (SilcChannelEntry)id_cache->context;
+	  fprintf(fdd, "  %d: name %s id %s\n", c,
+		  channel_entry->channel_name ? channel_entry->channel_name :
+		  "N/A", channel_entry->id ?
+		  silc_id_render(channel_entry->id, SILC_ID_CHANNEL) : "N/A");
+	  c++;
+	}
+    }
+  }
+#endif
+
+  fflush(fdd);
+  fclose(fdd);
+}
+
+#ifdef SILC_DEBUG
+
+typedef struct {
+  int level;
+  const char *string;
+} DebugLevel;
+
+static DebugLevel debug_levels[] = {
+  /* Very basic stuff from silcd/ */
+  { 3, "silcd\\.c,server\\.c" },
+
+  /* More stuff from silcd/ */
+  { 7, "silcd\\.c,server\\.c,command\\.c,server_backup\\.c,packet_send\\.c" },
+
+  /* All basic stuff from silcd/ */
+  { 10, "silc_server_*" },
+
+  /* All from silcd/ */
+  { 15, "*silcd*,*serverid*,silc_server_*,*idlist*" },
+
+  /* All from silcd/ and basic stuff from libs */
+  { 20, "*silcd*,*serverid*,silc_server_*,*idlist*,*silcconauth*,*silcske*" },
+
+  /* All from silcd/ and more stuff from libs */
+  { 25, "*silcd*,*serverid*,silc_server_*,*idlist*,*silcconauth*,"
+    "*silcpacket*,*ske*,*silcrng*" },
+
+  /* All from silcd/ and even more stuff from libs */
+  { 30, "*silcd*,*serverid*,silc_server_*,*idlist*,*silcconauth*,"
+    "*silcpacket*,*ske*,*silcrng*,*command*,*channel*,*private*,*notify*" },
+
+  /* All from silcd/ and even more stuff from libs + all from silccore */
+  { 35, "*silcd*,*serverid*,silc_server_*,*idlist*,*silcconauth*,"
+    "*silcpacket*,*ske*,*silcrng*,*command*,*channel*,*private*,*notify*"
+    "*silcid*,*argument*" },
+
+  /* All from silcd/, all from silccore, silccrypt and silcmath */
+  { 40, "*silcd*,*serverid*,silc_server_*,*idlist*,*silcconauth*,"
+    "*silcpacket*,*ske*,*silcrng*,*command*,*channel*,*private*,*notify*"
+    "*silcid*,*argument*,*pkcs*,*hmac*,*hash*,*cipher*,silc_math*" },
+
+  /* All from silcd/, all from silccore, silccrypt and silcmath + stuff
+     from silcutil */
+  { 45, "*silcd*,*serverid*,silc_server_*,*idlist*,*silcconauth*,"
+    "*silcpacket*,*ske*,*silcrng*,*command*,*channel*,*private*,*notify*"
+    "*silcid*,*argument*,*pkcs*,*hmac*,*hash*,*cipher*,silc_math*,*sim*"
+    "*sockconn*" },
+
+  /* All from silcd/, all from silccore, silccrypt and silcmath + more stuff
+     from silcutil */
+  { 50, "*silcd*,*serverid*,silc_server_*,*idlist*,*silcconauth*,"
+    "*silcpacket*,*ske*,*silcrng*,*command*,*channel*,*private*,*notify*"
+    "*silcid*,*argument*,*pkcs*,*hmac*,*hash*,*cipher*,silc_math*,*sim*"
+    "*sockconn*,*net*" },
+
+  /* All from silcd/, all from silccore, silccrypt and silcmath + more stuff
+     from silcutil */
+  { 55, "*silcd*,*serverid*,silc_server_*,*idlist*,*silcconauth*,"
+    "*silcpacket*,*ske*,*silcrng*,*command*,*channel*,*private*,*notify*"
+    "*silcid*,*argument*,*pkcs*,*hmac*,*hash*,*cipher*,silc_math*,*sim*"
+    "*sockconn*,*net*,*log*,*config*" },
+
+  /* All */
+  { 90, "*" },
+
+  { -1, NULL },
+};
+
+static void silc_get_debug_level(int level)
+{
+  int i;
+
+  if (level < 0)
+    return;
+
+  for (i = 0; debug_levels[i].string; i++)
+    if (level <= debug_levels[i].level) {
+      silc_log_set_debug_string(debug_levels[i].string);
+      break;
+    }
+}
+#endif /* SILC_DEBUG */
+
+/* This function should not be called directly but through the appropriate
+   wrapper macro defined in server.h */
+
+void silc_server_stderr(SilcLogType type, char *message)
+{
+  if (silcd->background) {
+    char *p, *n = message;
+
+    /* remove newlines if we are going to output it to a log file */
+    for (p = n; *p; p++) {
+      if (*p != '\n') {
+	if (p != n)
+	  *n = *p;
+	n++;
+      }
+    }
+    *n = 0;
+
+    /* the message is freed inside the logging function */
+    silc_log_output(type, message);
+  }
   else {
-    fprintf(stderr, "%s", message);
+    fprintf(stderr, "%s\n", message);
     silc_free(message);
   }
 }
@@ -166,34 +560,51 @@ void silc_server_stderr(char *message)
 int main(int argc, char **argv)
 {
   int ret, opt, option_index;
-  bool foreground = FALSE;
+  SilcBool foreground = FALSE;
+  SilcBool opt_create_keypair = FALSE;
   char *silcd_config_file = NULL;
   struct sigaction sa;
 
   /* Parse command line arguments */
   if (argc > 1) {
-    while ((opt = getopt_long(argc, argv, "f:p:d::xhFVC:",
+#ifdef HAVE_GETOPT_LONG
+    while ((opt = getopt_long(argc, argv, "f:p:d:D:xhFVC:",
 			      long_opts, &option_index)) != EOF) {
-      switch(opt)
-	{
+#else
+    while ((opt = getopt(argc, argv, "f:p:d:D:xhFVC:")) != EOF) {
+#endif /* HAVE_GETOPT_LONG */
+      switch(opt) {
 	case 'h':
 	  silc_usage();
 	  break;
 	case 'V':
 	  printf("SILCd Secure Internet Live Conferencing daemon, "
 		 "version %s (base: SILC Toolkit %s)\n",
-                 silc_dist_version, silc_version);
-	  printf("(c) 1997 - 2002 Pekka Riikonen "
+		 silc_dist_version, silc_version);
+	  printf("(c) 1997 - 2007 Pekka Riikonen "
 		 "<priikone@silcnet.org>\n");
 	  exit(0);
 	  break;
 	case 'd':
 #ifdef SILC_DEBUG
-	  silc_debug = TRUE;
+	  silc_log_debug(TRUE);
+	  silc_log_quick(TRUE);
 	  if (optarg)
 	    silc_log_set_debug_string(optarg);
-	  foreground = TRUE; /* implied */
-	  silc_log_quick = TRUE; /* implied */
+	  foreground = TRUE;	    /* implied */
+#else
+	  fprintf(stderr,
+		  "Run-time debugging is not enabled. To enable it recompile\n"
+		  "the server with --enable-debug configuration option.\n");
+#endif
+	  break;
+	case 'D':
+#ifdef SILC_DEBUG
+	  silc_log_debug(TRUE);
+	  silc_log_quick(TRUE);
+	  if (optarg)
+	    silc_get_debug_level(atoi(optarg));
+	  foreground = TRUE;	    /* implied */
 #else
 	  fprintf(stderr,
 		  "Run-time debugging is not enabled. To enable it recompile\n"
@@ -202,10 +613,10 @@ int main(int argc, char **argv)
 	  break;
 	case 'x':
 #ifdef SILC_DEBUG
-	  silc_debug_hexdump = TRUE;
-	  silc_debug = TRUE; /* implied */
+	  silc_log_debug(TRUE);
+	  silc_log_debug_hexdump(TRUE);
+	  silc_log_quick(TRUE);
 	  foreground = TRUE; /* implied */
-	  silc_log_quick = TRUE; /* implied */
 #else
 	  fprintf(stderr,
 		  "Run-time debugging is not enabled. To enable it recompile\n"
@@ -243,18 +654,26 @@ int main(int argc, char **argv)
 	default:
 	  silc_usage();
 	  break;
-	}
+      }
     }
   }
 
   if (opt_create_keypair == TRUE) {
     /* Create new key pair and exit */
+    char pubfile[256], prvfile[256];
+
+    memset(pubfile, 0, sizeof(pubfile));
+    memset(prvfile, 0, sizeof(prvfile));
+    snprintf(pubfile, sizeof(pubfile) - 1, "%s/silcd.pub", opt_keypath);
+    snprintf(prvfile, sizeof(prvfile) - 1, "%s/silcd.prv", opt_keypath);
+
     silc_cipher_register_default();
     silc_pkcs_register_default();
     silc_hash_register_default();
     silc_hmac_register_default();
-    silc_server_create_key_pair(opt_pkcs, opt_bits, opt_keypath,
-				opt_identifier, NULL, NULL);
+    if (!silc_create_key_pair(opt_pkcs, opt_bits, pubfile, prvfile,
+			      opt_identifier, "", NULL, NULL, FALSE))
+      exit(1);
     exit(0);
   }
 
@@ -267,12 +686,26 @@ int main(int argc, char **argv)
   if (ret == FALSE)
     goto fail;
 
+  /* Register default crypto stuff since we are going to need them
+     in the configuration file parsing phase */
+  silc_cipher_register_default();
+  silc_pkcs_register_default();
+  silc_hash_register_default();
+  silc_hmac_register_default();
+
   /* Read configuration files */
-  silcd->config = silc_server_config_alloc(silcd, silcd_config_file);
+  silcd->config = silc_server_config_alloc(silcd_config_file, silcd);
   if (silcd->config == NULL)
     goto fail;
   silcd->config_file = silcd_config_file;
 
+  /* Unregister the default crypto stuff so that configuration takes effect */
+  silc_cipher_unregister_all();
+  /* silc_pkcs_unregister_all();  MUST NOT do this anymore; SilcPublicKey
+     parsed from config file references pointers so we cannot unregister */
+  silc_hash_unregister_all();
+  silc_hmac_unregister_all();
+
   /* Check for another silcd running */
   silc_server_checkpid(silcd);
 
@@ -280,23 +713,27 @@ int main(int argc, char **argv)
   if (silc_server_init(silcd) == FALSE)
     goto fail;
 
-  /* Ignore SIGPIPE */
+  /* Ignore some signals */
   sa.sa_handler = SIG_IGN;
   sa.sa_flags = 0;
   sigemptyset(&sa.sa_mask);
-  sigaction(SIGPIPE, &sa, NULL);
-  sa.sa_handler = signal_handler;
-  sigaction(SIGHUP, &sa, NULL);
-  sigaction(SIGTERM, &sa, NULL);
-  sigaction(SIGINT, &sa, NULL);
-  silc_schedule_signal_register(silcd->schedule, SIGHUP, got_hup, NULL);
-  silc_schedule_signal_register(silcd->schedule, SIGTERM, stop_server, NULL);
-  silc_schedule_signal_register(silcd->schedule, SIGINT, stop_server, NULL);
+#if defined(SIGPIPE)
+  sigaction(SIGPIPE, &sa, NULL);      /* Ignore broken pipes */
+#endif /* SIGPIPE*/
+#if defined(SIGXFSZ)
+  sigaction(SIGXFSZ, &sa, NULL);      /* Ignore file limit exceeds */
+#endif /* SIGXFSZ */
+#if defined(SIGXCPU)
+  sigaction(SIGXCPU, &sa, NULL);      /* Ignore CPU time limit exceeds */
+#endif /* SIGXCPU */
+
+  /* Handle specificly some other signals. */
+  silc_schedule_task_add_signal(silcd->schedule, SIGHUP, got_hup, NULL);
+  silc_schedule_task_add_signal(silcd->schedule, SIGTERM, stop_server, NULL);
+  silc_schedule_task_add_signal(silcd->schedule, SIGINT, stop_server, NULL);
+  silc_schedule_task_add_signal(silcd->schedule, SIGUSR1, dump_stats, NULL);
 
   if (!foreground) {
-    /* Drop root. */
-    silc_server_drop(silcd);
-
     /* Before running the server, fork to background. */
     silc_server_daemonise(silcd);
 
@@ -307,125 +744,29 @@ int main(int argc, char **argv)
       snprintf(buf, sizeof(buf) - 1, "%d\n", getpid());
       silc_file_writefile(pidfile, buf, strlen(buf));
     }
+
   }
+  silc_server_drop_privs(silcd);
 
   /* Run the server. When this returns the server has been stopped
      and we will exit. */
   silc_server_run(silcd);
 
-  /* Stop the server and free it. */
-  silc_server_stop(silcd);
-  silc_server_free(silcd);
+  /* Free server */
   silc_server_config_destroy(silcd->config);
+  silc_server_free(silcd);
 
   /* Flush the logging system */
   silc_log_flush_all();
 
+  silc_free(silcd_config_file);
+  silc_free(opt_identifier);
+  silc_free(opt_keypath);
   exit(0);
+
  fail:
+  silc_free(silcd_config_file);
+  silc_free(opt_identifier);
+  silc_free(opt_keypath);
   exit(1);
 }
-
-/* Returns identifier string for public key generation. */
-
-static char *silc_server_create_identifier(void)
-{
-  char *username = NULL, *realname = NULL;
-  char hostname[256], email[256];
-
-  /* Get realname */
-  realname = silc_get_real_name();
-
-  /* Get hostname */
-  memset(hostname, 0, sizeof(hostname));
-  gethostname(hostname, sizeof(hostname));
-
-  /* Get username (mandatory) */
-  username = silc_get_username();
-  if (!username)
-    return NULL;
-
-  /* Create default email address, whether it is right or not */
-  snprintf(email, sizeof(email), "%s@%s", username, hostname);
-
-  return silc_pkcs_encode_identifier(username, hostname, realname, email,
-				     NULL, NULL);
-}
-
-/* Creates new public key and private key pair. This is used only
-   when user wants to create new key pair from command line. */
-
-static int
-silc_server_create_key_pair(char *pkcs_name, int bits, char *path,
-			    char *identifier,
-			    SilcPublicKey *ret_pub_key,
-			    SilcPrivateKey *ret_prv_key)
-{
-  SilcPKCS pkcs;
-  SilcPublicKey pub_key;
-  SilcPrivateKey prv_key;
-  SilcRng rng;
-  unsigned char *key;
-  SilcUInt32 key_len;
-  char pkfile[256], prvfile[256];
-
-  if (!pkcs_name || !path)
-    return FALSE;
-
-  if (!silc_pkcs_is_supported(pkcs_name)) {
-    fprintf(stderr, "Unsupported PKCS `%s'", pkcs_name);
-    return FALSE;
-  }
-
-  if (!bits)
-    bits = 1024;
-
-  if (!identifier)
-    identifier = silc_server_create_identifier();
-
-  rng = silc_rng_alloc();
-  silc_rng_init(rng);
-  silc_rng_global_init(rng);
-
-  snprintf(pkfile, sizeof(pkfile) - 1, "%s%s", path,
-	   SILC_SERVER_PUBLIC_KEY_NAME);
-  snprintf(prvfile, sizeof(prvfile) - 1, "%s%s", path,
-	   SILC_SERVER_PRIVATE_KEY_NAME);
-
-  /* Generate keys */
-  silc_pkcs_alloc(pkcs_name, &pkcs);
-  silc_pkcs_generate_key(pkcs, bits, rng);
-
-  /* Save public key into file */
-  key = silc_pkcs_get_public_key(pkcs, &key_len);
-  pub_key = silc_pkcs_public_key_alloc(pkcs->pkcs->name, identifier,
-				       key, key_len);
-  silc_pkcs_save_public_key(pkfile, pub_key, SILC_PKCS_FILE_PEM);
-  if (ret_pub_key)
-    *ret_pub_key = pub_key;
-  else
-    silc_pkcs_public_key_free(pub_key);
-
-  memset(key, 0, sizeof(key_len));
-  silc_free(key);
-
-  /* Save private key into file */
-  key = silc_pkcs_get_private_key(pkcs, &key_len);
-  prv_key = silc_pkcs_private_key_alloc(pkcs->pkcs->name, key, key_len);
-  silc_pkcs_save_private_key(prvfile, prv_key, NULL, SILC_PKCS_FILE_BIN);
-  if (ret_prv_key)
-    *ret_prv_key = prv_key;
-  else
-    silc_pkcs_private_key_free(prv_key);
-
-  printf("Public key has been saved into `%s'\n", pkfile);
-  printf("Private key has been saved into `%s'\n", prvfile);
-
-  memset(key, 0, sizeof(key_len));
-  silc_free(key);
-
-  silc_rng_free(rng);
-  silc_pkcs_free(pkcs);
-
-  return TRUE;
-}