Author: Johnny Mnemonic <johnny@themnemonic.org>
- Copyright (C) 1997 - 2002 Johnny Mnemonic
+ Copyright (C) 1997 - 2002 Pekka Riikonen
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
__type__ *findtmp, *tmp = (__type__ *) config->tmp; \
int got_errno = 0
+/* allocate the tmp field for fetching data */
+#define SILC_SERVER_CONFIG_ALLOCTMP(__type__) \
+ if (!tmp) { \
+ config->tmp = silc_calloc(1, sizeof(*findtmp)); \
+ tmp = (__type__ *) config->tmp; \
+ }
+
/* append the tmp field to the specified list */
#define SILC_SERVER_CONFIG_LIST_APPENDTMP(__list__) \
if (!__list__) { \
tmp = (void *) di->next;
/* Set EDOUBLE error value and bail out if necessary */
-#define CONFIG_IS_DOUBLE(x) \
- if ((x)) { \
- got_errno = SILC_CONFIG_EDOUBLE; \
- goto got_err; \
- }
+#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); \
+ if (__section__->publickeys) \
+ silc_hash_table_free(__section__->publickeys);
+
+static void my_free_public_key(void *key, void *context, void *user_data)
+{
+ silc_pkcs_public_key_free(context);
+}
+
+/* Set default values to those parameters that have not been defined */
+static void
+my_set_param_defaults(SilcServerConfigConnParams *params,
+ SilcServerConfigConnParams *defaults)
+{
+#define SET_PARAM_DEFAULT(p, d) params->p = \
+ (params->p ? params->p : (defaults && defaults->p ? defaults->p : d))
+
+ SET_PARAM_DEFAULT(connections_max, SILC_SERVER_MAX_CONNECTIONS);
+ SET_PARAM_DEFAULT(connections_max_per_host,
+ SILC_SERVER_MAX_CONNECTIONS_SINGLE);
+ SET_PARAM_DEFAULT(keepalive_secs, SILC_SERVER_KEEPALIVE);
+ SET_PARAM_DEFAULT(reconnect_count, SILC_SERVER_RETRY_COUNT);
+ SET_PARAM_DEFAULT(reconnect_interval, SILC_SERVER_RETRY_INTERVAL_MIN);
+ SET_PARAM_DEFAULT(reconnect_interval_max, SILC_SERVER_RETRY_INTERVAL_MAX);
+ SET_PARAM_DEFAULT(key_exchange_rekey, SILC_SERVER_REKEY);
+
+#undef SET_PARAM_DEFAULT
+}
/* Find connection parameters by the parameter block name. */
-static SilcServerConfigSectionConnectionParam *
+static SilcServerConfigConnParams *
my_find_param(SilcServerConfig config, const char *name)
{
- SilcServerConfigSectionConnectionParam *param;
-
- if (!name)
- return NULL;
+ SilcServerConfigConnParams *param;
for (param = config->conn_params; param; param = param->next) {
if (!strcasecmp(param->name, name))
return param;
}
- return NULL;
-}
+ SILC_SERVER_LOG_ERROR(("Error while parsing config file: "
+ "Cannot find Params \"%s\".\n", name));
-/* free an authdata according to its auth method */
-static void my_free_authdata(char *passphrase, void *public_key)
-{
- silc_free(passphrase);
- if (public_key)
- silc_pkcs_public_key_free((SilcPublicKey) public_key);
+ 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);
+ if (auth_data && auth_data_len) {
+ if (!silc_utf8_valid(p, strlen(p))) {
+ *auth_data_len = silc_utf8_encoded_len(p, strlen(p), 0);
+ *auth_data = silc_calloc(*auth_data_len, sizeof(unsigned char));
+ silc_utf8_encode(p, strlen(p), SILC_STRING_ASCII, *auth_data,
+ *auth_data_len);
+ } else {
+ *auth_data = (void *) strdup(p);
+ *auth_data_len = (SilcUInt32) strlen(p);
+ }
+ }
} else if (auth_meth == SILC_AUTH_PUBLIC_KEY) {
- /* p is a public key */
+ /* p is a public key file name */
SilcPublicKey public_key;
if (!silc_pkcs_load_public_key(p, &public_key, SILC_PKCS_FILE_PEM))
if (!silc_pkcs_load_public_key(p, &public_key, SILC_PKCS_FILE_BIN)) {
- fprintf(stderr, "\nError while parsing config file at line %lu: "
- "Could not load public key file!\n", line);
+ SILC_SERVER_LOG_ERROR(("\nError while parsing config file at line "
+ "%lu: Could not load public key file!\n",
+ line));
return FALSE;
}
- if (auth_data)
- *auth_data = (void *) public_key;
- if (auth_data_len)
- *auth_data_len = 0;
+
+ /* The auth_data is a pointer to the hash table of public keys. */
+ if (auth_data) {
+ if (*auth_data == NULL)
+ *auth_data = silc_hash_table_alloc(1, silc_hash_public_key, NULL,
+ NULL, NULL,
+ my_free_public_key, NULL,
+ TRUE);
+ silc_hash_table_add(*auth_data, public_key, public_key);
+ }
} else {
- fprintf(stderr, "\nError while parsing config file at line %lu: "
- "Unkonwn authentication method\n", line);
+ SILC_SERVER_LOG_ERROR(("\nError while parsing config file at line %lu: "
+ "Unknown authentication method.\n", line));
return FALSE;
}
return TRUE;
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 = *(uint32 *)val;
+ config->param.keepalive_secs = (SilcUInt32) *(int *)val;
}
else if (!strcmp(name, "reconnect_count")) {
- config->param.reconnect_count = *(uint32 *)val;
+ config->param.reconnect_count = (SilcUInt32) *(int *)val;
}
else if (!strcmp(name, "reconnect_interval")) {
- config->param.reconnect_interval = *(uint32 *)val;
+ config->param.reconnect_interval = (SilcUInt32) *(int *)val;
}
else if (!strcmp(name, "reconnect_interval_max")) {
- config->param.reconnect_interval_max = *(uint32 *)val;
+ 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 if (!strcmp(name, "version_protocol")) {
+ CONFIG_IS_DOUBLE(config->param.version_protocol);
+ config->param.version_protocol =
+ (*(char *)val ? strdup((char *) val) : NULL);
+ }
+ else if (!strcmp(name, "version_software")) {
+ CONFIG_IS_DOUBLE(config->param.version_software);
+ config->param.version_software =
+ (*(char *)val ? strdup((char *) val) : NULL);
+ }
+ else if (!strcmp(name, "version_software_vendor")) {
+ CONFIG_IS_DOUBLE(config->param.version_software_vendor);;
+ config->param.version_software_vendor =
+ (*(char *)val ? strdup((char *) val) : NULL);
+ }
+ else if (!strcmp(name, "detach_disabled")) {
+ config->detach_disabled = *(bool *)val;
+ }
+ else if (!strcmp(name, "detach_timeout")) {
+ config->detach_timeout = (SilcUInt32) *(int *)val;
+ }
else
return SILC_CONFIG_EINTERNAL;
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 */
- if (!tmp) /* empty sub-block? */
+ if (!tmp) /* discard empty sub-blocks */
return SILC_CONFIG_OK;
if (!tmp->name) {
got_errno = SILC_CONFIG_EMISSFIELDS;
goto got_err;
}
- /* the temporary struct is ok, append it to the list */
+
SILC_SERVER_CONFIG_LIST_APPENDTMP(config->cipher);
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 = (SilcServerConfigSectionCipher *) config->tmp;
- }
+ SILC_SERVER_CONFIG_ALLOCTMP(SilcServerConfigCipher);
/* Identify and save this value */
if (!strcmp(name, "name")) {
tmp->module = (*(char *)val ? strdup((char *) val) : NULL);
}
else if (!strcmp(name, "keylength")) {
- tmp->key_length = *(uint32 *)val;
+ tmp->key_length = *(SilcUInt32 *)val;
}
else if (!strcmp(name, "blocklength")) {
- tmp->block_length = *(uint32 *)val;
+ tmp->block_length = *(SilcUInt32 *)val;
}
else
return SILC_CONFIG_EINTERNAL;
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 */
- if (!tmp) /* empty sub-block? */
+ if (!tmp) /* discard empty sub-blocks */
return SILC_CONFIG_OK;
if (!tmp->name || (tmp->block_length == 0) || (tmp->digest_length == 0)) {
got_errno = SILC_CONFIG_EMISSFIELDS;
goto got_err;
}
- /* the temporary struct in tmp is ok */
+
SILC_SERVER_CONFIG_LIST_APPENDTMP(config->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;
- }
+ SILC_SERVER_CONFIG_ALLOCTMP(SilcServerConfigHash);
/* Identify and save this value */
if (!strcmp(name, "name")) {
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 */
- if (!tmp) /* empty sub-block? */
+ if (!tmp) /* discard empty sub-blocks */
return SILC_CONFIG_OK;
if (!tmp->name || !tmp->hash || (tmp->mac_length == 0)) {
got_errno = SILC_CONFIG_EMISSFIELDS;
goto got_err;
}
- /* the temporary struct is ok, append it to the list */
+
SILC_SERVER_CONFIG_LIST_APPENDTMP(config->hmac);
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 = (SilcServerConfigSectionHmac *) config->tmp;
- }
+ SILC_SERVER_CONFIG_ALLOCTMP(SilcServerConfigHmac);
/* Identify and save this value */
if (!strcmp(name, "name")) {
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)",
+ 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 (!tmp) /* discard empty sub-blocks */
return SILC_CONFIG_OK;
if (!tmp->name) {
got_errno = SILC_CONFIG_EMISSFIELDS;
goto got_err;
}
- /* the temporary struct is ok, append it to the list */
+
SILC_SERVER_CONFIG_LIST_APPENDTMP(config->pkcs);
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 = (SilcServerConfigSectionPkcs *) config->tmp;
- }
+ SILC_SERVER_CONFIG_ALLOCTMP(SilcServerConfigPkcs);
/* Identify and save this value */
if (!strcmp(name, "name")) {
SILC_CONFIG_CALLBACK(fetch_serverinfo)
{
- SilcServerConfig config = (SilcServerConfig) context;
- SilcServerConfigSectionServerInfo *server_info = config->server_info;
- int got_errno = 0;
+ SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigServerInfoInterface);
+ SilcServerConfigServerInfo *server_info = config->server_info;
/* if there isn't the struct alloc it */
if (!server_info)
- config->server_info = server_info = (SilcServerConfigSectionServerInfo *)
+ config->server_info = server_info = (SilcServerConfigServerInfo *)
silc_calloc(1, sizeof(*server_info));
if (type == SILC_CONFIG_ARG_BLOCK) {
- /* check for mandatory inputs */
+ if (!strcmp(name, "primary")) {
+ CONFIG_IS_DOUBLE(server_info->primary);
+ if (!tmp)
+ return SILC_CONFIG_OK;
+ server_info->primary = tmp;
+ config->tmp = NULL;
+ return SILC_CONFIG_OK;
+ } else if (!strcmp(name, "secondary")) {
+ if (!tmp)
+ return SILC_CONFIG_OK;
+ SILC_SERVER_CONFIG_LIST_APPENDTMP(server_info->secondary);
+ config->tmp = NULL;
+ return SILC_CONFIG_OK;
+ } else if (!server_info->public_key || !server_info->private_key) {
+ got_errno = SILC_CONFIG_EMISSFIELDS;
+ goto got_err;
+ }
return SILC_CONFIG_OK;
}
if (!strcmp(name, "hostname")) {
server_info->server_name = strdup((char *) val);
}
else if (!strcmp(name, "ip")) {
- CONFIG_IS_DOUBLE(server_info->server_ip);
- server_info->server_ip = strdup((char *) val);
+ SILC_SERVER_CONFIG_ALLOCTMP(SilcServerConfigServerInfoInterface);
+ CONFIG_IS_DOUBLE(tmp->server_ip);
+ tmp->server_ip = strdup((char *) val);
}
else if (!strcmp(name, "port")) {
int port = *(int *)val;
+ SILC_SERVER_CONFIG_ALLOCTMP(SilcServerConfigServerInfoInterface);
if ((port <= 0) || (port > 65535)) {
- fprintf(stderr, "Invalid port number!\n");
- return SILC_CONFIG_ESILENT;
+ SILC_SERVER_LOG_ERROR(("Error while parsing config file: "
+ "Invalid port number!\n"));
+ got_errno = SILC_CONFIG_EPRINTLINE;
+ goto got_err;
}
- server_info->port = (uint16) port;
+ tmp->port = (SilcUInt16) port;
}
else if (!strcmp(name, "servertype")) {
CONFIG_IS_DOUBLE(server_info->server_type);
server_info->pid_file = strdup((char *) val);
}
else if (!strcmp(name, "publickey")) {
- char *tmp = (char *) val;
+ char *file_tmp = (char *) val;
/* try to load specified file, if fail stop config parsing */
- if (!silc_pkcs_load_public_key(tmp, &server_info->public_key,
+ if (!silc_pkcs_load_public_key(file_tmp, &server_info->public_key,
SILC_PKCS_FILE_PEM))
- if (!silc_pkcs_load_public_key(tmp, &server_info->public_key,
+ if (!silc_pkcs_load_public_key(file_tmp, &server_info->public_key,
SILC_PKCS_FILE_BIN)) {
- fprintf(stderr, "\nError: Could not load public key file.");
- fprintf(stderr, "\n line %lu: file \"%s\"\n", line, tmp);
+ SILC_SERVER_LOG_ERROR(("Error: Could not load public key file.\n"));
+ SILC_SERVER_LOG_ERROR((" line %lu, file \"%s\"\n", line, file_tmp));
return SILC_CONFIG_ESILENT;
}
}
else if (!strcmp(name, "privatekey")) {
- char *tmp = (char *) val;
+ char *file_tmp = (char *) val;
/* try to load specified file, if fail stop config parsing */
- if (!silc_pkcs_load_private_key(tmp, &server_info->private_key,
+ if (!silc_pkcs_load_private_key(file_tmp, &server_info->private_key,
SILC_PKCS_FILE_BIN))
- if (!silc_pkcs_load_private_key(tmp, &server_info->private_key,
+ if (!silc_pkcs_load_private_key(file_tmp, &server_info->private_key,
SILC_PKCS_FILE_PEM)) {
- fprintf(stderr, "\nError: Could not load private key file.");
- fprintf(stderr, "\n line %lu: file \"%s\"\n", line, tmp);
+ SILC_SERVER_LOG_ERROR(("Error: Could not load private key file.\n"));
+ SILC_SERVER_LOG_ERROR((" line %lu, file \"%s\"\n", line, file_tmp));
return SILC_CONFIG_ESILENT;
}
}
return SILC_CONFIG_OK;
got_err:
+ silc_free(tmp);
+ silc_free(config->tmp);
+ config->tmp = NULL;
return got_errno;
}
SILC_CONFIG_CALLBACK(fetch_logging)
{
- SilcServerConfig config = (SilcServerConfig) context;
- SilcServerConfigSectionLogging *tmp =
- (SilcServerConfigSectionLogging *) config->tmp;
- int got_errno;
+ SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigLogging);
if (!strcmp(name, "quicklogs")) {
- silc_log_quick = *(bool *)val;
+ config->logging_quick = *(bool *)val;
}
else if (!strcmp(name, "flushdelay")) {
int flushdelay = *(int *)val;
if (flushdelay < 2) { /* this value was taken from silclog.h (min delay) */
- fprintf(stderr, "Error: line %lu: invalid flushdelay value, use "
- "quicklogs if you want real-time logging.\n", line);
- return SILC_CONFIG_ESILENT;
+ SILC_SERVER_LOG_ERROR(("Error while parsing config file: "
+ "Invalid flushdelay value, use quicklogs if you "
+ "want real-time logging.\n"));
+ return SILC_CONFIG_EPRINTLINE;
}
- silc_log_flushdelay = (long) flushdelay;
+ config->logging_flushdelay = (long) flushdelay;
}
+
+ /* The following istances happens only in Logging's sub-blocks, a match
+ for the sub-block name means that you should store the filename/maxsize
+ temporary struct to the proper logging channel.
+ If we get a match for "file" or "maxsize" this means that we are inside
+ a sub-sub-block and it is safe to alloc a new tmp. */
#define FETCH_LOGGING_CHAN(__chan__, __member__) \
else if (!strcmp(name, __chan__)) { \
if (!tmp) return SILC_CONFIG_OK; \
FETCH_LOGGING_CHAN("fatals", logging_fatals)
#undef FETCH_LOGGING_CHAN
else if (!strcmp(name, "file")) {
- if (!tmp) { /* FIXME: what the fuck is this? */
- config->tmp = silc_calloc(1, sizeof(*tmp));
- tmp = (SilcServerConfigSectionLogging *) config->tmp;
- }
- if (tmp->file) {
- got_errno = SILC_CONFIG_EMISSFIELDS; goto got_err;
- }
+ SILC_SERVER_CONFIG_ALLOCTMP(SilcServerConfigLogging);
+ CONFIG_IS_DOUBLE(tmp->file);
tmp->file = strdup((char *) val);
}
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;
SILC_CONFIG_CALLBACK(fetch_connparam)
{
- SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigSectionConnectionParam);
+ SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigConnParams);
- SERVER_CONFIG_DEBUG(("Received CONNPARAM 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)
+ /* check the temporary struct's fields */
+ if (!tmp) /* discard empty sub-blocks */
return SILC_CONFIG_OK;
+ 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;
}
-
- /* if there isn't a temporary struct alloc one */
- if (!tmp) {
- config->tmp = silc_calloc(1, sizeof(*findtmp));
- tmp = (SilcServerConfigSectionConnectionParam *) config->tmp;
- }
+ SILC_SERVER_CONFIG_ALLOCTMP(SilcServerConfigConnParams);
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 = *(uint32 *)val;
+ tmp->keepalive_secs = *(SilcUInt32 *)val;
}
else if (!strcmp(name, "reconnect_count")) {
- tmp->reconnect_count = *(uint32 *)val;
+ tmp->reconnect_count = *(SilcUInt32 *)val;
}
else if (!strcmp(name, "reconnect_interval")) {
- tmp->reconnect_interval = *(uint32 *)val;
+ tmp->reconnect_interval = *(SilcUInt32 *)val;
}
else if (!strcmp(name, "reconnect_interval_max")) {
- tmp->reconnect_interval_max = *(uint32 *)val;
+ 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 if (!strcmp(name, "version_protocol")) {
+ CONFIG_IS_DOUBLE(tmp->version_protocol);
+ tmp->version_protocol = (*(char *)val ? strdup((char *) val) : NULL);
+ }
+ else if (!strcmp(name, "version_software")) {
+ CONFIG_IS_DOUBLE(tmp->version_software);
+ tmp->version_software = (*(char *)val ? strdup((char *) val) : NULL);
+ }
+ else if (!strcmp(name, "version_software_vendor")) {
+ CONFIG_IS_DOUBLE(tmp->version_software_vendor);;
+ tmp->version_software_vendor =
+ (*(char *)val ? strdup((char *) val) : NULL);
+ }
else
return SILC_CONFIG_EINTERNAL;
SILC_CONFIG_CALLBACK(fetch_client)
{
- SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigSectionClient);
+ SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigClient);
- 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) {
- if (!tmp) /* empty sub-block? */
- return SILC_CONFIG_OK;
-
- /* Find connection parameter block */
- if (tmp->param_name) {
- tmp->param = my_find_param(config, tmp->param_name);
- if (!tmp->param) {
- fprintf(stderr, "Unknown ConnectionParam: %s\n", tmp->param_name);
- silc_free(tmp->param_name);
- got_errno = SILC_CONFIG_ESILENT;
- goto got_err;
- }
- silc_free(tmp->param_name);
- }
+ /* Alloc before block checking, because empty sub-blocks are welcome here */
+ SILC_SERVER_CONFIG_ALLOCTMP(SilcServerConfigClient);
+ if (type == SILC_CONFIG_ARG_BLOCK) {
+ /* empty sub-blocks are welcome */
SILC_SERVER_CONFIG_LIST_APPENDTMP(config->clients);
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;
- }
-
/* Identify and save this value */
if (!strcmp(name, "host")) {
CONFIG_IS_DOUBLE(tmp->host);
tmp->host = (*(char *)val ? strdup((char *) val) : NULL);
}
else if (!strcmp(name, "passphrase")) {
+ CONFIG_IS_DOUBLE(tmp->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;
}
else if (!strcmp(name, "publickey")) {
if (!my_parse_authdata(SILC_AUTH_PUBLIC_KEY, (char *) val, line,
- &tmp->publickey, NULL)) {
+ (void **)&tmp->publickeys, NULL)) {
got_errno = SILC_CONFIG_ESILENT;
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;
+ else if (!strcmp(name, "params")) {
+ CONFIG_IS_DOUBLE(tmp->param);
+ tmp->param = my_find_param(config, (char *) val);
+ if (!tmp->param) { /* error message already output */
+ got_errno = SILC_CONFIG_EPRINTLINE;
goto got_err;
}
- tmp->port = (uint16) port;
- }
- else if (!strcmp(name, "param")) {
- CONFIG_IS_DOUBLE(tmp->param_name);
- tmp->param_name = (*(char *)val ? strdup((char *) val) : NULL);
}
else
return SILC_CONFIG_EINTERNAL;
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) {
/* check the temporary struct's fields */
- if (!tmp) /* empty sub-block? */
+ if (!tmp) /* discard empty sub-blocks */
return SILC_CONFIG_OK;
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;
- }
+ SILC_SERVER_CONFIG_ALLOCTMP(SilcServerConfigAdmin);
/* Identify and save this value */
if (!strcmp(name, "host")) {
tmp->nick = (*(char *)val ? strdup((char *) val) : NULL);
}
else if (!strcmp(name, "passphrase")) {
+ CONFIG_IS_DOUBLE(tmp->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;
}
}
else if (!strcmp(name, "publickey")) {
+ CONFIG_IS_DOUBLE(tmp->publickeys);
if (!my_parse_authdata(SILC_AUTH_PUBLIC_KEY, (char *) val, line,
- &tmp->publickey, NULL)) {
+ (void **)&tmp->publickeys, NULL)) {
got_errno = SILC_CONFIG_ESILENT;
goto got_err;
}
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 */
- if (!tmp) /* empty sub-block? */
+ if (!tmp) /* discard empty sub-blocks */
return SILC_CONFIG_OK;
if (!tmp->reason) {
got_errno = SILC_CONFIG_EMISSFIELDS;
goto got_err;
}
+
SILC_SERVER_CONFIG_LIST_APPENDTMP(config->denied);
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 = (SilcServerConfigSectionDeny *) config->tmp;
- }
+ SILC_SERVER_CONFIG_ALLOCTMP(SilcServerConfigDeny);
/* Identify and save this value */
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")) {
CONFIG_IS_DOUBLE(tmp->reason);
tmp->reason = strdup((char *) val);
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) {
/* check the temporary struct's fields */
- if (!tmp) /* empty sub-block? */
+ if (!tmp) /* discard empty sub-blocks */
return SILC_CONFIG_OK;
- /* Find connection parameter block */
- if (tmp->param_name) {
- tmp->param = my_find_param(config, tmp->param_name);
- if (!tmp->param) {
- fprintf(stderr, "Unknown ConnectionParam: %s\n", tmp->param_name);
- silc_free(tmp->param_name);
- got_errno = SILC_CONFIG_ESILENT;
- goto got_err;
- }
- silc_free(tmp->param_name);
- }
-
/* 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;
- }
+ SILC_SERVER_CONFIG_ALLOCTMP(SilcServerConfigServer);
/* Identify and save this value */
if (!strcmp(name, "host")) {
tmp->host = (*(char *)val ? strdup((char *) val) : strdup("*"));
}
else if (!strcmp(name, "passphrase")) {
+ CONFIG_IS_DOUBLE(tmp->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;
}
}
else if (!strcmp(name, "publickey")) {
+ CONFIG_IS_DOUBLE(tmp->publickeys);
if (!my_parse_authdata(SILC_AUTH_PUBLIC_KEY, (char *) val, line,
- &tmp->publickey, NULL)) {
+ (void **)&tmp->publickeys, NULL)) {
got_errno = SILC_CONFIG_ESILENT;
goto got_err;
}
}
- else if (!strcmp(name, "versionid")) {
- CONFIG_IS_DOUBLE(tmp->version);
- tmp->version = strdup((char *) val);
- }
- else if (!strcmp(name, "param")) {
- CONFIG_IS_DOUBLE(tmp->param_name);
- tmp->param_name = (*(char *)val ? strdup((char *) val) : NULL);
+ else if (!strcmp(name, "params")) {
+ CONFIG_IS_DOUBLE(tmp->param);
+ tmp->param = my_find_param(config, (char *) val);
+ if (!tmp->param) { /* error message already output */
+ got_errno = SILC_CONFIG_EPRINTLINE;
+ goto got_err;
+ }
}
else if (!strcmp(name, "backup")) {
tmp->backup_router = *(bool *)val;
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) {
- if (!tmp) /* empty sub-block? */
+ if (!tmp) /* discard empty sub-blocks */
return SILC_CONFIG_OK;
- /* Find connection parameter block */
- if (tmp->param_name) {
- tmp->param = my_find_param(config, tmp->param_name);
- if (!tmp->param) {
- fprintf(stderr, "Unknown ConnectionParam: %s\n", tmp->param_name);
- silc_free(tmp->param_name);
- got_errno = SILC_CONFIG_ESILENT;
- goto got_err;
- }
- silc_free(tmp->param_name);
- }
-
- /* 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;
- }
+ SILC_SERVER_CONFIG_ALLOCTMP(SilcServerConfigRouter);
/* Identify and save this value */
if (!strcmp(name, "host")) {
else if (!strcmp(name, "port")) {
int port = *(int *)val;
if ((port <= 0) || (port > 65535)) {
- fprintf(stderr, "Invalid port number!\n");
- return SILC_CONFIG_ESILENT;
+ SILC_SERVER_LOG_ERROR(("Error while parsing config file: "
+ "Invalid port number!\n"));
+ got_errno = SILC_CONFIG_EPRINTLINE;
+ goto got_err;
}
- tmp->port = (uint16) port;
+ tmp->port = (SilcUInt16) port;
}
else if (!strcmp(name, "passphrase")) {
+ CONFIG_IS_DOUBLE(tmp->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;
}
}
else if (!strcmp(name, "publickey")) {
+ CONFIG_IS_DOUBLE(tmp->publickeys);
if (!my_parse_authdata(SILC_AUTH_PUBLIC_KEY, (char *) val, line,
- &tmp->publickey, NULL)) {
+ (void **)&tmp->publickeys, NULL)) {
got_errno = SILC_CONFIG_ESILENT;
goto got_err;
}
}
- else if (!strcmp(name, "versionid")) {
- CONFIG_IS_DOUBLE(tmp->version);
- tmp->version = strdup((char *) val);
- }
- else if (!strcmp(name, "param")) {
- CONFIG_IS_DOUBLE(tmp->param_name);
- tmp->param_name = (*(char *)val ? strdup((char *) val) : NULL);
+ else if (!strcmp(name, "params")) {
+ CONFIG_IS_DOUBLE(tmp->param);
+ tmp->param = my_find_param(config, (char *) val);
+ if (!tmp->param) { /* error message already output */
+ got_errno = SILC_CONFIG_EPRINTLINE;
+ goto got_err;
+ }
}
else if (!strcmp(name, "initiator")) {
tmp->initiator = *(bool *)val;
}
else if (!strcmp(name, "backuphost")) {
CONFIG_IS_DOUBLE(tmp->backup_replace_ip);
- tmp->backup_replace_ip = (*(char *)val ? strdup((char *) val) :
+ tmp->backup_replace_ip = (*(char *)val ? strdup((char *) val) :
strdup("*"));
+ tmp->backup_router = TRUE;
+ }
+ else if (!strcmp(name, "backupport")) {
+ int port = *(int *)val;
+ if ((port <= 0) || (port > 65535)) {
+ SILC_SERVER_LOG_ERROR(("Error while parsing config file: "
+ "Invalid port number!\n"));
+ got_errno = SILC_CONFIG_EPRINTLINE;
+ goto got_err;
+ }
+ tmp->backup_replace_port = (SilcUInt16) port;
+ }
+ else if (!strcmp(name, "backuplocal")) {
+ tmp->backup_local = *(bool *)val;
}
else
return SILC_CONFIG_EINTERNAL;
got_err:
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;
{ "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 },
+ { "version_protocol", SILC_CONFIG_ARG_STR, fetch_generic, NULL },
+ { "version_software", SILC_CONFIG_ARG_STR, fetch_generic, NULL },
+ { "version_software_vendor", SILC_CONFIG_ARG_STR, fetch_generic, NULL },
+ { "detach_disabled", SILC_CONFIG_ARG_TOGGLE, fetch_generic, NULL },
+ { "detach_timeout", SILC_CONFIG_ARG_INT, fetch_generic, NULL },
{ 0, 0, 0, 0 }
};
{ 0, 0, 0, 0 }
};
-static const SilcConfigTable table_serverinfo[] = {
- { "hostname", SILC_CONFIG_ARG_STR, fetch_serverinfo, NULL},
+static const SilcConfigTable table_serverinfo_c[] = {
{ "ip", SILC_CONFIG_ARG_STR, fetch_serverinfo, NULL},
{ "port", SILC_CONFIG_ARG_INT, fetch_serverinfo, NULL},
+ { 0, 0, 0, 0 }
+};
+
+static const SilcConfigTable table_serverinfo[] = {
+ { "hostname", SILC_CONFIG_ARG_STR, fetch_serverinfo, NULL},
+ { "primary", SILC_CONFIG_ARG_BLOCK, fetch_serverinfo, table_serverinfo_c},
+ { "secondary", SILC_CONFIG_ARG_BLOCK, fetch_serverinfo, table_serverinfo_c},
{ "servertype", SILC_CONFIG_ARG_STR, fetch_serverinfo, NULL},
{ "location", SILC_CONFIG_ARG_STR, fetch_serverinfo, NULL},
{ "admin", SILC_CONFIG_ARG_STR, fetch_serverinfo, 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 },
+ { "version_protocol", SILC_CONFIG_ARG_STR, fetch_connparam, NULL },
+ { "version_software", SILC_CONFIG_ARG_STR, fetch_connparam, NULL },
+ { "version_software_vendor", SILC_CONFIG_ARG_STR, fetch_connparam, NULL },
{ 0, 0, 0, 0 }
};
{ "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 },
- { "param", SILC_CONFIG_ARG_STR, fetch_client, NULL },
+ { "params", SILC_CONFIG_ARG_STR, fetch_client, NULL },
{ 0, 0, 0, 0 }
};
{ "passphrase", SILC_CONFIG_ARG_STR, fetch_admin, NULL },
{ "publickey", SILC_CONFIG_ARG_STR, fetch_admin, NULL },
{ "port", SILC_CONFIG_ARG_INT, fetch_admin, NULL },
- { "param", 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 }
};
{ "host", SILC_CONFIG_ARG_STRE, 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 },
- { "param", 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 }
};
{ "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 },
- { "param", 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 }
};
{ "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 },
- { "connectionparam", SILC_CONFIG_ARG_BLOCK, fetch_connparam, table_connparam },
+ { "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 },
{ 0, 0, 0, 0 }
};
+/* Set default values to stuff that was not configured. */
+
+static void silc_server_config_set_defaults(SilcServerConfig 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);
+}
+
/* Allocates a new configuration object, opens configuration file and
- * parses it. The parsed data is returned to the newly allocated
- * configuration object. */
+ parses it. The parsed data is returned to the newly allocated
+ configuration object. The SilcServerConfig must be freed by calling
+ the silc_server_config_destroy function. */
-SilcServerConfig silc_server_config_alloc(char *filename)
+SilcServerConfig silc_server_config_alloc(const char *filename)
{
- SilcServerConfig config;
+ SilcServerConfig config_new;
SilcConfigEntity ent;
SilcConfigFile *file;
int ret;
SILC_LOG_DEBUG(("Loading config data from `%s'", filename));
/* alloc a config object */
- config = (SilcServerConfig) silc_calloc(1, sizeof(*config));
+ config_new = silc_calloc(1, sizeof(*config_new));
+ config_new->refcount = 1;
+ if (!config_new)
+ return NULL;
+
/* obtain a config file object */
file = silc_config_open(filename);
if (!file) {
- fprintf(stderr, "\nError: can't open config file `%s'\n", filename);
+ SILC_SERVER_LOG_ERROR(("\nError: can't open config file `%s'\n",
+ filename));
return NULL;
}
+
/* obtain a SilcConfig entity, we can use it to start the parsing */
ent = silc_config_init(file);
+
/* load the known configuration options, give our empty object as context */
- silc_config_register_table(ent, table_main, (void *) config);
+ silc_config_register_table(ent, table_main, (void *) config_new);
+
/* 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);
- fprintf(stderr, "\nError while parsing config file: %s.\n",
- silc_config_strerror(ret));
+ SilcUInt32 line = silc_config_get_line(file);
+ if (ret != SILC_CONFIG_EPRINTLINE)
+ SILC_SERVER_LOG_ERROR(("Error while parsing config file: %s.\n",
+ silc_config_strerror(ret)));
linebuf = silc_config_read_line(file, line);
- fprintf(stderr, " file %s line %lu: %s\n\n", filename, line, linebuf);
+ SILC_SERVER_LOG_ERROR((" file %s line %lu: %s\n\n", filename,
+ line, linebuf));
silc_free(linebuf);
}
+ silc_server_config_destroy(config_new);
return NULL;
}
+
/* close (destroy) the file object */
silc_config_close(file);
- /* XXX FIXME: check for missing mandatory fields */
- if (!config->server_info) {
- fprintf(stderr, "\nError: Missing mandatory block `server_info'\n");
+ /* If config_new is incomplete, abort the object and return NULL */
+ if (!config_new->server_info) {
+ SILC_SERVER_LOG_ERROR(("\nError: Missing mandatory block "
+ "`server_info'\n"));
+ silc_server_config_destroy(config_new);
return NULL;
}
- return config;
+
+ /* XXX are there any other mandatory sections in the config file? */
+
+ /* Set default to configuration parameters */
+ silc_server_config_set_defaults(config_new);
+
+ return config_new;
+}
+
+/* Increments the reference counter of a config object */
+
+void silc_server_config_ref(SilcServerConfigRef *ref, SilcServerConfig config,
+ void *ref_ptr)
+{
+ if (ref_ptr) {
+ config->refcount++;
+ ref->config = config;
+ ref->ref_ptr = ref_ptr;
+ SILC_LOG_DEBUG(("Referencing config [%p] refcnt %d->%d", config,
+ config->refcount - 1, config->refcount));
+ }
+}
+
+/* Decrements the reference counter of a config object. If the counter
+ reaches 0, the config object is destroyed. */
+
+void silc_server_config_unref(SilcServerConfigRef *ref)
+{
+ if (ref->ref_ptr)
+ silc_server_config_destroy(ref->config);
}
-/* ... */
+/* Destroy a config object with all his children lists */
void silc_server_config_destroy(SilcServerConfig config)
{
void *tmp;
+
+ config->refcount--;
+ SILC_LOG_DEBUG(("Unreferencing config [%p] refcnt %d->%d", config,
+ config->refcount + 1, config->refcount));
+ if (config->refcount > 0)
+ return;
+
+ SILC_LOG_DEBUG(("Freeing config context"));
+
+ /* Destroy general config stuff */
silc_free(config->module_path);
+ silc_free(config->param.version_protocol);
+ silc_free(config->param.version_software);
+ silc_free(config->param.version_software_vendor);
/* Destroy Logging channels */
if (config->logging_info)
/* 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);
+ if (si->primary) {
+ silc_free(si->primary->server_ip);
+ silc_free(si->primary);
+ }
+ SILC_SERVER_CONFIG_LIST_DESTROY(SilcServerConfigServerInfoInterface,
+ si->secondary)
+ silc_free(di->server_ip);
+ silc_free(di);
+ }
silc_free(si->server_type);
silc_free(si->location);
silc_free(si->admin);
silc_free(si->group);
silc_free(si->motd_file);
silc_free(si->pid_file);
+ silc_pkcs_public_key_free(si->public_key);
+ silc_pkcs_private_key_free(si->private_key);
}
/* 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(SilcServerConfigConnParams,
+ config->conn_params)
silc_free(di->name);
+ silc_free(di->version_protocol);
+ silc_free(di->version_software);
+ silc_free(di->version_software_vendor);
silc_free(di);
}
- SILC_SERVER_CONFIG_LIST_DESTROY(SilcServerConfigSectionClient,
- config->clients)
+ 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);
}
+
+ memset(config, 'F', sizeof(*config));
+ silc_free(config);
}
/* Registers configured ciphers. These can then be allocated by the
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"));
int i;
for (i = 0; silc_default_ciphers[i].name; i++)
if (!strcmp(silc_default_ciphers[i].name, cipher->name)) {
- silc_cipher_register(&silc_default_ciphers[i]);
+ silc_cipher_register((SilcCipherObject *)&silc_default_ciphers[i]);
break;
}
if (!silc_cipher_is_supported(cipher->name)) {
/* Load (try at least) the crypto SIM module */
char buf[1023], *alg_name;
SilcCipherObject cipher_obj;
- SilcSimContext *sim;
+ SilcSim sim;
memset(&cipher_obj, 0, sizeof(cipher_obj));
cipher_obj.name = cipher->name;
/* build the libname */
snprintf(buf, sizeof(buf), "%s/%s", config->module_path,
cipher->module);
- sim = silc_sim_alloc();
- sim->type = SILC_SIM_CIPHER;
- sim->libname = buf;
+ sim = silc_sim_alloc(SILC_SIM_CIPHER, buf, 0);
alg_name = strdup(cipher->name);
if (strchr(alg_name, '-'))
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"));
int i;
for (i = 0; silc_default_hash[i].name; i++)
if (!strcmp(silc_default_hash[i].name, hash->name)) {
- silc_hash_register(&silc_default_hash[i]);
+ silc_hash_register((SilcHashObject *)&silc_default_hash[i]);
break;
}
if (!silc_hash_is_supported(hash->name)) {
#ifdef SILC_SIM
/* Load (try at least) the hash SIM module */
SilcHashObject hash_obj;
- SilcSimContext *sim;
+ SilcSim sim;
memset(&hash_obj, 0, sizeof(hash_obj));
hash_obj.name = hash->name;
hash_obj.block_len = hash->block_length;
hash_obj.hash_len = hash->digest_length;
- sim = silc_sim_alloc();
- sim->type = SILC_SIM_HASH;
- sim->libname = hash->module;
+ sim = silc_sim_alloc(SILC_SIM_HASH, hash->module, 0);
if ((silc_sim_load(sim))) {
hash_obj.init =
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"));
silc_server_stop(server);
exit(1);
}
+
/* Register the HMAC */
memset(&hmac_obj, 0, sizeof(hmac_obj));
hmac_obj.name = hmac->name;
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"));
int i;
for (i = 0; silc_default_pkcs[i].name; i++)
if (!strcmp(silc_default_pkcs[i].name, pkcs->name)) {
- silc_pkcs_register(&silc_default_pkcs[i]);
+ silc_pkcs_register((SilcPKCSObject *)&silc_default_pkcs[i]);
break;
}
if (!silc_pkcs_is_supported(pkcs->name)) {
void silc_server_config_setlogfiles(SilcServer server)
{
SilcServerConfig config = server->config;
- SilcServerConfigSectionLogging *this;
+ SilcServerConfigLogging *this;
- SILC_LOG_DEBUG(("Setting configured log file names"));
+ SILC_LOG_DEBUG(("Setting configured log file names and options"));
- if ((this = config->logging_info))
- 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,
+ silc_log_quick = config->logging_quick;
+ silc_log_flushdelay = (config->logging_flushdelay ?
+ config->logging_flushdelay :
+ SILC_SERVER_LOG_FLUSH_DELAY);
+
+ if ((this = config->logging_fatals))
+ silc_log_set_file(SILC_LOG_FATAL, this->file, this->maxsize,
server->schedule);
if ((this = config->logging_errors))
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,
+ if ((this = config->logging_warnings))
+ silc_log_set_file(SILC_LOG_WARNING, this->file, this->maxsize,
+ server->schedule);
+ if ((this = config->logging_info))
+ silc_log_set_file(SILC_LOG_INFO, this->file, this->maxsize,
server->schedule);
}
/* 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;
}
/* Returns admin connection configuration by host, username and/or
nickname. */
-SilcServerConfigSectionAdmin *
-silc_server_config_find_admin(SilcServer server, char *host, char *user,
+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)
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) {
/* 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;
/* 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;
bool silc_server_config_is_primary_route(SilcServer server)
{
SilcServerConfig config = server->config;
- SilcServerConfigSectionRouter *serv = NULL;
+ SilcServerConfigRouter *serv = NULL;
int i;
bool found = FALSE;
/* 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;
return NULL;
}
-
-/* Set default values to stuff that was not configured. */
-
-bool silc_server_config_set_defaults(SilcServer server)
-{
- SilcServerConfig config = server->config;
-
- config->param.keepalive_secs = (config->param.keepalive_secs ?
- config->param.keepalive_secs :
- SILC_SERVER_KEEPALIVE);
- config->param.reconnect_count = (config->param.reconnect_count ?
- config->param.reconnect_count :
- SILC_SERVER_RETRY_COUNT);
- config->param.reconnect_interval = (config->param.reconnect_interval ?
- config->param.reconnect_interval :
- SILC_SERVER_RETRY_INTERVAL_MIN);
- config->param.reconnect_interval_max =
- (config->param.reconnect_interval_max ?
- config->param.reconnect_interval_max :
- SILC_SERVER_RETRY_INTERVAL_MAX);
-
- return TRUE;
-}