static SERVER_CONNECT_REC *
server_connect_copy_skeleton(SERVER_CONNECT_REC *src)
{
SERVER_CONNECT_REC *dest;
dest = NULL;
signal_emit("server connect copy", 2, &dest, src);
g_return_val_if_fail(dest != NULL, NULL);
dest->type = module_get_uniq_id("SERVER CONNECT", 0);
dest->reconnection = src->reconnection;
dest->proxy = g_strdup(src->proxy);
dest->proxy_port = src->proxy_port;
dest->proxy_string = g_strdup(src->proxy_string);
dest->chatnet = g_strdup(src->chatnet);
dest->nick = g_strdup(src->nick);
dest->username = g_strdup(src->username);
dest->realname = g_strdup(src->realname);
if (src->own_ip != NULL) {
dest->own_ip = g_new(IPADDR, 1);
memcpy(dest->own_ip, src->own_ip, sizeof(IPADDR));
}
dest->channels = g_strdup(src->channels);
dest->away_reason = g_strdup(src->away_reason);
return dest;
}
/* initializes server record but doesn't start connecting */
void server_connect_init(SERVER_REC *server)
{
const char *str;
g_return_if_fail(server != NULL);
MODULE_DATA_INIT(server);
server->type = module_get_uniq_id("SERVER", 0);
server_ref(server);
server->nick = g_strdup(server->connrec->nick);
if (server->connrec->username == NULL || *server->connrec->username == '\0') {
g_free_not_null(server->connrec->username);
str = g_get_user_name();
if (*str == '\0') str = "unknown";
server->connrec->username = g_strdup(str);
}
if (server->connrec->realname == NULL || *server->connrec->realname == '\0') {
g_free_not_null(server->connrec->realname);
str = g_get_real_name();
if (*str == '\0') str = server->connrec->username;
server->connrec->realname = g_strdup(str);
}
server->tag = server_create_tag(server->connrec);
server->connect_tag = -1;
}
static void chatnet_read(CONFIG_NODE *node)
{
CHAT_PROTOCOL_REC *proto;
CHATNET_REC *rec;
char *type;
if (node == NULL || node->key == NULL)
return;
type = config_node_get_str(node, "type", NULL);
proto = type == NULL ? NULL : chat_protocol_find(type);
if (proto == NULL) {
proto = type == NULL ? chat_protocol_get_default() :
chat_protocol_get_unknown(type);
}
if (type == NULL)
iconfig_node_set_str(node, "type", proto->name);
rec = proto->create_chatnet();
rec->type = module_get_uniq_id("CHATNET", 0);
rec->chat_type = proto->id;
rec->name = g_strdup(node->key);
rec->nick = g_strdup(config_node_get_str(node, "nick", NULL));
rec->username = g_strdup(config_node_get_str(node, "username", NULL));
rec->realname = g_strdup(config_node_get_str(node, "realname", NULL));
rec->own_host = g_strdup(config_node_get_str(node, "host", NULL));
rec->autosendcmd = g_strdup(config_node_get_str(node, "autosendcmd", NULL));
chatnets = g_slist_append(chatnets, rec);
signal_emit("chatnet read", 2, rec, node);
}
void server_setup_add(SERVER_SETUP_REC *rec)
{
rec->type = module_get_uniq_id("SERVER SETUP", 0);
if (g_slist_find(setupservers, rec) == NULL)
setupservers = g_slist_append(setupservers, rec);
server_setup_save(rec);
signal_emit("server setup updated", 1, rec);
}
static SERVER_CONNECT_REC *
server_connect_copy_skeleton(SERVER_CONNECT_REC *src, int connect_info)
{
SERVER_CONNECT_REC *dest;
dest = NULL;
signal_emit("server connect copy", 2, &dest, src);
g_return_val_if_fail(dest != NULL, NULL);
server_connect_ref(dest);
dest->type = module_get_uniq_id("SERVER CONNECT", 0);
dest->reconnection = src->reconnection;
dest->proxy = g_strdup(src->proxy);
dest->proxy_port = src->proxy_port;
dest->proxy_string = g_strdup(src->proxy_string);
dest->proxy_string_after = g_strdup(src->proxy_string_after);
dest->proxy_password = g_strdup(src->proxy_password);
dest->tag = g_strdup(src->tag);
if (connect_info) {
dest->family = src->family;
dest->address = g_strdup(src->address);
dest->port = src->port;
dest->password = g_strdup(src->password);
}
dest->chatnet = g_strdup(src->chatnet);
dest->nick = g_strdup(src->nick);
dest->username = g_strdup(src->username);
dest->realname = g_strdup(src->realname);
if (src->own_ip4 != NULL) {
dest->own_ip4 = g_new(IPADDR, 1);
memcpy(dest->own_ip4, src->own_ip4, sizeof(IPADDR));
}
if (src->own_ip6 != NULL) {
dest->own_ip6 = g_new(IPADDR, 1);
memcpy(dest->own_ip6, src->own_ip6, sizeof(IPADDR));
}
dest->channels = g_strdup(src->channels);
dest->away_reason = g_strdup(src->away_reason);
dest->no_autojoin_channels = src->no_autojoin_channels;
dest->no_autosendcmd = src->no_autosendcmd;
dest->use_ssl = src->use_ssl;
dest->ssl_cert = g_strdup(src->ssl_cert);
dest->ssl_pkey = g_strdup(src->ssl_pkey);
dest->ssl_verify = src->ssl_verify;
dest->ssl_cafile = g_strdup(src->ssl_cafile);
dest->ssl_capath = g_strdup(src->ssl_capath);
dest->ssl_ciphers = g_strdup(src->ssl_ciphers);
return dest;
}
/* Add new nick to list */
void nicklist_insert(CHANNEL_REC *channel, NICK_REC *nick)
{
/*MODULE_DATA_INIT(nick);*/
nick->type = module_get_uniq_id("NICK", 0);
nick->chat_type = channel->chat_type;
nick_hash_add(channel, nick);
signal_emit("nicklist new", 2, channel, nick);
}
void chatnet_create(CHATNET_REC *chatnet)
{
g_return_if_fail(chatnet != NULL);
chatnet->type = module_get_uniq_id("CHATNET", 0);
if (g_slist_find(chatnets, chatnet) == NULL)
chatnets = g_slist_append(chatnets, chatnet);
signal_emit("chatnet created", 1, chatnet);
}
void chatnet_read(CHATNET_REC *chatnet, void *nodep)
{
CONFIG_NODE *node = nodep;
g_return_if_fail(chatnet != NULL);
g_return_if_fail(node != NULL);
g_return_if_fail(node->key != NULL);
chatnet->type = module_get_uniq_id("CHATNET", 0);
chatnet->name = g_strdup(node->key);
chatnet->nick = g_strdup(config_node_get_str(node, "nick", NULL));
chatnet->username = g_strdup(config_node_get_str(node, "username", NULL));
chatnet->realname = g_strdup(config_node_get_str(node, "realname", NULL));
chatnet->own_host = g_strdup(config_node_get_str(node, "host", NULL));
chatnet->autosendcmd = g_strdup(config_node_get_str(node, "autosendcmd", NULL));
chatnets = g_slist_append(chatnets, chatnet);
}
QUERY_REC *query_create(IRC_SERVER_REC *server, const char *nick, int automatic)
{
QUERY_REC *rec;
g_return_val_if_fail(nick != NULL, NULL);
rec = g_new0(QUERY_REC, 1);
queries = g_slist_append(queries, rec);
if (server != NULL) server->queries = g_slist_append(server->queries, rec);
MODULE_DATA_INIT(rec);
rec->type = module_get_uniq_id("IRC", WI_IRC_QUERY);
rec->nick = g_strdup(nick);
if (server != NULL) {
rec->server_tag = g_strdup(server->tag);
rec->server = server;
}
signal_emit("query created", 2, rec, GINT_TO_POINTER(automatic));
return rec;
}
static void server_setup_fill(SERVER_CONNECT_REC *conn,
const char *address, int port)
{
g_return_if_fail(conn != NULL);
g_return_if_fail(address != NULL);
conn->type = module_get_uniq_id("SERVER CONNECT", 0);
conn->address = g_strdup(address);
if (port > 0) conn->port = port;
if (strchr(address, '/') != NULL)
conn->unix_socket = TRUE;
if (!conn->nick) conn->nick = g_strdup(settings_get_str("nick"));
conn->username = g_strdup(settings_get_str("user_name"));
conn->realname = g_strdup(settings_get_str("real_name"));
/* proxy settings */
if (settings_get_bool("use_proxy")) {
conn->proxy = g_strdup(settings_get_str("proxy_address"));
conn->proxy_port = settings_get_int("proxy_port");
conn->proxy_string = g_strdup(settings_get_str("proxy_string"));
conn->proxy_string_after = g_strdup(settings_get_str("proxy_string_after"));
conn->proxy_password = g_strdup(settings_get_str("proxy_password"));
}
/* source IP */
if (source_host_ip4 != NULL) {
conn->own_ip4 = g_new(IPADDR, 1);
memcpy(conn->own_ip4, source_host_ip4, sizeof(IPADDR));
}
if (source_host_ip6 != NULL) {
conn->own_ip6 = g_new(IPADDR, 1);
memcpy(conn->own_ip6, source_host_ip6, sizeof(IPADDR));
}
signal_emit("server setup fill connect", 1, conn);
}
static CHANNEL_SETUP_REC *channel_setup_read(CONFIG_NODE *node)
{
CHANNEL_SETUP_REC *rec;
CHATNET_REC *chatnetrec;
char *channel, *chatnet;
g_return_val_if_fail(node != NULL, NULL);
channel = config_node_get_str(node, "name", NULL);
chatnet = config_node_get_str(node, "chatnet", NULL);
if (chatnet == NULL) /* FIXME: remove this after .98... */ {
chatnet = g_strdup(config_node_get_str(node, "ircnet", NULL));
if (chatnet != NULL) {
iconfig_node_set_str(node, "chatnet", chatnet);
iconfig_node_set_str(node, "ircnet", NULL);
}
}
chatnetrec = chatnet == NULL ? NULL : chatnet_find(chatnet);
if (channel == NULL || chatnetrec == NULL) {
/* missing information.. */
return NULL;
}
rec = CHAT_PROTOCOL(chatnetrec)->create_channel_setup();
rec->type = module_get_uniq_id("CHANNEL SETUP", 0);
rec->chat_type = CHAT_PROTOCOL(chatnetrec)->id;
rec->autojoin = config_node_get_bool(node, "autojoin", FALSE);
rec->name = g_strdup(channel);
rec->chatnet = g_strdup(chatnetrec != NULL ? chatnetrec->name : chatnet);
rec->password = g_strdup(config_node_get_str(node, "password", NULL));
rec->botmasks = g_strdup(config_node_get_str(node, "botmasks", NULL));
rec->autosendcmd = g_strdup(config_node_get_str(node, "autosendcmd", NULL));
setupchannels = g_slist_append(setupchannels, rec);
signal_emit("channel setup created", 2, rec, node);
return rec;
}
static void robustirc_server_connect_copy(SERVER_CONNECT_REC **dest, IRC_SERVER_CONNECT_REC *src) {
g_return_if_fail(dest != NULL);
if (!IS_IRC_SERVER_CONNECT(src))
return;
// *dest == NULL likely means the sig_server_connect_copy() in
// irssi/src/irc/core/irc-servers-reconnect.c did not run.
// Perhaps the irssi code structure has changed?
assert(*dest != NULL);
SERVER_REC *server = g_hash_table_lookup(connrecs, src);
g_return_if_fail(server != NULL);
// We need to trigger the server reconnect save status signal here because
// chat_type needs to be IRC_PROTOCOL at the time when that signal is
// processed so that channels are saved for rejoining after reconnecting.
(*dest)->type = module_get_uniq_id("SERVER CONNECT", 0);
// Passing |src| is intentional: properties get copied over from |src| to
// |*dest| in server_connect_copy_skeleton() once this signal handler
// returns.
signal_emit("server reconnect save status", 2, src, server);
// So that robustirc_server_init_connect is called on reconnects.
(*dest)->chat_type = ROBUSTIRC_PROTOCOL;
g_hash_table_remove(connrecs, src);
}
static SERVER_SETUP_REC *server_setup_read(CONFIG_NODE *node)
{
SERVER_SETUP_REC *rec;
CHATNET_REC *chatnetrec;
char *server, *chatnet, *family;
int port;
g_return_val_if_fail(node != NULL, NULL);
server = config_node_get_str(node, "address", NULL);
if (server == NULL)
return NULL;
port = config_node_get_int(node, "port", 0);
chatnet = config_node_get_str(node, "chatnet", NULL);
if (server_setup_find(server, port, chatnet) != NULL) {
return NULL;
}
rec = NULL;
chatnetrec = chatnet == NULL ? NULL : chatnet_find(chatnet);
if (chatnetrec == NULL && chatnet != NULL) {
/* chat network not found, create it. */
chatnetrec = chat_protocol_get_default()->create_chatnet();
chatnetrec->chat_type = chat_protocol_get_default()->id;
chatnetrec->name = g_strdup(chatnet);
chatnet_create(chatnetrec);
}
family = config_node_get_str(node, "family", "");
rec = CHAT_PROTOCOL(chatnetrec)->create_server_setup();
rec->type = module_get_uniq_id("SERVER SETUP", 0);
rec->chat_type = CHAT_PROTOCOL(chatnetrec)->id;
rec->chatnet = chatnetrec == NULL ? NULL : g_strdup(chatnetrec->name);
rec->family = g_ascii_strcasecmp(family, "inet6") == 0 ? AF_INET6 :
(g_ascii_strcasecmp(family, "inet") == 0 ? AF_INET : 0);
rec->address = g_strdup(server);
rec->password = g_strdup(config_node_get_str(node, "password", NULL));
rec->use_ssl = config_node_get_bool(node, "use_ssl", FALSE);
rec->ssl_cert = g_strdup(config_node_get_str(node, "ssl_cert", NULL));
rec->ssl_pkey = g_strdup(config_node_get_str(node, "ssl_pkey", NULL));
rec->ssl_verify = config_node_get_bool(node, "ssl_verify", FALSE);
rec->ssl_cafile = g_strdup(config_node_get_str(node, "ssl_cafile", NULL));
rec->ssl_capath = g_strdup(config_node_get_str(node, "ssl_capath", NULL));
if (rec->ssl_cafile || rec->ssl_capath)
rec->ssl_verify = TRUE;
if (rec->ssl_cert != NULL || rec->ssl_verify)
rec->use_ssl = TRUE;
rec->port = port;
rec->autoconnect = config_node_get_bool(node, "autoconnect", FALSE);
rec->no_proxy = config_node_get_bool(node, "no_proxy", FALSE);
rec->own_host = g_strdup(config_node_get_str(node, "own_host", NULL));
signal_emit("server setup read", 2, rec, node);
setupservers = g_slist_append(setupservers, rec);
return rec;
}
