static RECONNECT_REC *find_reconnect_server(const char *addr, int port)
{
RECONNECT_REC *match;
GSList *tmp;
g_return_val_if_fail(addr != NULL, NULL);
if (g_slist_length(reconnects) == 1) {
/* only one reconnection, we probably want to use it */
match = reconnects->data;
return IS_IRC_SERVER_CONNECT(match->conn) ? match : NULL;
}
/* check if there's a reconnection to the same host and maybe even
the same port */
match = NULL;
for (tmp = reconnects; tmp != NULL; tmp = tmp->next) {
RECONNECT_REC *rec = tmp->data;
if (IS_IRC_SERVER_CONNECT(rec->conn) &&
g_strcasecmp(rec->conn->address, addr) == 0) {
if (rec->conn->port == port)
return rec;
match = rec;
}
}
return match;
}
static void sig_server_setup_fill_connect(IRC_SERVER_CONNECT_REC *conn)
{
if (!IS_IRC_SERVER_CONNECT(conn))
return;
conn->alternate_nick = *settings_get_str("alternate_nick") != '\0' ?
g_strdup(settings_get_str("alternate_nick")) : NULL;
conn->usermode = g_strdup(settings_get_str("usermode"));
}
static void sig_server_reconnect_save_status(IRC_SERVER_CONNECT_REC *conn,
IRC_SERVER_REC *server)
{
if (!IS_IRC_SERVER_CONNECT(conn) || !IS_IRC_SERVER(server))
return;
g_free_not_null(conn->channels);
conn->channels = irc_server_get_channels(server);
g_free_not_null(conn->usermode);
conn->usermode = g_strdup(server->usermode);
}
/* Fill information to connection from server setup record */
static void sig_server_setup_fill_reconn(IRC_SERVER_CONNECT_REC *conn,
IRC_SERVER_SETUP_REC *sserver)
{
if (!IS_IRC_SERVER_CONNECT(conn) ||
!IS_IRC_SERVER_SETUP(sserver))
return;
if (sserver->cmd_queue_speed > 0)
conn->cmd_queue_speed = sserver->cmd_queue_speed;
if (sserver->max_cmds_at_once > 0)
conn->max_cmds_at_once = sserver->max_cmds_at_once;
if (sserver->max_query_chans > 0)
conn->max_query_chans = sserver->max_query_chans;
}
static void sig_server_setup_fill_chatnet(IRC_SERVER_CONNECT_REC *conn,
IRC_CHATNET_REC *ircnet)
{
if (!IS_IRC_SERVER_CONNECT(conn))
return;
g_return_if_fail(IS_IRCNET(ircnet));
if (ircnet->nick != NULL) g_free_and_null(conn->alternate_nick);
if (ircnet->usermode != NULL) {
g_free_and_null(conn->usermode);
conn->usermode = g_strdup(ircnet->usermode);
}
if (ircnet->max_kicks > 0) conn->max_kicks = ircnet->max_kicks;
if (ircnet->max_msgs > 0) conn->max_msgs = ircnet->max_msgs;
if (ircnet->max_modes > 0) conn->max_modes = ircnet->max_modes;
if (ircnet->max_whois > 0) conn->max_whois = ircnet->max_whois;
if (ircnet->max_cmds_at_once > 0)
conn->max_cmds_at_once = ircnet->max_cmds_at_once;
if (ircnet->cmd_queue_speed > 0)
conn->cmd_queue_speed = ircnet->cmd_queue_speed;
if (ircnet->max_query_chans > 0)
conn->max_query_chans = ircnet->max_query_chans;
/* Validate the SASL parameters filled by sig_chatnet_read() or cmd_network_add */
conn->sasl_mechanism = SASL_MECHANISM_NONE;
if (ircnet->sasl_mechanism != NULL) {
if (!g_ascii_strcasecmp(ircnet->sasl_mechanism, "plain")) {
/* The PLAIN method needs both the username and the password */
if (ircnet->sasl_username != NULL && *ircnet->sasl_username &&
ircnet->sasl_password != NULL && *ircnet->sasl_password) {
conn->sasl_mechanism = SASL_MECHANISM_PLAIN;
conn->sasl_username = ircnet->sasl_username;
conn->sasl_password = ircnet->sasl_password;
} else
g_warning("The fields sasl_username and sasl_password are either missing or empty");
}
else if (!g_ascii_strcasecmp(ircnet->sasl_mechanism, "external")) {
conn->sasl_mechanism = SASL_MECHANISM_EXTERNAL;
conn->sasl_username = NULL;
conn->sasl_password = NULL;
}
else
g_warning("Unsupported SASL mechanism \"%s\" selected", ircnet->sasl_mechanism);
}
}
static void sig_server_connect_copy(SERVER_CONNECT_REC **dest,
IRC_SERVER_CONNECT_REC *src)
{
IRC_SERVER_CONNECT_REC *rec;
g_return_if_fail(dest != NULL);
if (!IS_IRC_SERVER_CONNECT(src))
return;
rec = g_new0(IRC_SERVER_CONNECT_REC, 1);
rec->chat_type = IRC_PROTOCOL;
rec->cmd_queue_speed = src->cmd_queue_speed;
rec->max_kicks = src->max_kicks;
rec->max_modes = src->max_modes;
rec->max_msgs = src->max_msgs;
rec->usermode = g_strdup(src->usermode);
*dest = (SERVER_CONNECT_REC *) rec;
}
SERVER_REC *irc_server_init_connect(SERVER_CONNECT_REC *conn)
{
IRC_SERVER_CONNECT_REC *ircconn;
IRC_SERVER_REC *server;
g_return_val_if_fail(IS_IRC_SERVER_CONNECT(conn), NULL);
if (conn->address == NULL || *conn->address == '\0') return NULL;
if (conn->nick == NULL || *conn->nick == '\0') return NULL;
server = g_new0(IRC_SERVER_REC, 1);
server->chat_type = IRC_PROTOCOL;
ircconn = (IRC_SERVER_CONNECT_REC *) conn;
server->connrec = ircconn;
server_connect_ref(conn);
if (server->connrec->port <= 0) {
server->connrec->port =
server->connrec->use_ssl ? 6697 : 6667;
}
server->cmd_queue_speed = ircconn->cmd_queue_speed > 0 ?
ircconn->cmd_queue_speed : settings_get_time("cmd_queue_speed");
server->max_cmds_at_once = ircconn->max_cmds_at_once > 0 ?
ircconn->max_cmds_at_once : settings_get_int("cmds_max_at_once");
server->max_query_chans = ircconn->max_query_chans > 0 ?
ircconn->max_query_chans : DEFAULT_MAX_QUERY_CHANS;
server->max_kicks_in_cmd = ircconn->max_kicks > 0 ?
ircconn->max_kicks : DEFAULT_MAX_KICKS;
server->max_modes_in_cmd = ircconn->max_modes > 0 ?
ircconn->max_modes : DEFAULT_MAX_MODES;
server->max_whois_in_cmd = ircconn->max_whois > 0 ?
ircconn->max_whois : DEFAULT_MAX_WHOIS;
server->max_msgs_in_cmd = ircconn->max_msgs > 0 ?
ircconn->max_msgs : DEFAULT_MAX_MSGS;
server->connrec->use_ssl = conn->use_ssl;
modes_server_init(server);
server_connect_init((SERVER_REC *) server);
return (SERVER_REC *) server;
}
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);
}
