From: Pekka Riikonen Date: Thu, 24 May 2001 17:25:26 +0000 (+0000) Subject: updates. X-Git-Tag: robodoc-323~298 X-Git-Url: http://git.silcnet.org/gitweb/?a=commitdiff_plain;h=c46257aff172b7bff9c0fe560ae377543934ff64;p=silc.git updates. --- diff --git a/apps/irssi/src/core/modules.c b/apps/irssi/src/core/modules.c index 0dac04ae..4bcbbe75 100644 --- a/apps/irssi/src/core/modules.c +++ b/apps/irssi/src/core/modules.c @@ -255,7 +255,7 @@ static GModule *module_open(const char *name) path = g_strdup(name); else { /* first try from home dir */ - str = g_strdup_printf("%s/.irssi/modules", g_get_home_dir()); + str = g_strdup_printf("%s/.silc/modules", g_get_home_dir()); path = g_module_build_path(str, name); g_free(str); diff --git a/apps/irssi/src/core/settings.c b/apps/irssi/src/core/settings.c index 0169b268..28485601 100644 --- a/apps/irssi/src/core/settings.c +++ b/apps/irssi/src/core/settings.c @@ -532,7 +532,7 @@ static void init_configfile(void) struct stat statbuf; char *str; - str = g_strdup_printf("%s"G_DIR_SEPARATOR_S".irssi", g_get_home_dir()); + str = g_strdup_printf("%s"G_DIR_SEPARATOR_S".silc", g_get_home_dir()); if (stat(str, &statbuf) != 0) { /* ~/.irssi not found, create it. */ if (mkpath(str, 0700) != 0) { @@ -563,7 +563,7 @@ int settings_reread(const char *fname) CONFIG_REC *tempconfig; char *str; - if (fname == NULL) fname = "~/.irssi/config"; + if (fname == NULL) fname = "~/.silc/config"; str = convert_home(fname); tempconfig = parse_configfile(str); diff --git a/apps/irssi/src/fe-common/core/fe-help.c b/apps/irssi/src/fe-common/core/fe-help.c index fa90473d..c2e132de 100644 --- a/apps/irssi/src/fe-common/core/fe-help.c +++ b/apps/irssi/src/fe-common/core/fe-help.c @@ -166,7 +166,7 @@ static void show_help(const char *data) /* category changed */ if (items > 0) { if (!header) { - printtext(NULL, NULL, MSGLEVEL_CLIENTCRAP, "Irssi commands:"); + printtext(NULL, NULL, MSGLEVEL_CLIENTCRAP, "Commands:"); header = TRUE; } if (last->category != NULL) { @@ -217,7 +217,7 @@ static void show_help(const char *data) /* display the last category */ if (!header) { printtext(NULL, NULL, MSGLEVEL_CLIENTCRAP, - "Irssi commands:"); + "Commands:"); header = TRUE; } diff --git a/apps/irssi/src/fe-common/core/fe-settings.c b/apps/irssi/src/fe-common/core/fe-settings.c index 90262ee0..0d8aaa93 100644 --- a/apps/irssi/src/fe-common/core/fe-settings.c +++ b/apps/irssi/src/fe-common/core/fe-settings.c @@ -244,7 +244,7 @@ static void cmd_reload(const char *data) char *fname; fname = *data != '\0' ? g_strdup(data) : - g_strdup_printf("%s/.irssi/config", g_get_home_dir()); + g_strdup_printf("%s/.silc/config", g_get_home_dir()); if (settings_reread(fname)) { printformat(NULL, NULL, MSGLEVEL_CLIENTNOTICE, TXT_CONFIG_RELOADED, fname); diff --git a/apps/irssi/src/fe-common/core/module-formats.c b/apps/irssi/src/fe-common/core/module-formats.c index 9ccdd10a..2258c7e4 100644 --- a/apps/irssi/src/fe-common/core/module-formats.c +++ b/apps/irssi/src/fe-common/core/module-formats.c @@ -21,6 +21,8 @@ #include "module.h" #include "formats.h" +// { "line_start_irssi", "{line_start}{hilight Irssi:} ", 0 }, + FORMAT_REC fecommon_core_formats[] = { { MODULE_NAME, "Core", 0 }, @@ -28,7 +30,7 @@ FORMAT_REC fecommon_core_formats[] = { { NULL, "Windows", 0 }, { "line_start", "{line_start}", 0 }, - { "line_start_irssi", "{line_start}{hilight Irssi:} ", 0 }, + { "line_start_irssi", "{line_start} ", 0 }, { "timestamp", "{timestamp $Z} ", 6, { 1, 1, 1, 1, 1, 1 } }, { "servertag", "[$0] ", 1, { 0 } }, { "daychange", "Day changed to $[-2.0]{0} $3 $2", 4, { 1, 1, 1, 0 } }, @@ -41,7 +43,7 @@ FORMAT_REC fecommon_core_formats[] = { { "windowlist_header", "Ref Name Active item Server Level", 0 }, { "windowlist_line", "$[3]0 %|$[20]1 $[15]2 $[15]3 $4", 5, { 1, 0, 0, 0, 0 } }, { "windowlist_footer", "", 0 }, - { "windows_layout_saved", "Layout of windows is now remembered next time you start irssi", 0 }, + { "windows_layout_saved", "Layout of windows is now remembered next time you start silc", 0 }, { "windows_layout_reset", "Layout of windows reset to defaults", 0 }, /* ---- */ @@ -147,7 +149,7 @@ FORMAT_REC fecommon_core_formats[] = { { "log_opened", "Log file {hilight $0} opened", 1, { 0 } }, { "log_closed", "Log file {hilight $0} closed", 1, { 0 } }, { "log_create_failed", "Couldn't create log file {hilight $0}: $1", 2, { 0, 0 } }, - { "log_locked", "Log file {hilight $0} is locked, probably by another running Irssi", 1, { 0 } }, + { "log_locked", "Log file {hilight $0} is locked, probably by another running Irssi-SILC", 1, { 0 } }, { "log_not_open", "Log file {hilight $0} not open", 1, { 0 } }, { "log_started", "Started logging to file {hilight $0}", 1, { 0 } }, { "log_stopped", "Stopped logging to file {hilight $0}", 1, { 0 } }, @@ -167,7 +169,7 @@ FORMAT_REC fecommon_core_formats[] = { { "module_footer", "", 0, }, { "module_already_loaded", "Module {hilight $0} already loaded", 1, { 0 } }, { "module_load_error", "Error loading module {hilight $0}: $1", 2, { 0, 0 } }, - { "module_invalid", "{hilight $0} isn't Irssi module", 1, { 0 } }, + { "module_invalid", "{hilight $0} isn't Irssi-SILC module", 1, { 0 } }, { "module_loaded", "Loaded module {hilight $0}", 1, { 0 } }, { "module_unloaded", "Unloaded module {hilight $0}", 1, { 0 } }, @@ -220,7 +222,7 @@ FORMAT_REC fecommon_core_formats[] = { { "bind_unknown_id", "Unknown bind action: $0", 1, { 0 } }, { "config_saved", "Saved configuration to file $0", 1, { 0 } }, { "config_reloaded", "Reloaded configuration", 1, { 0 } }, - { "config_modified", "Configuration file was modified since irssi was last started - do you want to overwrite the possible changes?", 1, { 0 } }, + { "config_modified", "Configuration file was modified since Irssi-SILC was last started - do you want to overwrite the possible changes?", 1, { 0 } }, { "glib_error", "{error GLib $0} $1", 2, { 0, 0 } }, { "overwrite_config", "Overwrite config (y/N)?", 0 }, diff --git a/apps/irssi/src/fe-common/core/themes.c b/apps/irssi/src/fe-common/core/themes.c index de9b6dee..ca26f68f 100644 --- a/apps/irssi/src/fe-common/core/themes.c +++ b/apps/irssi/src/fe-common/core/themes.c @@ -701,7 +701,7 @@ THEME_REC *theme_load(const char *setname) theme = theme_find(name); /* check home dir */ - fname = g_strdup_printf("%s/.irssi/%s.theme", g_get_home_dir(), name); + fname = g_strdup_printf("%s/.silc/%s.theme", g_get_home_dir(), name); if (stat(fname, &statbuf) != 0) { /* check global config dir */ g_free(fname); @@ -1004,8 +1004,8 @@ static void theme_save(THEME_REC *theme) g_hash_table_foreach(theme->modules, (GHFunc) module_save, config); - /* always save the theme to ~/.irssi/ */ - path = g_strdup_printf("%s/.irssi/%s", g_get_home_dir(), + /* always save the theme to ~/.silc/ */ + path = g_strdup_printf("%s/.silc/%s", g_get_home_dir(), g_basename(theme->path)); ok = config_write(config, path, 0660) == 0; @@ -1131,7 +1131,7 @@ static void themes_read(void) /* first there's default theme.. */ current_theme = theme_load("default"); if (current_theme == NULL) { - fname = g_strdup_printf("%s/.irssi/default.theme", + fname = g_strdup_printf("%s/.silc/default.theme", g_get_home_dir()); current_theme = theme_create(fname, "default"); current_theme->default_color = 0; diff --git a/apps/irssi/src/fe-text/silc.c b/apps/irssi/src/fe-text/silc.c index 9112b568..7c05703c 100644 --- a/apps/irssi/src/fe-text/silc.c +++ b/apps/irssi/src/fe-text/silc.c @@ -204,7 +204,7 @@ static void check_oldcrap(void) int found; /* check that default.theme is up-to-date */ - path = g_strdup_printf("%s/.irssi/default.theme", g_get_home_dir()); + path = g_strdup_printf("%s/.silc/default.theme", g_get_home_dir()); f = fopen(path, "r+"); if (f == NULL) { g_free(path); @@ -220,7 +220,7 @@ static void check_oldcrap(void) return; } - printf("\nYou seem to have old default.theme in ~/.irssi/ directory.\n"); + printf("\nYou seem to have old default.theme in ~/.silc/ directory.\n"); printf("Themeing system has changed a bit since last irssi release,\n"); printf("you should either delete your old default.theme or manually\n"); printf("merge it with the new default.theme.\n\n"); @@ -238,7 +238,7 @@ static void check_files(void) struct stat statbuf; char *path; - path = g_strdup_printf("%s/.irssi", g_get_home_dir()); + path = g_strdup_printf("%s/.silc", g_get_home_dir()); if (stat(path, &statbuf) != 0) { /* ~/.irssi doesn't exist, first time running irssi */ display_firsttimer = TRUE; @@ -280,6 +280,7 @@ int main(int argc, char **argv) textui_init(); args_execute(argc, argv); + silc_init_finish(); if (!init_screen()) g_error("Can't initialize screen handling, quitting.\n"); diff --git a/apps/irssi/src/silc/core/Makefile.am b/apps/irssi/src/silc/core/Makefile.am index b25d7430..5de213a0 100644 --- a/apps/irssi/src/silc/core/Makefile.am +++ b/apps/irssi/src/silc/core/Makefile.am @@ -1,30 +1,29 @@ -moduledir = $(libdir)/irssi/modules - INCLUDES = $(GLIB_CFLAGS) -I$(IRSSI_INCLUDE) -I$(IRSSI_INCLUDE)/src -module_LTLIBRARIES = libsilc_core.la - -libsilc_core_la_LDFLAGS = -avoid-version +SILC_INCLUDE=../../../.. +IRSSI_INCLUDE=../../.. INCLUDES = \ - $(GLIB_CFLAGS) \ - -DSYSCONFDIR=\""$(sysconfdir)"\" \ - -I$(IRSSI_INCLUDE) -I$(IRSSI_INCLUDE)/src \ - -I$(IRSSI_INCLUDE)/src/core \ - -I$(SILC_INCLUDE)/includes \ - -I$(SILC_INCLUDE)/lib/silccore \ - -I$(SILC_INCLUDE)/lib/silccrypt \ - -I$(SILC_INCLUDE)/lib/silcmath \ - -I$(SILC_INCLUDE)/lib/silcske \ - -I$(SILC_INCLUDE)/lib/silcsim \ - -I$(SILC_INCLUDE)/lib/silcutil \ - -I$(SILC_INCLUDE)/lib/silcclient \ - -I$(SILC_INCLUDE)/lib/silcmath/gmp \ - -I$(SILC_INCLUDE)/lib/trq - -libsilc_core_la_DEPENDENCIES = .libs/libsilcclient.a .libs/libsilcorig.a - -libsilc_core_la_SOURCES = \ + $(GLIB_CFLAGS) \ + -DSYSCONFDIR=\""$(sysconfdir)"\" \ + -I$(IRSSI_INCLUDE) -I$(IRSSI_INCLUDE)/src \ + -I$(IRSSI_INCLUDE)/src/core \ + -I$(SILC_INCLUDE)/includes \ + -I$(SILC_INCLUDE)/lib/silccore \ + -I$(SILC_INCLUDE)/lib/silccrypt \ + -I$(SILC_INCLUDE)/lib/silcmath \ + -I$(SILC_INCLUDE)/lib/silcske \ + -I$(SILC_INCLUDE)/lib/silcsim \ + -I$(SILC_INCLUDE)/lib/silcutil \ + -I$(SILC_INCLUDE)/lib/silcclient \ + -I$(SILC_INCLUDE)/lib/silcmath/gmp \ + -I$(SILC_INCLUDE)/lib/trq + +noinst_LIBRARIES=libsilc_core.a + +libsilc_core_a_SOURCES = \ + clientutil.c \ + clientconfig.c \ silc-channels.c \ silc-core.c \ silc-nicklist.c \ @@ -39,20 +38,3 @@ noinst_HEADERS = \ silc-nicklist.h \ silc-queries.h \ silc-servers.h - -SILC_LIBS = \ - libsilcclient.la \ - libsilcorig.la - -libsilc_core_la_LIBADD = \ - $(SILC_LIBS) - -EXTRA_DIST = \ - $(SILC_LIBS) - -.libs/libsilcclient.a: - if [ ! -d .libs ]; then mkdir .libs; fi - cd .libs && ln -sf ../../../libsilcclient.a . && cd .. - -.libs/libsilcorig.a: .libs/libsilcclient.a - cd .libs && ln -sf ../../../libsilcorig.a . && cd .. diff --git a/apps/irssi/src/silc/core/clientconfig.c b/apps/irssi/src/silc/core/clientconfig.c new file mode 100644 index 00000000..6db8c6e7 --- /dev/null +++ b/apps/irssi/src/silc/core/clientconfig.c @@ -0,0 +1,837 @@ +/* + + serverconfig.c + + Author: Pekka Riikonen + + Copyright (C) 1997 - 2001 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 + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + +*/ +/* $Id$ */ + +#include "module.h" + +#include "net-nonblock.h" +#include "net-sendbuffer.h" +#include "signals.h" +#include "servers.h" +#include "commands.h" +#include "levels.h" +#include "modules.h" +#include "rawlog.h" +#include "misc.h" +#include "settings.h" + +#include "servers-setup.h" + +#include "silc-servers.h" +#include "silc-channels.h" +#include "silc-queries.h" +#include "window-item-def.h" + +#include "fe-common/core/printtext.h" + +/* + All possible configuration sections for SILC client. +*/ +SilcClientConfigSection silc_client_config_sections[] = { + { "[cipher]", + SILC_CLIENT_CONFIG_SECTION_TYPE_CIPHER, 4 }, + { "[pkcs]", + SILC_CLIENT_CONFIG_SECTION_TYPE_PKCS, 1 }, + { "[hash]", + SILC_CLIENT_CONFIG_SECTION_TYPE_HASH_FUNCTION, 4 }, + { "[hmac]", + SILC_CLIENT_CONFIG_SECTION_TYPE_HMAC, 3 }, + { "[connection]", + SILC_CLIENT_CONFIG_SECTION_TYPE_CONNECTION, 4 }, + + { NULL, SILC_CLIENT_CONFIG_SECTION_TYPE_NONE, 0 } +}; + +/* Allocates a new configuration object, opens configuration file and + parses the file. The parsed data is returned to the newly allocated + configuration object. */ + +SilcClientConfig silc_client_config_alloc(char *filename) +{ + SilcClientConfig new; + SilcBuffer buffer; + SilcClientConfigParse config_parse; + + SILC_LOG_DEBUG(("Allocating new configuration object")); + + new = silc_calloc(1, sizeof(*new)); + new->filename = filename; + + /* Open configuration file and parse it */ + config_parse = NULL; + buffer = NULL; + silc_config_open(filename, &buffer); + if (!buffer) + goto fail; + if ((silc_client_config_parse(new, buffer, &config_parse)) == FALSE) + goto fail; + if ((silc_client_config_parse_lines(new, config_parse)) == FALSE) + goto fail; + + silc_free(buffer); + + return new; + + fail: + silc_free(new); + return NULL; +} + +/* Free's a configuration object. */ + +void silc_client_config_free(SilcClientConfig config) +{ + if (config) { + + silc_free(config); + } +} + +/* Parses the the buffer and returns the parsed lines into return_config + argument. The return_config argument doesn't have to be initialized + before calling this. It will be initialized during the parsing. The + buffer sent as argument can be safely free'd after this function has + succesfully returned. */ + +int silc_client_config_parse(SilcClientConfig config, SilcBuffer buffer, + SilcClientConfigParse *return_config) +{ + int i, begin; + int linenum; + char line[1024], *cp; + SilcClientConfigSection *cptr = NULL; + SilcClientConfigParse parse = *return_config, first = NULL; + + SILC_LOG_DEBUG(("Parsing configuration file")); + + begin = 0; + linenum = 0; + while((begin = silc_gets(line, sizeof(line), + buffer->data, buffer->len, begin)) != EOF) { + cp = line; + linenum++; + + /* Check for bad line */ + if (silc_check_line(cp)) + continue; + + /* Remove tabs and whitespaces from the line */ + if (strchr(cp, '\t')) { + i = 0; + while(strchr(cp + i, '\t')) { + *strchr(cp + i, '\t') = ' '; + i++; + } + } + for (i = 0; i < strlen(cp); i++) { + if (cp[i] != ' ') { + if (i) + cp++; + break; + } + cp++; + } + + /* Parse line */ + switch(cp[0]) { + case '[': + /* + * Start of a section + */ + + /* Remove new line sign */ + if (strchr(cp, '\n')) + *strchr(cp, '\n') = '\0'; + + /* Check for matching sections */ + for (cptr = silc_client_config_sections; cptr->section; cptr++) + if (!strncasecmp(cp, cptr->section, strlen(cptr->section))) + break; + + if (!cptr->section) { + fprintf(stderr, "%s:%d: Unknown section `%s'\n", + config->filename, linenum, cp); + return FALSE; + } + + break; + default: + /* + * Start of a configuration line + */ + + /* Handle config section */ + if (cptr->type != SILC_CLIENT_CONFIG_SECTION_TYPE_NONE) { + + if (strchr(cp, '\n')) + *strchr(cp, '\n') = ':'; + + if (parse == NULL) { + parse = silc_calloc(1, sizeof(*parse)); + parse->line = NULL; + parse->section = NULL; + parse->next = NULL; + parse->prev = NULL; + } else { + if (parse->next == NULL) { + parse->next = silc_calloc(1, sizeof(*parse->next)); + parse->next->line = NULL; + parse->next->section = NULL; + parse->next->next = NULL; + parse->next->prev = parse; + parse = parse->next; + } + } + + if (first == NULL) + first = parse; + + /* Add the line to parsing structure for further parsing. */ + if (parse) { + parse->section = cptr; + parse->line = silc_buffer_alloc(strlen(cp) + 1); + parse->linenum = linenum; + silc_buffer_pull_tail(parse->line, strlen(cp)); + silc_buffer_put(parse->line, cp, strlen(cp)); + } + } + break; + } + } + + /* Set the return_config argument to its first value so that further + parsing can be started from the first line. */ + *return_config = first; + + return TRUE; +} + +/* Parses the lines earlier read from configuration file. The config object + must not be initialized, it will be initialized in this function. The + parse_config argument is uninitialized automatically during this + function. */ + +int silc_client_config_parse_lines(SilcClientConfig config, + SilcClientConfigParse parse_config) +{ + int ret, check = FALSE; + char *tmp; + SilcClientConfigParse pc = parse_config; + SilcBuffer line; + + SILC_LOG_DEBUG(("Parsing configuration lines")); + + if (!config) + return FALSE; + + while(pc) { + check = FALSE; + line = pc->line; + + /* Get number of tokens in line (command section is handeled + specially and has no tokens at all). */ + ret = silc_config_check_num_token(line); + if (ret != pc->section->maxfields) { + /* Bad line */ + fprintf(stderr, "%s:%d: Missing tokens, %d tokens (should be %d)\n", + config->filename, pc->linenum, ret, + pc->section->maxfields); + break; + } + + /* Parse the line */ + switch(pc->section->type) { + case SILC_CLIENT_CONFIG_SECTION_TYPE_CIPHER: + + if (!config->cipher) { + config->cipher = silc_calloc(1, sizeof(*config->cipher)); + config->cipher->next = NULL; + config->cipher->prev = NULL; + } else { + if (!config->cipher->next) { + config->cipher->next = + silc_calloc(1, sizeof(*config->cipher->next)); + config->cipher->next->next = NULL; + config->cipher->next->prev = config->cipher; + config->cipher = config->cipher->next; + } + } + + /* Get cipher name */ + ret = silc_config_get_token(line, &config->cipher->alg_name); + if (ret < 0) + break; + if (ret == 0) { + fprintf(stderr, "%s:%d: Cipher name not defined\n", + config->filename, pc->linenum); + break; + } + + /* Get module name */ + config->cipher->sim_name = NULL; + ret = silc_config_get_token(line, &config->cipher->sim_name); + if (ret < 0) + break; + + /* Get key 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", + config->filename, pc->linenum); + break; + } + config->cipher->key_len = atoi(tmp); + silc_free(tmp); + + /* Get block 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", + config->filename, pc->linenum); + break; + } + config->cipher->block_len = atoi(tmp); + silc_free(tmp); + + check = TRUE; + break; + + case SILC_CLIENT_CONFIG_SECTION_TYPE_PKCS: + + if (!config->pkcs) { + config->pkcs = silc_calloc(1, sizeof(*config->pkcs)); + config->pkcs->next = NULL; + config->pkcs->prev = NULL; + } else { + if (!config->pkcs->next) { + config->pkcs->next = + silc_calloc(1, sizeof(*config->pkcs->next)); + config->pkcs->next->next = NULL; + config->pkcs->next->prev = config->pkcs; + config->pkcs = config->pkcs->next; + } + } + + /* Get PKCS name */ + ret = silc_config_get_token(line, &config->pkcs->alg_name); + if (ret < 0) + break; + if (ret == 0) { + fprintf(stderr, "%s:%d: PKCS name not defined\n", + config->filename, pc->linenum); + break; + } + + check = TRUE; + break; + + case SILC_CLIENT_CONFIG_SECTION_TYPE_HASH_FUNCTION: + + if (!config->hash_func) { + config->hash_func = silc_calloc(1, sizeof(*config->hash_func)); + config->hash_func->next = NULL; + config->hash_func->prev = NULL; + } else { + if (!config->hash_func->next) { + config->hash_func->next = + silc_calloc(1, sizeof(*config->hash_func->next)); + config->hash_func->next->next = NULL; + config->hash_func->next->prev = config->hash_func; + config->hash_func = config->hash_func->next; + } + } + + /* Get Hash function name */ + ret = silc_config_get_token(line, &config->hash_func->alg_name); + if (ret < 0) + break; + if (ret == 0) { + fprintf(stderr, "%s:%d: Hash function name not defined\n", + config->filename, pc->linenum); + break; + } + + /* Get Hash function module name */ + config->hash_func->sim_name = NULL; + ret = silc_config_get_token(line, &config->hash_func->sim_name); + if (ret < 0) + break; + + /* Get block length */ + ret = silc_config_get_token(line, &tmp); + if (ret < 0) + break; + if (ret == 0) { + fprintf(stderr, "%s:%d: Hash function block length not defined\n", + config->filename, pc->linenum); + break; + } + config->hash_func->block_len = atoi(tmp); + silc_free(tmp); + + /* Get hash length */ + ret = silc_config_get_token(line, &tmp); + if (ret < 0) + break; + if (ret == 0) { + fprintf(stderr, "%s:%d: Hash function hash length not defined\n", + config->filename, pc->linenum); + break; + } + config->hash_func->key_len = atoi(tmp); + silc_free(tmp); + + check = TRUE; + break; + + case SILC_CLIENT_CONFIG_SECTION_TYPE_HMAC: + + if (!config->hmac) { + config->hmac = silc_calloc(1, sizeof(*config->hmac)); + config->hmac->next = NULL; + config->hmac->prev = NULL; + } else { + if (!config->hmac->next) { + config->hmac->next = + silc_calloc(1, sizeof(*config->hmac->next)); + config->hmac->next->next = NULL; + config->hmac->next->prev = config->hmac; + config->hmac = config->hmac->next; + } + } + + /* Get HMAC name */ + ret = silc_config_get_token(line, &config->hmac->alg_name); + if (ret < 0) + break; + if (ret == 0) { + fprintf(stderr, "%s:%d: HMAC name not defined\n", + config->filename, pc->linenum); + break; + } + + /* Get Hash function name */ + ret = silc_config_get_token(line, &config->hmac->sim_name); + if (ret < 0) + break; + if (ret == 0) { + fprintf(stderr, "%s:%d: Hash function name not defined\n", + config->filename, pc->linenum); + break; + } + + /* Get MAC length */ + ret = silc_config_get_token(line, &tmp); + if (ret < 0) + break; + if (ret == 0) { + fprintf(stderr, "%s:%d: HMAC's MAC length not defined\n", + config->filename, pc->linenum); + break; + } + config->hmac->key_len = atoi(tmp); + silc_free(tmp); + + check = TRUE; + break; + + case SILC_CLIENT_CONFIG_SECTION_TYPE_CONNECTION: + + if (!config->conns) { + config->conns = silc_calloc(1, sizeof(*config->conns)); + config->conns->next = NULL; + config->conns->prev = NULL; + } else { + if (!config->conns->next) { + config->conns->next = silc_calloc(1, sizeof(*config->conns)); + config->conns->next->next = NULL; + config->conns->next->prev = config->conns; + config->conns = config->conns->next; + } + } + + /* Get host */ + ret = silc_config_get_token(line, &config->conns->host); + if (ret < 0) + break; + if (ret == 0) + /* Any host */ + config->conns->host = strdup("*"); + + /* Get authentication method */ + ret = silc_config_get_token(line, &tmp); + if (ret < 0) + break; + if (ret) { + if (strcmp(tmp, SILC_CLIENT_CONFIG_AUTH_METH_PASSWD) && + strcmp(tmp, SILC_CLIENT_CONFIG_AUTH_METH_PUBKEY)) { + fprintf(stderr, "%s:%d: Unknown authentication method '%s'\n", + config->filename, pc->linenum, tmp); + break; + } + + if (!strcmp(tmp, SILC_CLIENT_CONFIG_AUTH_METH_PASSWD)) + config->conns->auth_meth = SILC_AUTH_PASSWORD; + + if (!strcmp(tmp, SILC_CLIENT_CONFIG_AUTH_METH_PUBKEY)) + config->conns->auth_meth = SILC_AUTH_PUBLIC_KEY; + + silc_free(tmp); + } + + /* Get authentication data */ + ret = silc_config_get_token(line, &config->conns->auth_data); + if (ret < 0) + break; + + /* Get port */ + ret = silc_config_get_token(line, &tmp); + if (ret < 0) + break; + if (ret) { + config->conns->port = atoi(tmp); + silc_free(tmp); + } + + check = TRUE; + break; + + case SILC_CLIENT_CONFIG_SECTION_TYPE_NONE: + default: + break; + } + + /* Check for error */ + if (check == FALSE) { + /* Line could not be parsed */ + fprintf(stderr, "%s:%d: Parse error\n", config->filename, pc->linenum); + break; + } + + pc = pc->next; + } + + if (check == FALSE) + return FALSE;; + + /* Before returning all the lists in the config object must be set + to their first values (the last value is first here). */ + while (config->cipher && config->cipher->prev) + config->cipher = config->cipher->prev; + while (config->pkcs && config->pkcs->prev) + config->pkcs = config->pkcs->prev; + while (config->hash_func && config->hash_func->prev) + config->hash_func = config->hash_func->prev; + while (config->hmac && config->hmac->prev) + config->hmac = config->hmac->prev; + while (config->conns && config->conns->prev) + config->conns = config->conns->prev; + + SILC_LOG_DEBUG(("Done")); + + return TRUE; +} + +/* Registers configured ciphers. These can then be allocated by the + client when needed. */ + +bool silc_client_config_register_ciphers(SilcClientConfig config) +{ + SilcClientConfigSectionAlg *alg; + SilcClient client = config->client; + + SILC_LOG_DEBUG(("Registering configured ciphers")); + + if (!config->cipher) + return FALSE; + + alg = config->cipher; + while(alg) { + + if (!alg->sim_name) { + /* Crypto module is supposed to be built in. Get the pointer to the + built in cipher and register it. */ + int i; + + for (i = 0; silc_default_ciphers[i].name; i++) + if (!strcmp(silc_default_ciphers[i].name, alg->alg_name)) { + silc_cipher_register(&silc_default_ciphers[i]); + break; + } + + if (!silc_cipher_is_supported(alg->alg_name)) { + SILC_LOG_ERROR(("Unknown cipher `%s'", alg->alg_name)); + silc_client_stop(client); + exit(1); + } + +#ifdef SILC_SIM + } else { + /* 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; + cipher.block_len = alg->block_len; + cipher.key_len = alg->key_len * 8; + + sim = silc_sim_alloc(); + 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_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_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_name, + SILC_CIPHER_SIM_ENCRYPT_CBC)); + SILC_LOG_DEBUG(("encrypt_cbc=%p", cipher.encrypt)); + cipher.decrypt = + 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_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 client */ + sims = silc_realloc(sims, + sizeof(*sims) * + (sims_count + 1)); + sims[sims_count] = sim; + sims_count++; + + silc_free(alg_name); + } else { + SILC_LOG_ERROR(("Error configuring ciphers")); + silc_client_stop(client); + exit(1); + } + + /* Register the cipher */ + silc_cipher_register(&cipher); +#endif + } + + alg = alg->next; + } + + return TRUE; +} + +/* Registers configured PKCS's. */ + +bool silc_client_config_register_pkcs(SilcClientConfig config) +{ + SilcClientConfigSectionAlg *alg = config->pkcs; + SilcClient client = config->client; + + SILC_LOG_DEBUG(("Registering configured PKCS")); + + if (!alg) + return FALSE; + + while(alg) { + int i; + + for (i = 0; silc_default_pkcs[i].name; i++) + if (!strcmp(silc_default_pkcs[i].name, alg->alg_name)) { + silc_pkcs_register(&silc_default_pkcs[i]); + break; + } + + if (!silc_pkcs_is_supported(alg->alg_name)) { + SILC_LOG_ERROR(("Unknown PKCS `%s'", alg->alg_name)); + silc_client_stop(client); + exit(1); + } + + alg = alg->next; + } + + return TRUE; +} + +/* Registers configured hash funtions. These can then be allocated by the + client when needed. */ + +bool silc_client_config_register_hashfuncs(SilcClientConfig config) +{ + SilcClientConfigSectionAlg *alg; + SilcClient client = config->client; + + SILC_LOG_DEBUG(("Registering configured hash functions")); + + if (!config->hash_func) + return FALSE; + + alg = config->hash_func; + while(alg) { + if (!alg->sim_name) { + int i; + + for (i = 0; silc_default_hash[i].name; i++) + if (!strcmp(silc_default_hash[i].name, alg->alg_name)) { + silc_hash_register(&silc_default_hash[i]); + break; + } + + if (!silc_hash_is_supported(alg->alg_name)) { + SILC_LOG_ERROR(("Unknown hash function `%s'", alg->alg_name)); + silc_client_stop(client); + exit(1); + } +#ifdef SILC_SIM + } else { + /* Load (try at least) the hash SIM module */ + SilcHashObject hash; + SilcSimContext *sim; + + memset(&hash, 0, sizeof(hash)); + hash.name = alg->alg_name; + hash.block_len = alg->block_len; + hash.hash_len = alg->key_len; + + sim = silc_sim_alloc(); + sim->type = SILC_SIM_HASH; + sim->libname = alg->sim_name; + + if ((silc_sim_load(sim))) { + hash.init = + silc_sim_getsym(sim, silc_sim_symname(alg->alg_name, + SILC_HASH_SIM_INIT)); + SILC_LOG_DEBUG(("init=%p", hash.init)); + hash.update = + silc_sim_getsym(sim, silc_sim_symname(alg->alg_name, + SILC_HASH_SIM_UPDATE)); + SILC_LOG_DEBUG(("update=%p", hash.update)); + hash.final = + silc_sim_getsym(sim, silc_sim_symname(alg->alg_name, + SILC_HASH_SIM_FINAL)); + SILC_LOG_DEBUG(("final=%p", hash.final)); + hash.context_len = + silc_sim_getsym(sim, silc_sim_symname(alg->alg_name, + SILC_HASH_SIM_CONTEXT_LEN)); + SILC_LOG_DEBUG(("context_len=%p", hash.context_len)); + + /* Put the SIM to the table of all SIM's in client */ + sims = silc_realloc(sims, + sizeof(*sims) * + (sims_count + 1)); + sims[sims_count] = sim; + sims_count++; + } else { + SILC_LOG_ERROR(("Error configuring hash functions")); + silc_client_stop(client); + exit(1); + } + + /* Register the hash function */ + silc_hash_register(&hash); +#endif + } + alg = alg->next; + } + + return TRUE; +} + +/* Registers configured HMACs. These can then be allocated by the + client when needed. */ + +bool silc_client_config_register_hmacs(SilcClientConfig config) +{ + SilcClientConfigSectionAlg *alg; + SilcClient client = config->client; + + SILC_LOG_DEBUG(("Registering configured HMACs")); + + if (!config->hmac) + return FALSE; + + alg = config->hmac; + while(alg) { + SilcHmacObject hmac; + + if (!silc_hash_is_supported(alg->sim_name)) { + SILC_LOG_ERROR(("Unknown hash function `%s' for HMAC `%s'", + alg->sim_name, alg->alg_name)); + silc_client_stop(client); + exit(1); + } + + /* Register the HMAC */ + memset(&hmac, 0, sizeof(hmac)); + hmac.name = alg->alg_name; + hmac.len = alg->key_len; + silc_hmac_register(&hmac); + + alg = alg->next; + } + + return TRUE; +} + +SilcClientConfigSectionConnection * +silc_client_config_find_connection(SilcClientConfig config, + char *host, int port) +{ + int i; + SilcClientConfigSectionConnection *conn = NULL; + + SILC_LOG_DEBUG(("Finding connection")); + + if (!host) + return NULL; + + if (!config->conns) + return NULL; + + conn = config->conns; + for (i = 0; conn; i++) { + if (silc_string_compare(conn->host, host)) + break; + conn = conn->next; + } + + if (!conn) + return NULL; + + SILC_LOG_DEBUG(("Found match")); + + return conn; +} diff --git a/apps/irssi/src/silc/core/clientconfig.h b/apps/irssi/src/silc/core/clientconfig.h new file mode 100644 index 00000000..a9a7f19e --- /dev/null +++ b/apps/irssi/src/silc/core/clientconfig.h @@ -0,0 +1,118 @@ +/* + + clientconfig.h + + Author: Pekka Riikonen + + Copyright (C) 1997 - 2000 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 + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + +*/ + +#ifndef CLIENTCONFIG_H +#define CLIENTCONFIG_H + +/* Holds information of configured algorithms */ +typedef struct SilcClientConfigSectionAlgStruct { + char *alg_name; + char *sim_name; + uint32 block_len; + uint32 key_len; + struct SilcClientConfigSectionAlgStruct *next; + struct SilcClientConfigSectionAlgStruct *prev; +#define SILC_CLIENT_CONFIG_MODNAME "builtin" +} SilcClientConfigSectionAlg; + +/* Holds all server connections from config file */ +typedef struct SilcClientConfigSectionConnectionStruct { + char *host; + int auth_meth; + char *auth_data; + uint16 port; + struct SilcClientConfigSectionConnectionStruct *next; + struct SilcClientConfigSectionConnectionStruct *prev; +#define SILC_CLIENT_CONFIG_AUTH_METH_PASSWD "passwd" +#define SILC_CLIENT_CONFIG_AUTH_METH_PUBKEY "pubkey" +} SilcClientConfigSectionConnection; + +/* + SILC Client Config object. + + This object holds all the data parsed from the SILC client configuration + file. This is mainly used at the initialization of the client. + +*/ +typedef struct { + /* Pointer back to the client */ + void *client; + + /* Filename of the configuration file */ + char *filename; + + /* Configuration sections */ + SilcClientConfigSectionAlg *cipher; + SilcClientConfigSectionAlg *pkcs; + SilcClientConfigSectionAlg *hash_func; + SilcClientConfigSectionAlg *hmac; + SilcClientConfigSectionConnection *conns; +} SilcClientConfigObject; + +typedef SilcClientConfigObject *SilcClientConfig; + +/* Configuration section type enumerations. */ +typedef enum { + SILC_CLIENT_CONFIG_SECTION_TYPE_NONE = 0, + SILC_CLIENT_CONFIG_SECTION_TYPE_CIPHER, + SILC_CLIENT_CONFIG_SECTION_TYPE_PKCS, + SILC_CLIENT_CONFIG_SECTION_TYPE_HASH_FUNCTION, + SILC_CLIENT_CONFIG_SECTION_TYPE_HMAC, + SILC_CLIENT_CONFIG_SECTION_TYPE_CONNECTION, +} SilcClientConfigSectionType; + +/* SILC Configuration Section structure. */ +typedef struct { + const char *section; + SilcClientConfigSectionType type; + int maxfields; +} SilcClientConfigSection; + +/* List of all possible config sections in SILC client */ +extern SilcClientConfigSection silc_client_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 SilcClientConfigParseStruct { + SilcBuffer line; + int linenum; + SilcClientConfigSection *section; + struct SilcClientConfigParseStruct *next; + struct SilcClientConfigParseStruct *prev; +} *SilcClientConfigParse; + +/* Prototypes */ +SilcClientConfig silc_client_config_alloc(char *filename); +void silc_client_config_free(SilcClientConfig config); +int silc_client_config_parse(SilcClientConfig config, SilcBuffer buffer, + SilcClientConfigParse *return_config); +int silc_client_config_parse_lines(SilcClientConfig config, + SilcClientConfigParse parse_config); +int silc_client_config_check_sections(uint32 checkmask); +void silc_client_config_setlogfiles(SilcClientConfig config); +bool silc_client_config_register_ciphers(SilcClientConfig config); +bool silc_client_config_register_pkcs(SilcClientConfig config); +bool silc_client_config_register_hashfuncs(SilcClientConfig config); +bool silc_client_config_register_hmacs(SilcClientConfig config); +SilcClientConfigSectionConnection * +silc_client_config_find_connection(SilcClientConfig config, + char *host, int port); + +#endif diff --git a/apps/irssi/src/silc/core/clientutil.c b/apps/irssi/src/silc/core/clientutil.c index 1bcc9c8b..ee7fcec0 100644 --- a/apps/irssi/src/silc/core/clientutil.c +++ b/apps/irssi/src/silc/core/clientutil.c @@ -19,130 +19,34 @@ */ /* $Id$ */ -#include "clientincludes.h" +#include "module.h" -/* Routine used to print lines to window. This can split the - line neatly if a word would overlap the line. */ +#include "net-nonblock.h" +#include "net-sendbuffer.h" +#include "signals.h" +#include "servers.h" +#include "commands.h" +#include "levels.h" +#include "modules.h" +#include "rawlog.h" +#include "misc.h" +#include "settings.h" -void silc_print_to_window(WINDOW *win, char *message) -{ - int str_len, len; - - str_len = strlen(message); - - if (str_len > COLS - 1) { - /* Split overlapping words to next line */ - /* XXX In principal this is wrong as this modifies the original - string as it replaces the last ' ' with '\n'. This could be done - with little more work so that it would not replace anything. */ - len = COLS - 1; - while (1) { - - while (len && message[len] != ' ') - len--; - - if (!len) - break; - - message[len] = '\n'; - len += COLS - 1; - if (len > str_len) - break; - } - } - - wprintw(win, "%s", message); - wrefresh(win); -} - -/* Prints message to the screen. This is used to print the messages - user is typed and message that came on channels. */ - -void silc_print(SilcClient client, char *msg, ...) -{ - va_list vp; - char message[2048]; - SilcClientInternal app = client->application; - - memset(message, 0, sizeof(message)); - strncat(message, "\n ", 2); - - va_start(vp, msg); - vsprintf(message + 1, msg, vp); - va_end(vp); - - /* Print the message */ - silc_print_to_window(app->screen->output_win[0], message); -} - -/* Returns user's mail path */ - -char *silc_get_mail_path() -{ - char pathbuf[MAXPATHLEN]; - char *path; - -#ifndef _PATH_MAILDIR -#define _PATH_MAILDIR "/var/mail" -#endif - - path = getenv("MAIL"); - if (path) { - strncpy(pathbuf, path, strlen(path)); - } else { - strcpy(pathbuf, _PATH_MAILDIR); - strcat(pathbuf, "/"); - strcat(pathbuf, silc_get_username()); - } +#include "servers-setup.h" - return strdup(pathbuf); -} - -/* gets the number of the user's mails, if possible */ - -int silc_get_number_of_emails() -{ - FILE *tl; - int num = 0; - char *filename; - char data[1024]; - - filename = silc_get_mail_path(); - - tl = fopen(filename, "r"); - if (!tl) { - fprintf(stderr, "Couldn't open mail file (%s).\n", filename); - } else { - while((fscanf(tl, "%s", data)) != EOF) { - if(!strcmp(data, "From:")) - num++; - } - - fclose(tl); - } - - return num; -} - -/* Returns time til next minute changes. Used to update the clock when - needed. */ +#include "silc-servers.h" +#include "silc-channels.h" +#include "silc-queries.h" +#include "window-item-def.h" -int silc_client_time_til_next_min() -{ - time_t curtime; - struct tm *min; - - curtime = time(0); - min = localtime(&curtime); - - return 60 - min->tm_sec; -} +#include "fe-common/core/printtext.h" /* Asks yes/no from user on the input line. Returns TRUE on "yes" and FALSE on "no". */ int silc_client_ask_yes_no(SilcClient client, char *prompt) { +#if 0 SilcClientInternal app = (SilcClientInternal)client->application; char answer[4]; int ret; @@ -173,6 +77,8 @@ int silc_client_ask_yes_no(SilcClient client, char *prompt) silc_screen_input_reset(app->screen); return ret; +#endif + return 0; } /* Lists supported (builtin) ciphers */ @@ -206,6 +112,7 @@ void silc_client_list_pkcs() char *silc_client_get_input(const char *prompt) { +#if 0 char input[2048]; int fd; @@ -230,67 +137,9 @@ char *silc_client_get_input(const char *prompt) if (strchr(input, '\n')) *strchr(input, '\n') = '\0'; - return strdup(input); -} - -/* Displays prompt on command line and takes passphrase with echo - off from user. */ - -char *silc_client_get_passphrase(const char *prompt) -{ -#if 0 - char input[2048]; - char *ret; - int fd; - struct termios to; - struct termios to_old; - - fd = open("/dev/tty", O_RDONLY); - if (fd < 0) { - fprintf(stderr, "silc: %s\n", strerror(errno)); - return NULL; - } - - signal(SIGINT, SIG_IGN); - - /* Get terminal info */ - tcgetattr(fd, &to); - to_old = to; - - /* Echo OFF */ - to.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL); - tcsetattr(fd, TCSANOW, &to); - - memset(input, 0, sizeof(input)); - - printf("%s", prompt); - fflush(stdout); - - if ((read(fd, input, sizeof(input))) < 0) { - fprintf(stderr, "silc: %s\n", strerror(errno)); - return NULL; - } - - if (strlen(input) <= 1) { - tcsetattr(fd, TCSANOW, &to_old); - return NULL; - } - - if (strchr(input, '\n')) - *strchr(input, '\n') = '\0'; - - /* Restore old terminfo */ - tcsetattr(fd, TCSANOW, &to_old); - signal(SIGINT, SIG_DFL); - - ret = silc_calloc(strlen(input), sizeof(char)); - memcpy(ret, input, strlen(input)); - memset(input, 0, sizeof(input)); - return ret; -#else - return NULL; #endif + return NULL; } /* Returns identifier string for public key generation. */ diff --git a/apps/irssi/src/silc/core/clientutil.h b/apps/irssi/src/silc/core/clientutil.h index b4215198..f69a3688 100644 --- a/apps/irssi/src/silc/core/clientutil.h +++ b/apps/irssi/src/silc/core/clientutil.h @@ -22,14 +22,8 @@ #define CLIENTUTIL_H /* Prototypes */ -void silc_print_to_window(WINDOW *win, char *message); -void silc_print(SilcClient client, char *msg, ...); -char *silc_get_mail_path(); -int silc_get_number_of_emails(); -int silc_client_time_til_next_min(); int silc_client_ask_yes_no(SilcClient client, char *prompt); char *silc_client_get_input(const char *prompt); -char *silc_client_get_passphrase(const char *prompt); void silc_client_list_ciphers(); void silc_client_list_hash_funcs(); void silc_client_list_pkcs(); diff --git a/apps/irssi/src/silc/core/silc-core.c b/apps/irssi/src/silc/core/silc-core.c index 98068d3a..9126d6d9 100644 --- a/apps/irssi/src/silc/core/silc-core.c +++ b/apps/irssi/src/silc/core/silc-core.c @@ -20,6 +20,7 @@ #include "module.h" #include "chat-protocols.h" +#include "args.h" #include "chatnets.h" #include "servers-setup.h" @@ -29,6 +30,7 @@ #include "silc-queries.h" #include "silc-nicklist.h" #include "version_internal.h" +#include "version.h" #include "signals.h" #include "levels.h" @@ -53,8 +55,15 @@ static char *opt_keyfile = NULL; static int opt_bits = 0; static int idletag; -static SilcClient silc_client; + +SilcClient silc_client = NULL; +SilcClientConfig silc_config = NULL; extern SilcClientOperations ops; +#ifdef SILC_SIM +/* SIM (SILC Module) table */ +SilcSimContext **sims = NULL; +uint32 sims_count = 0; +#endif static void silc_say(SilcClient client, SilcClientConnection conn, char *msg, ...) @@ -471,10 +480,10 @@ static SERVER_CONNECT_REC *create_server_connect(void) return g_malloc0(sizeof(SILC_SERVER_CONNECT_REC)); } +/* Init SILC. Called from src/fe-text/silc.c */ + void silc_core_init(void) { - CHAT_PROTOCOL_REC *rec; - static struct poptOption options[] = { { "create-key-pair", 'C', POPT_ARG_NONE, &opt_create_keypair, 0, "Create new public key pair", NULL }, @@ -488,6 +497,13 @@ void silc_core_init(void) }; args_register(options); +} + +/* Finalize init. Called from src/fe-text/silc.c */ + +void silc_core_init_finish(void) +{ + CHAT_PROTOCOL_REC *rec; if (opt_create_keypair == TRUE) { /* Create new key pair and exit */ @@ -501,7 +517,7 @@ void silc_core_init(void) exit(0); } - if (opt_keyfile == TRUE) { + if (opt_keyfile) { /* Dump the key */ silc_cipher_register_default(); silc_pkcs_register_default(); @@ -512,18 +528,55 @@ void silc_core_init(void) exit(0); } + /* Allocate SILC client */ silc_client = silc_client_alloc(&ops, NULL); + + /* Load local config file */ + silc_config = silc_client_config_alloc(SILC_CLIENT_HOME_CONFIG_FILE); + + /* Get user information */ silc_client->username = g_strdup(settings_get_str("user_name")); silc_client->hostname = silc_net_localhost(); silc_client->realname = g_strdup(settings_get_str("real_name")); - if (!load_keys(silc_client)) { + /* Register all configured ciphers, PKCS and hash functions. */ + if (silc_config) { + silc_config->client = silc_client; + if (!silc_client_config_register_ciphers(silc_config)) + silc_cipher_register_default(); + if (!silc_client_config_register_pkcs(silc_config)) + silc_pkcs_register_default(); + if (!silc_client_config_register_hashfuncs(silc_config)) + silc_hash_register_default(); + if (!silc_client_config_register_hmacs(silc_config)) + silc_hmac_register_default(); + } else { + /* Register default ciphers, pkcs, hash funtions and hmacs. */ + silc_cipher_register_default(); + silc_pkcs_register_default(); + silc_hash_register_default(); + silc_hmac_register_default(); + } + + /* Check ~/.silc directory and public and private keys */ + if (silc_client_check_silc_dir() == FALSE) { idletag = -1; return; } - silc_client_init(silc_client); + /* Load public and private key */ + if (silc_client_load_keys(silc_client) == FALSE) { + idletag = -1; + return; + } + + /* Initialize the SILC client */ + if (!silc_client_init(silc_client)) { + idletag = -1; + return; + } + /* Register SILC to the irssi */ rec = g_new0(CHAT_PROTOCOL_REC, 1); rec->name = "SILC"; rec->fullname = "Secure Internet Live Conferencing"; @@ -549,6 +602,8 @@ void silc_core_init(void) idletag = g_timeout_add(100, (GSourceFunc) my_silc_scheduler, NULL); } +/* Deinit SILC. Called from src/fe-text/silc.c */ + void silc_core_deinit(void) { if (idletag != -1) { diff --git a/apps/irssi/src/silc/core/silc-core.h b/apps/irssi/src/silc/core/silc-core.h index 968e15c1..15ac7132 100644 --- a/apps/irssi/src/silc/core/silc-core.h +++ b/apps/irssi/src/silc/core/silc-core.h @@ -1,7 +1,39 @@ #ifndef __SILC_CORE_H #define __SILC_CORE_H +#include "clientconfig.h" +#include "clientutil.h" + +/* Default client configuration file. This can be overridden at the + compilation time. Otherwise, use default. This can be overridden on + command line as well. */ +#ifndef SILC_CLIENT_CONFIG_FILE +#define SILC_CLIENT_CONFIG_FILE "/etc/silc/silc.conf" +#endif + +/* Default user configuration file. This file is searched from user's + home directory. This may override global configuration settings. */ +#define SILC_CLIENT_HOME_CONFIG_FILE "~/.silc/silc.conf" + +/* Default public and private key file names */ +#define SILC_CLIENT_PUBLIC_KEY_NAME "public_key.pub" +#define SILC_CLIENT_PRIVATE_KEY_NAME "private_key.prv" + +/* Default key expiration time, one year. */ +#define SILC_CLIENT_KEY_EXPIRES 365 + +/* Default settings for creating key pair */ +#define SILC_CLIENT_DEF_PKCS "rsa" +#define SILC_CLIENT_DEF_PKCS_LEN 1024 + extern SilcClient silc_client; +extern SilcClientConfig silc_config; + +#ifdef SILC_SIM +/* SIM (SILC Module) table */ +extern SilcSimContext **sims; +extern uint32 sims_count; +#endif #define IS_SILC_ITEM(rec) (IS_SILC_CHANNEL(rec) || IS_SILC_QUERY(rec))