GNU General Public License for more details.
*/
-/*
- * $Id$
- * $Log$
- * Revision 1.2 2000/07/05 06:14:01 priikone
- * Global costemic changes.
- *
- * Revision 1.1.1.1 2000/06/27 11:36:56 priikone
- * Imported from internal CVS/Added Log headers.
- *
- *
- */
+/* $Id$ */
#include "serverincludes.h"
#include "server_internal.h"
+<Local IP/UNIX socket path>:<Remote IP>:<Port>
+ <Identity>
+
+ This section is used to set both the user and group which silcd
+ sets itself upon starting.
+
+ Format:
+
+ <user>:<group>
+
<Logging>
This section is used to set various logging files, their paths
Format:
- +<Remote address or name>:<auth method>:<password/key/???>:<Port>:<Version ID>:<Class>
+ +<Remote address or name>:<auth method>:<password/key/???>:
+ <Port>:<Version ID>:<Class>:<Initiator>
<DenyConnection>
+<Remote address or name>:<Port>
*/
-SilcConfigServerSection silc_config_server_sections[] = {
+SilcServerConfigSection silc_server_config_sections[] = {
{ "[Cipher]",
SILC_CONFIG_SERVER_SECTION_TYPE_CIPHER, 4 },
{ "[PKCS]",
SILC_CONFIG_SERVER_SECTION_TYPE_ADMIN_INFO, 4 },
{ "[ListenPort]",
SILC_CONFIG_SERVER_SECTION_TYPE_LISTEN_PORT, 3 },
+ { "[Identity]",
+ SILC_CONFIG_SERVER_SECTION_TYPE_IDENTITY, 2 },
{ "[Logging]",
SILC_CONFIG_SERVER_SECTION_TYPE_LOGGING, 3 },
{ "[ConnectionClass]",
{ "[ServerConnection]",
SILC_CONFIG_SERVER_SECTION_TYPE_SERVER_CONNECTION, 6 },
{ "[RouterConnection]",
- SILC_CONFIG_SERVER_SECTION_TYPE_ROUTER_CONNECTION, 6 },
+ SILC_CONFIG_SERVER_SECTION_TYPE_ROUTER_CONNECTION, 7 },
{ "[AdminConnection]",
SILC_CONFIG_SERVER_SECTION_TYPE_ADMIN_CONNECTION, 5 },
{ "[DenyConnection]",
SILC_CONFIG_SERVER_SECTION_TYPE_DENY_CONNECTION, 4 },
{ "[RedirectClient]",
SILC_CONFIG_SERVER_SECTION_TYPE_REDIRECT_CLIENT, 2 },
+ { "[motd]",
+ SILC_CONFIG_SERVER_SECTION_TYPE_MOTD, 1 },
{ NULL, SILC_CONFIG_SERVER_SECTION_TYPE_NONE, 0 }
};
parses the file. The parsed data is returned to the newly allocated
configuration object. */
-SilcConfigServer silc_config_server_alloc(char *filename)
+SilcServerConfig silc_server_config_alloc(char *filename)
{
- SilcConfigServer new;
+ SilcServerConfig new;
SilcBuffer buffer;
- SilcConfigServerParse config_parse;
+ SilcServerConfigParse config_parse;
SILC_LOG_DEBUG(("Allocating new configuration object"));
silc_config_open(filename, &buffer);
if (!buffer)
goto fail;
- if ((silc_config_server_parse(new, buffer, &config_parse)) == FALSE)
+ if ((silc_server_config_parse(new, buffer, &config_parse)) == FALSE)
goto fail;
- if ((silc_config_server_parse_lines(new, config_parse)) == FALSE)
+ if ((silc_server_config_parse_lines(new, config_parse)) == FALSE)
goto fail;
silc_free(buffer);
/* Free's a configuration object. */
-void silc_config_server_free(SilcConfigServer config)
+void silc_server_config_free(SilcServerConfig config)
{
if (config) {
silc_free(config->filename);
silc_free(config->server_info);
silc_free(config->admin_info);
silc_free(config->listen_port);
+ silc_free(config->identity);
silc_free(config->conn_class);
silc_free(config->clients);
silc_free(config->admins);
silc_free(config->routers);
silc_free(config->denied);
silc_free(config->redirect);
+ silc_free(config->motd);
silc_free(config);
}
}
buffer sent as argument can be safely free'd after this function has
succesfully returned. */
-int silc_config_server_parse(SilcConfigServer config, SilcBuffer buffer,
- SilcConfigServerParse *return_config)
+int silc_server_config_parse(SilcServerConfig config, SilcBuffer buffer,
+ SilcServerConfigParse *return_config)
{
int i, begin;
unsigned int linenum;
char line[1024], *cp;
- SilcConfigServerSection *cptr = NULL;
- SilcConfigServerParse parse = *return_config, first = NULL;
+ SilcServerConfigSection *cptr = NULL;
+ SilcServerConfigParse parse = *return_config, first = NULL;
SILC_LOG_DEBUG(("Parsing configuration file"));
*strchr(cp, '\n') = '\0';
/* Check for matching sections */
- for (cptr = silc_config_server_sections; cptr->section; cptr++)
+ for (cptr = silc_server_config_sections; cptr->section; cptr++)
if (!strncasecmp(cp, cptr->section, strlen(cptr->section)))
break;
parse_config argument is uninitialized automatically during this
function. */
-int silc_config_server_parse_lines(SilcConfigServer config,
- SilcConfigServerParse parse_config)
+int silc_server_config_parse_lines(SilcServerConfig config,
+ SilcServerConfigParse parse_config)
{
int ret, check = FALSE;
unsigned int checkmask;
char *tmp;
- SilcConfigServerParse pc = parse_config;
+ SilcServerConfigParse pc = parse_config;
SilcBuffer line;
SILC_LOG_DEBUG(("Parsing configuration lines"));
if (ret < 0)
break;
- /* Get block length */
+ /* Get key length */
ret = silc_config_get_token(line, &tmp);
if (ret < 0)
break;
if (ret == 0) {
- fprintf(stderr, "%s:%d: Cipher block length not defined\n",
+ fprintf(stderr, "%s:%d: Cipher key length not defined\n",
config->filename, pc->linenum);
break;
}
- config->cipher->block_len = atoi(tmp);
+ config->cipher->key_len = atoi(tmp);
silc_free(tmp);
- /* Get key length */
+ /* Get block length */
ret = silc_config_get_token(line, &tmp);
if (ret < 0)
break;
if (ret == 0) {
- fprintf(stderr, "%s:%d: Cipher key length not defined\n",
+ fprintf(stderr, "%s:%d: Cipher block length not defined\n",
config->filename, pc->linenum);
break;
}
- config->cipher->key_len = atoi(tmp);
+ config->cipher->block_len = atoi(tmp);
silc_free(tmp);
check = TRUE;
if (!config->admin_info)
config->admin_info = silc_calloc(1, sizeof(*config->admin_info));
+ /* Get location */
+ ret = silc_config_get_token(line, &config->admin_info->location);
+ if (ret < 0)
+ break;
+
/* Get server type */
ret = silc_config_get_token(line, &config->admin_info->server_type);
if (ret < 0)
checkmask |= (1L << pc->section->type);
break;
+ case SILC_CONFIG_SERVER_SECTION_TYPE_IDENTITY:
+
+ if (!config->identity)
+ config->identity = silc_calloc(1, sizeof(*config->identity));
+
+ /* Get user */
+ ret = silc_config_get_token(line, &config->identity->user);
+ if (ret < 0)
+ break;
+ /* Get group */
+ ret = silc_config_get_token(line, &config->identity->group);
+ if (ret < 0)
+ break;
+
+ check = TRUE;
+ checkmask |= (1L << pc->section->type);
+
case SILC_CONFIG_SERVER_SECTION_TYPE_CONNECTION_CLASS:
SILC_SERVER_CONFIG_LIST_ALLOC(config->conn_class);
}
if (!strcmp(tmp, SILC_CONFIG_SERVER_AUTH_METH_PASSWD))
- config->clients->auth_meth = SILC_PROTOCOL_CONN_AUTH_PASSWORD;
+ config->clients->auth_meth = SILC_AUTH_PASSWORD;
if (!strcmp(tmp, SILC_CONFIG_SERVER_AUTH_METH_PUBKEY))
- config->clients->auth_meth = SILC_PROTOCOL_CONN_AUTH_PUBLIC_KEY;
+ config->clients->auth_meth = SILC_AUTH_PUBLIC_KEY;
silc_free(tmp);
}
}
if (!strcmp(tmp, SILC_CONFIG_SERVER_AUTH_METH_PASSWD))
- config->servers->auth_meth = SILC_PROTOCOL_CONN_AUTH_PASSWORD;
+ config->servers->auth_meth = SILC_AUTH_PASSWORD;
if (!strcmp(tmp, SILC_CONFIG_SERVER_AUTH_METH_PUBKEY))
- config->servers->auth_meth = SILC_PROTOCOL_CONN_AUTH_PUBLIC_KEY;
+ config->servers->auth_meth = SILC_AUTH_PUBLIC_KEY;
silc_free(tmp);
}
}
if (!strcmp(tmp, SILC_CONFIG_SERVER_AUTH_METH_PASSWD))
- config->routers->auth_meth = SILC_PROTOCOL_CONN_AUTH_PASSWORD;
+ config->routers->auth_meth = SILC_AUTH_PASSWORD;
if (!strcmp(tmp, SILC_CONFIG_SERVER_AUTH_METH_PUBKEY))
- config->routers->auth_meth = SILC_PROTOCOL_CONN_AUTH_PUBLIC_KEY;
+ config->routers->auth_meth = SILC_AUTH_PUBLIC_KEY;
silc_free(tmp);
}
silc_free(tmp);
}
+ /* Get whether we are initiator or not */
+ ret = silc_config_get_token(line, &tmp);
+ if (ret < 0)
+ break;
+ if (ret) {
+ config->routers->initiator = atoi(tmp);
+ if (config->routers->initiator != 0)
+ config->routers->initiator = TRUE;
+ silc_free(tmp);
+ }
+
check = TRUE;
checkmask |= (1L << pc->section->type);
break;
}
if (!strcmp(tmp, SILC_CONFIG_SERVER_AUTH_METH_PASSWD))
- config->admins->auth_meth = SILC_PROTOCOL_CONN_AUTH_PASSWORD;
+ config->admins->auth_meth = SILC_AUTH_PASSWORD;
if (!strcmp(tmp, SILC_CONFIG_SERVER_AUTH_METH_PUBKEY))
- config->admins->auth_meth = SILC_PROTOCOL_CONN_AUTH_PUBLIC_KEY;
+ config->admins->auth_meth = SILC_AUTH_PUBLIC_KEY;
silc_free(tmp);
}
check = TRUE;
break;
+ case SILC_CONFIG_SERVER_SECTION_TYPE_MOTD:
+
+ if (!config->motd)
+ config->motd = silc_calloc(1, sizeof(*config->motd));
+
+ /* Get motd file */
+ ret = silc_config_get_token(line, &config->motd->motd_file);
+ if (ret < 0)
+ break;
+
+ check = TRUE;
+ checkmask |= (1L << pc->section->type);
+ break;
+
case SILC_CONFIG_SERVER_SECTION_TYPE_NONE:
default:
/* Error */
/* Check that all mandatory sections really were found. If not, the server
cannot function and we return error. */
- ret = silc_config_server_check_sections(checkmask);
+ ret = silc_server_config_check_sections(checkmask);
if (ret == FALSE) {
/* XXX */
/* This function checks that the mask sent as argument includes all the
sections that are mandatory in SILC server. */
-int silc_config_server_check_sections(unsigned int checkmask)
+int silc_server_config_check_sections(unsigned int checkmask)
{
if (!(checkmask & (1L << SILC_CONFIG_SERVER_SECTION_TYPE_SERVER_INFO))) {
/* Sets log files where log messages is saved by the server. */
-void silc_config_server_setlogfiles(SilcConfigServer config)
+void silc_server_config_setlogfiles(SilcServerConfig config)
{
- SilcConfigServerSectionLogging *log;
+ SilcServerConfigSectionLogging *log;
char *info, *warning, *error, *fatal;
unsigned int info_size, warning_size, error_size, fatal_size;
/* Registers configured ciphers. These can then be allocated by the
server when needed. */
-void silc_config_server_register_ciphers(SilcConfigServer config)
+void silc_server_config_register_ciphers(SilcServerConfig config)
{
- SilcConfigServerSectionAlg *alg;
+ SilcServerConfigSectionAlg *alg;
SilcServer server = (SilcServer)config->server;
SILC_LOG_DEBUG(("Registering configured ciphers"));
/* Load (try at least) the crypto SIM module */
SilcCipherObject cipher;
SilcSimContext *sim;
+ char *alg_name;
memset(&cipher, 0, sizeof(cipher));
cipher.name = alg->alg_name;
sim->type = SILC_SIM_CIPHER;
sim->libname = alg->sim_name;
+ alg_name = strdup(alg->alg_name);
+ if (strchr(alg_name, '-'))
+ *strchr(alg_name, '-') = '\0';
+
if ((silc_sim_load(sim))) {
cipher.set_key =
- silc_sim_getsym(sim, silc_sim_symname(alg->alg_name,
+ silc_sim_getsym(sim, silc_sim_symname(alg_name,
SILC_CIPHER_SIM_SET_KEY));
SILC_LOG_DEBUG(("set_key=%p", cipher.set_key));
cipher.set_key_with_string =
- silc_sim_getsym(sim, silc_sim_symname(alg->alg_name,
+ 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.set_key_with_string));
cipher.encrypt =
- silc_sim_getsym(sim, silc_sim_symname(alg->alg_name,
+ silc_sim_getsym(sim, silc_sim_symname(alg_name,
SILC_CIPHER_SIM_ENCRYPT_CBC));
SILC_LOG_DEBUG(("encrypt_cbc=%p", cipher.encrypt));
cipher.decrypt =
- silc_sim_getsym(sim, silc_sim_symname(alg->alg_name,
+ silc_sim_getsym(sim, silc_sim_symname(alg_name,
SILC_CIPHER_SIM_DECRYPT_CBC));
SILC_LOG_DEBUG(("decrypt_cbc=%p", cipher.decrypt));
cipher.context_len =
- silc_sim_getsym(sim, silc_sim_symname(alg->alg_name,
+ silc_sim_getsym(sim, silc_sim_symname(alg_name,
SILC_CIPHER_SIM_CONTEXT_LEN));
SILC_LOG_DEBUG(("context_len=%p", cipher.context_len));
- /* Put the SIM to the table of all SIM's in server */
- server->sim = silc_realloc(server->sim,
- sizeof(*server->sim) *
- (server->sim_count + 1));
- server->sim[server->sim_count] = sim;
- server->sim_count++;
+ /* Put the SIM to the list of all SIM's in server */
+ silc_dlist_add(server->sim, sim);
+
+ silc_free(alg_name);
} else {
SILC_LOG_ERROR(("Error configuring ciphers"));
silc_server_stop(server);
as SIM's. This checks now only that the PKCS user requested is
really out there. */
-void silc_config_server_register_pkcs(SilcConfigServer config)
+void silc_server_config_register_pkcs(SilcServerConfig config)
{
- SilcConfigServerSectionAlg *alg = config->pkcs;
+ SilcServerConfigSectionAlg *alg = config->pkcs;
SilcServer server = (SilcServer)config->server;
SilcPKCS tmp = NULL;
/* Registers configured hash functions. These can then be allocated by the
server when needed. */
-void silc_config_server_register_hashfuncs(SilcConfigServer config)
+void silc_server_config_register_hashfuncs(SilcServerConfig config)
{
- SilcConfigServerSectionAlg *alg;
+ SilcServerConfigSectionAlg *alg;
SilcServer server = (SilcServer)config->server;
SILC_LOG_DEBUG(("Registering configured hash functions"));
SILC_LOG_DEBUG(("context_len=%p", hash.context_len));
/* Put the SIM to the table of all SIM's in server */
- server->sim = silc_realloc(server->sim,
- sizeof(*server->sim) *
- (server->sim_count + 1));
- server->sim[server->sim_count] = sim;
- server->sim_count++;
+ silc_dlist_add(server->sim, sim);
} else {
SILC_LOG_ERROR(("Error configuring hash functions"));
silc_server_stop(server);
/* Returns client authentication information from server configuration
by host (name or ip). */
-SilcConfigServerSectionClientConnection *
-silc_config_server_find_client_conn(SilcConfigServer config,
+SilcServerConfigSectionClientConnection *
+silc_server_config_find_client_conn(SilcServerConfig config,
char *host, int port)
{
int i;
- SilcConfigServerSectionClientConnection *client = NULL;
+ SilcServerConfigSectionClientConnection *client = NULL;
if (!host)
return NULL;
/* Returns server connection info from server configuartion by host
(name or ip). */
-SilcConfigServerSectionServerConnection *
-silc_config_server_find_server_conn(SilcConfigServer config,
+SilcServerConfigSectionServerConnection *
+silc_server_config_find_server_conn(SilcServerConfig config,
char *host, int port)
{
int i;
- SilcConfigServerSectionServerConnection *serv = NULL;
+ SilcServerConfigSectionServerConnection *serv = NULL;
if (!host)
return NULL;
/* Returns router connection info from server configuartion by
host (name or ip). */
-SilcConfigServerSectionServerConnection *
-silc_config_server_find_router_conn(SilcConfigServer config,
+SilcServerConfigSectionServerConnection *
+silc_server_config_find_router_conn(SilcServerConfig config,
char *host, int port)
{
int i;
- SilcConfigServerSectionServerConnection *serv = NULL;
+ SilcServerConfigSectionServerConnection *serv = NULL;
if (!host)
return NULL;
/* Prints out example configuration file with default built in
configuration values. */
-void silc_config_server_print()
+void silc_server_config_print()
{
char *buf;
projects / silc.git / blobdiff