From: Pekka Riikonen Date: Wed, 21 Feb 2001 10:34:03 +0000 (+0000) Subject: update. X-Git-Tag: SILC.0.1~193 X-Git-Url: http://git.silcnet.org/gitweb/?p=silc.git;a=commitdiff_plain;h=2065f5e3a2a7a8dbaae72f359066205bc26e1258 update. --- diff --git a/CHANGES b/CHANGES index cca91038..26f2563c 100644 --- a/CHANGES +++ b/CHANGES @@ -1,3 +1,9 @@ +Wed Feb 21 12:44:00 EET 2001 Mika Boström + + * Changed all SilcConfigServer* and silc_config_server* to + SilcServerConfig* and silc_server_config*, respectively. + Patch by Bostik. + Wed Feb 21 00:10:00 EET 2001 Pekka Riikonen * Associated the ID (client or server ID) to the Authentication diff --git a/apps/silc/clientconfig.c b/apps/silc/clientconfig.c index b6f5b150..94ddb7f0 100644 --- a/apps/silc/clientconfig.c +++ b/apps/silc/clientconfig.c @@ -435,10 +435,10 @@ int silc_client_config_parse_lines(SilcClientConfig config, } if (!strcmp(tmp, SILC_CLIENT_CONFIG_AUTH_METH_PASSWD)) - config->conns->auth_meth = SILC_PROTOCOL_CONN_AUTH_PASSWORD; + config->conns->auth_meth = SILC_AUTH_PASSWORD; if (!strcmp(tmp, SILC_CLIENT_CONFIG_AUTH_METH_PUBKEY)) - config->conns->auth_meth = SILC_PROTOCOL_CONN_AUTH_PUBLIC_KEY; + config->conns->auth_meth = SILC_AUTH_PUBLIC_KEY; silc_free(tmp); } diff --git a/apps/silcd/protocol.c b/apps/silcd/protocol.c index 5ade39a4..fdb7a38e 100644 --- a/apps/silcd/protocol.c +++ b/apps/silcd/protocol.c @@ -592,14 +592,14 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth) /* Remote end is client */ if (conn_type == SILC_SOCKET_TYPE_CLIENT) { - SilcConfigServerSectionClientConnection *client = NULL; + SilcServerConfigSectionClientConnection *client = NULL; client = - silc_config_server_find_client_conn(server->config, + silc_server_config_find_client_conn(server->config, ctx->sock->ip, ctx->sock->port); if (!client) client = - silc_config_server_find_client_conn(server->config, + silc_server_config_find_client_conn(server->config, ctx->sock->hostname, ctx->sock->port); @@ -671,14 +671,14 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth) /* Remote end is server */ if (conn_type == SILC_SOCKET_TYPE_SERVER) { - SilcConfigServerSectionServerConnection *serv = NULL; + SilcServerConfigSectionServerConnection *serv = NULL; serv = - silc_config_server_find_server_conn(server->config, + silc_server_config_find_server_conn(server->config, ctx->sock->ip, ctx->sock->port); if (!serv) serv = - silc_config_server_find_server_conn(server->config, + silc_server_config_find_server_conn(server->config, ctx->sock->hostname, ctx->sock->port); @@ -750,14 +750,14 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth) /* Remote end is router */ if (conn_type == SILC_SOCKET_TYPE_ROUTER) { - SilcConfigServerSectionServerConnection *serv = NULL; + SilcServerConfigSectionServerConnection *serv = NULL; serv = - silc_config_server_find_router_conn(server->config, + silc_server_config_find_router_conn(server->config, ctx->sock->ip, ctx->sock->port); if (!serv) serv = - silc_config_server_find_router_conn(server->config, + silc_server_config_find_router_conn(server->config, ctx->sock->hostname, ctx->sock->port); diff --git a/apps/silcd/server.c b/apps/silcd/server.c index b0d10ecd..e8e51569 100644 --- a/apps/silcd/server.c +++ b/apps/silcd/server.c @@ -129,12 +129,12 @@ int silc_server_init(SilcServer server) /* Set log files where log message should be saved. */ server->config->server = server; - silc_config_server_setlogfiles(server->config); + silc_server_config_setlogfiles(server->config); /* Register all configured ciphers, PKCS and hash functions. */ - silc_config_server_register_ciphers(server->config); - silc_config_server_register_pkcs(server->config); - silc_config_server_register_hashfuncs(server->config); + silc_server_config_register_ciphers(server->config); + silc_server_config_register_pkcs(server->config); + silc_server_config_register_hashfuncs(server->config); /* Initialize random number generator for the server. */ server->rng = silc_rng_alloc(); @@ -636,7 +636,7 @@ SILC_TASK_CALLBACK(silc_server_connect_to_router) /* If we are a SILC router we need to establish all of our primary routes. */ if (server->server_type == SILC_ROUTER) { - SilcConfigServerSectionServerConnection *ptr; + SilcServerConfigSectionServerConnection *ptr; SILC_LOG_DEBUG(("We are router")); @@ -720,10 +720,10 @@ SILC_TASK_CALLBACK(silc_server_connect_to_router_second) /* Resolve the authentication method used in this connection */ proto_ctx->auth_meth = SILC_AUTH_PASSWORD; if (server->config->routers) { - SilcConfigServerSectionServerConnection *conn = NULL; + SilcServerConfigSectionServerConnection *conn = NULL; /* Check if we find a match from user configured connections */ - conn = silc_config_server_find_router_conn(server->config, + conn = silc_server_config_find_router_conn(server->config, sock->hostname, sock->port); if (conn) { diff --git a/apps/silcd/server_internal.h b/apps/silcd/server_internal.h index 0e1ac428..874b4520 100644 --- a/apps/silcd/server_internal.h +++ b/apps/silcd/server_internal.h @@ -127,7 +127,7 @@ struct SilcServerStruct { SilcHmac sha1hmac; /* Configuration object */ - SilcConfigServer config; + SilcServerConfig config; /* Random pool */ SilcRng rng; diff --git a/apps/silcd/serverconfig.c b/apps/silcd/serverconfig.c index aed90177..9caff411 100644 --- a/apps/silcd/serverconfig.c +++ b/apps/silcd/serverconfig.c @@ -157,7 +157,7 @@ +: */ -SilcConfigServerSection silc_config_server_sections[] = { +SilcServerConfigSection silc_server_config_sections[] = { { "[Cipher]", SILC_CONFIG_SERVER_SECTION_TYPE_CIPHER, 4 }, { "[PKCS]", @@ -198,11 +198,11 @@ SilcConfigServerSection silc_config_server_sections[] = { 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")); @@ -220,9 +220,9 @@ SilcConfigServer silc_config_server_alloc(char *filename) 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); @@ -236,7 +236,7 @@ SilcConfigServer silc_config_server_alloc(char *filename) /* 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); @@ -262,14 +262,14 @@ void silc_config_server_free(SilcConfigServer 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")); @@ -313,7 +313,7 @@ int silc_config_server_parse(SilcConfigServer config, SilcBuffer buffer, *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; @@ -379,13 +379,13 @@ int silc_config_server_parse(SilcConfigServer config, SilcBuffer buffer, 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")); @@ -1049,7 +1049,7 @@ int silc_config_server_parse_lines(SilcConfigServer config, /* 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 */ @@ -1084,7 +1084,7 @@ int silc_config_server_parse_lines(SilcConfigServer config, /* 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))) { @@ -1118,9 +1118,9 @@ int silc_config_server_check_sections(unsigned int checkmask) /* 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; @@ -1165,9 +1165,9 @@ void silc_config_server_setlogfiles(SilcConfigServer config) /* 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")); @@ -1247,9 +1247,9 @@ void silc_config_server_register_ciphers(SilcConfigServer config) 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; @@ -1271,9 +1271,9 @@ void silc_config_server_register_pkcs(SilcConfigServer config) /* 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")); @@ -1346,12 +1346,12 @@ void silc_config_server_register_hashfuncs(SilcConfigServer config) /* 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; @@ -1376,12 +1376,12 @@ silc_config_server_find_client_conn(SilcConfigServer config, /* 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; @@ -1405,12 +1405,12 @@ silc_config_server_find_server_conn(SilcConfigServer config, /* 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; @@ -1434,7 +1434,7 @@ silc_config_server_find_router_conn(SilcConfigServer config, /* Prints out example configuration file with default built in configuration values. */ -void silc_config_server_print() +void silc_server_config_print() { char *buf; diff --git a/apps/silcd/serverconfig.h b/apps/silcd/serverconfig.h index 0b045fa1..ef26de85 100644 --- a/apps/silcd/serverconfig.h +++ b/apps/silcd/serverconfig.h @@ -22,15 +22,15 @@ #define SERVERCONFIG_H /* Holds information of configured algorithms */ -typedef struct SilcConfigServerSectionAlgStruct { +typedef struct SilcServerConfigSectionAlgStruct { char *alg_name; char *sim_name; unsigned int block_len; unsigned int key_len; - struct SilcConfigServerSectionAlgStruct *next; - struct SilcConfigServerSectionAlgStruct *prev; + struct SilcServerConfigSectionAlgStruct *next; + struct SilcServerConfigSectionAlgStruct *prev; #define SILC_CONFIG_SERVER_MODNAME "builtin" -} SilcConfigServerSectionAlg; +} SilcServerConfigSectionAlg; /* Holds server information from config file */ typedef struct { @@ -38,7 +38,7 @@ typedef struct { char *server_ip; char *location; unsigned short port; -} SilcConfigServerSectionServerInfo; +} SilcServerConfigSectionServerInfo; /* Holds server's administrative information from config file */ typedef struct { @@ -46,76 +46,76 @@ typedef struct { char *server_type; char *admin_name; char *admin_email; -} SilcConfigServerSectionAdminInfo; +} SilcServerConfigSectionAdminInfo; /* Holds all the ports the server is listenning on */ -typedef struct SilcConfigServerSectionListenPortStruct { +typedef struct SilcServerConfigSectionListenPortStruct { char *host; char *remote_ip; unsigned short port; - struct SilcConfigServerSectionListenPortStruct *next; - struct SilcConfigServerSectionListenPortStruct *prev; -} SilcConfigServerSectionListenPort; + struct SilcServerConfigSectionListenPortStruct *next; + struct SilcServerConfigSectionListenPortStruct *prev; +} SilcServerConfigSectionListenPort; /* Holds server's execution identity, or the user and group which to change from root when server starts */ typedef struct { char *user; char *group; -} SilcConfigServerSectionIdentity; +} SilcServerConfigSectionIdentity; /* Holds all the configured log files. */ -typedef struct SilcConfigServerSectionLoggingStruct { +typedef struct SilcServerConfigSectionLoggingStruct { char *logtype; char *filename; unsigned int maxsize; - struct SilcConfigServerSectionLoggingStruct *next; - struct SilcConfigServerSectionLoggingStruct *prev; + struct SilcServerConfigSectionLoggingStruct *next; + struct SilcServerConfigSectionLoggingStruct *prev; /* Allowed section types */ #define SILC_CONFIG_SERVER_LF_INFO "infologfile" #define SILC_CONFIG_SERVER_LF_WARNING "warninglogfile" #define SILC_CONFIG_SERVER_LF_ERROR "errorlogfile" #define SILC_CONFIG_SERVER_LF_FATAL "fatalogfile" -} SilcConfigServerSectionLogging; +} SilcServerConfigSectionLogging; /* Holds all configured connection classes */ -typedef struct SilcConfigServerSectionConnectionClassStruct { +typedef struct SilcServerConfigSectionConnectionClassStruct { unsigned int class; unsigned int ping_freq; unsigned int connect_freq; unsigned int max_links; - struct SilcConfigServerSectionConnectionClassStruct *next; - struct SilcConfigServerSectionConnectionClassStruct *prev; -} SilcConfigServerSectionConnectionClass; + struct SilcServerConfigSectionConnectionClassStruct *next; + struct SilcServerConfigSectionConnectionClassStruct *prev; +} SilcServerConfigSectionConnectionClass; #define SILC_CONFIG_SERVER_AUTH_METH_PASSWD "passwd" #define SILC_CONFIG_SERVER_AUTH_METH_PUBKEY "pubkey" /* Holds all client authentication data from config file */ -typedef struct SilcConfigServerSectionClientConnectionStruct { +typedef struct SilcServerConfigSectionClientConnectionStruct { char *host; int auth_meth; char *auth_data; unsigned short port; unsigned int class; - struct SilcConfigServerSectionClientConnectionStruct *next; - struct SilcConfigServerSectionClientConnectionStruct *prev; -} SilcConfigServerSectionClientConnection; + struct SilcServerConfigSectionClientConnectionStruct *next; + struct SilcServerConfigSectionClientConnectionStruct *prev; +} SilcServerConfigSectionClientConnection; /* Hols all server's administrators authentication data from config file */ -typedef struct SilcConfigServerSectionAdminConnectionStruct { +typedef struct SilcServerConfigSectionAdminConnectionStruct { char *host; int auth_meth; char *auth_data; char *nickname; unsigned int class; - struct SilcConfigServerSectionAdminConnectionStruct *next; - struct SilcConfigServerSectionAdminConnectionStruct *prev; -} SilcConfigServerSectionAdminConnection; + struct SilcServerConfigSectionAdminConnectionStruct *next; + struct SilcServerConfigSectionAdminConnectionStruct *prev; +} SilcServerConfigSectionAdminConnection; /* Holds all configured server/router connections from config file */ -typedef struct SilcConfigServerSectionServerConnectionStruct { +typedef struct SilcServerConfigSectionServerConnectionStruct { char *host; int auth_meth; char *auth_data; @@ -123,9 +123,9 @@ typedef struct SilcConfigServerSectionServerConnectionStruct { char *version; unsigned int class; int initiator; - struct SilcConfigServerSectionServerConnectionStruct *next; - struct SilcConfigServerSectionServerConnectionStruct *prev; -} SilcConfigServerSectionServerConnection; + struct SilcServerConfigSectionServerConnectionStruct *next; + struct SilcServerConfigSectionServerConnectionStruct *prev; +} SilcServerConfigSectionServerConnection; /* Holds all configured denied connections from config file */ typedef struct { @@ -133,18 +133,18 @@ typedef struct { char *time; char *comment; unsigned short port; -} SilcConfigServerSectionDenyConnection; +} SilcServerConfigSectionDenyConnection; /* Holds all client redirections from config file */ typedef struct { char *host; unsigned short port; -} SilcConfigServerSectionRedirectClient; +} SilcServerConfigSectionRedirectClient; /* Holds motd file */ typedef struct { char *motd_file; -} SilcConfigServerSectionMotd; +} SilcServerConfigSectionMotd; /* SILC Server Config object. @@ -161,25 +161,25 @@ typedef struct { char *filename; /* Configuration sections */ - SilcConfigServerSectionAlg *cipher; - SilcConfigServerSectionAlg *pkcs; - SilcConfigServerSectionAlg *hash_func; - SilcConfigServerSectionServerInfo *server_info; - SilcConfigServerSectionAdminInfo *admin_info; - SilcConfigServerSectionListenPort *listen_port; - SilcConfigServerSectionIdentity *identity; - SilcConfigServerSectionLogging *logging; - SilcConfigServerSectionConnectionClass *conn_class; - SilcConfigServerSectionClientConnection *clients; - SilcConfigServerSectionServerConnection *servers; - SilcConfigServerSectionServerConnection *routers; - SilcConfigServerSectionAdminConnection *admins; - SilcConfigServerSectionDenyConnection *denied; - SilcConfigServerSectionRedirectClient *redirect; - SilcConfigServerSectionMotd *motd; -} SilcConfigServerObject; - -typedef SilcConfigServerObject *SilcConfigServer; + SilcServerConfigSectionAlg *cipher; + SilcServerConfigSectionAlg *pkcs; + SilcServerConfigSectionAlg *hash_func; + SilcServerConfigSectionServerInfo *server_info; + SilcServerConfigSectionAdminInfo *admin_info; + SilcServerConfigSectionListenPort *listen_port; + SilcServerConfigSectionIdentity *identity; + SilcServerConfigSectionLogging *logging; + SilcServerConfigSectionConnectionClass *conn_class; + SilcServerConfigSectionClientConnection *clients; + SilcServerConfigSectionServerConnection *servers; + SilcServerConfigSectionServerConnection *routers; + SilcServerConfigSectionAdminConnection *admins; + SilcServerConfigSectionDenyConnection *denied; + SilcServerConfigSectionRedirectClient *redirect; + SilcServerConfigSectionMotd *motd; +} SilcServerConfigObject; + +typedef SilcServerConfigObject *SilcServerConfig; /* Configuration section type enumerations. */ typedef enum { @@ -200,27 +200,27 @@ typedef enum { SILC_CONFIG_SERVER_SECTION_TYPE_DENY_CONNECTION, SILC_CONFIG_SERVER_SECTION_TYPE_REDIRECT_CLIENT, SILC_CONFIG_SERVER_SECTION_TYPE_MOTD, -} SilcConfigServerSectionType; +} SilcServerConfigSectionType; /* SILC Configuration Section structure. */ typedef struct { const char *section; - SilcConfigServerSectionType type; + SilcServerConfigSectionType type; unsigned int maxfields; -} SilcConfigServerSection; +} SilcServerConfigSection; /* LIst of all possible config sections in SILC server. */ -extern SilcConfigServerSection silc_config_server_sections[]; +extern SilcServerConfigSection silc_server_config_sections[]; /* Structure used in parsing the configuration lines. The line is read from a file to this structure before parsing it further. */ -typedef struct SilcConfigServerParseStruct { +typedef struct SilcServerConfigParseStruct { SilcBuffer line; unsigned int linenum; - SilcConfigServerSection *section; - struct SilcConfigServerParseStruct *next; - struct SilcConfigServerParseStruct *prev; -} *SilcConfigServerParse; + SilcServerConfigSection *section; + struct SilcServerConfigParseStruct *next; + struct SilcServerConfigParseStruct *prev; +} *SilcServerConfigParse; /* Macros */ @@ -243,26 +243,26 @@ do { \ } while(0) /* Prototypes */ -SilcConfigServer silc_config_server_alloc(char *filename); -void silc_config_server_free(SilcConfigServer config); -int silc_config_server_parse(SilcConfigServer config, SilcBuffer buffer, - SilcConfigServerParse *return_config); -int silc_config_server_parse_lines(SilcConfigServer config, - SilcConfigServerParse parse_config); -int silc_config_server_check_sections(unsigned int checkmask); -void silc_config_server_setlogfiles(SilcConfigServer config); -void silc_config_server_register_ciphers(SilcConfigServer config); -void silc_config_server_register_pkcs(SilcConfigServer config); -void silc_config_server_register_hashfuncs(SilcConfigServer config); -SilcConfigServerSectionClientConnection * -silc_config_server_find_client_conn(SilcConfigServer config, +SilcServerConfig silc_server_config_alloc(char *filename); +void silc_server_config_free(SilcServerConfig config); +int silc_server_config_parse(SilcServerConfig config, SilcBuffer buffer, + SilcServerConfigParse *return_config); +int silc_server_config_parse_lines(SilcServerConfig config, + SilcServerConfigParse parse_config); +int silc_server_config_check_sections(unsigned int checkmask); +void silc_server_config_setlogfiles(SilcServerConfig config); +void silc_server_config_register_ciphers(SilcServerConfig config); +void silc_server_config_register_pkcs(SilcServerConfig config); +void silc_server_config_register_hashfuncs(SilcServerConfig config); +SilcServerConfigSectionClientConnection * +silc_server_config_find_client_conn(SilcServerConfig config, char *host, int port); -SilcConfigServerSectionServerConnection * -silc_config_server_find_server_conn(SilcConfigServer config, +SilcServerConfigSectionServerConnection * +silc_server_config_find_server_conn(SilcServerConfig config, char *host, int port); -SilcConfigServerSectionServerConnection * -silc_config_server_find_router_conn(SilcConfigServer config, +SilcServerConfigSectionServerConnection * +silc_server_config_find_router_conn(SilcServerConfig config, char *host, int port); -void silc_config_server_print(); +void silc_server_config_print(); #endif diff --git a/apps/silcd/silcd.c b/apps/silcd/silcd.c index 54369353..db974ec7 100644 --- a/apps/silcd/silcd.c +++ b/apps/silcd/silcd.c @@ -82,7 +82,7 @@ int main(int argc, char **argv) break; case 'c': /* Print out example configuration file */ - silc_config_server_print(); + silc_server_config_print(); exit(0); break; case 'd': @@ -108,7 +108,7 @@ int main(int argc, char **argv) goto fail; /* Read configuration files */ - silcd->config = silc_config_server_alloc(config_file); + silcd->config = silc_server_config_alloc(config_file); if (silcd->config == NULL) goto fail; diff --git a/doc/draft-riikonen-silc-spec-01.nroff b/doc/draft-riikonen-silc-spec-01.nroff index 31f490f0..00b37a35 100644 --- a/doc/draft-riikonen-silc-spec-01.nroff +++ b/doc/draft-riikonen-silc-spec-01.nroff @@ -2195,6 +2195,7 @@ List of all defined commands in SILC follows. SILC_STATUS_ERR_TOO_MANY_PARAMS SILC_STATUS_ERR_NO_SUCH_CLIENT_ID SILC_STATUS_ERR_NO_CLIENT_ID + SILC_STATUS_ERR_NO_ROUTER_PRIV 10 SILC_COMMAND_INFO diff --git a/lib/silccore/silcauth.c b/lib/silccore/silcauth.c index 4bee9bad..139ec176 100644 --- a/lib/silccore/silcauth.c +++ b/lib/silccore/silcauth.c @@ -52,7 +52,7 @@ SilcAuthPayload silc_auth_payload_parse(SilcBuffer buffer) /* Parse the payload */ ret = silc_buffer_unformat(buffer, SILC_STR_UI_SHORT(&new->len), - SILC_STR_UI_CHAR(&new->auth_method), + SILC_STR_UI_SHORT(&new->auth_method), SILC_STR_UI16_NSTRING_ALLOC(&new->random_data, &new->random_len), SILC_STR_UI16_NSTRING_ALLOC(&new->auth_data,