Author: Johnny Mnemonic <johnny@themnemonic.org>
- Copyright (C) 1997 - 2002 Pekka Riikonen
+ Copyright (C) 1997 - 2002 Johnny Mnemonic
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
#include "serverincludes.h"
#include "server_internal.h"
-#define SILC_CONFIG_SERVER_AUTH_METH_PASSWD "passwd"
-#define SILC_CONFIG_SERVER_AUTH_METH_PUBKEY "pubkey"
-
#if 0
#define SERVER_CONFIG_DEBUG(fmt) SILC_LOG_DEBUG(fmt)
#else
/* append the tmp field to the specified list */
#define SILC_SERVER_CONFIG_LIST_APPENDTMP(__list__) \
- if (!__list__) \
+ if (!__list__) { \
__list__ = tmp; \
- else { \
+ } else { \
for (findtmp = __list__; findtmp->next; findtmp = findtmp->next); \
findtmp->next = tmp; \
}
__type__ *di = (__type__ *) tmp; \
tmp = (void *) di->next;
-/* free an authdata according to its auth method */
-static void my_free_authdata(SilcAuthMethod auth_meth, void *auth_data)
+/* 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)
{
- if (auth_meth == SILC_AUTH_PASSWORD) {
- silc_free(auth_data);
- } else if (auth_meth == SILC_AUTH_PUBLIC_KEY) {
- silc_pkcs_public_key_free((SilcPublicKey) auth_data);
+#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 */
- *auth_data = (void *) strdup(p);
- *auth_data_len = (uint32) strlen(p);
+ if (auth_data)
+ *auth_data = (void *) strdup(p);
+ if (auth_data_len)
+ *auth_data_len = (SilcUInt32) strlen(p);
} else if (auth_meth == SILC_AUTH_PUBLIC_KEY) {
/* p is a public key */
SilcPublicKey public_key;
"Could not load public key file!\n", line);
return FALSE;
}
- *auth_data = (void *) public_key;
- *auth_data_len = 0;
+ if (auth_data)
+ *auth_data = (void *) public_key;
+ if (auth_data_len)
+ *auth_data_len = 0;
} else {
- fprintf(stderr, "\nError while parsing config file at line %lu: Specify "
- "the AuthMethod before specifying the AuthData.\n", line);
+ fprintf(stderr, "\nError while parsing config file at line %lu: "
+ "Unknown authentication method.\n", line);
return FALSE;
}
return TRUE;
SILC_CONFIG_CALLBACK(fetch_generic)
{
SilcServerConfig config = (SilcServerConfig) context;
+ int got_errno = 0;
- if (!strcmp(name, "modulepath")) {
- if (config->module_path) return SILC_CONFIG_EDOUBLE;
- /* dup it only if non-empty, otherwise point it to NULL */
+ if (!strcmp(name, "module_path")) {
+ 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)", type, name, context));
+ 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 */
if (!tmp) /* empty sub-block? */
/* 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, "key_length"))
- tmp->key_length = *(uint32 *)val;
- else if (!strcmp(name, "block_length"))
- 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;
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)", type, name, context));
+ 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 */
if (!tmp) /* empty sub-block? */
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, "block_length"))
+ else if (!strcmp(name, "blocklength")) {
tmp->block_length = *(int *)val;
- else if (!strcmp(name, "digest_length"))
+ }
+ else if (!strcmp(name, "digestlength")) {
tmp->digest_length = *(int *)val;
+ }
else
return SILC_CONFIG_EINTERNAL;
return SILC_CONFIG_OK;
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)", type, name, context));
+ 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 */
if (!tmp) /* empty sub-block? */
/* 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, "mac_length"))
+ else if (!strcmp(name, "maclength")) {
tmp->mac_length = *(int *)val;
+ }
else
return SILC_CONFIG_EINTERNAL;
return SILC_CONFIG_OK;
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));
+ SERVER_CONFIG_DEBUG(("Received PKCS type=%d name=\"%s\" (val=%x)",
+ type, name, context));
if (type == SILC_CONFIG_ARG_BLOCK) {
/* check the temporary struct's fields */
if (!tmp) /* empty sub-block? */
/* 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
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")) {
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, "email")) {
- if (server_info->email) return SILC_CONFIG_EDOUBLE;
+ else if (!strcmp(name, "adminemail")) {
+ 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")) {
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")) {
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;
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;
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 CONNPARAM type=%d name=\"%s\" (val=%x)",
+ type, name, context));
- SERVER_CONFIG_DEBUG(("Received CLIENT 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;
- if (tmp->auth_meth && !tmp->auth_data) {
- fprintf(stderr, "\nError: line %lu: If you specify \"AuthMethod\" field "
- "then you must also specify the \"AuthData\" field.\n", line);
- got_errno = SILC_CONFIG_ESILENT;
+
+ if (!tmp->name) {
+ got_errno = SILC_CONFIG_EMISSFIELDS;
goto got_err;
}
- SILC_SERVER_CONFIG_LIST_APPENDTMP(config->clients);
+
+ /* Set defaults */
+ my_set_param_defaults(tmp, &config->param);
+
+ SILC_SERVER_CONFIG_LIST_APPENDTMP(config->conn_params);
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 = (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);
}
- /* get authentication method */
- else if (!strcmp(name, "authmethod")) {
- if (!strcmp((char *) val, SILC_CONFIG_SERVER_AUTH_METH_PASSWD))
- tmp->auth_meth = SILC_AUTH_PASSWORD;
- else if (!strcmp((char *) val, SILC_CONFIG_SERVER_AUTH_METH_PUBKEY))
- tmp->auth_meth = SILC_AUTH_PUBLIC_KEY;
- else {
- got_errno = SILC_CONFIG_EINVALIDTEXT; goto got_err;
+ else if (!strcmp(name, "passphrase")) {
+ if (!my_parse_authdata(SILC_AUTH_PASSWORD, (char *) val, line,
+ (void **)&tmp->passphrase,
+ &tmp->passphrase_len)) {
+ got_errno = SILC_CONFIG_ESILENT;
+ goto got_err;
}
}
- else if (!strcmp(name, "authdata")) {
- if (!my_parse_authdata(tmp->auth_meth, (char *) val, line,
- &tmp->auth_data, &tmp->auth_data_len)) {
+ else if (!strcmp(name, "publickey")) {
+ if (!my_parse_authdata(SILC_AUTH_PUBLIC_KEY, (char *) val, line,
+ &tmp->publickey, NULL)) {
got_errno = SILC_CONFIG_ESILENT;
- goto got_err; /* error outputted in my_parse_authdata */
+ 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;
got_err:
silc_free(tmp->host);
- my_free_authdata(tmp->auth_meth, tmp->auth_data);
+ 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)",
+ type, name, context));
- SERVER_CONFIG_DEBUG(("Received CLIENT type=%d name=\"%s\" (val=%x)", type, name, context));
if (type == SILC_CONFIG_ARG_BLOCK) {
/* check the temporary struct's fields */
if (!tmp) /* empty sub-block? */
return SILC_CONFIG_OK;
- if (!tmp->auth_meth) {
- got_errno = SILC_CONFIG_EMISSFIELDS; goto got_err;
- }
+
SILC_SERVER_CONFIG_LIST_APPENDTMP(config->admins);
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 = (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);
}
- /* get authentication method */
- else if (!strcmp(name, "authmethod")) {
- if (!strcmp((char *) val, SILC_CONFIG_SERVER_AUTH_METH_PASSWD))
- tmp->auth_meth = SILC_AUTH_PASSWORD;
- else if (!strcmp((char *) val, SILC_CONFIG_SERVER_AUTH_METH_PUBKEY))
- tmp->auth_meth = SILC_AUTH_PUBLIC_KEY;
- else {
- got_errno = SILC_CONFIG_EINVALIDTEXT; goto got_err;
+ else if (!strcmp(name, "passphrase")) {
+ if (!my_parse_authdata(SILC_AUTH_PASSWORD, (char *) val, line,
+ (void **)&tmp->passphrase,
+ &tmp->passphrase_len)) {
+ got_errno = SILC_CONFIG_ESILENT;
+ goto got_err;
}
}
- else if (!strcmp(name, "authdata")) {
- if (!my_parse_authdata(tmp->auth_meth, (char *) val, line,
- &tmp->auth_data, &tmp->auth_data_len)) {
+ else if (!strcmp(name, "publickey")) {
+ if (!my_parse_authdata(SILC_AUTH_PUBLIC_KEY, (char *) val, line,
+ &tmp->publickey, NULL)) {
got_errno = SILC_CONFIG_ESILENT;
- goto got_err; /* error outputted in my_parse_authdata */
+ goto got_err;
}
}
else
silc_free(tmp->host);
silc_free(tmp->user);
silc_free(tmp->nick);
- my_free_authdata(tmp->auth_meth, tmp->auth_data);
+ 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)", type, name, context));
+ 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 */
if (!tmp) /* empty sub-block? */
/* 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
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)",
+ type, name, context));
- SERVER_CONFIG_DEBUG(("Received SERVER type=%d name=\"%s\" (val=%x)", type, name, context));
if (type == SILC_CONFIG_ARG_BLOCK) {
/* check the temporary struct's fields */
if (!tmp) /* empty sub-block? */
return SILC_CONFIG_OK;
- if (!tmp->auth_meth || !tmp->version) {
- got_errno = SILC_CONFIG_EMISSFIELDS;
- goto got_err;
- }
+
/* the temporary struct is ok, append it to the list */
SILC_SERVER_CONFIG_LIST_APPENDTMP(config->servers);
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 = (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("*"));
}
- /* get authentication method */
- else if (!strcmp(name, "authmethod")) {
- if (!strcmp((char *) val, SILC_CONFIG_SERVER_AUTH_METH_PASSWD))
- tmp->auth_meth = SILC_AUTH_PASSWORD;
- else if (!strcmp((char *) val, SILC_CONFIG_SERVER_AUTH_METH_PUBKEY))
- tmp->auth_meth = SILC_AUTH_PUBLIC_KEY;
- else {
- got_errno = SILC_CONFIG_EINVALIDTEXT; goto got_err;
- }
- }
- else if (!strcmp(name, "authdata")) {
- if (!my_parse_authdata(tmp->auth_meth, (char *) val, line,
- &tmp->auth_data, &tmp->auth_data_len)) {
+ else if (!strcmp(name, "passphrase")) {
+ if (!my_parse_authdata(SILC_AUTH_PASSWORD, (char *) val, line,
+ (void **)&tmp->passphrase,
+ &tmp->passphrase_len)) {
got_errno = SILC_CONFIG_ESILENT;
- goto got_err; /* error outputted in my_parse_authdata */
+ 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, "publickey")) {
+ if (!my_parse_authdata(SILC_AUTH_PUBLIC_KEY, (char *) val, line,
+ &tmp->publickey, NULL)) {
+ got_errno = SILC_CONFIG_ESILENT;
+ goto got_err;
}
- tmp->port = (uint16) port;
}
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;
}
else
return SILC_CONFIG_EINTERNAL;
+
return SILC_CONFIG_OK;
got_err:
silc_free(tmp->host);
silc_free(tmp->version);
- my_free_authdata(tmp->auth_meth, tmp->auth_data);
+ 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)",
+ type, name, context));
- SERVER_CONFIG_DEBUG(("Received ROUTER type=%d name=\"%s\" (val=%x)", type, name, context));
if (type == SILC_CONFIG_ARG_BLOCK) {
if (!tmp) /* empty sub-block? */
return SILC_CONFIG_OK;
- if (!tmp->auth_meth || !tmp->version) {
- got_errno = SILC_CONFIG_EMISSFIELDS;
- goto got_err;
- }
+
/* the temporary struct is ok, append it to the list */
SILC_SERVER_CONFIG_LIST_APPENDTMP(config->routers);
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 = (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, "authmethod")) {
- if (!strcmp((char *) val, SILC_CONFIG_SERVER_AUTH_METH_PASSWD))
- tmp->auth_meth = SILC_AUTH_PASSWORD;
- else if (!strcmp((char *) val, SILC_CONFIG_SERVER_AUTH_METH_PUBKEY))
- tmp->auth_meth = SILC_AUTH_PUBLIC_KEY;
- else {
- got_errno = SILC_CONFIG_EINVALIDTEXT; goto got_err;
+ else if (!strcmp(name, "port")) {
+ int port = *(int *)val;
+ if ((port <= 0) || (port > 65535)) {
+ fprintf(stderr, "Invalid port number!\n");
+ return SILC_CONFIG_ESILENT;
}
+ tmp->port = (SilcUInt16) port;
}
- else if (!strcmp(name, "authdata")) {
- if (!my_parse_authdata(tmp->auth_meth, (char *) val, line,
- &tmp->auth_data, &tmp->auth_data_len)) {
+ else if (!strcmp(name, "passphrase")) {
+ if (!my_parse_authdata(SILC_AUTH_PASSWORD, (char *) val, line,
+ (void **)&tmp->passphrase,
+ &tmp->passphrase_len)) {
got_errno = SILC_CONFIG_ESILENT;
- goto got_err; /* error outputted in my_parse_authdata */
+ 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, "publickey")) {
+ if (!my_parse_authdata(SILC_AUTH_PUBLIC_KEY, (char *) val, line,
+ &tmp->publickey, NULL)) {
+ got_errno = SILC_CONFIG_ESILENT;
+ goto got_err;
}
- tmp->port = (uint16) port;
}
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;
+
return SILC_CONFIG_OK;
got_err:
silc_free(tmp->host);
silc_free(tmp->version);
silc_free(tmp->backup_replace_ip);
- my_free_authdata(tmp->auth_meth, tmp->auth_data);
+ CONFIG_FREE_AUTH(tmp);
silc_free(tmp);
+ config->tmp = NULL;
return got_errno;
}
/* known config options tables */
static const SilcConfigTable table_general[] = {
- { "modulepath", 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 }
};
static const SilcConfigTable table_cipher[] = {
{ "name", SILC_CONFIG_ARG_STR, fetch_cipher, NULL },
{ "module", SILC_CONFIG_ARG_STRE, fetch_cipher, NULL },
- { "key_length", SILC_CONFIG_ARG_INT, fetch_cipher, NULL },
- { "block_length", SILC_CONFIG_ARG_INT, fetch_cipher, NULL },
+ { "keylength", SILC_CONFIG_ARG_INT, fetch_cipher, NULL },
+ { "blocklength", SILC_CONFIG_ARG_INT, fetch_cipher, NULL },
{ 0, 0, 0, 0 }
};
static const SilcConfigTable table_hash[] = {
{ "name", SILC_CONFIG_ARG_STR, fetch_hash, NULL },
{ "module", SILC_CONFIG_ARG_STRE, fetch_hash, NULL },
- { "block_length", SILC_CONFIG_ARG_INT, fetch_hash, NULL },
- { "digest_length", SILC_CONFIG_ARG_INT, fetch_hash, NULL },
+ { "blocklength", SILC_CONFIG_ARG_INT, fetch_hash, NULL },
+ { "digestlength", SILC_CONFIG_ARG_INT, fetch_hash, NULL },
{ 0, 0, 0, 0 }
};
static const SilcConfigTable table_hmac[] = {
{ "name", SILC_CONFIG_ARG_STR, fetch_hmac, NULL },
{ "hash", SILC_CONFIG_ARG_STR, fetch_hmac, NULL },
- { "mac_length", SILC_CONFIG_ARG_INT, fetch_hmac, NULL },
+ { "maclength", SILC_CONFIG_ARG_INT, fetch_hmac, NULL },
{ 0, 0, 0, 0 }
};
{ "servertype", SILC_CONFIG_ARG_STR, fetch_serverinfo, NULL},
{ "location", SILC_CONFIG_ARG_STR, fetch_serverinfo, NULL},
{ "admin", SILC_CONFIG_ARG_STR, fetch_serverinfo, NULL},
- { "email", SILC_CONFIG_ARG_STR, fetch_serverinfo, NULL},
+ { "adminemail", SILC_CONFIG_ARG_STR, fetch_serverinfo, NULL},
{ "user", SILC_CONFIG_ARG_STR, fetch_serverinfo, NULL},
{ "group", SILC_CONFIG_ARG_STR, fetch_serverinfo, NULL},
{ "publickey", SILC_CONFIG_ARG_STR, fetch_serverinfo, NULL},
{ 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 },
- { "authmethod", SILC_CONFIG_ARG_STR, fetch_client, NULL },
- { "authdata", SILC_CONFIG_ARG_STR, fetch_client, NULL },
- { "port", SILC_CONFIG_ARG_INT, fetch_client, NULL },
- { "class", SILC_CONFIG_ARG_STR, fetch_client, NULL },
+ { "passphrase", SILC_CONFIG_ARG_STR, fetch_client, NULL },
+ { "publickey", SILC_CONFIG_ARG_STR, fetch_client, NULL },
+ { "params", SILC_CONFIG_ARG_STR, fetch_client, NULL },
{ 0, 0, 0, 0 }
};
{ "host", SILC_CONFIG_ARG_STRE, fetch_admin, NULL },
{ "user", SILC_CONFIG_ARG_STRE, fetch_admin, NULL },
{ "nick", SILC_CONFIG_ARG_STRE, fetch_admin, NULL },
- { "authmethod", SILC_CONFIG_ARG_STR, fetch_admin, NULL },
- { "authdata", SILC_CONFIG_ARG_STR, fetch_admin, NULL },
+ { "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 }
};
static const SilcConfigTable table_serverconn[] = {
{ "host", SILC_CONFIG_ARG_STRE, fetch_server, NULL },
- { "authmethod", SILC_CONFIG_ARG_STR, fetch_server, NULL },
- { "authdata", SILC_CONFIG_ARG_STR, fetch_server, NULL },
- { "port", SILC_CONFIG_ARG_INT, fetch_server, NULL },
+ { "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 }
};
static const SilcConfigTable table_routerconn[] = {
{ "host", SILC_CONFIG_ARG_STRE, fetch_router, NULL },
- { "authmethod", SILC_CONFIG_ARG_STR, fetch_router, NULL },
- { "authdata", SILC_CONFIG_ARG_STR, fetch_router, NULL },
{ "port", SILC_CONFIG_ARG_INT, fetch_router, NULL },
+ { "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 }
};
/* 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);
/* 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);
/* 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->auth_meth, di->auth_data);
+ 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->auth_meth, di->auth_data);
+ 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->auth_meth, di->auth_data);
+ 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->auth_meth, di->auth_data);
+ CONFIG_FREE_AUTH(di);
silc_free(di);
}
}
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"));
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));
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"));
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"));
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"));
/* Sets log files where log messages are saved by the server logger. */
-void silc_server_config_setlogfiles(SilcServerConfig config,
- SilcSchedule sked)
+void silc_server_config_setlogfiles(SilcServer server)
{
- SilcServerConfigSectionLogging *this;
+ SilcServerConfig config = server->config;
+ SilcServerConfigLogging *this;
SILC_LOG_DEBUG(("Setting configured log file names"));
if ((this = config->logging_info))
- silc_log_set_file(SILC_LOG_INFO, this->file, this->maxsize, sked);
+ silc_log_set_file(SILC_LOG_INFO, this->file, this->maxsize,
+ server->schedule);
if ((this = config->logging_warnings))
- silc_log_set_file(SILC_LOG_WARNING, this->file, this->maxsize, sked);
+ silc_log_set_file(SILC_LOG_WARNING, this->file, this->maxsize,
+ server->schedule);
if ((this = config->logging_errors))
- silc_log_set_file(SILC_LOG_ERROR, this->file, this->maxsize, sked);
+ silc_log_set_file(SILC_LOG_ERROR, this->file, this->maxsize,
+ server->schedule);
if ((this = config->logging_fatals))
- silc_log_set_file(SILC_LOG_FATAL, this->file, this->maxsize, sked);
+ silc_log_set_file(SILC_LOG_FATAL, this->file, this->maxsize,
+ server->schedule);
}
/* Returns client authentication information from configuration file by host
(name or ip) */
-SilcServerConfigSectionClient *
-silc_server_config_find_client(SilcServerConfig config, char *host, int port)
+SilcServerConfigClient *
+silc_server_config_find_client(SilcServer server, char *host)
{
- SilcServerConfigSectionClient *client;
+ SilcServerConfig config = server->config;
+ 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;
}
+
/* if none matched, then client is already NULL */
return client;
}
/* Returns admin connection configuration by host, username and/or
nickname. */
-SilcServerConfigSectionAdmin *
-silc_server_config_find_admin(SilcServerConfig config,
- char *host, char *user, char *nick)
+SilcServerConfigAdmin *
+silc_server_config_find_admin(SilcServer server, char *host, char *user,
+ char *nick)
{
- SilcServerConfigSectionAdmin *admin;
+ SilcServerConfig config = server->config;
+ SilcServerConfigAdmin *admin;
/* make sure we have a value for the matching parameters */
if (!host)
/* no checks failed -> this entry matches */
break;
}
+
/* if none matched, then admin is already NULL */
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(SilcServerConfig config,
- char *host, uint16 port)
+SilcServerConfigDeny *
+silc_server_config_find_denied(SilcServer server, char *host)
{
- SilcServerConfigSectionDeny *deny;
+ SilcServerConfig config = server->config;
+ 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) {
continue;
break;
}
+
/* if none matched, then deny is already NULL */
return deny;
}
/* Returns server connection info from server configuartion by host
- (name or ip). If `port' is non-null then both name or IP and the port
- must match. */
+ (name or ip). */
-SilcServerConfigSectionServer *
-silc_server_config_find_server_conn(SilcServerConfig config,
- char *host, int port)
+SilcServerConfigServer *
+silc_server_config_find_server_conn(SilcServer server, char *host)
{
- int i;
- SilcServerConfigSectionServer *serv = NULL;
- bool match = FALSE;
+ SilcServerConfig config = server->config;
+ SilcServerConfigServer *serv = NULL;
if (!host)
return NULL;
if (!config->servers)
return NULL;
- serv = config->servers;
- for (i = 0; serv; i++) {
- if (silc_string_compare(serv->host, host))
- match = TRUE;
-
- if (port && serv->port && serv->port != port)
- match = FALSE;
-
- if (match)
- break;
-
- serv = serv->next;
+ for (serv = config->servers; serv; serv = serv->next) {
+ if (!silc_string_compare(serv->host, host))
+ continue;
+ break;
}
- if (!serv)
- return NULL;
-
return serv;
}
/* Returns router connection info from server configuration by
host (name or ip). */
-SilcServerConfigSectionRouter *
-silc_server_config_find_router_conn(SilcServerConfig config,
- char *host, int port)
+SilcServerConfigRouter *
+silc_server_config_find_router_conn(SilcServer server, char *host, int port)
{
- int i;
- SilcServerConfigSectionRouter *serv = NULL;
- bool match = FALSE;
+ SilcServerConfig config = server->config;
+ SilcServerConfigRouter *serv = NULL;
if (!host)
return NULL;
if (!config->routers)
return NULL;
- serv = config->routers;
- for (i = 0; serv; i++) {
- if (silc_string_compare(serv->host, host))
- match = TRUE;
-
+ for (serv = config->routers; serv; serv = serv->next) {
+ if (!silc_string_compare(serv->host, host))
+ continue;
if (port && serv->port && serv->port != port)
- match = FALSE;
-
- if (match)
- break;
-
- serv = serv->next;
+ continue;
+ break;
}
- if (!serv)
- return NULL;
-
return serv;
}
/* Returns TRUE if configuration for a router connection that we are
initiating exists. */
-bool silc_server_config_is_primary_route(SilcServerConfig config)
+bool silc_server_config_is_primary_route(SilcServer server)
{
+ SilcServerConfig config = server->config;
+ SilcServerConfigRouter *serv = NULL;
int i;
- SilcServerConfigSectionRouter *serv = NULL;
bool found = FALSE;
serv = config->routers;
/* Returns our primary connection configuration or NULL if we do not
have primary router configured. */
-SilcServerConfigSectionRouter *
-silc_server_config_get_primary_router(SilcServerConfig config)
+SilcServerConfigRouter *
+silc_server_config_get_primary_router(SilcServer server)
{
+ SilcServerConfig config = server->config;
+ SilcServerConfigRouter *serv = NULL;
int i;
- SilcServerConfigSectionRouter *serv = NULL;
serv = config->routers;
for (i = 0; serv; i++) {
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;
+}
projects / silc.git / blobdiff