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);
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) {
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);
/* 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) {
/* display the last category */
if (!header) {
printtext(NULL, NULL, MSGLEVEL_CLIENTCRAP,
- "Irssi commands:");
+ "Commands:");
header = TRUE;
}
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);
#include "module.h"
#include "formats.h"
+// { "line_start_irssi", "{line_start}{hilight Irssi:} ", 0 },
+
FORMAT_REC fecommon_core_formats[] = {
{ MODULE_NAME, "Core", 0 },
{ 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 } },
{ "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 },
/* ---- */
{ "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 } },
{ "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 } },
{ "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 },
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);
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;
/* 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;
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);
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");
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;
textui_init();
args_execute(argc, argv);
+ silc_init_finish();
if (!init_screen())
g_error("Can't initialize screen handling, quitting.\n");
-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 \
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 ..
--- /dev/null
+/*
+
+ serverconfig.c
+
+ Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
+
+ 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;
+}
--- /dev/null
+/*
+
+ clientconfig.h
+
+ Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
+
+ 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
*/
/* $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;
silc_screen_input_reset(app->screen);
return ret;
+#endif
+ return 0;
}
/* Lists supported (builtin) ciphers */
char *silc_client_get_input(const char *prompt)
{
+#if 0
char input[2048];
int fd;
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. */
#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();
#include "module.h"
#include "chat-protocols.h"
+#include "args.h"
#include "chatnets.h"
#include "servers-setup.h"
#include "silc-queries.h"
#include "silc-nicklist.h"
#include "version_internal.h"
+#include "version.h"
#include "signals.h"
#include "levels.h"
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, ...)
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 },
};
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 */
exit(0);
}
- if (opt_keyfile == TRUE) {
+ if (opt_keyfile) {
/* Dump the key */
silc_cipher_register_default();
silc_pkcs_register_default();
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";
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) {
#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))
projects / silc.git / commitdiff