apps/silcd/silcd.c

   1 /*
   2
   3   silcd.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 1997 - 2001 Pekka Riikonen
   8
   9   This program is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU General Public License as published by
  11   the Free Software Foundation; either version 2 of the License, or
  12   (at your option) any later version.
  13
  14   This program is distributed in the hope that it will be useful,
  15   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17   GNU General Public License for more details.
  18
  19 */
  20 /*
  21  * Created: Wed Mar 19 00:17:12 1997
  22  *
  23  * This is the main program for the SILC daemon. This parses command
  24  * line arguments and creates the server object.
  25  */
  26 /* $Id$ */
  27
  28 #include "serverincludes.h"
  29 #include "server_internal.h"
  30 #include "version.h"
  31
  32 static void silc_usage();
  33 static char *silc_server_create_identifier();
  34 static int
  35 silc_server_create_key_pair(char *pkcs_name, int bits, char *path,
  36                             char *identifier,
  37                             SilcPublicKey *ret_pub_key,
  38                             SilcPrivateKey *ret_prv_key);
  39
  40 /* Long command line options */
  41 static struct option long_opts[] =
  42 {
  43   { "config-file", 1, NULL, 'f' },
  44   { "debug", 1, NULL, 'd' },
  45   { "help", 0, NULL, 'h' },
  46   { "foreground", 0, NULL, 'F' },
  47   { "version", 0, NULL,'V' },
  48
  49   /* Key management options */
  50   { "create-key-pair", 1, NULL, 'C' },
  51   { "pkcs", 1, NULL, 10 },
  52   { "bits", 1, NULL, 11 },
  53   { "identifier", 1, NULL, 12 },
  54
  55   { NULL, 0, NULL, 0 }
  56 };
  57
  58 /* Command line option variables */
  59 static bool opt_create_keypair = FALSE;
  60 static char *opt_keypath = NULL;
  61 static char *opt_pkcs = "rsa";
  62 static char *opt_identifier = NULL;
  63 static int opt_bits = 1024;
  64
  65 /* Prints out the usage of silc client */
  66
  67 static void silc_usage()
  68 {
  69   printf("\
  70 Usage: silcd [options]\n\
  71 \n\
  72   Generic Options:\n\
  73   -f  --config-file=FILE        Alternate configuration file\n\
  74   -d  --debug=string            Enable debugging (Implies --foreground)\n\
  75   -h  --help                    Display this message\n\
  76   -F  --foreground              Dont fork\n\
  77   -V  --version                 Display version\n\
  78 \n\
  79   Key Management Options:\n\
  80   -C, --create-key-pair=PATH    Create new public key pair\n\
  81       --pkcs=PKCS               Set the PKCS of the public key pair\n\
  82       --bits=VALUE              Set length of the public key pair\n\
  83       --identifier=IDENTIFIER   Public key identifier\n\
  84 \n\
  85       The public key identifier may be of the following format:\n\
  86 \n\
  87       UN=<username>, HN=<hostname or IP>, RN=<real name>, E=<email>,\n\
  88       O=<organization>, C=<country>\n\
  89 \n\
  90       The UN and HN must be provided, the others are optional.  If the\n\
  91       --identifier option is not used an identifier will be created for\n\
  92       the public key automatically.\n\
  93 \n\
  94       Example identifier: \"UN=foobar, HN=foo.bar.com, RN=Foo T. Bar, \n\
  95                            E=foo@bar.com, C=FI\"\n\
  96 \n");
  97   exit(0);
  98 }
  99
 100 /* Dies if a *valid* pid file exists already */
 101
 102 static void silc_checkpid(SilcServer silcd)
 103 {
 104   if (silcd->config->pidfile && silcd->config->pidfile->pid_file) {
 105     int oldpid;
 106     char *buf;
 107     uint32 buf_len;
 108
 109     SILC_LOG_DEBUG(("Checking for another silcd running"));
 110     buf = silc_file_readfile(silcd->config->pidfile->pid_file, &buf_len);
 111     if (!buf)
 112       return;
 113     oldpid = atoi(buf);
 114     silc_free(buf);
 115     if (oldpid <= 0)
 116       return;
 117     kill(oldpid, SIGCHLD); /* this signal does nothing, check if alive */
 118     if (errno != ESRCH) {
 119       fprintf(stderr, "\nI detected another daemon running with the same pid file.\n");
 120       fprintf(stderr, "Please change the config file, or erase the %s\n",
 121         silcd->config->pidfile->pid_file);
 122       exit(1);
 123     }
 124   }
 125 }
 126
 127 int main(int argc, char **argv)
 128 {
 129   int ret;
 130   int opt, option_index;
 131   int foreground = FALSE;
 132   char *config_file = NULL;
 133   SilcServer silcd;
 134   struct sigaction sa;
 135
 136   silc_debug = FALSE;
 137
 138   /* Parse command line arguments */
 139   if (argc > 1) {
 140     while ((opt = getopt_long(argc, argv, "cf:d:hFVC:",
 141                               long_opts, &option_index)) != EOF) {
 142       switch(opt)
 143         {
 144         case 'h':
 145           silc_usage();
 146           break;
 147         case 'V':
 148           printf("SILCd Secure Internet Live Conferencing daemon, "
 149                  "version %s (base: SILC Toolkit %s)\n",
 150                  silc_dist_version, silc_version);
 151           printf("(c) 1997 - 2001 Pekka Riikonen "
 152                  "<priikone@silcnet.org>\n");
 153           exit(0);
 154           break;
 155         case 'd':
 156           silc_debug = TRUE;
 157           silc_debug_hexdump = TRUE;
 158           silc_log_set_debug_string(optarg);
 159           foreground = TRUE;
 160 #ifndef SILC_DEBUG
 161           fprintf(stdout,
 162                   "Run-time debugging is not enabled. To enable it recompile\n"
 163                   "the server with --enable-debug configuration option.\n");
 164 #endif
 165           break;
 166         case 'f':
 167           config_file = strdup(optarg);
 168           break;
 169         case 'F':
 170           foreground = TRUE;
 171           break;
 172
 173           /*
 174            * Key management options
 175            */
 176         case 'C':
 177           opt_create_keypair = TRUE;
 178           if (optarg)
 179             opt_keypath = strdup(optarg);
 180           break;
 181         case 10:
 182           if (optarg)
 183             opt_pkcs = strdup(optarg);
 184           break;
 185         case 11:
 186           if (optarg)
 187             opt_bits = atoi(optarg);
 188           break;
 189         case 12:
 190           if (optarg)
 191             opt_identifier = strdup(optarg);
 192           break;
 193
 194         default:
 195           silc_usage();
 196           break;
 197         }
 198     }
 199   }
 200
 201   if (opt_create_keypair == TRUE) {
 202     /* Create new key pair and exit */
 203     silc_cipher_register_default();
 204     silc_pkcs_register_default();
 205     silc_hash_register_default();
 206     silc_hmac_register_default();
 207     silc_server_create_key_pair(opt_pkcs, opt_bits, opt_keypath,
 208                                 opt_identifier, NULL, NULL);
 209     exit(0);
 210   }
 211
 212   /* Default configuration file */
 213   if (!config_file)
 214     config_file = strdup(SILC_SERVER_CONFIG_FILE);
 215
 216   /* Create SILC Server object */
 217   ret = silc_server_alloc(&silcd);
 218   if (ret == FALSE)
 219     goto fail;
 220
 221   /* Read configuration files */
 222   silcd->config = silc_server_config_alloc(config_file);
 223   if (silcd->config == NULL)
 224     goto fail;
 225
 226   /* Check for another silcd running */
 227   silc_checkpid(silcd);
 228
 229   /* Initialize the server */
 230   ret = silc_server_init(silcd);
 231   if (ret == FALSE)
 232     goto fail;
 233
 234   /* Ignore SIGPIPE */
 235   sa.sa_handler = SIG_IGN;
 236   sa.sa_flags = 0;
 237   sigemptyset(&sa.sa_mask);
 238   sigaction(SIGPIPE, &sa, NULL);
 239
 240   /* Before running the server, fork to background. */
 241   if (!foreground)
 242     silc_server_daemonise(silcd);
 243
 244   /* If set, write pid to file */
 245   if (silcd->config->pidfile && silcd->config->pidfile->pid_file) {
 246     char buf[10];
 247     unlink(silcd->config->pidfile->pid_file);
 248     snprintf(buf, sizeof(buf) - 1, "%d\n", getpid());
 249     silc_file_writefile(silcd->config->pidfile->pid_file, buf, strlen(buf));
 250   }
 251
 252   /* Drop root. */
 253   silc_server_drop(silcd);
 254
 255   /* Run the server. When this returns the server has been stopped
 256      and we will exit. */
 257   silc_server_run(silcd);
 258
 259   /* Stop the server. This probably has been done already but it
 260      doesn't hurt to do it here again. */
 261   silc_server_stop(silcd);
 262   silc_server_free(silcd);
 263
 264   exit(0);
 265  fail:
 266   exit(1);
 267 }
 268
 269 /* Returns identifier string for public key generation. */
 270
 271 static char *silc_server_create_identifier()
 272 {
 273   char *username = NULL, *realname = NULL;
 274   char hostname[256], email[256];
 275
 276   /* Get realname */
 277   realname = silc_get_real_name();
 278
 279   /* Get hostname */
 280   memset(hostname, 0, sizeof(hostname));
 281   gethostname(hostname, sizeof(hostname));
 282
 283   /* Get username (mandatory) */
 284   username = silc_get_username();
 285   if (!username)
 286     return NULL;
 287
 288   /* Create default email address, whether it is right or not */
 289   snprintf(email, sizeof(email), "%s@%s", username, hostname);
 290
 291   return silc_pkcs_encode_identifier(username, hostname, realname, email,
 292                                      NULL, NULL);
 293 }
 294
 295 /* Creates new public key and private key pair. This is used only
 296    when user wants to create new key pair from command line. */
 297
 298 static int
 299 silc_server_create_key_pair(char *pkcs_name, int bits, char *path,
 300                             char *identifier,
 301                             SilcPublicKey *ret_pub_key,
 302                             SilcPrivateKey *ret_prv_key)
 303 {
 304   SilcPKCS pkcs;
 305   SilcPublicKey pub_key;
 306   SilcPrivateKey prv_key;
 307   SilcRng rng;
 308   unsigned char *key;
 309   uint32 key_len;
 310   char pkfile[256], prvfile[256];
 311
 312   if (!pkcs_name || !path)
 313     return FALSE;
 314
 315   if (!silc_pkcs_is_supported(pkcs_name)) {
 316     fprintf(stderr, "Unsupported PKCS `%s'", pkcs_name);
 317     return FALSE;
 318   }
 319
 320   if (!bits)
 321     bits = 1024;
 322
 323   if (!identifier)
 324     identifier = silc_server_create_identifier();
 325
 326   rng = silc_rng_alloc();
 327   silc_rng_init(rng);
 328   silc_rng_global_init(rng);
 329
 330   snprintf(pkfile, sizeof(pkfile) - 1, "%s%s", path,
 331            SILC_SERVER_PUBLIC_KEY_NAME);
 332   snprintf(prvfile, sizeof(prvfile) - 1, "%s%s", path,
 333            SILC_SERVER_PRIVATE_KEY_NAME);
 334
 335   /* Generate keys */
 336   silc_pkcs_alloc(pkcs_name, &pkcs);
 337   pkcs->pkcs->init(pkcs->context, bits, rng);
 338
 339   /* Save public key into file */
 340   key = silc_pkcs_get_public_key(pkcs, &key_len);
 341   pub_key = silc_pkcs_public_key_alloc(pkcs->pkcs->name, identifier,
 342                                        key, key_len);
 343   silc_pkcs_save_public_key(pkfile, pub_key, SILC_PKCS_FILE_PEM);
 344   if (ret_pub_key)
 345     *ret_pub_key = pub_key;
 346   else
 347     silc_pkcs_public_key_free(pub_key);
 348
 349   memset(key, 0, sizeof(key_len));
 350   silc_free(key);
 351
 352   /* Save private key into file */
 353   key = silc_pkcs_get_private_key(pkcs, &key_len);
 354   prv_key = silc_pkcs_private_key_alloc(pkcs->pkcs->name, key, key_len);
 355   silc_pkcs_save_private_key(prvfile, prv_key, NULL, SILC_PKCS_FILE_BIN);
 356   if (ret_prv_key)
 357     *ret_prv_key = prv_key;
 358   else
 359     silc_pkcs_private_key_free(prv_key);
 360
 361   printf("Public key has been saved into `%s'\n", pkfile);
 362   printf("Private key has been saved into `%s'\n", prvfile);
 363
 364   memset(key, 0, sizeof(key_len));
 365   silc_free(key);
 366
 367   silc_rng_free(rng);
 368   silc_pkcs_free(pkcs);
 369
 370   return TRUE;
 371 }