__type__ *di = (__type__ *) tmp; \
tmp = (void *) di->next;
-/* free an authdata according to its auth method */
-static void my_free_authdata(char *passphrase, void *public_key)
+/* Set EDOUBLE error value and bail out if necessary */
+#define CONFIG_IS_DOUBLE(__x__) \
+ if ((__x__)) { \
+ got_errno = SILC_CONFIG_EDOUBLE; \
+ goto got_err; \
+ }
+
+/* Free the authentication fields in the specified struct
+ * Expands to two instructions */
+#define CONFIG_FREE_AUTH(__section__) \
+ silc_free(__section__->passphrase); \
+ silc_pkcs_public_key_free(__section__->publickey)
+
+/* Find connection parameters by the parameter block name. */
+static SilcServerConfigSectionConnectionParam *
+my_find_param(SilcServerConfig config, const char *name, uint32 line)
{
- silc_free(passphrase);
- if (public_key)
- silc_pkcs_public_key_free((SilcPublicKey) public_key);
+ SilcServerConfigSectionConnectionParam *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 */
*auth_data_len = 0;
} else {
fprintf(stderr, "\nError while parsing config file at line %lu: "
- "Unkonwn authentication method\n", line);
+ "Unknown authentication method.\n", line);
return FALSE;
}
return TRUE;
SILC_CONFIG_CALLBACK(fetch_generic)
{
SilcServerConfig config = (SilcServerConfig) context;
+ int got_errno = 0;
if (!strcmp(name, "module_path")) {
- if (config->module_path)
- return SILC_CONFIG_EDOUBLE;
-
- /* dup it only if non-empty, otherwise point it to NULL */
+ CONFIG_IS_DOUBLE(config->module_path);
config->module_path = (*(char *)val ? strdup((char *) val) : NULL);
}
else if (!strcmp(name, "prefer_passphrase_auth")) {
config->prefer_passphrase_auth = *(bool *)val;
}
+ else if (!strcmp(name, "require_reverse_lookup")) {
+ config->require_reverse_lookup = *(bool *)val;
+ }
+ else if (!strcmp(name, "keepalive_secs")) {
+ config->param.keepalive_secs = (uint32) *(int *)val;
+ }
+ else if (!strcmp(name, "reconnect_count")) {
+ config->param.reconnect_count = (uint32) *(int *)val;
+ }
+ else if (!strcmp(name, "reconnect_interval")) {
+ config->param.reconnect_interval = (uint32) *(int *)val;
+ }
+ else if (!strcmp(name, "reconnect_interval_max")) {
+ config->param.reconnect_interval_max = (uint32) *(int *)val;
+ }
+ else if (!strcmp(name, "reconnect_keep_trying")) {
+ config->param.reconnect_keep_trying = *(bool *)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);
- 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 */
/* Identify and save this value */
if (!strcmp(name, "name")) {
- if (tmp->name) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; }
+ CONFIG_IS_DOUBLE(tmp->name);
tmp->name = strdup((char *) val);
}
- else if (!strcmp(name, "module")) { /* can be empty */
- if (tmp->module) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; }
- /* dup it only if non-empty, otherwise point it to NULL */
+ else if (!strcmp(name, "module")) {
+ CONFIG_IS_DOUBLE(tmp->module);
tmp->module = (*(char *)val ? strdup((char *) val) : NULL);
}
- else if (!strcmp(name, "keylength"))
+ else if (!strcmp(name, "keylength")) {
tmp->key_length = *(uint32 *)val;
- else if (!strcmp(name, "blocklength"))
+ }
+ else if (!strcmp(name, "blocklength")) {
tmp->block_length = *(uint32 *)val;
+ }
else
return SILC_CONFIG_EINTERNAL;
return SILC_CONFIG_OK;
{
SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigSectionHash);
- 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 */
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));
/* Identify and save this value */
if (!strcmp(name, "name")) {
- if (tmp->name) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; }
+ CONFIG_IS_DOUBLE(tmp->name);
tmp->name = strdup((char *) val);
}
- else if (!strcmp(name, "module")) { /* can be empty */
- if (tmp->module) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; }
- /* dup it only if non-empty, otherwise point it to NULL */
+ else if (!strcmp(name, "module")) {
+ CONFIG_IS_DOUBLE(tmp->module);
tmp->module = (*(char *)val ? strdup((char *) val) : NULL);
}
- else if (!strcmp(name, "blocklength"))
+ else if (!strcmp(name, "blocklength")) {
tmp->block_length = *(int *)val;
- else if (!strcmp(name, "digestlength"))
+ }
+ else if (!strcmp(name, "digestlength")) {
tmp->digest_length = *(int *)val;
+ }
else
return SILC_CONFIG_EINTERNAL;
return SILC_CONFIG_OK;
{
SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigSectionHmac);
- 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 */
/* Identify and save this value */
if (!strcmp(name, "name")) {
- if (tmp->name) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; }
+ CONFIG_IS_DOUBLE(tmp->name);
tmp->name = strdup((char *) val);
}
else if (!strcmp(name, "hash")) {
- if (tmp->hash) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; }
+ CONFIG_IS_DOUBLE(tmp->hash);
tmp->hash = strdup((char *) val);
}
- else if (!strcmp(name, "maclength"))
+ else if (!strcmp(name, "maclength")) {
tmp->mac_length = *(int *)val;
+ }
else
return SILC_CONFIG_EINTERNAL;
return SILC_CONFIG_OK;
/* 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
{
SilcServerConfig config = (SilcServerConfig) context;
SilcServerConfigSectionServerInfo *server_info = config->server_info;
+ int got_errno = 0;
/* if there isn't the struct alloc it */
- if (!server_info) {
+ if (!server_info)
config->server_info = server_info = (SilcServerConfigSectionServerInfo *)
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")) {
server_info->port = (uint16) port;
}
else if (!strcmp(name, "servertype")) {
- if (server_info->server_type) return SILC_CONFIG_EDOUBLE;
+ CONFIG_IS_DOUBLE(server_info->server_type);
server_info->server_type = strdup((char *) val);
}
else if (!strcmp(name, "admin")) {
- if (server_info->admin) return SILC_CONFIG_EDOUBLE;
+ CONFIG_IS_DOUBLE(server_info->admin);
server_info->admin = strdup((char *) val);
}
else if (!strcmp(name, "adminemail")) {
- if (server_info->email) return SILC_CONFIG_EDOUBLE;
+ CONFIG_IS_DOUBLE(server_info->email);
server_info->email = strdup((char *) val);
}
else if (!strcmp(name, "location")) {
- if (server_info->location) return SILC_CONFIG_EDOUBLE;
+ CONFIG_IS_DOUBLE(server_info->location);
server_info->location = strdup((char *) val);
}
else if (!strcmp(name, "user")) {
- if (server_info->user) return SILC_CONFIG_EDOUBLE;
+ CONFIG_IS_DOUBLE(server_info->user);
server_info->user = strdup((char *) val);
}
else if (!strcmp(name, "group")) {
- if (server_info->group) return SILC_CONFIG_EDOUBLE;
+ CONFIG_IS_DOUBLE(server_info->group);
server_info->group = strdup((char *) val);
}
else if (!strcmp(name, "motdfile")) {
- if (server_info->motd_file) return SILC_CONFIG_EDOUBLE;
+ CONFIG_IS_DOUBLE(server_info->motd_file);
server_info->motd_file = strdup((char *) val);
}
else if (!strcmp(name, "pidfile")) {
- if (server_info->pid_file) return SILC_CONFIG_EDOUBLE;
+ CONFIG_IS_DOUBLE(server_info->pid_file);
server_info->pid_file = strdup((char *) val);
}
else if (!strcmp(name, "publickey")) {
else
return SILC_CONFIG_EINTERNAL;
return SILC_CONFIG_OK;
+
+ got_err:
+ return got_errno;
}
SILC_CONFIG_CALLBACK(fetch_logging)
return got_errno;
}
-SILC_CONFIG_CALLBACK(fetch_client)
+SILC_CONFIG_CALLBACK(fetch_connparam)
{
- SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigSectionClient);
+ SILC_SERVER_CONFIG_SECTION_INIT(SilcServerConfigSectionConnectionParam);
- SERVER_CONFIG_DEBUG(("Received CLIENT type=%d name=\"%s\" (val=%x)",
+ SERVER_CONFIG_DEBUG(("Received CONNPARAM type=%d name=\"%s\" (val=%x)",
type, name, context));
if (type == SILC_CONFIG_ARG_BLOCK) {
- if (!tmp) /* empty sub-block? */
+ if (!tmp)
return SILC_CONFIG_OK;
- SILC_SERVER_CONFIG_LIST_APPENDTMP(config->clients);
+ 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;
+ }
+
+ if (!strcmp(name, "name")) {
+ CONFIG_IS_DOUBLE(tmp->name);
+ tmp->name = (*(char *)val ? strdup((char *) val) : NULL);
+ }
+ else if (!strcmp(name, "keepalive_secs")) {
+ tmp->keepalive_secs = *(uint32 *)val;
+ }
+ else if (!strcmp(name, "reconnect_count")) {
+ tmp->reconnect_count = *(uint32 *)val;
+ }
+ else if (!strcmp(name, "reconnect_interval")) {
+ tmp->reconnect_interval = *(uint32 *)val;
+ }
+ else if (!strcmp(name, "reconnect_interval_max")) {
+ tmp->reconnect_interval_max = *(uint32 *)val;
+ }
+ else if (!strcmp(name, "reconnect_keep_trying")) {
+ tmp->reconnect_keep_trying = *(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(SilcServerConfigSectionClient);
+
+ 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 = (SilcServerConfigSectionClient *) config->tmp;
}
+ if (type == SILC_CONFIG_ARG_BLOCK) {
+ /* closing the block */
+ SILC_SERVER_CONFIG_LIST_APPENDTMP(config->clients);
+ config->tmp = NULL;
+ return SILC_CONFIG_OK;
+ }
+
/* Identify and save this value */
- if (!strcmp(name, "host")) { /* any host (*) accepted */
- if (tmp->host) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; }
+ if (!strcmp(name, "host")) {
+ CONFIG_IS_DOUBLE(tmp->host);
tmp->host = (*(char *)val ? strdup((char *) val) : NULL);
}
else if (!strcmp(name, "passphrase")) {
if (!my_parse_authdata(SILC_AUTH_PASSWORD, (char *) val, line,
- (void **)&tmp->passphrase,
+ (void **)&tmp->passphrase,
&tmp->passphrase_len)) {
got_errno = SILC_CONFIG_ESILENT;
goto got_err;
int port = *(int *)val;
if ((port <= 0) || (port > 65535)) {
fprintf(stderr, "Invalid port number!\n");
- got_errno = SILC_CONFIG_ESILENT; goto got_err;
+ 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 if (!strcmp(name, "param")) {
+ 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
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_SERVER_CONFIG_SECTION_INIT(SilcServerConfigSectionAdmin);
- 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) {
}
/* Identify and save this value */
- if (!strcmp(name, "host")) { /* any host (*) accepted */
- if (tmp->host) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; }
+ if (!strcmp(name, "host")) {
+ CONFIG_IS_DOUBLE(tmp->host);
tmp->host = (*(char *)val ? strdup((char *) val) : NULL);
}
else if (!strcmp(name, "user")) {
- if (tmp->user) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; }
+ CONFIG_IS_DOUBLE(tmp->user);
tmp->user = (*(char *)val ? strdup((char *) val) : NULL);
}
else if (!strcmp(name, "nick")) {
- if (tmp->nick) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; }
+ CONFIG_IS_DOUBLE(tmp->nick);
tmp->nick = (*(char *)val ? strdup((char *) val) : NULL);
}
else if (!strcmp(name, "passphrase")) {
if (!my_parse_authdata(SILC_AUTH_PASSWORD, (char *) val, line,
- (void **)&tmp->passphrase,
+ (void **)&tmp->passphrase,
&tmp->passphrase_len)) {
got_errno = SILC_CONFIG_ESILENT;
goto got_err;
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_SERVER_CONFIG_SECTION_INIT(SilcServerConfigSectionDeny);
- 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 */
}
/* 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")) {
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_SERVER_CONFIG_SECTION_INIT(SilcServerConfigSectionServer);
- 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) {
if (!tmp) /* empty sub-block? */
return SILC_CONFIG_OK;
+ /* XXX mandatory fields for server? */
+
/* the temporary struct is ok, append it to the list */
SILC_SERVER_CONFIG_LIST_APPENDTMP(config->servers);
config->tmp = NULL;
}
/* Identify and save this value */
- if (!strcmp(name, "host")) { /* any host (*) accepted */
- if (tmp->host) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; }
+ if (!strcmp(name, "host")) {
+ CONFIG_IS_DOUBLE(tmp->host);
tmp->host = (*(char *)val ? strdup((char *) val) : strdup("*"));
}
else if (!strcmp(name, "passphrase")) {
if (!my_parse_authdata(SILC_AUTH_PASSWORD, (char *) val, line,
- (void **)&tmp->passphrase,
+ (void **)&tmp->passphrase,
&tmp->passphrase_len)) {
got_errno = SILC_CONFIG_ESILENT;
goto got_err;
}
}
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, "param")) {
+ 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;
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_SERVER_CONFIG_SECTION_INIT(SilcServerConfigSectionRouter);
- 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? */
return SILC_CONFIG_OK;
+ /* XXX mandatory fields for router? */
+
/* the temporary struct is ok, append it to the list */
SILC_SERVER_CONFIG_LIST_APPENDTMP(config->routers);
config->tmp = NULL;
/* Identify and save this value */
if (!strcmp(name, "host")) {
- if (tmp->host) { got_errno = SILC_CONFIG_EDOUBLE; goto got_err; }
+ CONFIG_IS_DOUBLE(tmp->host);
tmp->host = strdup((char *) val);
}
else if (!strcmp(name, "port")) {
}
else if (!strcmp(name, "passphrase")) {
if (!my_parse_authdata(SILC_AUTH_PASSWORD, (char *) val, line,
- (void **)&tmp->passphrase,
+ (void **)&tmp->passphrase,
&tmp->passphrase_len)) {
got_errno = SILC_CONFIG_ESILENT;
goto got_err;
}
}
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, "param")) {
+ 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
return SILC_CONFIG_EINTERNAL;
silc_free(tmp->host);
silc_free(tmp->version);
silc_free(tmp->backup_replace_ip);
- my_free_authdata(tmp->passphrase, tmp->publickey);
+ CONFIG_FREE_AUTH(tmp);
silc_free(tmp);
config->tmp = NULL;
return got_errno;
/* known config options tables */
static const SilcConfigTable table_general[] = {
- { "module_path", SILC_CONFIG_ARG_STRE, fetch_generic, NULL },
- { "prefer_passphrase_auth", SILC_CONFIG_ARG_STRE, fetch_generic, NULL },
+ { "module_path", SILC_CONFIG_ARG_STRE, fetch_generic, NULL },
+ { "prefer_passphrase_auth", SILC_CONFIG_ARG_TOGGLE, fetch_generic, NULL },
+ { "require_reverse_lookup", SILC_CONFIG_ARG_TOGGLE, fetch_generic, NULL },
+ { "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 },
{ 0, 0, 0, 0 }
};
{ 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 },
+ { "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 },
{ 0, 0, 0, 0 }
-}; */
+};
static const SilcConfigTable table_client[] = {
{ "host", SILC_CONFIG_ARG_STRE, fetch_client, NULL },
{ "passphrase", SILC_CONFIG_ARG_STR, fetch_client, NULL },
{ "publickey", SILC_CONFIG_ARG_STR, fetch_client, NULL },
{ "port", SILC_CONFIG_ARG_INT, fetch_client, NULL },
- { "class", SILC_CONFIG_ARG_STR, fetch_client, NULL },
+ { "param", 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 },
- { "class", SILC_CONFIG_ARG_STR, fetch_admin, NULL },
+ { "param", SILC_CONFIG_ARG_STR, fetch_admin, NULL },
{ 0, 0, 0, 0 }
};
{ "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 },
+ { "param", SILC_CONFIG_ARG_STR, fetch_server, NULL },
{ "backup", SILC_CONFIG_ARG_TOGGLE, fetch_server, NULL },
{ 0, 0, 0, 0 }
};
{ "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 },
+ { "param", 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 },
};
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 },
+ { "connectionparam", 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 }
};
SILC_SERVER_CONFIG_LIST_DESTROY(SilcServerConfigSectionClient,
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_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)
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_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);
}
}
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;
+}
projects / silc.git / blobdiff