static void update_reconnection(SERVER_CONNECT_REC *conn, SERVER_REC *server) { SERVER_CONNECT_REC *oldconn; RECONNECT_REC *recon; if (server != NULL) { oldconn = server->connrec; server_connect_ref(oldconn); reconnect_save_status(conn, server); } else { /* maybe we can reconnect some server from reconnection queue */ recon = find_reconnect_server(conn->chat_type, conn->address, conn->port); if (recon == NULL) return; oldconn = recon->conn; server_connect_ref(oldconn); server_reconnect_destroy(recon); conn->away_reason = g_strdup(oldconn->away_reason); conn->channels = g_strdup(oldconn->channels); } conn->reconnection = TRUE; if (conn->chatnet == NULL && oldconn->chatnet != NULL) conn->chatnet = g_strdup(oldconn->chatnet); server_connect_unref(oldconn); if (server != NULL) { signal_emit("command disconnect", 2, "* Changing server", server); } }
static void reconnect_all(void) { GSList *list; SERVER_CONNECT_REC *conn; RECONNECT_REC *rec; /* first move reconnects to another list so if server_connect() fails and goes to reconnection list again, we won't get stuck here forever */ list = NULL; while (reconnects != NULL) { rec = reconnects->data; list = g_slist_append(list, rec->conn); server_connect_ref(rec->conn); server_reconnect_destroy(rec); } while (list != NULL) { conn = list->data; server_connect(conn); server_connect_unref(conn); list = g_slist_remove(list, conn); } }
static SERVER_CONNECT_REC * create_addr_conn(int chat_type, const char *address, int port, const char *chatnet, const char *password, const char *nick) { CHAT_PROTOCOL_REC *proto; SERVER_CONNECT_REC *conn; SERVER_SETUP_REC *sserver; CHATNET_REC *chatnetrec; g_return_val_if_fail(address != NULL, NULL); sserver = server_setup_find(address, port, chatnet); if (sserver != NULL) { if (chat_type < 0) chat_type = sserver->chat_type; else if (chat_type != sserver->chat_type) sserver = NULL; } proto = chat_type >= 0 ? chat_protocol_find_id(chat_type) : chat_protocol_get_default(); conn = proto->create_server_connect(); server_connect_ref(conn); conn->chat_type = proto->id; if (chatnet != NULL && *chatnet != '\0') conn->chatnet = g_strdup(chatnet); /* fill in the defaults */ server_setup_fill(conn, address, port); /* fill the rest from chat network settings */ chatnetrec = chatnet != NULL ? chatnet_find(chatnet) : (sserver == NULL || sserver->chatnet == NULL ? NULL : chatnet_find(sserver->chatnet)); if (chatnetrec != NULL) server_setup_fill_chatnet(conn, chatnetrec); /* fill the information from setup */ if (sserver != NULL) server_setup_fill_server(conn, sserver); /* nick / password given in command line overrides all settings */ if (password && *password) { g_free_not_null(conn->password); conn->password = g_strdup(password); } if (nick && *nick) { g_free_not_null(conn->nick); conn->nick = g_strdup(nick); } return conn; }
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; }
static void server_reconnect_add(SERVER_CONNECT_REC *conn, time_t next_connect) { RECONNECT_REC *rec; g_return_if_fail(IS_SERVER_CONNECT(conn)); rec = g_new(RECONNECT_REC, 1); rec->tag = ++last_reconnect_tag; rec->next_connect = next_connect; rec->conn = conn; server_connect_ref(conn); reconnects = g_slist_append(reconnects, rec); }
static int server_reconnect_timeout(void) { SERVER_CONNECT_REC *conn; GSList *list, *tmp, *next; time_t now; now = time(NULL); /* timeout any connections that haven't gotten to connected-stage */ for (tmp = servers; tmp != NULL; tmp = next) { SERVER_REC *server = tmp->data; next = tmp->next; if (!server->connected && server->connect_time + connect_timeout < now && connect_timeout > 0) { server->connection_lost = TRUE; server_disconnect(server); } } /* If server_connect() removes the next reconnection in queue, we're screwed. I don't think this should happen anymore, but just to be sure we don't crash, do this safely. */ list = g_slist_copy(reconnects); for (tmp = list; tmp != NULL; tmp = tmp->next) { RECONNECT_REC *rec = tmp->data; if (g_slist_find(reconnects, rec) == NULL) continue; if (rec->next_connect <= now) { conn = rec->conn; server_connect_ref(conn); server_reconnect_destroy(rec); server_connect(conn); server_connect_unref(conn); } } g_slist_free(list); return 1; }
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; }
/* SYNTAX: RECONNECT <tag> [<quit message>] */ static void cmd_reconnect(const char *data, SERVER_REC *server) { SERVER_CONNECT_REC *conn; RECONNECT_REC *rec; char *tag, *msg; void *free_arg; int tagnum; if (!cmd_get_params(data, &free_arg, 2 | PARAM_FLAG_GETREST, &tag, &msg)) return; if (*tag != '\0' && strcmp(tag, "*") != 0) server = server_find_tag(tag); if (server != NULL) { /* reconnect connected server */ conn = server_connect_copy_skeleton(server->connrec, TRUE); if (server->connected) reconnect_save_status(conn, server); msg = g_strconcat("* ", *msg == '\0' ? "Reconnecting" : msg, NULL); signal_emit("command disconnect", 2, msg, server); g_free(msg); conn->reconnection = TRUE; server_connect(conn); server_connect_unref(conn); cmd_params_free(free_arg); return; } if (g_ascii_strcasecmp(tag, "all") == 0) { /* reconnect all servers in reconnect queue */ reconnect_all(); cmd_params_free(free_arg); return; } if (*data == '\0') { /* reconnect to first server in reconnection list */ if (reconnects == NULL) cmd_param_error(CMDERR_NOT_CONNECTED); rec = reconnects->data; } else { if (g_ascii_strncasecmp(data, "RECON-", 6) == 0) data += 6; tagnum = atoi(tag); rec = tagnum <= 0 ? NULL : reconnect_find_tag(tagnum); } if (rec == NULL) { signal_emit("server reconnect not found", 1, data); } else { conn = rec->conn; server_connect_ref(conn); server_reconnect_destroy(rec); server_connect(conn); server_connect_unref(conn); } cmd_params_free(free_arg); }
SERVER_REC * xmpp_server_init_connect(SERVER_CONNECT_REC *connrec) { XMPP_SERVER_REC *server; XMPP_SERVER_CONNECT_REC *conn = (XMPP_SERVER_CONNECT_REC *)connrec; char *recoded; if (conn->address == NULL || conn->address[0] == '\0') return NULL; if (conn->nick == NULL || conn->nick[0] == '\0') return NULL; g_return_val_if_fail(IS_XMPP_SERVER_CONNECT(conn), NULL); server = g_new0(XMPP_SERVER_REC, 1); server->chat_type = XMPP_PROTOCOL; server->user = xmpp_extract_user(conn->nick); server->domain = xmpp_have_domain(conn->nick) ? xmpp_extract_domain(conn->nick) : g_strdup(conn->address); server->jid = xmpp_have_domain(conn->nick) ? xmpp_strip_resource(conn->nick) : g_strconcat(server->user, "@", server->domain, (void *)NULL); server->resource = xmpp_extract_resource(conn->nick); if (server->resource == NULL) server->resource = g_strdup("irssi-xmpp"); server->priority = settings_get_int("xmpp_priority"); if (xmpp_priority_out_of_bound(server->priority)) server->priority = 0; server->ping_id = NULL; server->server_features = NULL; server->my_resources = NULL; server->roster = NULL; server->msg_handlers = NULL; server->channels_join = channels_join; server->isnickflag = isnickflag_func; server->ischannel = ischannel_func; server->get_nick_flags = get_nick_flags; server->send_message = send_message; server->connrec = (XMPP_SERVER_CONNECT_REC *)conn; server_connect_ref(connrec); /* don't use irssi's sockets */ server->connrec->no_connect = TRUE; server->connect_pid = -1; if (server->connrec->port <= 0) server->connrec->port = (server->connrec->use_ssl) ? LM_CONNECTION_DEFAULT_PORT_SSL : LM_CONNECTION_DEFAULT_PORT; if (conn->real_jid == NULL) conn->real_jid = conn->nick; else g_free(conn->nick); conn->nick = g_strdup(settings_get_bool("xmpp_set_nick_as_username") ? server->user : server->jid); /* init loudmouth connection structure */ server->lmconn = lm_connection_new(NULL); lm_connection_set_server(server->lmconn, server->connrec->address); lm_connection_set_port(server->lmconn, server->connrec->port); recoded = xmpp_recode_out(server->jid); lm_connection_set_jid(server->lmconn, recoded); g_free(recoded); lm_connection_set_keep_alive_rate(server->lmconn, 30); server->timeout_tag = 0; server_connect_init((SERVER_REC *)server); server->connect_tag = 1; return (SERVER_REC *)server; }