X-Git-Url: http://git.silcnet.org/gitweb/?a=blobdiff_plain;f=apps%2Fsilcd%2Fsilcd.c;h=9e2c2a16b0ee5b161d4ad675fd13d5f41f3933b4;hb=413da0f8686910f5e627393157566ae729ca99c4;hp=bb8dc0d44d14b67f3ea8274b25053504e0700f7a;hpb=e52f6fc409c05c184abdfcdab1204882b4b8be72;p=silc.git diff --git a/apps/silcd/silcd.c b/apps/silcd/silcd.c index bb8dc0d4..9e2c2a16 100644 --- a/apps/silcd/silcd.c +++ b/apps/silcd/silcd.c @@ -4,7 +4,7 @@ Author: Pekka Riikonen - Copyright (C) 1997 - 2002 Pekka Riikonen + Copyright (C) 1997 - 2003 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 @@ -33,11 +33,6 @@ 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); /* Long command line options */ static struct option long_opts[] = @@ -45,6 +40,7 @@ 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' }, @@ -75,6 +71,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" @@ -245,9 +242,8 @@ static void signal_handler(int sig) 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); } @@ -259,15 +255,315 @@ SILC_TASK_CALLBACK(stop_server) silc_schedule_stop(silcd->schedule); } -/* This function should not be called directly but throught the wrapper - macro SILC_SERVER_LOG_STDERR() */ +/* Dump server statistics into a file into /tmp directory */ -void silc_server_stderr(char *message) +SILC_TASK_CALLBACK(dump_stats) { - if (silcd->background) - silc_log_output(SILC_LOG_ERROR, message); + FILE *fdd; + char filename[256]; + + memset(filename, 0, sizeof(filename)); + snprintf(filename, sizeof(filename) - 1, "/tmp/silcd.%d.stats", getpid()); + fdd = fopen(filename, "w+"); + if (!fdd) + 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); + +#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, " 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 socket connections */ + { + int i; + SilcSocketConnection s; + + fprintf(fdd, "\nDumping socket connections\n"); + for (i = 0; i < silcd->config->param.connections_max; i++) { + s = silcd->sockets[i]; + if (!s) + continue; + fprintf(fdd, " %d: host %s ip %s port %d type %d flags 0x%x\n", + s->sock, s->hostname ? s->hostname : "N/A", + s->ip ? s->ip : "N/A", s->port, s->type, + (unsigned int)s->flags); + } + } + + /* Dump lists */ + { + SilcIDCacheList list = NULL; + 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)) { + if (silc_idcache_list_first(list, &id_cache)) { + fprintf(fdd, "\nServers in local-list:\n"); + c = 1; + while (id_cache) { + 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); + if (!silc_idcache_list_next(list, &id_cache)) + break; + c++; + } + } + silc_idcache_list_free(list); + } + if (silc_idcache_get_all(silcd->global_list->servers, &list)) { + if (silc_idcache_list_first(list, &id_cache)) { + fprintf(fdd, "\nServers in global-list:\n"); + c = 1; + while (id_cache) { + 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); + if (!silc_idcache_list_next(list, &id_cache)) + break; + c++; + } + } + silc_idcache_list_free(list); + } + if (silc_idcache_get_all(silcd->local_list->clients, &list)) { + if (silc_idcache_list_first(list, &id_cache)) { + fprintf(fdd, "\nClients in local-list:\n"); + c = 1; + while (id_cache) { + client_entry = (SilcClientEntry)id_cache->context; + fprintf(fdd, " %d: name %s id %s status 0x%x\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); + if (!silc_idcache_list_next(list, &id_cache)) + break; + c++; + } + } + silc_idcache_list_free(list); + } + if (silc_idcache_get_all(silcd->global_list->clients, &list)) { + if (silc_idcache_list_first(list, &id_cache)) { + fprintf(fdd, "\nClients in global-list:\n"); + c = 1; + while (id_cache) { + client_entry = (SilcClientEntry)id_cache->context; + fprintf(fdd, " %d: name %s id %s status 0x%x\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); + if (!silc_idcache_list_next(list, &id_cache)) + break; + c++; + } + } + silc_idcache_list_free(list); + } + if (silc_idcache_get_all(silcd->local_list->channels, &list)) { + if (silc_idcache_list_first(list, &id_cache)) { + fprintf(fdd, "\nChannels in local-list:\n"); + c = 1; + while (id_cache) { + 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"); + if (!silc_idcache_list_next(list, &id_cache)) + break; + c++; + } + } + silc_idcache_list_free(list); + } + if (silc_idcache_get_all(silcd->global_list->channels, &list)) { + if (silc_idcache_list_first(list, &id_cache)) { + fprintf(fdd, "\nChannels in global-list:\n"); + c = 1; + while (id_cache) { + 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"); + if (!silc_idcache_list_next(list, &id_cache)) + break; + c++; + } + } + silc_idcache_list_free(list); + } + } +#endif + + fflush(fdd); + fclose(fdd); +} + +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*,*silcauth*,*silcske*" }, + + /* All from silcd/ and more stuff from libs */ + { 25, "*silcd*,*serverid*,silc_server_*,*idlist*,*silcauth*," + "*silcpacket*,*ske*,*silcrng*" }, + + /* All from silcd/ and even more stuff from libs */ + { 30, "*silcd*,*serverid*,silc_server_*,*idlist*,*silcauth*," + "*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*,*silcauth*," + "*silcpacket*,*ske*,*silcrng*,*command*,*channel*,*private*,*notify*" + "*silcid*,*argument*" }, + + /* All from silcd/, all from silccore, silccrypt and silcmath */ + { 40, "*silcd*,*serverid*,silc_server_*,*idlist*,*silcauth*," + "*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*,*silcauth*," + "*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*,*silcauth*," + "*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*,*silcauth*," + "*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; + } +} + +/* 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); } } @@ -282,7 +578,7 @@ int main(int argc, char **argv) /* Parse command line arguments */ if (argc > 1) { - while ((opt = getopt_long(argc, argv, "f:p:d:xhFVC:", + while ((opt = getopt_long(argc, argv, "f:p:d:D:xhFVC:", long_opts, &option_index)) != EOF) { switch(opt) { case 'h': @@ -301,8 +597,21 @@ int main(int argc, char **argv) silc_debug = TRUE; if (optarg) silc_log_set_debug_string(optarg); - foreground = TRUE; /* implied */ - silc_log_quick = TRUE; /* implied */ + foreground = TRUE; /* implied */ + silc_log_quick = 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_debug = TRUE; + if (optarg) + silc_get_debug_level(atoi(optarg)); + foreground = TRUE; /* implied */ + silc_log_quick = TRUE; /* implied */ #else fprintf(stderr, "Run-time debugging is not enabled. To enable it recompile\n" @@ -358,12 +667,19 @@ int main(int argc, char **argv) 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); + silc_create_key_pair(opt_pkcs, opt_bits, pubfile, prvfile, + opt_identifier, "", NULL, NULL, NULL, FALSE); exit(0); } @@ -376,12 +692,25 @@ 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_config_file); 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(); + silc_hash_unregister_all(); + silc_hmac_unregister_all(); + /* Check for another silcd running */ silc_server_checkpid(silcd); @@ -389,18 +718,30 @@ 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); +#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. */ sa.sa_handler = signal_handler; sigaction(SIGHUP, &sa, NULL); sigaction(SIGTERM, &sa, NULL); sigaction(SIGINT, &sa, NULL); + sigaction(SIGUSR1, &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); + silc_schedule_signal_register(silcd->schedule, SIGUSR1, dump_stats, NULL); if (!foreground) { /* Before running the server, fork to background. */ @@ -432,111 +773,14 @@ int main(int argc, char **argv) /* 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 = 2048; - - 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; -}