+Wed Feb 21 12:44:00 EET 2001 Mika Boström <bostik@lut.fi>
+
+ * 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 <priikone@poseidon.pspt.fi>
* Associated the ID (client or server ID) to the Authentication
}
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);
}
/* 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);
/* 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);
/* 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);
/* 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();
/* 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"));
/* 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) {
SilcHmac sha1hmac;
/* Configuration object */
- SilcConfigServer config;
+ SilcServerConfig config;
/* Random pool */
SilcRng rng;
+<Remote address or name>:<Port>
*/
-SilcConfigServerSection silc_config_server_sections[] = {
+SilcServerConfigSection silc_server_config_sections[] = {
{ "[Cipher]",
SILC_CONFIG_SERVER_SECTION_TYPE_CIPHER, 4 },
{ "[PKCS]",
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);
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"));
/* 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"));
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"));
/* 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;
#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 {
char *server_ip;
char *location;
unsigned short port;
-} SilcConfigServerSectionServerInfo;
+} SilcServerConfigSectionServerInfo;
/* Holds server's administrative information from config file */
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 <Logging> 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;
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 {
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.
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 {
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 */
} 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
break;
case 'c':
/* Print out example configuration file */
- silc_config_server_print();
+ silc_server_config_print();
exit(0);
break;
case 'd':
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;
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
/* 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,
projects / silc.git / commitdiff