X-Git-Url: http://git.silcnet.org/gitweb/?a=blobdiff_plain;f=apps%2Fsilcd%2Fserverconfig.c;h=09fde6070f8fdab3de3aa6accfd0e64efb627e97;hb=a818c5b5411bbc4436d1c5f011236985c96bb787;hp=7cb2a9e5495c47d8ee8bb83e8c1d99464e442314;hpb=8a5f64b6ead2707ba7f623e4e8c6f6a58f4d712f;p=silc.git diff --git a/apps/silcd/serverconfig.c b/apps/silcd/serverconfig.c index 7cb2a9e5..09fde607 100644 --- a/apps/silcd/serverconfig.c +++ b/apps/silcd/serverconfig.c @@ -50,24 +50,71 @@ __type__ *di = (__type__ *) tmp; \ tmp = (void *) di->next; -/* free an authdata according to its auth method */ -static void my_free_authdata(char *passphrase, void *public_key) +/* Set EDOUBLE error value and bail out if necessary */ +#define CONFIG_IS_DOUBLE(__x__) \ + if ((__x__)) { \ + got_errno = SILC_CONFIG_EDOUBLE; \ + goto got_err; \ + } + +/* Free the authentication fields in the specified struct + * Expands to two instructions */ +#define CONFIG_FREE_AUTH(__section__) \ + silc_free(__section__->passphrase); \ + silc_pkcs_public_key_free(__section__->publickey) + +/* Set default values to those parameters that have not been defined */ +static void +my_set_param_defaults(SilcServerConfigConnParams *params, + SilcServerConfigConnParams *defaults) { - silc_free(passphrase); - if (public_key) - silc_pkcs_public_key_free((SilcPublicKey) public_key); +#define SET_PARAM_DEFAULT(p, d) \ + (params->p ? params->p : (defaults && defaults->p ? defaults->p : d)) + + params->connections_max = + SET_PARAM_DEFAULT(connections_max, SILC_SERVER_MAX_CONNECTIONS); + params->connections_max_per_host = + SET_PARAM_DEFAULT(connections_max_per_host, + SILC_SERVER_MAX_CONNECTIONS_SINGLE); + params->keepalive_secs = + SET_PARAM_DEFAULT(keepalive_secs, SILC_SERVER_KEEPALIVE); + params->reconnect_count = + SET_PARAM_DEFAULT(reconnect_count, SILC_SERVER_RETRY_COUNT); + params->reconnect_interval = + SET_PARAM_DEFAULT(reconnect_interval, SILC_SERVER_RETRY_INTERVAL_MIN); + params->reconnect_interval_max = + SET_PARAM_DEFAULT(reconnect_interval_max, SILC_SERVER_RETRY_INTERVAL_MAX); + params->key_exchange_rekey = + SET_PARAM_DEFAULT(key_exchange_rekey, SILC_SERVER_REKEY); +} + +/* Find connection parameters by the parameter block name. */ +static SilcServerConfigConnParams * +my_find_param(SilcServerConfig config, const char *name, SilcUInt32 line) +{ + SilcServerConfigConnParams *param; + + for (param = config->conn_params; param; param = param->next) { + if (!strcasecmp(param->name, name)) + return param; + } + + fprintf(stderr, "\nError while parsing config file at line %lu: " + "Cannot find Param \"%s\".\n", line, name); + + return NULL; } /* parse an authdata according to its auth method */ -static bool my_parse_authdata(SilcAuthMethod auth_meth, char *p, uint32 line, - void **auth_data, uint32 *auth_data_len) +static bool my_parse_authdata(SilcAuthMethod auth_meth, char *p, SilcUInt32 line, + void **auth_data, SilcUInt32 *auth_data_len) { if (auth_meth == SILC_AUTH_PASSWORD) { /* p is a plain text password */ if (auth_data) *auth_data = (void *) strdup(p); if (auth_data_len) - *auth_data_len = (uint32) strlen(p); + *auth_data_len = (SilcUInt32) strlen(p); } else if (auth_meth == SILC_AUTH_PUBLIC_KEY) { /* p is a public key */ SilcPublicKey public_key; @@ -84,7 +131,7 @@ static bool my_parse_authdata(SilcAuthMethod auth_meth, char *p, uint32 line, *auth_data_len = 0; } else { fprintf(stderr, "\nError while parsing config file at line %lu: " - "Unkonwn authentication method\n", line); + "Unknown authentication method.\n", line); return FALSE; } return TRUE; @@ -95,28 +142,68 @@ static bool my_parse_authdata(SilcAuthMethod auth_meth, char *p, uint32 line, SILC_CONFIG_CALLBACK(fetch_generic) { SilcServerConfig config = (SilcServerConfig) context; + int got_errno = 0; if (!strcmp(name, "module_path")) { - if (config->module_path) - return SILC_CONFIG_EDOUBLE; - - /* dup it only if non-empty, otherwise point it to NULL */ + CONFIG_IS_DOUBLE(config->module_path); config->module_path = (*(char *)val ? strdup((char *) val) : NULL); } else if (!strcmp(name, "prefer_passphrase_auth")) { config->prefer_passphrase_auth = *(bool *)val; } + else if (!strcmp(name, "require_reverse_lookup")) { + config->require_reverse_lookup = *(bool *)val; + } + else if (!strcmp(name, "connections_max")) { + config->param.connections_max = (SilcUInt32) *(int *)val; + } + else if (!strcmp(name, "connections_max_per_host")) { + config->param.connections_max_per_host = (SilcUInt32) *(int *)val; + } + else if (!strcmp(name, "keepalive_secs")) { + config->param.keepalive_secs = (SilcUInt32) *(int *)val; + } + else if (!strcmp(name, "reconnect_count")) { + config->param.reconnect_count = (SilcUInt32) *(int *)val; + } + else if (!strcmp(name, "reconnect_interval")) { + config->param.reconnect_interval = (SilcUInt32) *(int *)val; + } + else if (!strcmp(name, "reconnect_interval_max")) { + config->param.reconnect_interval_max = (SilcUInt32) *(int *)val; + } + else if (!strcmp(name, "reconnect_keep_trying")) { + config->param.reconnect_keep_trying = *(bool *)val; + } + else if (!strcmp(name, "key_exchange_rekey")) { + config->param.key_exchange_rekey = (SilcUInt32) *(int *)val; + } + else if (!strcmp(name, "key_exchange_pfs")) { + config->param.key_exchange_pfs = *(bool *)val; + } + else if (!strcmp(name, "channel_rekey_secs")) { + config->channel_rekey_secs = (SilcUInt32) *(int *)val; + } + else if (!strcmp(name, "key_exchange_timeout")) { + config->key_exchange_timeout = (SilcUInt32) *(int *)val; + } + else if (!strcmp(name, "conn_auth_timeout")) { + config->conn_auth_timeout = (SilcUInt32) *(int *)val; + } else return SILC_CONFIG_EINTERNAL; return SILC_CONFIG_OK; + + got_err: + return got_errno; } SILC_CONFIG_CALLBACK(fetch_cipher) { - SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigSectionCipher); + SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigCipher); - SERVER_CONFIG_DEBUG(("Received CIPHER type=%d name=\"%s\" (val=%x)", + SERVER_CONFIG_DEBUG(("Received CIPHER type=%d name=\"%s\" (val=%x)", type, name, context)); if (type == SILC_CONFIG_ARG_BLOCK) { /* check the temporary struct's fields */ @@ -134,23 +221,24 @@ SILC_CONFIG_CALLBACK(fetch_cipher) /* if there isn't a temporary struct alloc one */ if (!tmp) { config->tmp = silc_calloc(1, sizeof(*findtmp)); - tmp = (SilcServerConfigSectionCipher *) config->tmp; + tmp = (SilcServerConfigCipher *) config->tmp; } /* Identify and save this value */ if (!strcmp(name, "name")) { - if (tmp->name) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; } + CONFIG_IS_DOUBLE(tmp->name); tmp->name = strdup((char *) val); } - else if (!strcmp(name, "module")) { /* can be empty */ - if (tmp->module) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; } - /* dup it only if non-empty, otherwise point it to NULL */ + else if (!strcmp(name, "module")) { + CONFIG_IS_DOUBLE(tmp->module); tmp->module = (*(char *)val ? strdup((char *) val) : NULL); } - else if (!strcmp(name, "keylength")) - tmp->key_length = *(uint32 *)val; - else if (!strcmp(name, "blocklength")) - tmp->block_length = *(uint32 *)val; + else if (!strcmp(name, "keylength")) { + tmp->key_length = *(SilcUInt32 *)val; + } + else if (!strcmp(name, "blocklength")) { + tmp->block_length = *(SilcUInt32 *)val; + } else return SILC_CONFIG_EINTERNAL; return SILC_CONFIG_OK; @@ -165,9 +253,9 @@ SILC_CONFIG_CALLBACK(fetch_cipher) SILC_CONFIG_CALLBACK(fetch_hash) { - SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigSectionHash); + SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigHash); - SERVER_CONFIG_DEBUG(("Received HASH type=%d name=%s (val=%x)", + SERVER_CONFIG_DEBUG(("Received HASH type=%d name=%s (val=%x)", type, name, context)); if (type == SILC_CONFIG_ARG_BLOCK) { /* check the temporary struct's fields */ @@ -182,26 +270,28 @@ SILC_CONFIG_CALLBACK(fetch_hash) config->tmp = NULL; return SILC_CONFIG_OK; } + /* if there isn't a temporary struct alloc one */ if (!tmp) { config->tmp = silc_calloc(1, sizeof(*findtmp)); - tmp = (SilcServerConfigSectionHash *) config->tmp; + tmp = (SilcServerConfigHash *) config->tmp; } /* Identify and save this value */ if (!strcmp(name, "name")) { - if (tmp->name) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; } + CONFIG_IS_DOUBLE(tmp->name); tmp->name = strdup((char *) val); } - else if (!strcmp(name, "module")) { /* can be empty */ - if (tmp->module) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; } - /* dup it only if non-empty, otherwise point it to NULL */ + else if (!strcmp(name, "module")) { + CONFIG_IS_DOUBLE(tmp->module); tmp->module = (*(char *)val ? strdup((char *) val) : NULL); } - else if (!strcmp(name, "blocklength")) + else if (!strcmp(name, "blocklength")) { tmp->block_length = *(int *)val; - else if (!strcmp(name, "digestlength")) + } + else if (!strcmp(name, "digestlength")) { tmp->digest_length = *(int *)val; + } else return SILC_CONFIG_EINTERNAL; return SILC_CONFIG_OK; @@ -216,9 +306,9 @@ SILC_CONFIG_CALLBACK(fetch_hash) SILC_CONFIG_CALLBACK(fetch_hmac) { - SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigSectionHmac); + SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigHmac); - SERVER_CONFIG_DEBUG(("Received HMAC type=%d name=\"%s\" (val=%x)", + SERVER_CONFIG_DEBUG(("Received HMAC type=%d name=\"%s\" (val=%x)", type, name, context)); if (type == SILC_CONFIG_ARG_BLOCK) { /* check the temporary struct's fields */ @@ -236,20 +326,21 @@ SILC_CONFIG_CALLBACK(fetch_hmac) /* if there isn't a temporary struct alloc one */ if (!tmp) { config->tmp = silc_calloc(1, sizeof(*findtmp)); - tmp = (SilcServerConfigSectionHmac *) config->tmp; + tmp = (SilcServerConfigHmac *) config->tmp; } /* Identify and save this value */ if (!strcmp(name, "name")) { - if (tmp->name) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; } + CONFIG_IS_DOUBLE(tmp->name); tmp->name = strdup((char *) val); } else if (!strcmp(name, "hash")) { - if (tmp->hash) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; } + CONFIG_IS_DOUBLE(tmp->hash); tmp->hash = strdup((char *) val); } - else if (!strcmp(name, "maclength")) + else if (!strcmp(name, "maclength")) { tmp->mac_length = *(int *)val; + } else return SILC_CONFIG_EINTERNAL; return SILC_CONFIG_OK; @@ -264,7 +355,7 @@ SILC_CONFIG_CALLBACK(fetch_hmac) SILC_CONFIG_CALLBACK(fetch_pkcs) { - SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigSectionPkcs); + SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigPkcs); SERVER_CONFIG_DEBUG(("Received PKCS type=%d name=\"%s\" (val=%x)", type, name, context)); @@ -284,12 +375,12 @@ SILC_CONFIG_CALLBACK(fetch_pkcs) /* if there isn't a temporary struct alloc one */ if (!tmp) { config->tmp = silc_calloc(1, sizeof(*findtmp)); - tmp = (SilcServerConfigSectionPkcs *) config->tmp; + tmp = (SilcServerConfigPkcs *) config->tmp; } /* Identify and save this value */ if (!strcmp(name, "name")) { - if (tmp->name) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; } + CONFIG_IS_DOUBLE(tmp->name); tmp->name = strdup((char *) val); } else @@ -306,24 +397,24 @@ SILC_CONFIG_CALLBACK(fetch_pkcs) SILC_CONFIG_CALLBACK(fetch_serverinfo) { SilcServerConfig config = (SilcServerConfig) context; - SilcServerConfigSectionServerInfo *server_info = config->server_info; + SilcServerConfigServerInfo *server_info = config->server_info; + int got_errno = 0; /* if there isn't the struct alloc it */ - if (!server_info) { - config->server_info = server_info = (SilcServerConfigSectionServerInfo *) + if (!server_info) + config->server_info = server_info = (SilcServerConfigServerInfo *) silc_calloc(1, sizeof(*server_info)); - } if (type == SILC_CONFIG_ARG_BLOCK) { /* check for mandatory inputs */ return SILC_CONFIG_OK; } if (!strcmp(name, "hostname")) { - if (server_info->server_name) return SILC_CONFIG_EDOUBLE; + CONFIG_IS_DOUBLE(server_info->server_name); server_info->server_name = strdup((char *) val); } else if (!strcmp(name, "ip")) { - if (server_info->server_ip) return SILC_CONFIG_EDOUBLE; + CONFIG_IS_DOUBLE(server_info->server_ip); server_info->server_ip = strdup((char *) val); } else if (!strcmp(name, "port")) { @@ -332,38 +423,38 @@ SILC_CONFIG_CALLBACK(fetch_serverinfo) fprintf(stderr, "Invalid port number!\n"); return SILC_CONFIG_ESILENT; } - server_info->port = (uint16) port; + server_info->port = (SilcUInt16) port; } else if (!strcmp(name, "servertype")) { - if (server_info->server_type) return SILC_CONFIG_EDOUBLE; + CONFIG_IS_DOUBLE(server_info->server_type); server_info->server_type = strdup((char *) val); } else if (!strcmp(name, "admin")) { - if (server_info->admin) return SILC_CONFIG_EDOUBLE; + CONFIG_IS_DOUBLE(server_info->admin); server_info->admin = strdup((char *) val); } else if (!strcmp(name, "adminemail")) { - if (server_info->email) return SILC_CONFIG_EDOUBLE; + CONFIG_IS_DOUBLE(server_info->email); server_info->email = strdup((char *) val); } else if (!strcmp(name, "location")) { - if (server_info->location) return SILC_CONFIG_EDOUBLE; + CONFIG_IS_DOUBLE(server_info->location); server_info->location = strdup((char *) val); } else if (!strcmp(name, "user")) { - if (server_info->user) return SILC_CONFIG_EDOUBLE; + CONFIG_IS_DOUBLE(server_info->user); server_info->user = strdup((char *) val); } else if (!strcmp(name, "group")) { - if (server_info->group) return SILC_CONFIG_EDOUBLE; + CONFIG_IS_DOUBLE(server_info->group); server_info->group = strdup((char *) val); } else if (!strcmp(name, "motdfile")) { - if (server_info->motd_file) return SILC_CONFIG_EDOUBLE; + CONFIG_IS_DOUBLE(server_info->motd_file); server_info->motd_file = strdup((char *) val); } else if (!strcmp(name, "pidfile")) { - if (server_info->pid_file) return SILC_CONFIG_EDOUBLE; + CONFIG_IS_DOUBLE(server_info->pid_file); server_info->pid_file = strdup((char *) val); } else if (!strcmp(name, "publickey")) { @@ -395,13 +486,16 @@ SILC_CONFIG_CALLBACK(fetch_serverinfo) else return SILC_CONFIG_EINTERNAL; return SILC_CONFIG_OK; + + got_err: + return got_errno; } SILC_CONFIG_CALLBACK(fetch_logging) { SilcServerConfig config = (SilcServerConfig) context; - SilcServerConfigSectionLogging *tmp = - (SilcServerConfigSectionLogging *) config->tmp; + SilcServerConfigLogging *tmp = + (SilcServerConfigLogging *) config->tmp; int got_errno; if (!strcmp(name, "quicklogs")) { @@ -433,7 +527,7 @@ SILC_CONFIG_CALLBACK(fetch_logging) else if (!strcmp(name, "file")) { if (!tmp) { /* FIXME: what the fuck is this? */ config->tmp = silc_calloc(1, sizeof(*tmp)); - tmp = (SilcServerConfigSectionLogging *) config->tmp; + tmp = (SilcServerConfigLogging *) config->tmp; } if (tmp->file) { got_errno = SILC_CONFIG_EMISSFIELDS; goto got_err; @@ -443,9 +537,9 @@ SILC_CONFIG_CALLBACK(fetch_logging) else if (!strcmp(name, "size")) { if (!tmp) { config->tmp = silc_calloc(1, sizeof(*tmp)); - tmp = (SilcServerConfigSectionLogging *) config->tmp; + tmp = (SilcServerConfigLogging *) config->tmp; } - tmp->maxsize = *(uint32 *) val; + tmp->maxsize = *(SilcUInt32 *) val; } else return SILC_CONFIG_EINTERNAL; @@ -458,18 +552,26 @@ SILC_CONFIG_CALLBACK(fetch_logging) return got_errno; } -SILC_CONFIG_CALLBACK(fetch_client) +SILC_CONFIG_CALLBACK(fetch_connparam) { - SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigSectionClient); + SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigConnParams); - SERVER_CONFIG_DEBUG(("Received CLIENT type=%d name=\"%s\" (val=%x)", + SERVER_CONFIG_DEBUG(("Received CONNPARAM type=%d name=\"%s\" (val=%x)", type, name, context)); if (type == SILC_CONFIG_ARG_BLOCK) { - if (!tmp) /* empty sub-block? */ + if (!tmp) return SILC_CONFIG_OK; - SILC_SERVER_CONFIG_LIST_APPENDTMP(config->clients); + if (!tmp->name) { + got_errno = SILC_CONFIG_EMISSFIELDS; + goto got_err; + } + + /* Set defaults */ + my_set_param_defaults(tmp, &config->param); + + SILC_SERVER_CONFIG_LIST_APPENDTMP(config->conn_params); config->tmp = NULL; return SILC_CONFIG_OK; } @@ -477,17 +579,80 @@ SILC_CONFIG_CALLBACK(fetch_client) /* if there isn't a temporary struct alloc one */ if (!tmp) { config->tmp = silc_calloc(1, sizeof(*findtmp)); - tmp = (SilcServerConfigSectionClient *) config->tmp; + tmp = (SilcServerConfigConnParams *) config->tmp; + } + + if (!strcmp(name, "name")) { + CONFIG_IS_DOUBLE(tmp->name); + tmp->name = (*(char *)val ? strdup((char *) val) : NULL); + } + else if (!strcmp(name, "connections_max")) { + tmp->connections_max = *(SilcUInt32 *)val; + } + else if (!strcmp(name, "connections_max_per_host")) { + tmp->connections_max_per_host = *(SilcUInt32 *)val; + } + else if (!strcmp(name, "keepalive_secs")) { + tmp->keepalive_secs = *(SilcUInt32 *)val; + } + else if (!strcmp(name, "reconnect_count")) { + tmp->reconnect_count = *(SilcUInt32 *)val; + } + else if (!strcmp(name, "reconnect_interval")) { + tmp->reconnect_interval = *(SilcUInt32 *)val; + } + else if (!strcmp(name, "reconnect_interval_max")) { + tmp->reconnect_interval_max = *(SilcUInt32 *)val; + } + else if (!strcmp(name, "reconnect_keep_trying")) { + tmp->reconnect_keep_trying = *(bool *)val; + } + else if (!strcmp(name, "key_exchange_rekey")) { + tmp->key_exchange_rekey = *(SilcUInt32 *)val; + } + else if (!strcmp(name, "key_exchange_pfs")) { + tmp->key_exchange_pfs = *(bool *)val; + } + else + return SILC_CONFIG_EINTERNAL; + + return SILC_CONFIG_OK; + + got_err: + silc_free(tmp->name); + silc_free(tmp); + config->tmp = NULL; + return got_errno; +} + +SILC_CONFIG_CALLBACK(fetch_client) +{ + SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigClient); + + SERVER_CONFIG_DEBUG(("Received CLIENT type=%d name=\"%s\" (val=%x)", + type, name, context)); + + /* alloc tmp before block checking (empty sub-blocks are welcome here) */ + if (!tmp) { + config->tmp = silc_calloc(1, sizeof(*findtmp)); + tmp = (SilcServerConfigClient *) config->tmp; + } + + if (type == SILC_CONFIG_ARG_BLOCK) { + /* closing the block */ + SILC_SERVER_CONFIG_LIST_APPENDTMP(config->clients); + config->tmp = NULL; + return SILC_CONFIG_OK; } /* Identify and save this value */ - if (!strcmp(name, "host")) { /* any host (*) accepted */ - if (tmp->host) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; } + if (!strcmp(name, "host")) { + CONFIG_IS_DOUBLE(tmp->host); tmp->host = (*(char *)val ? strdup((char *) val) : NULL); } else if (!strcmp(name, "passphrase")) { if (!my_parse_authdata(SILC_AUTH_PASSWORD, (char *) val, line, - (void **)&tmp->passphrase, + (void **)&tmp->passphrase, &tmp->passphrase_len)) { got_errno = SILC_CONFIG_ESILENT; goto got_err; @@ -500,17 +665,13 @@ SILC_CONFIG_CALLBACK(fetch_client) goto got_err; } } - else if (!strcmp(name, "port")) { - int port = *(int *)val; - if ((port <= 0) || (port > 65535)) { - fprintf(stderr, "Invalid port number!\n"); - got_errno = SILC_CONFIG_ESILENT; goto got_err; + else if (!strcmp(name, "params")) { + CONFIG_IS_DOUBLE(tmp->param); + tmp->param = my_find_param(config, (char *) val, line); + if (!tmp->param) { /* error already output */ + got_errno = SILC_CONFIG_ESILENT; + goto got_err; } - tmp->port = (uint16) port; - } - /* FIXME: Improvement: use a direct class struct pointer instead of num */ - else if (!strcmp(name, "class")) { - /* XXX do nothing */ } else return SILC_CONFIG_EINTERNAL; @@ -518,16 +679,17 @@ SILC_CONFIG_CALLBACK(fetch_client) got_err: silc_free(tmp->host); - my_free_authdata(tmp->passphrase, tmp->publickey); + CONFIG_FREE_AUTH(tmp); silc_free(tmp); + config->tmp = NULL; return got_errno; } SILC_CONFIG_CALLBACK(fetch_admin) { - SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigSectionAdmin); + SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigAdmin); - SERVER_CONFIG_DEBUG(("Received CLIENT type=%d name=\"%s\" (val=%x)", + SERVER_CONFIG_DEBUG(("Received CLIENT type=%d name=\"%s\" (val=%x)", type, name, context)); if (type == SILC_CONFIG_ARG_BLOCK) { @@ -543,25 +705,25 @@ SILC_CONFIG_CALLBACK(fetch_admin) /* if there isn't a temporary struct alloc one */ if (!tmp) { config->tmp = silc_calloc(1, sizeof(*findtmp)); - tmp = (SilcServerConfigSectionAdmin *) config->tmp; + tmp = (SilcServerConfigAdmin *) config->tmp; } /* Identify and save this value */ - if (!strcmp(name, "host")) { /* any host (*) accepted */ - if (tmp->host) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; } + if (!strcmp(name, "host")) { + CONFIG_IS_DOUBLE(tmp->host); tmp->host = (*(char *)val ? strdup((char *) val) : NULL); } else if (!strcmp(name, "user")) { - if (tmp->user) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; } + CONFIG_IS_DOUBLE(tmp->user); tmp->user = (*(char *)val ? strdup((char *) val) : NULL); } else if (!strcmp(name, "nick")) { - if (tmp->nick) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; } + CONFIG_IS_DOUBLE(tmp->nick); tmp->nick = (*(char *)val ? strdup((char *) val) : NULL); } else if (!strcmp(name, "passphrase")) { if (!my_parse_authdata(SILC_AUTH_PASSWORD, (char *) val, line, - (void **)&tmp->passphrase, + (void **)&tmp->passphrase, &tmp->passphrase_len)) { got_errno = SILC_CONFIG_ESILENT; goto got_err; @@ -582,16 +744,17 @@ SILC_CONFIG_CALLBACK(fetch_admin) silc_free(tmp->host); silc_free(tmp->user); silc_free(tmp->nick); - my_free_authdata(tmp->passphrase, tmp->publickey); + CONFIG_FREE_AUTH(tmp); silc_free(tmp); + config->tmp = NULL; return got_errno; } SILC_CONFIG_CALLBACK(fetch_deny) { - SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigSectionDeny); + SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigDeny); - SERVER_CONFIG_DEBUG(("Received DENY type=%d name=\"%s\" (val=%x)", + SERVER_CONFIG_DEBUG(("Received DENY type=%d name=\"%s\" (val=%x)", type, name, context)); if (type == SILC_CONFIG_ARG_BLOCK) { /* check the temporary struct's fields */ @@ -608,24 +771,16 @@ SILC_CONFIG_CALLBACK(fetch_deny) /* if there isn't a temporary struct alloc one */ if (!tmp) { config->tmp = silc_calloc(1, sizeof(*findtmp)); - tmp = (SilcServerConfigSectionDeny *) config->tmp; + tmp = (SilcServerConfigDeny *) config->tmp; } /* Identify and save this value */ - if (!strcmp(name, "host")) { /* any host (*) accepted */ - if (tmp->host) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; } + if (!strcmp(name, "host")) { + CONFIG_IS_DOUBLE(tmp->host); tmp->host = (*(char *)val ? strdup((char *) val) : strdup("*")); } - else if (!strcmp(name, "port")) { - int port = *(int *)val; - if ((port <= 0) || (port > 65535)) { - fprintf(stderr, "Invalid port number!\n"); - got_errno = SILC_CONFIG_ESILENT; goto got_err; - } - tmp->port = (uint16) port; - } else if (!strcmp(name, "reason")) { - if (tmp->reason) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; } + CONFIG_IS_DOUBLE(tmp->reason); tmp->reason = strdup((char *) val); } else @@ -636,14 +791,15 @@ SILC_CONFIG_CALLBACK(fetch_deny) silc_free(tmp->host); silc_free(tmp->reason); silc_free(tmp); + config->tmp = NULL; return got_errno; } SILC_CONFIG_CALLBACK(fetch_server) { - SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigSectionServer); + SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigServer); - SERVER_CONFIG_DEBUG(("Received SERVER type=%d name=\"%s\" (val=%x)", + SERVER_CONFIG_DEBUG(("Received SERVER type=%d name=\"%s\" (val=%x)", type, name, context)); if (type == SILC_CONFIG_ARG_BLOCK) { @@ -660,17 +816,17 @@ SILC_CONFIG_CALLBACK(fetch_server) /* if there isn't a temporary struct alloc one */ if (!tmp) { config->tmp = silc_calloc(1, sizeof(*findtmp)); - tmp = (SilcServerConfigSectionServer *) config->tmp; + tmp = (SilcServerConfigServer *) config->tmp; } /* Identify and save this value */ - if (!strcmp(name, "host")) { /* any host (*) accepted */ - if (tmp->host) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; } + if (!strcmp(name, "host")) { + CONFIG_IS_DOUBLE(tmp->host); tmp->host = (*(char *)val ? strdup((char *) val) : strdup("*")); } else if (!strcmp(name, "passphrase")) { if (!my_parse_authdata(SILC_AUTH_PASSWORD, (char *) val, line, - (void **)&tmp->passphrase, + (void **)&tmp->passphrase, &tmp->passphrase_len)) { got_errno = SILC_CONFIG_ESILENT; goto got_err; @@ -684,12 +840,16 @@ SILC_CONFIG_CALLBACK(fetch_server) } } else if (!strcmp(name, "versionid")) { - if (tmp->version) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; } + CONFIG_IS_DOUBLE(tmp->version); tmp->version = strdup((char *) val); } - /* FIXME: Improvement: use a direct class struct pointer instead of num */ - else if (!strcmp(name, "class")) { - /* XXX do nothing */ + else if (!strcmp(name, "params")) { + CONFIG_IS_DOUBLE(tmp->param); + tmp->param = my_find_param(config, (char *) val, line); + if (!tmp->param) { /* error already output */ + got_errno = SILC_CONFIG_ESILENT; + goto got_err; + } } else if (!strcmp(name, "backup")) { tmp->backup_router = *(bool *)val; @@ -702,16 +862,17 @@ SILC_CONFIG_CALLBACK(fetch_server) got_err: silc_free(tmp->host); silc_free(tmp->version); - my_free_authdata(tmp->passphrase, tmp->publickey); + CONFIG_FREE_AUTH(tmp); silc_free(tmp); + config->tmp = NULL; return got_errno; } SILC_CONFIG_CALLBACK(fetch_router) { - SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigSectionRouter); + SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigRouter); - SERVER_CONFIG_DEBUG(("Received ROUTER type=%d name=\"%s\" (val=%x)", + SERVER_CONFIG_DEBUG(("Received ROUTER type=%d name=\"%s\" (val=%x)", type, name, context)); if (type == SILC_CONFIG_ARG_BLOCK) { @@ -727,12 +888,12 @@ SILC_CONFIG_CALLBACK(fetch_router) /* if there isn't a temporary struct alloc one */ if (!tmp) { config->tmp = silc_calloc(1, sizeof(*findtmp)); - tmp = (SilcServerConfigSectionRouter *) config->tmp; + tmp = (SilcServerConfigRouter *) config->tmp; } /* Identify and save this value */ if (!strcmp(name, "host")) { - if (tmp->host) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; } + CONFIG_IS_DOUBLE(tmp->host); tmp->host = strdup((char *) val); } else if (!strcmp(name, "port")) { @@ -741,11 +902,11 @@ SILC_CONFIG_CALLBACK(fetch_router) fprintf(stderr, "Invalid port number!\n"); return SILC_CONFIG_ESILENT; } - tmp->port = (uint16) port; + tmp->port = (SilcUInt16) port; } else if (!strcmp(name, "passphrase")) { if (!my_parse_authdata(SILC_AUTH_PASSWORD, (char *) val, line, - (void **)&tmp->passphrase, + (void **)&tmp->passphrase, &tmp->passphrase_len)) { got_errno = SILC_CONFIG_ESILENT; goto got_err; @@ -759,18 +920,35 @@ SILC_CONFIG_CALLBACK(fetch_router) } } else if (!strcmp(name, "versionid")) { - if (tmp->version) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; } + CONFIG_IS_DOUBLE(tmp->version); tmp->version = strdup((char *) val); } - /* FIXME: Improvement: use a direct class struct pointer instead of num */ - else if (!strcmp(name, "class")) { - /* XXX do nothing */ + else if (!strcmp(name, "params")) { + CONFIG_IS_DOUBLE(tmp->param); + tmp->param = my_find_param(config, (char *) val, line); + if (!tmp->param) { /* error already output */ + got_errno = SILC_CONFIG_ESILENT; + goto got_err; + } } - else if (!strcmp(name, "initiator")) + else if (!strcmp(name, "initiator")) { tmp->initiator = *(bool *)val; + } else if (!strcmp(name, "backuphost")) { - if (tmp->backup_replace_ip) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; } - tmp->backup_replace_ip = (*(char *)val ? strdup((char *) val) : strdup("*")); + CONFIG_IS_DOUBLE(tmp->backup_replace_ip); + tmp->backup_replace_ip = (*(char *)val ? strdup((char *) val) : + strdup("*")); + } + else if (!strcmp(name, "backupport")) { + int port = *(int *)val; + if ((port <= 0) || (port > 65535)) { + fprintf(stderr, "Invalid port number!\n"); + return SILC_CONFIG_ESILENT; + } + tmp->backup_replace_port = (SilcUInt16) port; + } + else if (!strcmp(name, "backuplocal")) { + tmp->backup_local = *(bool *)val; } else return SILC_CONFIG_EINTERNAL; @@ -781,15 +959,29 @@ SILC_CONFIG_CALLBACK(fetch_router) silc_free(tmp->host); silc_free(tmp->version); silc_free(tmp->backup_replace_ip); - my_free_authdata(tmp->passphrase, tmp->publickey); + CONFIG_FREE_AUTH(tmp); silc_free(tmp); + config->tmp = NULL; return got_errno; } /* known config options tables */ static const SilcConfigTable table_general[] = { - { "module_path", SILC_CONFIG_ARG_STRE, fetch_generic, NULL }, - { "prefer_passphrase_auth", SILC_CONFIG_ARG_STRE, fetch_generic, NULL }, + { "module_path", SILC_CONFIG_ARG_STRE, fetch_generic, NULL }, + { "prefer_passphrase_auth", SILC_CONFIG_ARG_TOGGLE, fetch_generic, NULL }, + { "require_reverse_lookup", SILC_CONFIG_ARG_TOGGLE, fetch_generic, NULL }, + { "connections_max", SILC_CONFIG_ARG_INT, fetch_generic, NULL }, + { "connections_max_per_host", SILC_CONFIG_ARG_INT, fetch_generic, NULL }, + { "keepalive_secs", SILC_CONFIG_ARG_INT, fetch_generic, NULL }, + { "reconnect_count", SILC_CONFIG_ARG_INT, fetch_generic, NULL }, + { "reconnect_interval", SILC_CONFIG_ARG_INT, fetch_generic, NULL }, + { "reconnect_interval_max", SILC_CONFIG_ARG_INT, fetch_generic, NULL }, + { "reconnect_keep_trying", SILC_CONFIG_ARG_TOGGLE, fetch_generic, NULL }, + { "key_exchange_rekey", SILC_CONFIG_ARG_INT, fetch_generic, NULL }, + { "key_exchange_pfs", SILC_CONFIG_ARG_TOGGLE, fetch_generic, NULL }, + { "channel_rekey_secs", SILC_CONFIG_ARG_INT, fetch_generic, NULL }, + { "key_exchange_timeout", SILC_CONFIG_ARG_INT, fetch_generic, NULL }, + { "conn_auth_timeout", SILC_CONFIG_ARG_INT, fetch_generic, NULL }, { 0, 0, 0, 0 } }; @@ -855,21 +1047,26 @@ static const SilcConfigTable table_logging[] = { { 0, 0, 0, 0 } }; -/* still unsupported -static const SilcConfigTable table_class[] = { - { "name", SILC_CONFIG_ARG_STR, fetch_class, NULL }, - { "ping", SILC_CONFIG_ARG_INT, fetch_class, NULL }, - { "connect", SILC_CONFIG_ARG_INT, fetch_class, NULL }, - { "links", SILC_CONFIG_ARG_INT, fetch_class, NULL }, +static const SilcConfigTable table_connparam[] = { + { "name", SILC_CONFIG_ARG_STR, fetch_connparam, NULL }, + { "require_reverse_lookup", SILC_CONFIG_ARG_TOGGLE, fetch_connparam, NULL }, + { "connections_max", SILC_CONFIG_ARG_INT, fetch_connparam, NULL }, + { "connections_max_per_host",SILC_CONFIG_ARG_INT, fetch_connparam, NULL }, + { "keepalive_secs", SILC_CONFIG_ARG_INT, fetch_connparam, NULL }, + { "reconnect_count", SILC_CONFIG_ARG_INT, fetch_connparam, NULL }, + { "reconnect_interval", SILC_CONFIG_ARG_INT, fetch_connparam, NULL }, + { "reconnect_interval_max", SILC_CONFIG_ARG_INT, fetch_connparam, NULL }, + { "reconnect_keep_trying", SILC_CONFIG_ARG_TOGGLE, fetch_connparam, NULL }, + { "key_exchange_rekey", SILC_CONFIG_ARG_INT, fetch_connparam, NULL }, + { "key_exchange_pfs", SILC_CONFIG_ARG_TOGGLE, fetch_connparam, NULL }, { 0, 0, 0, 0 } -}; */ +}; static const SilcConfigTable table_client[] = { { "host", SILC_CONFIG_ARG_STRE, fetch_client, NULL }, { "passphrase", SILC_CONFIG_ARG_STR, fetch_client, NULL }, { "publickey", SILC_CONFIG_ARG_STR, fetch_client, NULL }, - { "port", SILC_CONFIG_ARG_INT, fetch_client, NULL }, - { "class", SILC_CONFIG_ARG_STR, fetch_client, NULL }, + { "params", SILC_CONFIG_ARG_STR, fetch_client, NULL }, { 0, 0, 0, 0 } }; @@ -880,13 +1077,12 @@ static const SilcConfigTable table_admin[] = { { "passphrase", SILC_CONFIG_ARG_STR, fetch_admin, NULL }, { "publickey", SILC_CONFIG_ARG_STR, fetch_admin, NULL }, { "port", SILC_CONFIG_ARG_INT, fetch_admin, NULL }, - { "class", SILC_CONFIG_ARG_STR, fetch_admin, NULL }, + { "params", SILC_CONFIG_ARG_STR, fetch_admin, NULL }, { 0, 0, 0, 0 } }; static const SilcConfigTable table_deny[] = { { "host", SILC_CONFIG_ARG_STRE, fetch_deny, NULL }, - { "port", SILC_CONFIG_ARG_INT, fetch_deny, NULL }, { "reason", SILC_CONFIG_ARG_STR, fetch_deny, NULL }, { 0, 0, 0, 0 } }; @@ -896,7 +1092,7 @@ static const SilcConfigTable table_serverconn[] = { { "passphrase", SILC_CONFIG_ARG_STR, fetch_server, NULL }, { "publickey", SILC_CONFIG_ARG_STR, fetch_server, NULL }, { "versionid", SILC_CONFIG_ARG_STR, fetch_server, NULL }, - { "class", SILC_CONFIG_ARG_STR, fetch_server, NULL }, + { "params", SILC_CONFIG_ARG_STR, fetch_server, NULL }, { "backup", SILC_CONFIG_ARG_TOGGLE, fetch_server, NULL }, { 0, 0, 0, 0 } }; @@ -907,28 +1103,28 @@ static const SilcConfigTable table_routerconn[] = { { "passphrase", SILC_CONFIG_ARG_STR, fetch_router, NULL }, { "publickey", SILC_CONFIG_ARG_STR, fetch_router, NULL }, { "versionid", SILC_CONFIG_ARG_STR, fetch_router, NULL }, - { "class", SILC_CONFIG_ARG_STR, fetch_router, NULL }, + { "params", SILC_CONFIG_ARG_STR, fetch_router, NULL }, { "initiator", SILC_CONFIG_ARG_TOGGLE, fetch_router, NULL }, { "backuphost", SILC_CONFIG_ARG_STRE, fetch_router, NULL }, { "backupport", SILC_CONFIG_ARG_INT, fetch_router, NULL }, - { "localbackup", SILC_CONFIG_ARG_TOGGLE, fetch_router, NULL }, + { "backuplocal", SILC_CONFIG_ARG_TOGGLE, fetch_router, NULL }, { 0, 0, 0, 0 } }; static const SilcConfigTable table_main[] = { - { "general", SILC_CONFIG_ARG_BLOCK, NULL, table_general }, - { "cipher", SILC_CONFIG_ARG_BLOCK, fetch_cipher, table_cipher }, - { "hash", SILC_CONFIG_ARG_BLOCK, fetch_hash, table_hash }, - { "hmac", SILC_CONFIG_ARG_BLOCK, fetch_hmac, table_hmac }, - { "pkcs", SILC_CONFIG_ARG_BLOCK, fetch_pkcs, table_pkcs }, + { "general", SILC_CONFIG_ARG_BLOCK, NULL, table_general }, + { "cipher", SILC_CONFIG_ARG_BLOCK, fetch_cipher, table_cipher }, + { "hash", SILC_CONFIG_ARG_BLOCK, fetch_hash, table_hash }, + { "hmac", SILC_CONFIG_ARG_BLOCK, fetch_hmac, table_hmac }, + { "pkcs", SILC_CONFIG_ARG_BLOCK, fetch_pkcs, table_pkcs }, { "serverinfo", SILC_CONFIG_ARG_BLOCK, fetch_serverinfo, table_serverinfo }, - { "logging", SILC_CONFIG_ARG_BLOCK, NULL, table_logging }, -/*{ "class", SILC_CONFIG_ARG_BLOCK, fetch_class, table_class }, */ - { "client", SILC_CONFIG_ARG_BLOCK, fetch_client, table_client }, - { "admin", SILC_CONFIG_ARG_BLOCK, fetch_admin, table_admin }, - { "deny", SILC_CONFIG_ARG_BLOCK, fetch_deny, table_deny }, - { "serverconnection", SILC_CONFIG_ARG_BLOCK, fetch_server, table_serverconn }, - { "routerconnection", SILC_CONFIG_ARG_BLOCK, fetch_router, table_routerconn }, + { "logging", SILC_CONFIG_ARG_BLOCK, NULL, table_logging }, + { "connectionparams", SILC_CONFIG_ARG_BLOCK, fetch_connparam, table_connparam }, + { "client", SILC_CONFIG_ARG_BLOCK, fetch_client, table_client }, + { "admin", SILC_CONFIG_ARG_BLOCK, fetch_admin, table_admin }, + { "deny", SILC_CONFIG_ARG_BLOCK, fetch_deny, table_deny }, + { "serverconnection", SILC_CONFIG_ARG_BLOCK, fetch_server, table_serverconn }, + { "routerconnection", SILC_CONFIG_ARG_BLOCK, fetch_router, table_routerconn }, { 0, 0, 0, 0 } }; @@ -959,14 +1155,15 @@ SilcServerConfig silc_server_config_alloc(char *filename) /* enter the main parsing loop. When this returns, we have the parsing * result and the object filled (or partially, in case of errors). */ ret = silc_config_main(ent); - SILC_LOG_DEBUG(("Parser returned [ret=%d]: %s", ret, silc_config_strerror(ret))); + SILC_LOG_DEBUG(("Parser returned [ret=%d]: %s", ret, + silc_config_strerror(ret))); /* Check if the parser returned errors */ if (ret) { /* handle this special error return which asks to quietly return */ if (ret != SILC_CONFIG_ESILENT) { char *linebuf, *filename = silc_config_get_filename(file); - uint32 line = silc_config_get_line(file); + SilcUInt32 line = silc_config_get_line(file); fprintf(stderr, "\nError while parsing config file: %s.\n", silc_config_strerror(ret)); linebuf = silc_config_read_line(file, line); @@ -1005,7 +1202,7 @@ void silc_server_config_destroy(SilcServerConfig config) /* Destroy the ServerInfo struct */ if (config->server_info) { - register SilcServerConfigSectionServerInfo *si = config->server_info; + register SilcServerConfigServerInfo *si = config->server_info; silc_free(si->server_name); silc_free(si->server_ip); silc_free(si->server_type); @@ -1020,57 +1217,57 @@ void silc_server_config_destroy(SilcServerConfig config) /* Now let's destroy the lists */ - SILC_SERVER_CONFIG_LIST_DESTROY(SilcServerConfigSectionCipher, + SILC_SERVER_CONFIG_LIST_DESTROY(SilcServerConfigCipher, config->cipher) silc_free(di->name); silc_free(di->module); silc_free(di); } - SILC_SERVER_CONFIG_LIST_DESTROY(SilcServerConfigSectionHash, config->hash) + SILC_SERVER_CONFIG_LIST_DESTROY(SilcServerConfigHash, config->hash) silc_free(di->name); silc_free(di->module); silc_free(di); } - SILC_SERVER_CONFIG_LIST_DESTROY(SilcServerConfigSectionHmac, config->hmac) + SILC_SERVER_CONFIG_LIST_DESTROY(SilcServerConfigHmac, config->hmac) silc_free(di->name); silc_free(di->hash); silc_free(di); } - SILC_SERVER_CONFIG_LIST_DESTROY(SilcServerConfigSectionPkcs, config->pkcs) + SILC_SERVER_CONFIG_LIST_DESTROY(SilcServerConfigPkcs, config->pkcs) silc_free(di->name); silc_free(di); } - SILC_SERVER_CONFIG_LIST_DESTROY(SilcServerConfigSectionClient, + SILC_SERVER_CONFIG_LIST_DESTROY(SilcServerConfigClient, config->clients) silc_free(di->host); - my_free_authdata(di->passphrase, di->publickey); + CONFIG_FREE_AUTH(di); silc_free(di); } - SILC_SERVER_CONFIG_LIST_DESTROY(SilcServerConfigSectionAdmin, config->admins) + SILC_SERVER_CONFIG_LIST_DESTROY(SilcServerConfigAdmin, config->admins) silc_free(di->host); silc_free(di->user); silc_free(di->nick); - my_free_authdata(di->passphrase, di->publickey); + CONFIG_FREE_AUTH(di); silc_free(di); } - SILC_SERVER_CONFIG_LIST_DESTROY(SilcServerConfigSectionDeny, config->denied) + SILC_SERVER_CONFIG_LIST_DESTROY(SilcServerConfigDeny, config->denied) silc_free(di->host); silc_free(di->reason); silc_free(di); } - SILC_SERVER_CONFIG_LIST_DESTROY(SilcServerConfigSectionServer, + SILC_SERVER_CONFIG_LIST_DESTROY(SilcServerConfigServer, config->servers) silc_free(di->host); silc_free(di->version); - my_free_authdata(di->passphrase, di->publickey); + CONFIG_FREE_AUTH(di); silc_free(di); } - SILC_SERVER_CONFIG_LIST_DESTROY(SilcServerConfigSectionRouter, + SILC_SERVER_CONFIG_LIST_DESTROY(SilcServerConfigRouter, config->routers) silc_free(di->host); silc_free(di->version); silc_free(di->backup_replace_ip); - my_free_authdata(di->passphrase, di->publickey); + CONFIG_FREE_AUTH(di); silc_free(di); } } @@ -1081,7 +1278,7 @@ void silc_server_config_destroy(SilcServerConfig config) bool silc_server_config_register_ciphers(SilcServer server) { SilcServerConfig config = server->config; - SilcServerConfigSectionCipher *cipher = config->cipher; + SilcServerConfigCipher *cipher = config->cipher; char *module_path = config->module_path; SILC_LOG_DEBUG(("Registering configured ciphers")); @@ -1133,9 +1330,11 @@ bool silc_server_config_register_ciphers(SilcServer server) SILC_CIPHER_SIM_SET_KEY)); SILC_LOG_DEBUG(("set_key=%p", cipher_obj.set_key)); cipher_obj.set_key_with_string = - silc_sim_getsym(sim, silc_sim_symname(alg_name, - SILC_CIPHER_SIM_SET_KEY_WITH_STRING)); - SILC_LOG_DEBUG(("set_key_with_string=%p", cipher_obj.set_key_with_string)); + silc_sim_getsym(sim, + silc_sim_symname(alg_name, + SILC_CIPHER_SIM_SET_KEY_WITH_STRING)); + SILC_LOG_DEBUG(("set_key_with_string=%p", + cipher_obj.set_key_with_string)); cipher_obj.encrypt = silc_sim_getsym(sim, silc_sim_symname(alg_name, SILC_CIPHER_SIM_ENCRYPT_CBC)); @@ -1180,7 +1379,7 @@ bool silc_server_config_register_ciphers(SilcServer server) bool silc_server_config_register_hashfuncs(SilcServer server) { SilcServerConfig config = server->config; - SilcServerConfigSectionHash *hash = config->hash; + SilcServerConfigHash *hash = config->hash; char *module_path = config->module_path; SILC_LOG_DEBUG(("Registering configured hash functions")); @@ -1265,7 +1464,7 @@ bool silc_server_config_register_hashfuncs(SilcServer server) bool silc_server_config_register_hmacs(SilcServer server) { SilcServerConfig config = server->config; - SilcServerConfigSectionHmac *hmac = config->hmac; + SilcServerConfigHmac *hmac = config->hmac; SILC_LOG_DEBUG(("Registering configured HMACs")); @@ -1296,7 +1495,7 @@ bool silc_server_config_register_hmacs(SilcServer server) bool silc_server_config_register_pkcs(SilcServer server) { SilcServerConfig config = server->config; - SilcServerConfigSectionPkcs *pkcs = config->pkcs; + SilcServerConfigPkcs *pkcs = config->pkcs; SILC_LOG_DEBUG(("Registering configured PKCS")); @@ -1326,7 +1525,7 @@ bool silc_server_config_register_pkcs(SilcServer server) void silc_server_config_setlogfiles(SilcServer server) { SilcServerConfig config = server->config; - SilcServerConfigSectionLogging *this; + SilcServerConfigLogging *this; SILC_LOG_DEBUG(("Setting configured log file names")); @@ -1347,26 +1546,18 @@ void silc_server_config_setlogfiles(SilcServer server) /* Returns client authentication information from configuration file by host (name or ip) */ -SilcServerConfigSectionClient * -silc_server_config_find_client(SilcServer server, char *host, int port) +SilcServerConfigClient * +silc_server_config_find_client(SilcServer server, char *host) { SilcServerConfig config = server->config; - SilcServerConfigSectionClient *client; + SilcServerConfigClient *client; - if (!config || !port) { - SILC_LOG_WARNING(("Bogus: config_find_client(config=0x%08x, " - "host=0x%08x \"%s\", port=%hu)", - (uint32) config, (uint32) host, host, port)); - return NULL; - } - if (!host) + if (!config || !host) return NULL; for (client = config->clients; client; client = client->next) { if (client->host && !silc_string_compare(client->host, host)) continue; - if (client->port && (client->port != port)) - continue; break; } @@ -1377,12 +1568,12 @@ silc_server_config_find_client(SilcServer server, char *host, int port) /* Returns admin connection configuration by host, username and/or nickname. */ -SilcServerConfigSectionAdmin * +SilcServerConfigAdmin * silc_server_config_find_admin(SilcServer server, char *host, char *user, char *nick) { SilcServerConfig config = server->config; - SilcServerConfigSectionAdmin *admin; + SilcServerConfigAdmin *admin; /* make sure we have a value for the matching parameters */ if (!host) @@ -1407,22 +1598,16 @@ silc_server_config_find_admin(SilcServer server, char *host, char *user, return admin; } -/* Returns the denied connection configuration entry by host and port. */ +/* Returns the denied connection configuration entry by host. */ -SilcServerConfigSectionDeny * -silc_server_config_find_denied(SilcServer server, char *host, uint16 port) +SilcServerConfigDeny * +silc_server_config_find_denied(SilcServer server, char *host) { SilcServerConfig config = server->config; - SilcServerConfigSectionDeny *deny; + SilcServerConfigDeny *deny; /* make sure we have a value for the matching parameters */ - if (!config || !port) { - SILC_LOG_WARNING(("Bogus: config_find_denied(config=0x%08x, " - "host=0x%08x \"%s\", port=%hu)", - (uint32) config, (uint32) host, host, port)); - return NULL; - } - if (!host) + if (!config || !host) return NULL; for (deny = config->denied; deny; deny = deny->next) { @@ -1438,11 +1623,11 @@ silc_server_config_find_denied(SilcServer server, char *host, uint16 port) /* Returns server connection info from server configuartion by host (name or ip). */ -SilcServerConfigSectionServer * +SilcServerConfigServer * silc_server_config_find_server_conn(SilcServer server, char *host) { SilcServerConfig config = server->config; - SilcServerConfigSectionServer *serv = NULL; + SilcServerConfigServer *serv = NULL; if (!host) return NULL; @@ -1462,11 +1647,11 @@ silc_server_config_find_server_conn(SilcServer server, char *host) /* Returns router connection info from server configuration by host (name or ip). */ -SilcServerConfigSectionRouter * +SilcServerConfigRouter * silc_server_config_find_router_conn(SilcServer server, char *host, int port) { SilcServerConfig config = server->config; - SilcServerConfigSectionRouter *serv = NULL; + SilcServerConfigRouter *serv = NULL; if (!host) return NULL; @@ -1491,7 +1676,7 @@ silc_server_config_find_router_conn(SilcServer server, char *host, int port) bool silc_server_config_is_primary_route(SilcServer server) { SilcServerConfig config = server->config; - SilcServerConfigSectionRouter *serv = NULL; + SilcServerConfigRouter *serv = NULL; int i; bool found = FALSE; @@ -1511,11 +1696,11 @@ bool silc_server_config_is_primary_route(SilcServer server) /* Returns our primary connection configuration or NULL if we do not have primary router configured. */ -SilcServerConfigSectionRouter * +SilcServerConfigRouter * silc_server_config_get_primary_router(SilcServer server) { SilcServerConfig config = server->config; - SilcServerConfigSectionRouter *serv = NULL; + SilcServerConfigRouter *serv = NULL; int i; serv = config->routers; @@ -1527,3 +1712,24 @@ silc_server_config_get_primary_router(SilcServer server) return NULL; } + +/* Set default values to stuff that was not configured. */ + +bool silc_server_config_set_defaults(SilcServer server) +{ + SilcServerConfig config = server->config; + + my_set_param_defaults(&config->param, NULL); + + config->channel_rekey_secs = (config->channel_rekey_secs ? + config->channel_rekey_secs : + SILC_SERVER_CHANNEL_REKEY); + config->key_exchange_timeout = (config->key_exchange_timeout ? + config->key_exchange_timeout : + SILC_SERVER_SKE_TIMEOUT); + config->conn_auth_timeout = (config->conn_auth_timeout ? + config->conn_auth_timeout : + SILC_SERVER_CONNAUTH_TIMEOUT); + + return TRUE; +}