← Back to branch summary

~ubuntu-branches/ubuntu/trusty/irssi-plugin-xmpp/trusty

« back to all changes in this revision

Viewing changes to .pc/singpolyma-0001-Set-presence-in-one-place.patch/src/core/xmpp-servers.c

  • Committer: Package Import Robot
  • Author(s): Florian Schlichting, Florian Schlichting
  • Date: 2014-01-03 00:25:20 UTC
  • mfrom: (2.2.7 sid)
  • Revision ID: package-import@ubuntu.com-20140103002520-4ztm9phbq47vn4bl
Tags: 0.52+git20140102-1
[ Florian Schlichting ]
* Import Upstream version 0.52+git20140102
* Add VCS-* fields for collab-maint on alioth
* Add upstream git URL to Source field in debian/copyright
* Drop patches plucked from upstream CVS
* Refresh hardening.patch (offset, drop hunk fixed upstream)
* Provide xmpp-admin.pl script by Seth Difley
* Add GTalk-MUC-support.patch, plucked from github/freemandrew
* Add support for XMPP-PGP, plucked from github/singpolyma
* New useless-dependency-on-libidn.patch, to fix a lintian warning
* Declare compliance with Debian Policy 3.9.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/singpolyma-0001-Set-presence-in-one-place.patch/src/core/xmpp-servers.c
 
1
/*
 
2
 * Copyright (C) 2007 Colin DIDIER
 
3
 *
 
4
 * This program is free software; you can redistribute it and/or modify
 
5
 * it under the terms of the GNU General Public License version 2 as
 
6
 * published by the Free Software Foundation.
 
7
 *
 
8
 * This program is distributed in the hope that it will be useful,
 
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
 * GNU General Public License for more details.
 
12
 *
 
13
 * You should have received a copy of the GNU General Public License along
 
14
 * with this program; if not, write to the Free Software Foundation, Inc.,
 
15
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
16
 */
 
17
 
 
18
#include <sys/types.h>
 
19
#include <sys/socket.h>
 
20
#include <signal.h>
 
21
#include <string.h>
 
22
#include <termios.h>
 
23
 
 
24
#include "module.h"
 
25
#include "network.h"
 
26
#include "recode.h"
 
27
#include "settings.h"
 
28
#include "signals.h"
 
29
 
 
30
#include "xmpp-servers.h"
 
31
#include "protocol.h"
 
32
#include "rosters-tools.h"
 
33
#include "tools.h"
 
34
 
 
35
static void
 
36
channels_join(SERVER_REC *server, const char *data, int automatic)
 
37
{
 
38
}
 
39
 
 
40
static int
 
41
isnickflag_func(SERVER_REC *server, char flag)
 
42
{
 
43
        return FALSE;
 
44
}
 
45
 
 
46
static int
 
47
ischannel_func(SERVER_REC *server, const char *data)
 
48
{
 
49
        return FALSE;
 
50
}
 
51
 
 
52
static const char *
 
53
get_nick_flags(SERVER_REC *server)
 
54
{
 
55
        return "";
 
56
}
 
57
 
 
58
static void
 
59
send_message(SERVER_REC *server, const char *target, const char *msg,
 
60
    int target_type)
 
61
{
 
62
        LmMessage *lmsg;
 
63
        char *str, *recoded;
 
64
 
 
65
        if (!IS_XMPP_SERVER(server))
 
66
                return;
 
67
        g_return_if_fail(target != NULL);
 
68
        g_return_if_fail(msg != NULL);
 
69
        if (target_type == SEND_TARGET_CHANNEL) {
 
70
                recoded = xmpp_recode_out(target);
 
71
                lmsg = lm_message_new_with_sub_type(recoded,
 
72
                    LM_MESSAGE_TYPE_MESSAGE, LM_MESSAGE_SUB_TYPE_GROUPCHAT);
 
73
        } else {
 
74
                str = rosters_resolve_name(XMPP_SERVER(server), target);
 
75
                recoded = xmpp_recode_out(str != NULL ? str : target);
 
76
                g_free(str);
 
77
                lmsg = lm_message_new_with_sub_type(recoded,
 
78
                    LM_MESSAGE_TYPE_MESSAGE, LM_MESSAGE_SUB_TYPE_CHAT);
 
79
        }
 
80
        g_free(recoded);
 
81
        /* ugly from irssi: recode the sent message back */
 
82
        str = recode_in(server, msg, target);
 
83
        recoded = xmpp_recode_out(str);
 
84
        g_free(str);
 
85
        lm_message_node_add_child(lmsg->node, "body", recoded);
 
86
        g_free(recoded);
 
87
        signal_emit("xmpp send message", 2, server, lmsg);
 
88
        lm_message_unref(lmsg);
 
89
}
 
90
 
 
91
static void
 
92
server_cleanup(XMPP_SERVER_REC *server)
 
93
{
 
94
        if (!IS_XMPP_SERVER(server))
 
95
                return;
 
96
        if (server->timeout_tag)
 
97
                g_source_remove(server->timeout_tag);
 
98
        if (lm_connection_get_state(server->lmconn) !=
 
99
            LM_CONNECTION_STATE_CLOSED)
 
100
                lm_connection_close(server->lmconn, NULL);
 
101
        lm_connection_unref(server->lmconn);
 
102
        g_free(server->jid);
 
103
        g_free(server->user);
 
104
        g_free(server->domain);
 
105
        g_free(server->resource);
 
106
        g_free(server->ping_id);
 
107
}
 
108
 
 
109
SERVER_REC *
 
110
xmpp_server_init_connect(SERVER_CONNECT_REC *connrec)
 
111
{
 
112
        XMPP_SERVER_REC *server;
 
113
        XMPP_SERVER_CONNECT_REC *conn = (XMPP_SERVER_CONNECT_REC *)connrec;
 
114
        char *recoded;
 
115
 
 
116
        if (conn->address == NULL || conn->address[0] == '\0')
 
117
                return NULL;
 
118
        if (conn->nick == NULL || conn->nick[0] == '\0')
 
119
                return NULL;
 
120
        g_return_val_if_fail(IS_XMPP_SERVER_CONNECT(conn), NULL);
 
121
 
 
122
        server = g_new0(XMPP_SERVER_REC, 1);
 
123
        server->chat_type = XMPP_PROTOCOL;
 
124
        server->user = xmpp_extract_user(conn->nick);
 
125
        server->domain = xmpp_have_domain(conn->nick) ?
 
126
            xmpp_extract_domain(conn->nick) : g_strdup(conn->address);
 
127
        server->jid = xmpp_have_domain(conn->nick) ?
 
128
            xmpp_strip_resource(conn->nick)
 
129
            : g_strconcat(server->user, "@", server->domain, (void *)NULL);
 
130
        server->resource = xmpp_extract_resource(conn->nick);
 
131
        if (server->resource == NULL)
 
132
                server->resource = g_strdup("irssi-xmpp");
 
133
        server->priority = settings_get_int("xmpp_priority");
 
134
        if (xmpp_priority_out_of_bound(server->priority))
 
135
                server->priority = 0;
 
136
        server->ping_id = NULL;
 
137
        server->server_features = NULL;
 
138
        server->my_resources = NULL;
 
139
        server->roster = NULL;
 
140
        server->msg_handlers = NULL;
 
141
        server->channels_join = channels_join;
 
142
        server->isnickflag = isnickflag_func;
 
143
        server->ischannel = ischannel_func;
 
144
        server->get_nick_flags = get_nick_flags;
 
145
        server->send_message = send_message;
 
146
        server->connrec = (XMPP_SERVER_CONNECT_REC *)conn;
 
147
        server_connect_ref(connrec);
 
148
 
 
149
        /* don't use irssi's sockets */
 
150
        server->connrec->no_connect = TRUE;
 
151
        server->connect_pid = -1;
 
152
 
 
153
        if (server->connrec->port <= 0)
 
154
                server->connrec->port = (server->connrec->use_ssl) ?
 
155
                    LM_CONNECTION_DEFAULT_PORT_SSL : LM_CONNECTION_DEFAULT_PORT;
 
156
 
 
157
        if (conn->real_jid == NULL)
 
158
                conn->real_jid = conn->nick;
 
159
        else
 
160
                g_free(conn->nick);
 
161
        conn->nick = g_strdup(settings_get_bool("xmpp_set_nick_as_username") ?
 
162
            server->user : server->jid);
 
163
 
 
164
        /* init loudmouth connection structure */
 
165
        server->lmconn = lm_connection_new(NULL);
 
166
        lm_connection_set_server(server->lmconn, server->connrec->address);
 
167
        lm_connection_set_port(server->lmconn, server->connrec->port);
 
168
        recoded = xmpp_recode_out(server->jid);
 
169
        lm_connection_set_jid(server->lmconn, recoded);
 
170
        g_free(recoded);
 
171
        lm_connection_set_keep_alive_rate(server->lmconn, 30);
 
172
 
 
173
        server->timeout_tag = 0;
 
174
        server_connect_init((SERVER_REC *)server);
 
175
        server->connect_tag = 1;
 
176
        return (SERVER_REC *)server;
 
177
}
 
178
 
 
179
static LmSSLResponse
 
180
lm_ssl_cb(LmSSL *ssl, LmSSLStatus status, gpointer user_data)
 
181
{
 
182
        XMPP_SERVER_REC *server;
 
183
 
 
184
        if ((server = XMPP_SERVER(user_data)) == NULL)
 
185
                return LM_SSL_RESPONSE_CONTINUE;
 
186
        switch (status) {
 
187
        case LM_SSL_STATUS_NO_CERT_FOUND:
 
188
                g_warning("SSL (%s): no certificate found",
 
189
                    server->connrec->address);
 
190
                break;
 
191
        case LM_SSL_STATUS_UNTRUSTED_CERT:
 
192
                g_warning("SSL (%s): certificate is not trusted",
 
193
                    server->connrec->address);
 
194
                break;
 
195
        case LM_SSL_STATUS_CERT_EXPIRED:
 
196
                g_warning("SSL (%s): certificate has expired",
 
197
                    server->connrec->address);
 
198
                break;
 
199
        case LM_SSL_STATUS_CERT_NOT_ACTIVATED:
 
200
                g_warning("SSL (%s): certificate has not been activated",
 
201
                    server->connrec->address);
 
202
                break;
 
203
        case LM_SSL_STATUS_CERT_HOSTNAME_MISMATCH:
 
204
                g_warning("SSL (%s): certificate hostname does not match "
 
205
                    "expected hostname", server->connrec->address);
 
206
                break;
 
207
        case LM_SSL_STATUS_CERT_FINGERPRINT_MISMATCH: 
 
208
                g_warning("SSL (%s): certificate fingerprint does not match "
 
209
                    "expected fingerprint", server->connrec->address);
 
210
                break;
 
211
        case LM_SSL_STATUS_GENERIC_ERROR:
 
212
                g_warning("SSL (%s): generic error", server->connrec->address);
 
213
                break;
 
214
        }
 
215
        return LM_SSL_RESPONSE_CONTINUE;
 
216
}
 
217
 
 
218
static void
 
219
lm_close_cb(LmConnection *connection, LmDisconnectReason reason,
 
220
    gpointer user_data)
 
221
{
 
222
        XMPP_SERVER_REC *server;
 
223
 
 
224
        if ((server = XMPP_SERVER(user_data)) == NULL || !server->connected
 
225
            || reason == LM_DISCONNECT_REASON_OK)
 
226
                return;
 
227
        server->connection_lost = TRUE;
 
228
        server_disconnect(SERVER(server));
 
229
}
 
230
 
 
231
static void
 
232
lm_auth_cb(LmConnection *connection, gboolean success,
 
233
    gpointer user_data)
 
234
{
 
235
        XMPP_SERVER_REC *server;
 
236
        
 
237
        if ((server = XMPP_SERVER(user_data)) == NULL)
 
238
                return;
 
239
        if (!success) {
 
240
                server_connect_failed(SERVER(server), "Authentication failed");
 
241
                return;
 
242
        }
 
243
        signal_emit("xmpp server status", 2, server,
 
244
            "Authenticated successfully.");
 
245
 
 
246
        /* finnish connection process */
 
247
        lookup_servers = g_slist_remove(lookup_servers, server);
 
248
        g_source_remove(server->connect_tag);
 
249
        server->connect_tag = -1;
 
250
        server->show = XMPP_PRESENCE_AVAILABLE;
 
251
        server->connected = TRUE;
 
252
        if (server->timeout_tag) {
 
253
                g_source_remove(server->timeout_tag);
 
254
                server->timeout_tag = 0;
 
255
        }
 
256
        server_connect_finished(SERVER(server));
 
257
        server->real_connect_time = server->connect_time;
 
258
}
 
259
 
 
260
/*
 
261
 * Displays input prompt on command line and takes input data from user
 
262
 * From irssi-silc (silc-client/lib/silcutil/silcutil.c)
 
263
 */
 
264
static char *
 
265
get_password()
 
266
{
 
267
        char input[2048], *ret = NULL;
 
268
        int fd;
 
269
 
 
270
#ifndef DISABLE_TERMIOS
 
271
        struct termios to;
 
272
        struct termios to_old;
 
273
 
 
274
        if ((fd = open("/dev/tty", O_RDONLY)) < 0) {
 
275
                g_warning("Cannot open /dev/tty: %s\n",
 
276
                    strerror(errno));
 
277
                return NULL;
 
278
        }
 
279
        signal(SIGINT, SIG_IGN);
 
280
 
 
281
        /* Get terminal info */
 
282
        tcgetattr(fd, &to);
 
283
        to_old = to;
 
284
        /* Echo OFF, and assure we can prompt and get input */
 
285
        to.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL);
 
286
        to.c_lflag |= ICANON;
 
287
        to.c_cc[VMIN] = 255;
 
288
        tcsetattr(fd, TCSANOW, &to);
 
289
 
 
290
        printf("\tXMPP Password: ");
 
291
        fflush(stdout);
 
292
 
 
293
        memset(input, 0, sizeof(input));
 
294
        if ((read(fd, input, sizeof(input))) < 0) {
 
295
                g_warning("Cannot read from /dev/tty: %s\n",
 
296
                    strerror(errno));
 
297
                tcsetattr(fd, TCSANOW, &to_old);
 
298
                return NULL;
 
299
        }
 
300
        if (strlen(input) <= 1) {
 
301
                tcsetattr(fd, TCSANOW, &to_old);
 
302
                return NULL;
 
303
        }
 
304
        if ((ret = strchr(input, '\n')) != NULL)
 
305
                *ret = '\0';
 
306
 
 
307
        /* Restore old terminfo */
 
308
        tcsetattr(fd, TCSANOW, &to_old);
 
309
        signal(SIGINT, SIG_DFL);
 
310
 
 
311
        ret = g_strdup(input);
 
312
        memset(input, 0, sizeof(input));
 
313
#endif /* DISABLE_TERMIOS */
 
314
        return ret;
 
315
}
 
316
 
 
317
static void
 
318
lm_open_cb(LmConnection *connection, gboolean success,
 
319
    gpointer user_data)
 
320
{
 
321
        XMPP_SERVER_REC *server;
 
322
        IPADDR ip;
 
323
        char *host;
 
324
        char *recoded_user, *recoded_password, *recoded_resource;
 
325
 
 
326
        if ((server = XMPP_SERVER(user_data)) == NULL || !success)
 
327
                return;
 
328
        /* get the server address */
 
329
        host = lm_connection_get_local_host(server->lmconn);
 
330
        if (host != NULL) {
 
331
                net_host2ip(host, &ip);
 
332
                signal_emit("server connecting", 2, server, &ip);
 
333
                g_free(host);
 
334
        } else
 
335
                signal_emit("server connecting", 1, server);
 
336
        if (server->connrec->use_ssl)
 
337
                signal_emit("xmpp server status", 2, server, 
 
338
                    "Using SSL encryption.");
 
339
        else if (lm_ssl_get_use_starttls(lm_connection_get_ssl(server->lmconn)))
 
340
                signal_emit("xmpp server status", 2, server,
 
341
                    "Using STARTTLS encryption.");
 
342
        recoded_user = xmpp_recode_out(server->user);
 
343
 
 
344
        /* prompt for password or re-use typed password */
 
345
        if (server->connrec->prompted_password != NULL) {
 
346
                g_free_not_null(server->connrec->password);
 
347
                server->connrec->password =
 
348
                    g_strdup(server->connrec->prompted_password);
 
349
        } else if (server->connrec->password == NULL
 
350
            || *(server->connrec->password) == '\0'
 
351
            || *(server->connrec->password) == '\r') {
 
352
                g_free_not_null(server->connrec->password);
 
353
                server->connrec->prompted_password = get_password();
 
354
                signal_emit("send command", 1, "redraw");
 
355
                if (server->connrec->prompted_password != NULL)
 
356
                        server->connrec->password =
 
357
                            g_strdup(server->connrec->prompted_password);
 
358
                else
 
359
                        server->connrec->password = g_strdup("");
 
360
        }
 
361
 
 
362
        recoded_password = xmpp_recode_out(server->connrec->password);
 
363
        recoded_resource = xmpp_recode_out(server->resource);
 
364
        lm_connection_authenticate(connection, recoded_user,
 
365
            recoded_password, recoded_resource, lm_auth_cb, server,
 
366
            NULL, NULL);
 
367
        g_free(recoded_user);
 
368
        g_free(recoded_password);
 
369
        g_free(recoded_resource);
 
370
}
 
371
 
 
372
gboolean
 
373
set_ssl(LmConnection *lmconn, GError **error, gpointer user_data,
 
374
    gboolean use_starttls)
 
375
{
 
376
        LmSSL *ssl;
 
377
 
 
378
        if (!lm_ssl_is_supported() && error != NULL) {
 
379
                *error = g_new(GError, 1);
 
380
                (*error)->message =
 
381
                    g_strdup("SSL is not supported in this build");
 
382
                return FALSE;
 
383
        }
 
384
        ssl = lm_ssl_new(NULL, lm_ssl_cb, user_data, NULL);
 
385
        lm_connection_set_ssl(lmconn, ssl);
 
386
        if (use_starttls)
 
387
                lm_ssl_use_starttls(ssl, TRUE, FALSE);
 
388
        lm_ssl_unref(ssl);
 
389
        return TRUE;
 
390
}
 
391
 
 
392
gboolean
 
393
set_proxy(LmConnection *lmconn, GError **error)
 
394
{
 
395
        LmProxy *proxy;
 
396
        LmProxyType type;
 
397
        const char *str;
 
398
        char *recoded;
 
399
 
 
400
        str = settings_get_str("xmpp_proxy_type");
 
401
        if (str != NULL && g_ascii_strcasecmp(str, XMPP_PROXY_HTTP) == 0)
 
402
                type = LM_PROXY_TYPE_HTTP;
 
403
        else {
 
404
                if (error != NULL) {
 
405
                        *error = g_new(GError, 1);
 
406
                        (*error)->message = g_strdup("Invalid proxy type");
 
407
                }
 
408
                return FALSE;
 
409
        }
 
410
        str = settings_get_str("xmpp_proxy_address");
 
411
        if (str == NULL || *str == '\0') {
 
412
                if (error != NULL) {
 
413
                        *error = g_new(GError, 1);
 
414
                        (*error)->message =
 
415
                            g_strdup("Proxy address not specified");
 
416
                }
 
417
                return FALSE;
 
418
        }
 
419
        int port = settings_get_int("xmpp_proxy_port");
 
420
        if (port <= 0) {
 
421
                if (error != NULL) {
 
422
                        *error = g_new(GError, 1);
 
423
                        (*error)->message =
 
424
                            g_strdup("Invalid proxy port range");
 
425
                }
 
426
                return FALSE;
 
427
        }
 
428
        proxy = lm_proxy_new_with_server(type, str, port);
 
429
        str = settings_get_str("xmpp_proxy_user");
 
430
        if (str != NULL && *str != '\0') {
 
431
                recoded = xmpp_recode_out(str);
 
432
                lm_proxy_set_username(proxy, recoded);
 
433
                g_free(recoded);
 
434
        }
 
435
        str = settings_get_str("xmpp_proxy_password");
 
436
        if (str != NULL && *str != '\0') {
 
437
                recoded = xmpp_recode_out(str);
 
438
                lm_proxy_set_password(proxy, recoded);
 
439
                g_free(recoded);
 
440
        }
 
441
        lm_connection_set_proxy(lmconn, proxy);
 
442
        lm_proxy_unref(proxy);
 
443
        return TRUE;
 
444
}
 
445
 
 
446
static int
 
447
check_connection_timeout(XMPP_SERVER_REC *server)
 
448
{
 
449
        if (g_slist_find(lookup_servers, server) == NULL)
 
450
                return FALSE;
 
451
        if (!server->connected) {
 
452
                g_warning("%s: no response from server",
 
453
                    server->connrec->address);
 
454
                server->connection_lost = TRUE;
 
455
                server_disconnect(SERVER(server));
 
456
        } else
 
457
                server->timeout_tag = 0;
 
458
        return FALSE;
 
459
}
 
460
 
 
461
void
 
462
xmpp_server_connect(XMPP_SERVER_REC *server)
 
463
{
 
464
        GError *error;
 
465
        const char *err_msg;
 
466
 
 
467
        if (!IS_XMPP_SERVER(server))
 
468
                return;
 
469
        error = NULL;
 
470
        err_msg = NULL;
 
471
        if (server->connrec->use_ssl) {
 
472
                if (!set_ssl(server->lmconn, &error, server, FALSE)) {
 
473
                        err_msg = "Cannot init ssl";
 
474
                        goto err;
 
475
                }
 
476
        } else
 
477
                set_ssl(server->lmconn, &error, server, TRUE);
 
478
        if (settings_get_bool("xmpp_use_proxy")
 
479
            && !set_proxy(server->lmconn, &error)) {
 
480
                err_msg = "Cannot set proxy";
 
481
                goto err;
 
482
        }
 
483
        lm_connection_set_disconnect_function(server->lmconn,
 
484
            lm_close_cb, server, NULL);
 
485
        lookup_servers = g_slist_append(lookup_servers, server);
 
486
        signal_emit("server looking", 1, server);
 
487
        server->timeout_tag = g_timeout_add(
 
488
            settings_get_time("server_connect_timeout"),
 
489
            (GSourceFunc)check_connection_timeout, server);
 
490
        if (!lm_connection_open(server->lmconn,  lm_open_cb, server,
 
491
            NULL, &error)) {
 
492
                err_msg = "Connection failed";
 
493
                goto err;
 
494
        }
 
495
        return;
 
496
 
 
497
err:
 
498
        server->connection_lost = TRUE;
 
499
        if (error != NULL) {
 
500
                server_connect_failed(SERVER(server), error->message);
 
501
                g_error_free(error);
 
502
        } else
 
503
                server_connect_failed(SERVER(server), err_msg);
 
504
}
 
505
 
 
506
static void
 
507
sig_connected(XMPP_SERVER_REC *server)
 
508
{
 
509
        LmMessage *lmsg;
 
510
        char *str;
 
511
 
 
512
        if (!IS_XMPP_SERVER(server) || (server->connrec->reconnection
 
513
            && xmpp_presence_changed(server->connrec->show, server->show,
 
514
            server->connrec->away_reason, server->away_reason,
 
515
            server->connrec->priority, server->priority)))
 
516
                return;
 
517
        /* set presence available */
 
518
        lmsg = lm_message_new_with_sub_type(NULL, LM_MESSAGE_TYPE_PRESENCE,
 
519
            LM_MESSAGE_SUB_TYPE_AVAILABLE);
 
520
        str = g_strdup_printf("%d", server->priority);
 
521
        lm_message_node_add_child(lmsg->node, "priority", str);
 
522
        g_free(str);
 
523
        signal_emit("xmpp send presence", 2, server, lmsg);
 
524
        lm_message_unref(lmsg);
 
525
}
 
526
 
 
527
static void
 
528
sig_server_quit(XMPP_SERVER_REC *server, char *reason)
 
529
{
 
530
        LmMessage *lmsg;
 
531
        char *str;
 
532
 
 
533
        if (!IS_XMPP_SERVER(server))
 
534
                return;
 
535
        lmsg = lm_message_new_with_sub_type(NULL, LM_MESSAGE_TYPE_PRESENCE,
 
536
            LM_MESSAGE_SUB_TYPE_UNAVAILABLE);
 
537
        str = xmpp_recode_out((reason != NULL) ?
 
538
            reason : settings_get_str("quit_message"));
 
539
        lm_message_node_add_child(lmsg->node, "status", str);
 
540
        g_free(str);
 
541
        signal_emit("xmpp send presence", 2, server, lmsg);
 
542
        lm_message_unref(lmsg);
 
543
}
 
544
 
 
545
static void
 
546
disconnect_all(void)
 
547
{
 
548
        GSList *tmp, *next;
 
549
 
 
550
        for (tmp = lookup_servers; tmp != NULL; tmp = next) {
 
551
                next = tmp->next;
 
552
                if (IS_XMPP_SERVER(tmp->data))
 
553
                        server_connect_failed(SERVER(tmp->data), NULL);
 
554
        }
 
555
        for (tmp = servers; tmp != NULL; tmp = next) {
 
556
                next = tmp->next;
 
557
                if (IS_XMPP_SERVER(tmp->data))
 
558
                        server_disconnect(SERVER(tmp->data));
 
559
        }
 
560
}
 
561
 
 
562
static void
 
563
sig_session_save(void)
 
564
{
 
565
        /* We don't support /UPGRADE, so disconnect all servers
 
566
         * before performing it. */
 
567
        disconnect_all();
 
568
}
 
569
 
 
570
void
 
571
xmpp_servers_init(void)
 
572
{
 
573
        signal_add_last("server connected", sig_connected);
 
574
        signal_add_last("server disconnected", server_cleanup);
 
575
        signal_add_last("server connect failed", server_cleanup);
 
576
        signal_add("server quit", sig_server_quit);
 
577
        signal_add_first("session save", sig_session_save);
 
578
 
 
579
        settings_add_int("xmpp", "xmpp_priority", 0);
 
580
        settings_add_int("xmpp", "xmpp_priority_away", -1);
 
581
        settings_add_bool("xmpp_lookandfeel", "xmpp_set_nick_as_username",
 
582
            FALSE);
 
583
        settings_add_bool("xmpp_proxy", "xmpp_use_proxy", FALSE);
 
584
        settings_add_str("xmpp_proxy", "xmpp_proxy_type", "http");
 
585
        settings_add_str("xmpp_proxy", "xmpp_proxy_address", NULL);
 
586
        settings_add_int("xmpp_proxy", "xmpp_proxy_port", 8080);
 
587
        settings_add_str("xmpp_proxy", "xmpp_proxy_user", NULL);
 
588
        settings_add_str("xmpp_proxy", "xmpp_proxy_password", NULL);
 
589
}
 
590
 
 
591
void
 
592
xmpp_servers_deinit(void)
 
593
{
 
594
        /* disconnect all servers before unloading the module */
 
595
        disconnect_all();
 
596
 
 
597
        signal_remove("server connected", sig_connected);
 
598
        signal_remove("server disconnected", server_cleanup);
 
599
        signal_remove("server connect failed", server_cleanup);
 
600
        signal_remove("server quit", sig_server_quit);
 
601
        signal_remove("session save", sig_session_save);
 
602
}