int server_unref(SERVER_REC *server)
{
g_return_val_if_fail(IS_SERVER(server), FALSE);
if (--server->refcount > 0)
return TRUE;
if (g_slist_find(servers, server) != NULL) {
g_warning("Non-referenced server wasn't disconnected");
server_disconnect(server);
return TRUE;
}
MODULE_DATA_DEINIT(server);
server_connect_unref(server->connrec);
if (server->rawlog != NULL) rawlog_destroy(server->rawlog);
if (server->buffer != NULL) line_split_free(server->buffer);
g_free(server->version);
g_free(server->away_reason);
g_free(server->nick);
g_free(server->tag);
server->type = 0;
g_free(server);
return FALSE;
}
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 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);
}
}
void irc_server_connect(SERVER_REC *server)
{
if (!server_start_connect(server)) {
server_connect_unref(server->connrec);
g_free(server);
}
}
static void sserver_connect(SERVER_SETUP_REC *rec, SERVER_CONNECT_REC *conn)
{
conn->family = rec->family;
conn->address = g_strdup(rec->address);
if (conn->port == 0) conn->port = rec->port;
server_setup_fill_reconn(conn, rec);
server_reconnect_add(conn, rec->last_connect+reconnect_time);
server_connect_unref(conn);
}
void server_reconnect_destroy(RECONNECT_REC *rec)
{
g_return_if_fail(rec != NULL);
reconnects = g_slist_remove(reconnects, rec);
signal_emit("server reconnect remove", 1, rec);
server_connect_unref(rec->conn);
g_free(rec);
if (reconnects == NULL)
last_reconnect_tag = 0;
}
/* NOTE: -network replaces the old -ircnet flag. */
static void cmd_connect(const char *data)
{
SERVER_CONNECT_REC *conn;
SERVER_REC *server;
char *rawlog_file;
conn = get_server_connect(data, NULL, &rawlog_file);
if (conn != NULL) {
server = server_connect(conn);
server_connect_unref(conn);
if (server != NULL && rawlog_file != NULL)
rawlog_open(server->rawlog, rawlog_file);
g_free(rawlog_file);
}
}
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;
}
/* NOTE: -network replaces the old -ircnet flag. */
static void cmd_server_connect(const char *data, SERVER_REC *server)
{
SERVER_CONNECT_REC *conn;
char *rawlog_file;
int plus_addr;
g_return_if_fail(data != NULL);
/* create connection record */
conn = get_server_connect(data, &plus_addr, &rawlog_file);
if (conn != NULL) {
if (!plus_addr)
update_reconnection(conn, server);
server = server_connect(conn);
server_connect_unref(conn);
if (server != NULL && rawlog_file != NULL)
rawlog_open(server->rawlog, rawlog_file);
g_free(rawlog_file);
}
}
/* 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);
}
static void sig_reconnect(SERVER_REC *server)
{
SERVER_CONNECT_REC *conn;
SERVER_SETUP_REC *sserver;
GSList *tmp;
int use_next, through;
time_t now;
g_return_if_fail(IS_SERVER(server));
if (reconnect_time == -1 || !server_should_reconnect(server))
return;
conn = server_connect_copy_skeleton(server->connrec, FALSE);
g_return_if_fail(conn != NULL);
/* save the server status */
if (server->connected) {
conn->reconnection = TRUE;
reconnect_save_status(conn, server);
}
sserver = server_setup_find(server->connrec->address,
server->connrec->port,
server->connrec->chatnet);
if (sserver != NULL) {
/* save the last connection time/status */
sserver->last_connect = server->connect_time == 0 ?
time(NULL) : server->connect_time;
sserver->last_failed = !server->connected;
sserver->banned = server->banned;
sserver->dns_error = server->dns_error;
}
if (sserver == NULL || conn->chatnet == NULL) {
/* not in any chatnet, just reconnect back to same server */
conn->family = server->connrec->family;
conn->address = g_strdup(server->connrec->address);
conn->port = server->connrec->port;
conn->password = g_strdup(server->connrec->password);
server_reconnect_add(conn, (server->connect_time == 0 ? time(NULL) :
server->connect_time) + reconnect_time);
server_connect_unref(conn);
return;
}
/* always try to first connect to the first on the list where we
haven't got unsuccessful connection attempts for the past half
an hour. */
now = time(NULL);
for (tmp = setupservers; tmp != NULL; tmp = tmp->next) {
SERVER_SETUP_REC *rec = tmp->data;
if (sserver_connect_ok(rec, conn->chatnet) &&
(!rec->last_connect || !rec->last_failed ||
rec->last_connect < now-FAILED_RECONNECT_WAIT)) {
if (rec == sserver)
conn->port = server->connrec->port;
sserver_connect(rec, conn);
return;
}
}
/* just try the next server in list */
use_next = through = FALSE;
for (tmp = setupservers; tmp != NULL; ) {
SERVER_SETUP_REC *rec = tmp->data;
if (!use_next && server->connrec->port == rec->port &&
g_strcasecmp(rec->address, server->connrec->address) == 0)
use_next = TRUE;
else if (use_next && sserver_connect_ok(rec, conn->chatnet)) {
if (rec == sserver)
conn->port = server->connrec->port;
sserver_connect(rec, conn);
break;
}
if (tmp->next != NULL) {
tmp = tmp->next;
continue;
}
if (through) {
/* shouldn't happen unless there's no servers in
this chatnet in setup.. */
server_connect_unref(conn);
break;
}
tmp = setupservers;
use_next = through = TRUE;
}
}
static SERVER_CONNECT_REC *get_server_connect(const char *data, int *plus_addr,
char **rawlog_file)
{
CHAT_PROTOCOL_REC *proto;
SERVER_CONNECT_REC *conn;
GHashTable *optlist;
char *addr, *portstr, *password, *nick, *chatnet, *host, *tmp;
void *free_arg;
g_return_val_if_fail(data != NULL, NULL);
if (!cmd_get_params(data, &free_arg, 4 | PARAM_FLAG_OPTIONS,
"connect", &optlist, &addr, &portstr,
&password, &nick))
return NULL;
if (plus_addr != NULL) *plus_addr = *addr == '+';
if (*addr == '+') addr++;
if (*addr == '\0') {
signal_emit("error command", 1,
GINT_TO_POINTER(CMDERR_NOT_ENOUGH_PARAMS));
cmd_params_free(free_arg);
return NULL;
}
if (strcmp(password, "-") == 0)
*password = '******';
/* check if -<chatnet> option is used to specify chat protocol */
proto = chat_protocol_find_net(optlist);
/* connect to server */
chatnet = proto == NULL ? NULL :
g_hash_table_lookup(optlist, proto->chatnet);
if (chatnet == NULL)
chatnet = g_hash_table_lookup(optlist, "network");
conn = server_create_conn(proto != NULL ? proto->id : -1, addr,
atoi(portstr), chatnet, password, nick);
if (proto == NULL)
proto = chat_protocol_find_id(conn->chat_type);
if (proto->not_initialized) {
/* trying to use protocol that isn't yet initialized */
signal_emit("chat protocol unknown", 1, proto->name);
server_connect_unref(conn);
cmd_params_free(free_arg);
return NULL;
}
if (strchr(addr, '/') != NULL)
conn->unix_socket = TRUE;
if (g_hash_table_lookup(optlist, "6") != NULL)
conn->family = AF_INET6;
else if (g_hash_table_lookup(optlist, "4") != NULL)
conn->family = AF_INET;
if (g_hash_table_lookup(optlist, "ssl") != NULL)
conn->use_ssl = TRUE;
if ((tmp = g_hash_table_lookup(optlist, "ssl_cert")) != NULL)
conn->ssl_cert = g_strdup(tmp);
if ((tmp = g_hash_table_lookup(optlist, "ssl_pkey")) != NULL)
conn->ssl_pkey = g_strdup(tmp);
if ((tmp = g_hash_table_lookup(optlist, "ssl_pass")) != NULL)
conn->ssl_pass = g_strdup(tmp);
if (g_hash_table_lookup(optlist, "ssl_verify") != NULL)
conn->ssl_verify = TRUE;
if ((tmp = g_hash_table_lookup(optlist, "ssl_cafile")) != NULL)
conn->ssl_cafile = g_strdup(tmp);
if ((tmp = g_hash_table_lookup(optlist, "ssl_capath")) != NULL)
conn->ssl_capath = g_strdup(tmp);
if ((conn->ssl_capath != NULL && conn->ssl_capath[0] != '\0')
|| (conn->ssl_cafile != NULL && conn->ssl_cafile[0] != '\0'))
conn->ssl_verify = TRUE;
if ((conn->ssl_cert != NULL && conn->ssl_cert[0] != '\0') || conn->ssl_verify)
conn->use_ssl = TRUE;
if (g_hash_table_lookup(optlist, "!") != NULL)
conn->no_autojoin_channels = TRUE;
if (g_hash_table_lookup(optlist, "noautosendcmd") != NULL)
conn->no_autosendcmd = TRUE;
if (g_hash_table_lookup(optlist, "noproxy") != NULL)
g_free_and_null(conn->proxy);
*rawlog_file = g_strdup(g_hash_table_lookup(optlist, "rawlog"));
host = g_hash_table_lookup(optlist, "host");
if (host != NULL && *host != '\0') {
IPADDR ip4, ip6;
if (net_gethostbyname(host, &ip4, &ip6) == 0)
server_connect_own_ip_save(conn, &ip4, &ip6);
}
cmd_params_free(free_arg);
return conn;
}
