?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Migrate certificates, icons, logs to XDG dirs
[pidgin-git.git] / libpurple / protocols / jabber / jabber.c
blob97a77d77edad90a502c82423cdbe87a67c84b811
1 /*
2 * purple - Jabber Protocol Plugin
3 *
4 * Purple is the legal property of its developers, whose names are too numerous
5 * to list here. Please refer to the COPYRIGHT file distributed with this
6 * source distribution.
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
21 *
22 */
23 #include "internal.h"
24
25 #include "account.h"
26 #include "accountopt.h"
27 #include "buddylist.h"
28 #include "core.h"
29 #include "cmds.h"
30 #include "connection.h"
31 #include "conversation.h"
32 #include "debug.h"
33 #include "http.h"
34 #include "message.h"
35 #include "notify.h"
36 #include "pluginpref.h"
37 #include "proxy.h"
38 #include "protocol.h"
39 #include "request.h"
40 #include "server.h"
41 #include "status.h"
42 #include "util.h"
43 #include "version.h"
44 #include "xmlnode.h"
45
46 #include "auth.h"
47 #include "buddy.h"
48 #include "caps.h"
49 #include "chat.h"
50 #include "data.h"
51 #include "disco.h"
52 #include "google/google.h"
53 #include "google/google_p2p.h"
54 #include "google/google_roster.h"
55 #include "google/google_session.h"
56 #include "ibb.h"
57 #include "iq.h"
58 #include "jutil.h"
59 #include "message.h"
60 #include "parser.h"
61 #include "presence.h"
62 #include "jabber.h"
63 #include "roster.h"
64 #include "ping.h"
65 #include "si.h"
66 #include "usermood.h"
67 #include "xdata.h"
68 #include "pep.h"
69 #include "adhoccommands.h"
70 #include "xmpp.h"
71 #include "gtalk.h"
72
73 #include "jingle/jingle.h"
74 #include "jingle/content.h"
75 #include "jingle/iceudp.h"
76 #include "jingle/rawudp.h"
77 #include "jingle/rtp.h"
78 #include "jingle/session.h"
79
80 #define PING_TIMEOUT 60
81 /* Send a whitespace keepalive to the server if we haven't sent
82 * anything in the last 120 seconds
83 */
84 #define DEFAULT_INACTIVITY_TIME 120
85
86 GList *jabber_features = NULL;
87 GList *jabber_identities = NULL;
88
89 static PurpleProtocol *xmpp_protocol = NULL;
90 static PurpleProtocol *gtalk_protocol = NULL;
91
92 static GHashTable *jabber_cmds = NULL; /* PurpleProtocol * => GSList of ids */
93
94 static gint plugin_ref = 0;
95
96 static void jabber_unregister_account_cb(JabberStream *js);
97
98 static void jabber_stream_init(JabberStream *js)
99 {
100 char *open_stream;
101
102 g_free(js->stream_id);
103 js->stream_id = NULL;
104
105 open_stream = g_strdup_printf("<stream:stream to='%s' "
106 "xmlns='" NS_XMPP_CLIENT "' "
107 "xmlns:stream='" NS_XMPP_STREAMS "' "
108 "version='1.0'>",
109 js->user->domain);
110 /* setup the parser fresh for each stream */
111 jabber_parser_setup(js);
112 jabber_send_raw(js, open_stream, -1);
113 js->reinit = FALSE;
114 g_free(open_stream);
115 }
116
117 static void
118 jabber_session_initialized_cb(JabberStream *js, const char *from,
119 JabberIqType type, const char *id,
120 PurpleXmlNode *packet, gpointer data)
121 {
122 if (type == JABBER_IQ_RESULT) {
123 jabber_disco_items_server(js);
124 if(js->unregistration)
125 jabber_unregister_account_cb(js);
126 } else {
127 purple_connection_error(js->gc,
128 PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
129 ("Error initializing session"));
130 }
131 }
132
133 static void jabber_session_init(JabberStream *js)
134 {
135 JabberIq *iq = jabber_iq_new(js, JABBER_IQ_SET);
136 PurpleXmlNode *session;
137
138 jabber_iq_set_callback(iq, jabber_session_initialized_cb, NULL);
139
140 session = purple_xmlnode_new_child(iq->node, "session");
141 purple_xmlnode_set_namespace(session, NS_XMPP_SESSION);
142
143 jabber_iq_send(iq);
144 }
145
146 static void jabber_bind_result_cb(JabberStream *js, const char *from,
147 JabberIqType type, const char *id,
148 PurpleXmlNode *packet, gpointer data)
149 {
150 PurpleXmlNode *bind;
151
152 if (type == JABBER_IQ_RESULT &&
153 (bind = purple_xmlnode_get_child_with_namespace(packet, "bind", NS_XMPP_BIND))) {
154 PurpleXmlNode *jid;
155 char *full_jid;
156 if((jid = purple_xmlnode_get_child(bind, "jid")) && (full_jid = purple_xmlnode_get_data(jid))) {
157 jabber_id_free(js->user);
158
159 js->user = jabber_id_new(full_jid);
160 if (js->user == NULL) {
161 purple_connection_error(js->gc,
162 PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
163 _("Invalid response from server"));
164 g_free(full_jid);
165 return;
166 }
167
168 js->user_jb = jabber_buddy_find(js, full_jid, TRUE);
169 js->user_jb->subscription |= JABBER_SUB_BOTH;
170
171 purple_connection_set_display_name(js->gc, full_jid);
172
173 g_free(full_jid);
174 }
175 } else {
176 PurpleConnectionError reason = PURPLE_CONNECTION_ERROR_NETWORK_ERROR;
177 char *msg = jabber_parse_error(js, packet, &reason);
178 purple_connection_error(js->gc, reason, msg);
179 g_free(msg);
180
181 return;
182 }
183
184 jabber_session_init(js);
185 }
186
187 static char *jabber_prep_resource(char *input) {
188 char hostname[256], /* current hostname */
189 *dot = NULL;
190
191 /* Empty resource == don't send any */
192 if (input == NULL || *input == '\0')
193 return NULL;
194
195 if (strstr(input, "__HOSTNAME__") == NULL)
196 return g_strdup(input);
197
198 /* Replace __HOSTNAME__ with hostname */
199 if (gethostname(hostname, sizeof(hostname) - 1)) {
200 purple_debug_warning("jabber", "gethostname: %s\n", g_strerror(errno));
201 /* according to glibc doc, the only time an error is returned
202 is if the hostname is longer than the buffer, in which case
203 glibc 2.2+ would still fill the buffer with partial
204 hostname, so maybe we want to detect that and use it
205 instead
206 */
207 g_strlcpy(hostname, "localhost", sizeof(hostname));
208 }
209 hostname[sizeof(hostname) - 1] = '\0';
210
211 /* We want only the short hostname, not the FQDN - this will prevent the
212 * resource string from being unreasonably long on systems which stuff the
213 * whole FQDN in the hostname */
214 if((dot = strchr(hostname, '.')))
215 *dot = '\0';
216
217 return purple_strreplace(input, "__HOSTNAME__", hostname);
218 }
219
220 static gboolean
221 jabber_process_starttls(JabberStream *js, PurpleXmlNode *packet)
222 {
223 #if 0
224 PurpleXmlNode *starttls;
225
226 PurpleAccount *account;
227
228 account = purple_connection_get_account(js->gc);
229
230 /*
231 * This code DOES NOT EXIST, will never be enabled by default, and
232 * will never ever be supported (by me).
233 * It's literally *only* for developer testing.
234 */
235 {
236 const gchar *connection_security = purple_account_get_string(account, "connection_security", JABBER_DEFAULT_REQUIRE_TLS);
237 if (!g_str_equal(connection_security, "none")) {
238 jabber_send_raw(js,
239 "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>", -1);
240 return TRUE;
241 }
242 }
243 #else
244 jabber_send_raw(js,
245 "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>", -1);
246 return TRUE;
247 #endif
248
249 #if 0
250 starttls = purple_xmlnode_get_child(packet, "starttls");
251 if(purple_xmlnode_get_child(starttls, "required")) {
252 purple_connection_error(js->gc,
253 PURPLE_CONNECTION_ERROR_NO_SSL_SUPPORT,
254 _("Server requires TLS/SSL, but no TLS/SSL support was found."));
255 return TRUE;
256 }
257
258 if (g_str_equal("require_tls", purple_account_get_string(account, "connection_security", JABBER_DEFAULT_REQUIRE_TLS))) {
259 purple_connection_error(js->gc,
260 PURPLE_CONNECTION_ERROR_NO_SSL_SUPPORT,
261 _("You require encryption, but no TLS/SSL support was found."));
262 return TRUE;
263 }
264
265 return FALSE;
266 #endif
267 }
268
269 void jabber_stream_features_parse(JabberStream *js, PurpleXmlNode *packet)
270 {
271 PurpleAccount *account = purple_connection_get_account(js->gc);
272 const char *connection_security =
273 purple_account_get_string(account, "connection_security", JABBER_DEFAULT_REQUIRE_TLS);
274
275 if (purple_xmlnode_get_child(packet, "starttls")) {
276 if (jabber_process_starttls(js, packet)) {
277 jabber_stream_set_state(js, JABBER_STREAM_INITIALIZING_ENCRYPTION);
278 return;
279 }
280 } else if (g_str_equal(connection_security, "require_tls") && !jabber_stream_is_ssl(js)) {
281 purple_connection_error(js->gc,
282 PURPLE_CONNECTION_ERROR_ENCRYPTION_ERROR,
283 _("You require encryption, but it is not available on this server."));
284 return;
285 }
286
287 if(js->registration) {
288 jabber_register_start(js);
289 } else if(purple_xmlnode_get_child(packet, "mechanisms")) {
290 jabber_stream_set_state(js, JABBER_STREAM_AUTHENTICATING);
291 jabber_auth_start(js, packet);
292 } else if(purple_xmlnode_get_child(packet, "bind")) {
293 PurpleXmlNode *bind, *resource;
294 char *requested_resource;
295 JabberIq *iq = jabber_iq_new(js, JABBER_IQ_SET);
296 bind = purple_xmlnode_new_child(iq->node, "bind");
297 purple_xmlnode_set_namespace(bind, NS_XMPP_BIND);
298 requested_resource = jabber_prep_resource(js->user->resource);
299
300 if (requested_resource != NULL) {
301 resource = purple_xmlnode_new_child(bind, "resource");
302 purple_xmlnode_insert_data(resource, requested_resource, -1);
303 g_free(requested_resource);
304 }
305
306 jabber_iq_set_callback(iq, jabber_bind_result_cb, NULL);
307
308 jabber_iq_send(iq);
309 } else if (purple_xmlnode_get_child_with_namespace(packet, "ver", NS_ROSTER_VERSIONING)) {
310 js->server_caps |= JABBER_CAP_ROSTER_VERSIONING;
311 } else /* if(purple_xmlnode_get_child_with_namespace(packet, "auth")) */ {
312 /* If we get an empty stream:features packet, or we explicitly get
313 * an auth feature with namespace http://jabber.org/features/iq-auth
314 * we should revert back to iq:auth authentication, even though we're
315 * connecting to an XMPP server. */
316 jabber_stream_set_state(js, JABBER_STREAM_AUTHENTICATING);
317 jabber_auth_start_old(js);
318 }
319 }
320
321 static void jabber_stream_handle_error(JabberStream *js, PurpleXmlNode *packet)
322 {
323 PurpleConnectionError reason = PURPLE_CONNECTION_ERROR_NETWORK_ERROR;
324 char *msg = jabber_parse_error(js, packet, &reason);
325
326 purple_connection_error(js->gc, reason, msg);
327
328 g_free(msg);
329 }
330
331 static void tls_init(JabberStream *js);
332
333 void jabber_process_packet(JabberStream *js, PurpleXmlNode **packet)
334 {
335 const char *name;
336 const char *xmlns;
337
338 purple_signal_emit(purple_connection_get_protocol(js->gc), "jabber-receiving-xmlnode", js->gc, packet);
339
340 /* if the signal leaves us with a null packet, we're done */
341 if(NULL == *packet)
342 return;
343
344 name = (*packet)->name;
345 xmlns = purple_xmlnode_get_namespace(*packet);
346
347 if(!strcmp((*packet)->name, "iq")) {
348 jabber_iq_parse(js, *packet);
349 } else if(!strcmp((*packet)->name, "presence")) {
350 jabber_presence_parse(js, *packet);
351 } else if(!strcmp((*packet)->name, "message")) {
352 jabber_message_parse(js, *packet);
353 } else if (purple_strequal(xmlns, NS_XMPP_STREAMS)) {
354 if (g_str_equal(name, "features"))
355 jabber_stream_features_parse(js, *packet);
356 else if (g_str_equal(name, "error"))
357 jabber_stream_handle_error(js, *packet);
358 } else if (purple_strequal(xmlns, NS_XMPP_SASL)) {
359 if (js->state != JABBER_STREAM_AUTHENTICATING)
360 purple_debug_warning("jabber", "Ignoring spurious SASL stanza %s\n", name);
361 else {
362 if (g_str_equal(name, "challenge"))
363 jabber_auth_handle_challenge(js, *packet);
364 else if (g_str_equal(name, "success"))
365 jabber_auth_handle_success(js, *packet);
366 else if (g_str_equal(name, "failure"))
367 jabber_auth_handle_failure(js, *packet);
368 }
369 } else if (purple_strequal(xmlns, NS_XMPP_TLS)) {
370 if (js->state != JABBER_STREAM_INITIALIZING_ENCRYPTION || js->gsc)
371 purple_debug_warning("jabber", "Ignoring spurious %s\n", name);
372 else {
373 if (g_str_equal(name, "proceed"))
374 tls_init(js);
375 /* TODO: Handle <failure/>, I guess? */
376 }
377 } else {
378 purple_debug_warning("jabber", "Unknown packet: %s\n", (*packet)->name);
379 }
380 }
381
382 static int jabber_do_send(JabberStream *js, const char *data, int len)
383 {
384 int ret;
385
386 if (js->gsc)
387 ret = purple_ssl_write(js->gsc, data, len);
388 else
389 ret = write(js->fd, data, len);
390
391 return ret;
392 }
393
394 static void jabber_send_cb(gpointer data, gint source, PurpleInputCondition cond)
395 {
396 JabberStream *js = data;
397 const gchar *output = NULL;
398 int ret, writelen;
399
400 writelen = purple_circular_buffer_get_max_read(js->write_buffer);
401 output = purple_circular_buffer_get_output(js->write_buffer);
402
403 if (writelen == 0) {
404 purple_input_remove(js->writeh);
405 js->writeh = 0;
406 return;
407 }
408
409 ret = jabber_do_send(js, output, writelen);
410
411 if (ret < 0 && errno == EAGAIN)
412 return;
413 else if (ret <= 0) {
414 gchar *tmp = g_strdup_printf(_("Lost connection with server: %s"),
415 g_strerror(errno));
416 purple_connection_error(js->gc,
417 PURPLE_CONNECTION_ERROR_NETWORK_ERROR, tmp);
418 g_free(tmp);
419 return;
420 }
421
422 purple_circular_buffer_mark_read(js->write_buffer, ret);
423 }
424
425 static gboolean do_jabber_send_raw(JabberStream *js, const char *data, int len)
426 {
427 int ret;
428 gboolean success = TRUE;
429
430 g_return_val_if_fail(len > 0, FALSE);
431
432 if (js->state == JABBER_STREAM_CONNECTED)
433 jabber_stream_restart_inactivity_timer(js);
434
435 if (js->writeh == 0)
436 ret = jabber_do_send(js, data, len);
437 else {
438 ret = -1;
439 errno = EAGAIN;
440 }
441
442 if (ret < 0 && errno != EAGAIN) {
443 PurpleAccount *account = purple_connection_get_account(js->gc);
444 /*
445 * The server may have closed the socket (on a stream error), so if
446 * we're disconnecting, don't generate (possibly another) error that
447 * (for some UIs) would mask the first.
448 */
449 if (!purple_account_is_disconnecting(account)) {
450 gchar *tmp = g_strdup_printf(_("Lost connection with server: %s"),
451 g_strerror(errno));
452 purple_connection_error(js->gc,
453 PURPLE_CONNECTION_ERROR_NETWORK_ERROR, tmp);
454 g_free(tmp);
455 }
456
457 success = FALSE;
458 } else if (ret < len) {
459 if (ret < 0)
460 ret = 0;
461 if (js->writeh == 0)
462 js->writeh = purple_input_add(
463 js->gsc ? js->gsc->fd : js->fd,
464 PURPLE_INPUT_WRITE, jabber_send_cb, js);
465 purple_circular_buffer_append(js->write_buffer,
466 data + ret, len - ret);
467 }
468
469 return success;
470 }
471
472 void jabber_send_raw(JabberStream *js, const char *data, int len)
473 {
474 PurpleConnection *gc;
475 PurpleAccount *account;
476
477 gc = js->gc;
478 account = purple_connection_get_account(gc);
479
480 g_return_if_fail(data != NULL);
481
482 /* because printing a tab to debug every minute gets old */
483 if (data && strcmp(data, "\t") != 0) {
484 const char *username;
485 char *text = NULL, *last_part = NULL, *tag_start = NULL;
486
487 /* Because debug logs with plaintext passwords make me sad */
488 if (!purple_debug_is_unsafe() && js->state != JABBER_STREAM_CONNECTED &&
489 /* Either <auth> or <query><password>... */
490 (((tag_start = strstr(data, "<auth ")) &&
491 strstr(data, "xmlns='" NS_XMPP_SASL "'")) ||
492 ((tag_start = strstr(data, "<query ")) &&
493 strstr(data, "xmlns='jabber:iq:auth'>") &&
494 (tag_start = strstr(tag_start, "<password>"))))) {
495 char *data_start, *tag_end = strchr(tag_start, '>');
496 text = g_strdup(data);
497
498 /* Better to print out some wacky debugging than crash
499 * due to a plugin sending bad xml */
500 if (tag_end == NULL)
501 tag_end = tag_start;
502
503 data_start = text + (tag_end - data) + 1;
504
505 last_part = strchr(data_start, '<');
506 *data_start = '\0';
507 }
508
509 username = purple_connection_get_display_name(gc);
510 if (!username)
511 username = purple_account_get_username(account);
512
513 purple_debug_misc("jabber", "Sending%s (%s): %s%s%s\n",
514 jabber_stream_is_ssl(js) ? " (ssl)" : "", username,
515 text ? text : data,
516 last_part ? "password removed" : "",
517 last_part ? last_part : "");
518
519 g_free(text);
520 }
521
522 purple_signal_emit(purple_connection_get_protocol(gc), "jabber-sending-text", gc, &data);
523 if (data == NULL)
524 return;
525
526 if (len == -1)
527 len = strlen(data);
528
529 /* If we've got a security layer, we need to encode the data,
530 * splitting it on the maximum buffer length negotiated */
531 #ifdef HAVE_CYRUS_SASL
532 if (js->sasl_maxbuf>0) {
533 int pos = 0;
534
535 if (!js->gsc && js->fd<0)
536 g_return_if_reached();
537
538 while (pos < len) {
539 int towrite;
540 const char *out;
541 unsigned olen;
542 int rc;
543
544 towrite = MIN((len - pos), js->sasl_maxbuf);
545
546 rc = sasl_encode(js->sasl, &data[pos], towrite,
547 &out, &olen);
548 if (rc != SASL_OK) {
549 gchar *error =
550 g_strdup_printf(_("SASL error: %s"),
551 sasl_errdetail(js->sasl));
552 purple_debug_error("jabber",
553 "sasl_encode error %d: %s\n", rc,
554 sasl_errdetail(js->sasl));
555 purple_connection_error(gc,
556 PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
557 error);
558 g_free(error);
559 return;
560 }
561 pos += towrite;
562
563 /* do_jabber_send_raw returns FALSE when it throws a
564 * connection error.
565 */
566 if (!do_jabber_send_raw(js, out, olen))
567 break;
568 }
569 return;
570 }
571 #endif
572
573 if (js->bosh)
574 jabber_bosh_connection_send(js->bosh, data);
575 else
576 do_jabber_send_raw(js, data, len);
577 }
578
579 int jabber_protocol_send_raw(PurpleConnection *gc, const char *buf, int len)
580 {
581 JabberStream *js = purple_connection_get_protocol_data(gc);
582
583 g_return_val_if_fail(js != NULL, -1);
584 /* TODO: It's probably worthwhile to restrict this to when the account
585 * state is CONNECTED, but I can /almost/ envision reasons for wanting
586 * to do things during the connection process.
587 */
588
589 jabber_send_raw(js, buf, len);
590 return (len < 0 ? (int)strlen(buf) : len);
591 }
592
593 void jabber_send_signal_cb(PurpleConnection *pc, PurpleXmlNode **packet,
594 gpointer unused)
595 {
596 JabberStream *js;
597 char *txt;
598 int len;
599
600 if (NULL == packet)
601 return;
602
603 PURPLE_ASSERT_CONNECTION_IS_VALID(pc);
604
605 js = purple_connection_get_protocol_data(pc);
606
607 if (NULL == js)
608 return;
609
610 if (js->bosh)
611 if (g_str_equal((*packet)->name, "message") ||
612 g_str_equal((*packet)->name, "iq") ||
613 g_str_equal((*packet)->name, "presence"))
614 purple_xmlnode_set_namespace(*packet, NS_XMPP_CLIENT);
615 txt = purple_xmlnode_to_str(*packet, &len);
616 jabber_send_raw(js, txt, len);
617 g_free(txt);
618 }
619
620 void jabber_send(JabberStream *js, PurpleXmlNode *packet)
621 {
622 purple_signal_emit(purple_connection_get_protocol(js->gc), "jabber-sending-xmlnode", js->gc, &packet);
623 }
624
625 static gboolean jabber_keepalive_timeout(PurpleConnection *gc)
626 {
627 JabberStream *js = purple_connection_get_protocol_data(gc);
628 purple_connection_error(gc, PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
629 _("Ping timed out"));
630 js->keepalive_timeout = 0;
631 return FALSE;
632 }
633
634 void jabber_keepalive(PurpleConnection *gc)
635 {
636 JabberStream *js = purple_connection_get_protocol_data(gc);
637 time_t now = time(NULL);
638
639 if (js->keepalive_timeout == 0 && (now - js->last_ping) >= PING_TIMEOUT) {
640 js->last_ping = now;
641
642 jabber_keepalive_ping(js);
643 js->keepalive_timeout = purple_timeout_add_seconds(120,
644 (GSourceFunc)(jabber_keepalive_timeout), gc);
645 }
646 }
647
648 static void
649 jabber_recv_cb_ssl(gpointer data, PurpleSslConnection *gsc,
650 PurpleInputCondition cond)
651 {
652 PurpleConnection *gc = data;
653 JabberStream *js = purple_connection_get_protocol_data(gc);
654 int len;
655 static char buf[4096];
656
657 PURPLE_ASSERT_CONNECTION_IS_VALID(gc);
658
659 while((len = purple_ssl_read(gsc, buf, sizeof(buf) - 1)) > 0) {
660 purple_connection_update_last_received(gc);
661 buf[len] = '\0';
662 purple_debug_misc("jabber", "Recv (ssl)(%d): %s", len, buf);
663 jabber_parser_process(js, buf, len);
664 if(js->reinit)
665 jabber_stream_init(js);
666 }
667
668 if(len < 0 && errno == EAGAIN)
669 return;
670 else {
671 gchar *tmp;
672 if (len == 0)
673 tmp = g_strdup(_("Server closed the connection"));
674 else
675 tmp = g_strdup_printf(_("Lost connection with server: %s"),
676 g_strerror(errno));
677 purple_connection_error(js->gc,
678 PURPLE_CONNECTION_ERROR_NETWORK_ERROR, tmp);
679 g_free(tmp);
680 }
681 }
682
683 static void
684 jabber_recv_cb(gpointer data, gint source, PurpleInputCondition condition)
685 {
686 PurpleConnection *gc = data;
687 JabberStream *js = purple_connection_get_protocol_data(gc);
688 int len;
689 static char buf[4096];
690
691 PURPLE_ASSERT_CONNECTION_IS_VALID(gc);
692
693 if((len = read(js->fd, buf, sizeof(buf) - 1)) > 0) {
694 purple_connection_update_last_received(gc);
695 #ifdef HAVE_CYRUS_SASL
696 if (js->sasl_maxbuf > 0) {
697 const char *out;
698 unsigned int olen;
699 int rc;
700
701 rc = sasl_decode(js->sasl, buf, len, &out, &olen);
702 if (rc != SASL_OK) {
703 gchar *error =
704 g_strdup_printf(_("SASL error: %s"),
705 sasl_errdetail(js->sasl));
706 purple_debug_error("jabber",
707 "sasl_decode_error %d: %s\n", rc,
708 sasl_errdetail(js->sasl));
709 purple_connection_error(gc,
710 PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
711 error);
712 } else if (olen > 0) {
713 purple_debug_info("jabber", "RecvSASL (%u): %s\n", olen, out);
714 jabber_parser_process(js, out, olen);
715 if (js->reinit)
716 jabber_stream_init(js);
717 }
718 return;
719 }
720 #endif
721 buf[len] = '\0';
722 purple_debug_misc("jabber", "Recv (%d): %s", len, buf);
723 jabber_parser_process(js, buf, len);
724 if(js->reinit)
725 jabber_stream_init(js);
726 } else if(len < 0 && errno == EAGAIN) {
727 return;
728 } else {
729 gchar *tmp;
730 if (len == 0)
731 tmp = g_strdup(_("Server closed the connection"));
732 else
733 tmp = g_strdup_printf(_("Lost connection with server: %s"),
734 g_strerror(errno));
735 purple_connection_error(js->gc,
736 PURPLE_CONNECTION_ERROR_NETWORK_ERROR, tmp);
737 g_free(tmp);
738 }
739 }
740
741 static void
742 jabber_login_callback_ssl(gpointer data, PurpleSslConnection *gsc,
743 PurpleInputCondition cond)
744 {
745 PurpleConnection *gc = data;
746 JabberStream *js;
747
748 PURPLE_ASSERT_CONNECTION_IS_VALID(gc);
749
750 js = purple_connection_get_protocol_data(gc);
751
752 if(js->state == JABBER_STREAM_CONNECTING)
753 jabber_send_raw(js, "<?xml version='1.0' ?>", -1);
754 jabber_stream_set_state(js, JABBER_STREAM_INITIALIZING);
755 purple_ssl_input_add(gsc, jabber_recv_cb_ssl, gc);
756
757 /* Tell the app that we're doing encryption */
758 jabber_stream_set_state(js, JABBER_STREAM_INITIALIZING_ENCRYPTION);
759 }
760
761 static void
762 txt_resolved_cb(GObject *sender, GAsyncResult *result, gpointer data)
763 {
764 GError *error = NULL;
765 GList *records = NULL, *l = NULL;
766 JabberStream *js = data;
767 gboolean found = FALSE;
768
769 records = g_resolver_lookup_records_finish(G_RESOLVER(sender),
770 result, &error);
771 if(error) {
772 purple_debug_warning("jabber", "Unable to find alternative XMPP connection "
773 "methods after failing to connect directly. : %s\n",
774 error->message);
775
776 purple_connection_error(js->gc,
777 PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
778 _("Unable to connect"));
779
780 g_error_free(error);
781
782 return;
783 }
784
785 for(l = records; l; l = l->next) {
786 GVariantIter *iter = NULL;
787 gchar *str = NULL;
788
789 g_variant_get((GVariant *)l->data, "(as)", &iter);
790 while(g_variant_iter_loop(iter, "s", &str)) {
791 gchar **token = g_strsplit(str, "=", 2);
792
793 if(!g_ascii_strcasecmp(token[0], "_xmpp-client-xbosh")) {
794 purple_debug_info("jabber","Found alternative connection method using %s at %s.\n", token[0], token[1]);
795
796 js->bosh = jabber_bosh_connection_new(js, token[1]);
797
798 g_strfreev(token);
799
800 break;
801 }
802
803 g_strfreev(token);
804 }
805
806 g_variant_iter_free(iter);
807 }
808
809 g_list_free_full(records, (GDestroyNotify)g_variant_unref);
810
811 if (js->bosh)
812 found = TRUE;
813
814 if (!found) {
815 purple_debug_warning("jabber", "Unable to find alternative XMPP connection "
816 "methods after failing to connect directly.\n");
817 purple_connection_error(js->gc,
818 PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
819 _("Unable to connect"));
820 return;
821 }
822 }
823
824 static void
825 jabber_login_callback(gpointer data, gint source, const gchar *error)
826 {
827 PurpleConnection *gc = data;
828 JabberStream *js = purple_connection_get_protocol_data(gc);
829
830 if (source < 0) {
831 GResolver *resolver = g_resolver_get_default();
832 gchar *name = g_strdup_printf("_xmppconnect.%s", js->user->domain);
833
834 purple_debug_info("jabber", "Couldn't connect directly to %s. Trying to find alternative connection methods, like BOSH.\n", js->user->domain);
835
836 g_resolver_lookup_records_async(resolver,
837 name,
838 G_RESOLVER_RECORD_TXT,
839 js->cancellable,
840 txt_resolved_cb,
841 js);
842 g_free(name);
843 g_object_unref(resolver);
844
845 return;
846 }
847
848 js->fd = source;
849
850 if(js->state == JABBER_STREAM_CONNECTING)
851 jabber_send_raw(js, "<?xml version='1.0' ?>", -1);
852
853 jabber_stream_set_state(js, JABBER_STREAM_INITIALIZING);
854 js->inpa = purple_input_add(js->fd, PURPLE_INPUT_READ, jabber_recv_cb, gc);
855 }
856
857 static void
858 jabber_ssl_connect_failure(PurpleSslConnection *gsc, PurpleSslErrorType error,
859 gpointer data)
860 {
861 PurpleConnection *gc = data;
862 JabberStream *js;
863
864 PURPLE_ASSERT_CONNECTION_IS_VALID(gc);
865
866 js = purple_connection_get_protocol_data(gc);
867 js->gsc = NULL;
868
869 purple_connection_ssl_error (gc, error);
870 }
871
872 static void tls_init(JabberStream *js)
873 {
874 purple_input_remove(js->inpa);
875 js->inpa = 0;
876 js->gsc = purple_ssl_connect_with_host_fd(purple_connection_get_account(js->gc), js->fd,
877 jabber_login_callback_ssl, jabber_ssl_connect_failure, js->certificate_CN, js->gc);
878 /* The fd is no longer our concern */
879 js->fd = -1;
880 }
881
882 static gboolean jabber_login_connect(JabberStream *js, const char *domain, const char *host, int port,
883 gboolean fatal_failure)
884 {
885 /* host should be used in preference to domain to
886 * allow SASL authentication to work with FQDN of the server,
887 * but we use domain as fallback for when users enter IP address
888 * in connect server */
889 g_free(js->serverFQDN);
890 if (purple_ip_address_is_valid(host))
891 js->serverFQDN = g_strdup(domain);
892 else
893 js->serverFQDN = g_strdup(host);
894
895 if (purple_proxy_connect(js->gc, purple_connection_get_account(js->gc),
896 host, port, jabber_login_callback, js->gc) == NULL) {
897 if (fatal_failure) {
898 purple_connection_error(js->gc,
899 PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
900 _("Unable to connect"));
901 }
902
903 return FALSE;
904 }
905
906 return TRUE;
907 }
908
909 static void
910 srv_resolved_cb(GObject *sender, GAsyncResult *result, gpointer data)
911 {
912 GError *error = NULL;
913 GList *targets = NULL, *l = NULL;
914 JabberStream *js = data;
915
916 targets = g_resolver_lookup_service_finish(G_RESOLVER(sender),
917 result, &error);
918 if(error) {
919 purple_debug_warning("jabber",
920 "SRV lookup failed, proceeding with normal connection : %s",
921 error->message);
922
923 g_error_free(error);
924
925 jabber_login_connect(js, js->user->domain, js->user->domain,
926 purple_account_get_int(purple_connection_get_account(js->gc), "port", 5222),
927 TRUE);
928
929 } else {
930 for(l = targets; l; l = l->next) {
931 GSrvTarget *target = (GSrvTarget *)l->data;
932 const gchar *hostname = g_srv_target_get_hostname(target);
933 guint port = g_srv_target_get_port(target);
934
935 if(jabber_login_connect(js, hostname, hostname, port, FALSE)) {
936 g_resolver_free_targets(targets);
937
938 return;
939 }
940 }
941
942 g_resolver_free_targets(targets);
943
944 jabber_login_connect(js, js->user->domain, js->user->domain,
945 purple_account_get_int(purple_connection_get_account(js->gc), "port", 5222),
946 TRUE);
947 }
948 }
949
950 static JabberStream *
951 jabber_stream_new(PurpleAccount *account)
952 {
953 PurpleConnection *gc = purple_account_get_connection(account);
954 JabberStream *js;
955 PurplePresence *presence;
956 gchar *user;
957 gchar *slash;
958
959 js = g_new0(JabberStream, 1);
960 purple_connection_set_protocol_data(gc, js);
961 js->gc = gc;
962 js->fd = -1;
963 js->http_conns = purple_http_connection_set_new();
964
965 /* we might want to expose this at some point */
966 js->cancellable = g_cancellable_new();
967
968 user = g_strdup(purple_account_get_username(account));
969 /* jabber_id_new doesn't accept "user@domain/" as valid */
970 slash = strchr(user, '/');
971 if (slash && *(slash + 1) == '\0')
972 *slash = '\0';
973 js->user = jabber_id_new(user);
974
975 if (!js->user) {
976 purple_connection_error(gc,
977 PURPLE_CONNECTION_ERROR_INVALID_SETTINGS,
978 _("Invalid XMPP ID"));
979 g_free(user);
980 /* Destroying the connection will free the JabberStream */
981 return NULL;
982 }
983
984 if (!js->user->node || *(js->user->node) == '\0') {
985 purple_connection_error(gc,
986 PURPLE_CONNECTION_ERROR_INVALID_SETTINGS,
987 _("Invalid XMPP ID. Username portion must be set."));
988 g_free(user);
989 /* Destroying the connection will free the JabberStream */
990 return NULL;
991 }
992
993 if (!js->user->domain || *(js->user->domain) == '\0') {
994 purple_connection_error(gc,
995 PURPLE_CONNECTION_ERROR_INVALID_SETTINGS,
996 _("Invalid XMPP ID. Domain must be set."));
997 g_free(user);
998 /* Destroying the connection will free the JabberStream */
999 return NULL;
1000 }
1001
1002 js->buddies = g_hash_table_new_full(g_str_hash, g_str_equal,
1003 g_free, (GDestroyNotify)jabber_buddy_free);
1004
1005 /* This is overridden during binding, but we need it here
1006 * in case the server only does legacy non-sasl auth!.
1007 */
1008 purple_connection_set_display_name(gc, user);
1009
1010 js->user_jb = jabber_buddy_find(js, user, TRUE);
1011 g_free(user);
1012 if (!js->user_jb) {
1013 /* This basically *can't* fail, but for good measure... */
1014 purple_connection_error(gc,
1015 PURPLE_CONNECTION_ERROR_INVALID_SETTINGS,
1016 _("Invalid XMPP ID"));
1017 /* Destroying the connection will free the JabberStream */
1018 g_return_val_if_reached(NULL);
1019 }
1020
1021 js->user_jb->subscription |= JABBER_SUB_BOTH;
1022
1023 js->iq_callbacks = g_hash_table_new_full(g_str_hash, g_str_equal,
1024 g_free, (GDestroyNotify)jabber_iq_callbackdata_free);
1025 js->chats = g_hash_table_new_full(g_str_hash, g_str_equal,
1026 g_free, (GDestroyNotify)jabber_chat_free);
1027 js->next_id = g_random_int();
1028 js->write_buffer = purple_circular_buffer_new(512);
1029 js->old_length = 0;
1030 js->keepalive_timeout = 0;
1031 js->max_inactivity = DEFAULT_INACTIVITY_TIME;
1032 /* Set the default protocol version to 1.0. Overridden in parser.c. */
1033 js->protocol_version.major = 1;
1034 js->protocol_version.minor = 0;
1035 js->sessions = NULL;
1036 js->stun_ip = NULL;
1037 js->stun_port = 0;
1038 js->google_relay_token = NULL;
1039 js->google_relay_host = NULL;
1040
1041 /* if we are idle, set idle-ness on the stream (this could happen if we get
1042 disconnected and the reconnects while being idle. I don't think it makes
1043 sense to do this when registering a new account... */
1044 presence = purple_account_get_presence(account);
1045 if (purple_presence_is_idle(presence))
1046 js->idle = purple_presence_get_idle_time(presence);
1047
1048 return js;
1049 }
1050
1051 static void
1052 jabber_stream_connect(JabberStream *js)
1053 {
1054 PurpleConnection *gc = js->gc;
1055 PurpleAccount *account = purple_connection_get_account(gc);
1056 const char *connect_server = purple_account_get_string(account,
1057 "connect_server", "");
1058 const char *bosh_url = purple_account_get_string(account,
1059 "bosh_url", "");
1060
1061 jabber_stream_set_state(js, JABBER_STREAM_CONNECTING);
1062
1063 /* If both BOSH and a Connect Server are specified, we prefer BOSH. I'm not
1064 * attached to that choice, though.
1065 */
1066 if (*bosh_url) {
1067 js->bosh = jabber_bosh_connection_new(js, bosh_url);
1068 if (!js->bosh) {
1069 purple_connection_error(gc,
1070 PURPLE_CONNECTION_ERROR_INVALID_SETTINGS,
1071 _("Malformed BOSH URL"));
1072 }
1073
1074 return;
1075 }
1076
1077 js->certificate_CN = g_strdup(connect_server[0] ? connect_server : js->user->domain);
1078
1079 /* if they've got old-ssl mode going, we probably want to ignore SRV lookups */
1080 if (g_str_equal("old_ssl", purple_account_get_string(account, "connection_security", JABBER_DEFAULT_REQUIRE_TLS))) {
1081 js->gsc = purple_ssl_connect(account, js->certificate_CN,
1082 purple_account_get_int(account, "port", 5223),
1083 jabber_login_callback_ssl, jabber_ssl_connect_failure, gc);
1084 if (!js->gsc) {
1085 purple_connection_error(gc,
1086 PURPLE_CONNECTION_ERROR_NO_SSL_SUPPORT,
1087 _("Unable to establish SSL connection"));
1088 }
1089
1090 return;
1091 }
1092
1093 /* no old-ssl, so if they've specified a connect server, we'll use that, otherwise we'll
1094 * invoke the magic of SRV lookups, to figure out host and port */
1095 if(connect_server[0]) {
1096 jabber_login_connect(js, js->user->domain, connect_server,
1097 purple_account_get_int(account, "port", 5222), TRUE);
1098 } else {
1099 GResolver *resolver = g_resolver_get_default();
1100 g_resolver_lookup_service_async(resolver,
1101 "xmpp-client",
1102 "tcp",
1103 js->user->domain,
1104 js->cancellable,
1105 srv_resolved_cb,
1106 js);
1107 g_object_unref(resolver);
1108 }
1109 }
1110
1111 void
1112 jabber_login(PurpleAccount *account)
1113 {
1114 PurpleConnection *gc = purple_account_get_connection(account);
1115 JabberStream *js;
1116 PurpleImage *image;
1117
1118 purple_connection_set_flags(gc, PURPLE_CONNECTION_FLAG_HTML |
1119 PURPLE_CONNECTION_FLAG_ALLOW_CUSTOM_SMILEY |
1120 PURPLE_CONNECTION_FLAG_NO_IMAGES);
1121 js = jabber_stream_new(account);
1122 if (js == NULL)
1123 return;
1124
1125 /* replace old default proxies with the new default: NULL
1126 * TODO: these can eventually be removed */
1127 if (g_str_equal("proxy.jabber.org", purple_account_get_string(account, "ft_proxies", ""))
1128 || g_str_equal("proxy.eu.jabber.org", purple_account_get_string(account, "ft_proxies", "")))
1129 purple_account_set_string(account, "ft_proxies", NULL);
1130
1131 /*
1132 * Calculate the avatar hash for our current image so we know (when we
1133 * fetch our vCard and PEP avatar) if we should send our avatar to the
1134 * server.
1135 */
1136 image = purple_buddy_icons_find_account_icon(account);
1137 if (image != NULL) {
1138 js->initial_avatar_hash = jabber_calculate_data_hash(
1139 purple_image_get_data(image),
1140 purple_image_get_size(image), "sha1");
1141 g_object_unref(image);
1142 }
1143
1144 jabber_stream_connect(js);
1145 }
1146
1147
1148 static gboolean
1149 conn_close_cb(gpointer data)
1150 {
1151 JabberStream *js = data;
1152 PurpleAccount *account = purple_connection_get_account(js->gc);
1153
1154 jabber_parser_free(js);
1155
1156 purple_account_disconnect(account);
1157
1158 js->conn_close_timeout = 0;
1159
1160 return FALSE;
1161 }
1162
1163 static void
1164 jabber_connection_schedule_close(JabberStream *js)
1165 {
1166 js->conn_close_timeout = purple_timeout_add(0, conn_close_cb, js);
1167 }
1168
1169 static void
1170 jabber_registration_result_cb(JabberStream *js, const char *from,
1171 JabberIqType type, const char *id,
1172 PurpleXmlNode *packet, gpointer data)
1173 {
1174 PurpleAccount *account = purple_connection_get_account(js->gc);
1175 char *buf;
1176 char *to = data;
1177
1178 if (type == JABBER_IQ_RESULT) {
1179 if(js->registration) {
1180 buf = g_strdup_printf(_("Registration of %s@%s successful"),
1181 js->user->node, js->user->domain);
1182 purple_account_register_completed(account, TRUE);
1183 } else {
1184 g_return_if_fail(to != NULL);
1185 buf = g_strdup_printf(_("Registration to %s successful"),
1186 to);
1187 }
1188 purple_notify_info(NULL, _("Registration Successful"),
1189 _("Registration Successful"), buf,
1190 purple_request_cpar_from_connection(js->gc));
1191 g_free(buf);
1192 } else {
1193 char *msg = jabber_parse_error(js, packet, NULL);
1194
1195 if(!msg)
1196 msg = g_strdup(_("Unknown Error"));
1197
1198 purple_notify_error(NULL, _("Registration Failed"),
1199 _("Registration Failed"), msg,
1200 purple_request_cpar_from_connection(js->gc));
1201 g_free(msg);
1202 purple_account_register_completed(account, FALSE);
1203 }
1204 g_free(to);
1205 if(js->registration)
1206 jabber_connection_schedule_close(js);
1207 }
1208
1209 static void
1210 jabber_unregistration_result_cb(JabberStream *js, const char *from,
1211 JabberIqType type, const char *id,
1212 PurpleXmlNode *packet, gpointer data)
1213 {
1214 char *buf;
1215 char *to = data;
1216
1217 /* This function is never called for unregistering our XMPP account from
1218 * the server, so there should always be a 'to' address. */
1219 g_return_if_fail(to != NULL);
1220
1221 if (type == JABBER_IQ_RESULT) {
1222 buf = g_strdup_printf(_("Registration from %s successfully removed"),
1223 to);
1224 purple_notify_info(NULL, _("Unregistration Successful"),
1225 _("Unregistration Successful"), buf,
1226 purple_request_cpar_from_connection(js->gc));
1227 g_free(buf);
1228 } else {
1229 char *msg = jabber_parse_error(js, packet, NULL);
1230
1231 if(!msg)
1232 msg = g_strdup(_("Unknown Error"));
1233
1234 purple_notify_error(NULL, _("Unregistration Failed"),
1235 _("Unregistration Failed"), msg,
1236 purple_request_cpar_from_connection(js->gc));
1237 g_free(msg);
1238 }
1239 g_free(to);
1240 }
1241
1242 typedef struct _JabberRegisterCBData {
1243 JabberStream *js;
1244 char *who;
1245 } JabberRegisterCBData;
1246
1247 static void
1248 jabber_register_cb(JabberRegisterCBData *cbdata, PurpleRequestFields *fields)
1249 {
1250 GList *groups, *flds;
1251 PurpleXmlNode *query, *y;
1252 JabberIq *iq;
1253 char *username;
1254
1255 iq = jabber_iq_new_query(cbdata->js, JABBER_IQ_SET, "jabber:iq:register");
1256 query = purple_xmlnode_get_child(iq->node, "query");
1257 if (cbdata->who)
1258 purple_xmlnode_set_attrib(iq->node, "to", cbdata->who);
1259
1260 for(groups = purple_request_fields_get_groups(fields); groups;
1261 groups = groups->next) {
1262 for(flds = purple_request_field_group_get_fields(groups->data);
1263 flds; flds = flds->next) {
1264 PurpleRequestField *field = flds->data;
1265 const char *id = purple_request_field_get_id(field);
1266 if(!strcmp(id,"unregister")) {
1267 gboolean value = purple_request_field_bool_get_value(field);
1268 if(value) {
1269 /* unregister from service. this doesn't include any of the fields, so remove them from the stanza by recreating it
1270 (there's no "remove child" function for PurpleXmlNode) */
1271 jabber_iq_free(iq);
1272 iq = jabber_iq_new_query(cbdata->js, JABBER_IQ_SET, "jabber:iq:register");
1273 query = purple_xmlnode_get_child(iq->node, "query");
1274 if (cbdata->who)
1275 purple_xmlnode_set_attrib(iq->node,"to",cbdata->who);
1276 purple_xmlnode_new_child(query, "remove");
1277
1278 jabber_iq_set_callback(iq, jabber_unregistration_result_cb, cbdata->who);
1279
1280 jabber_iq_send(iq);
1281 g_free(cbdata);
1282 return;
1283 }
1284 } else {
1285 const char *ids[] = {"username", "password", "name", "email", "nick", "first",
1286 "last", "address", "city", "state", "zip", "phone", "url", "date",
1287 NULL};
1288 const char *value = purple_request_field_string_get_value(field);
1289 int i;
1290 for (i = 0; ids[i]; i++) {
1291 if (!strcmp(id, ids[i]))
1292 break;
1293 }
1294
1295 if (!ids[i])
1296 continue;
1297 y = purple_xmlnode_new_child(query, ids[i]);
1298 purple_xmlnode_insert_data(y, value, -1);
1299 if(cbdata->js->registration && !strcmp(id, "username")) {
1300 g_free(cbdata->js->user->node);
1301 cbdata->js->user->node = g_strdup(value);
1302 }
1303 if(cbdata->js->registration && !strcmp(id, "password"))
1304 purple_account_set_password(purple_connection_get_account(cbdata->js->gc), value, NULL, NULL);
1305 }
1306 }
1307 }
1308
1309 if(cbdata->js->registration) {
1310 username = g_strdup_printf("%s@%s%s%s", cbdata->js->user->node, cbdata->js->user->domain,
1311 cbdata->js->user->resource ? "/" : "",
1312 cbdata->js->user->resource ? cbdata->js->user->resource : "");
1313 purple_account_set_username(purple_connection_get_account(cbdata->js->gc), username);
1314 g_free(username);
1315 }
1316
1317 jabber_iq_set_callback(iq, jabber_registration_result_cb, cbdata->who);
1318
1319 jabber_iq_send(iq);
1320 g_free(cbdata);
1321 }
1322
1323 static void
1324 jabber_register_cancel_cb(JabberRegisterCBData *cbdata, PurpleRequestFields *fields)
1325 {
1326 PurpleAccount *account = purple_connection_get_account(cbdata->js->gc);
1327 if(account && cbdata->js->registration) {
1328 purple_account_register_completed(account, FALSE);
1329 jabber_connection_schedule_close(cbdata->js);
1330 }
1331 g_free(cbdata->who);
1332 g_free(cbdata);
1333 }
1334
1335 static void jabber_register_x_data_cb(JabberStream *js, PurpleXmlNode *result, gpointer data)
1336 {
1337 PurpleXmlNode *query;
1338 JabberIq *iq;
1339 char *to = data;
1340
1341 iq = jabber_iq_new_query(js, JABBER_IQ_SET, "jabber:iq:register");
1342 query = purple_xmlnode_get_child(iq->node, "query");
1343 if (to)
1344 purple_xmlnode_set_attrib(iq->node,"to",to);
1345
1346 purple_xmlnode_insert_child(query, result);
1347
1348 jabber_iq_set_callback(iq, jabber_registration_result_cb, to);
1349 jabber_iq_send(iq);
1350 }
1351
1352 static const struct {
1353 const char *name;
1354 const char *label;
1355 } registration_fields[] = {
1356 { "email", N_("Email") },
1357 { "nick", N_("Nickname") },
1358 { "first", N_("First name") },
1359 { "last", N_("Last name") },
1360 { "address", N_("Address") },
1361 { "city", N_("City") },
1362 { "state", N_("State") },
1363 { "zip", N_("Postal code") },
1364 { "phone", N_("Phone") },
1365 { "url", N_("URL") },
1366 { "date", N_("Date") },
1367 { NULL, NULL }
1368 };
1369
1370 void jabber_register_parse(JabberStream *js, const char *from, JabberIqType type,
1371 const char *id, PurpleXmlNode *query)
1372 {
1373 PurpleAccount *account = purple_connection_get_account(js->gc);
1374 PurpleRequestFields *fields;
1375 PurpleRequestFieldGroup *group;
1376 PurpleRequestField *field;
1377 PurpleXmlNode *x, *y, *node;
1378 char *instructions;
1379 JabberRegisterCBData *cbdata;
1380 gboolean registered = FALSE;
1381 int i;
1382
1383 if (type != JABBER_IQ_RESULT)
1384 return;
1385
1386 if(js->registration) {
1387 /* get rid of the login thingy */
1388 purple_connection_set_state(js->gc, PURPLE_CONNECTION_CONNECTED);
1389 }
1390
1391 if(purple_xmlnode_get_child(query, "registered")) {
1392 registered = TRUE;
1393
1394 if(js->registration) {
1395 purple_notify_error(NULL, _("Already Registered"),
1396 _("Already Registered"), NULL,
1397 purple_request_cpar_from_connection(js->gc));
1398 purple_account_register_completed(account, FALSE);
1399 jabber_connection_schedule_close(js);
1400 return;
1401 }
1402 }
1403
1404 if((x = purple_xmlnode_get_child_with_namespace(query, "x", "jabber:x:data"))) {
1405 jabber_x_data_request(js, x, jabber_register_x_data_cb, g_strdup(from));
1406 return;
1407
1408 } else if((x = purple_xmlnode_get_child_with_namespace(query, "x", NS_OOB_X_DATA))) {
1409 PurpleXmlNode *url;
1410
1411 if((url = purple_xmlnode_get_child(x, "url"))) {
1412 char *href;
1413 if((href = purple_xmlnode_get_data(url))) {
1414 purple_notify_uri(NULL, href);
1415 g_free(href);
1416
1417 if(js->registration) {
1418 /* succeeded, but we have no login info */
1419 purple_account_register_completed(account, TRUE);
1420 purple_connection_error(js->gc, PURPLE_CONNECTION_ERROR_OTHER_ERROR,
1421 _("Registration completed successfully. Please reconnect to continue."));
1422 jabber_connection_schedule_close(js);
1423 }
1424 return;
1425 }
1426 }
1427 }
1428
1429 /* as a last resort, use the old jabber:iq:register syntax */
1430
1431 fields = purple_request_fields_new();
1432 group = purple_request_field_group_new(NULL);
1433 purple_request_fields_add_group(fields, group);
1434
1435 if((node = purple_xmlnode_get_child(query, "username"))) {
1436 char *data = purple_xmlnode_get_data(node);
1437 if(js->registration)
1438 field = purple_request_field_string_new("username", _("Username"), data ? data : js->user->node, FALSE);
1439 else
1440 field = purple_request_field_string_new("username", _("Username"), data, FALSE);
1441
1442 purple_request_field_group_add_field(group, field);
1443 g_free(data);
1444 }
1445 if((node = purple_xmlnode_get_child(query, "password"))) {
1446 if(js->registration)
1447 field = purple_request_field_string_new("password", _("Password"),
1448 purple_connection_get_password(js->gc), FALSE);
1449 else {
1450 char *data = purple_xmlnode_get_data(node);
1451 field = purple_request_field_string_new("password", _("Password"), data, FALSE);
1452 g_free(data);
1453 }
1454
1455 purple_request_field_string_set_masked(field, TRUE);
1456 purple_request_field_group_add_field(group, field);
1457 }
1458
1459 if((node = purple_xmlnode_get_child(query, "name"))) {
1460 if(js->registration)
1461 field = purple_request_field_string_new("name", _("Name"),
1462 purple_account_get_private_alias(purple_connection_get_account(js->gc)), FALSE);
1463 else {
1464 char *data = purple_xmlnode_get_data(node);
1465 field = purple_request_field_string_new("name", _("Name"), data, FALSE);
1466 g_free(data);
1467 }
1468 purple_request_field_group_add_field(group, field);
1469 }
1470
1471 for (i = 0; registration_fields[i].name != NULL; ++i) {
1472 if ((node = purple_xmlnode_get_child(query, registration_fields[i].name))) {
1473 char *data = purple_xmlnode_get_data(node);
1474 field = purple_request_field_string_new(registration_fields[i].name,
1475 _(registration_fields[i].label),
1476 data, FALSE);
1477 purple_request_field_group_add_field(group, field);
1478 g_free(data);
1479 }
1480 }
1481
1482 if(registered) {
1483 field = purple_request_field_bool_new("unregister", _("Unregister"), FALSE);
1484 purple_request_field_group_add_field(group, field);
1485 }
1486
1487 if((y = purple_xmlnode_get_child(query, "instructions")))
1488 instructions = purple_xmlnode_get_data(y);
1489 else if(registered)
1490 instructions = g_strdup(_("Please fill out the information below "
1491 "to change your account registration."));
1492 else
1493 instructions = g_strdup(_("Please fill out the information below "
1494 "to register your new account."));
1495
1496 cbdata = g_new0(JabberRegisterCBData, 1);
1497 cbdata->js = js;
1498 cbdata->who = g_strdup(from);
1499
1500 if(js->registration)
1501 purple_request_fields(js->gc, _("Register New XMPP Account"),
1502 _("Register New XMPP Account"), instructions, fields,
1503 _("Register"), G_CALLBACK(jabber_register_cb),
1504 _("Cancel"), G_CALLBACK(jabber_register_cancel_cb),
1505 purple_request_cpar_from_connection(js->gc),
1506 cbdata);
1507 else {
1508 char *title;
1509 g_return_if_fail(from != NULL);
1510 title = registered ? g_strdup_printf(_("Change Account Registration at %s"), from)
1511 :g_strdup_printf(_("Register New Account at %s"), from);
1512 purple_request_fields(js->gc, title, title, instructions,
1513 fields, (registered ? _("Change Registration") :
1514 _("Register")), G_CALLBACK(jabber_register_cb),
1515 _("Cancel"), G_CALLBACK(jabber_register_cancel_cb),
1516 purple_request_cpar_from_connection(js->gc), cbdata);
1517 g_free(title);
1518 }
1519
1520 g_free(instructions);
1521 }
1522
1523 void jabber_register_start(JabberStream *js)
1524 {
1525 JabberIq *iq;
1526
1527 iq = jabber_iq_new_query(js, JABBER_IQ_GET, "jabber:iq:register");
1528 jabber_iq_send(iq);
1529 }
1530
1531 void jabber_register_gateway(JabberStream *js, const char *gateway) {
1532 JabberIq *iq;
1533
1534 iq = jabber_iq_new_query(js, JABBER_IQ_GET, "jabber:iq:register");
1535 purple_xmlnode_set_attrib(iq->node, "to", gateway);
1536 jabber_iq_send(iq);
1537 }
1538
1539 void jabber_register_account(PurpleAccount *account)
1540 {
1541 JabberStream *js;
1542
1543 js = jabber_stream_new(account);
1544 if (js == NULL)
1545 return;
1546
1547 js->registration = TRUE;
1548 jabber_stream_connect(js);
1549 }
1550
1551 static void
1552 jabber_unregister_account_iq_cb(JabberStream *js, const char *from,
1553 JabberIqType type, const char *id,
1554 PurpleXmlNode *packet, gpointer data)
1555 {
1556 PurpleAccount *account = purple_connection_get_account(js->gc);
1557
1558 if (type == JABBER_IQ_ERROR) {
1559 char *msg = jabber_parse_error(js, packet, NULL);
1560
1561 purple_notify_error(js->gc, _("Error unregistering account"),
1562 _("Error unregistering account"), msg,
1563 purple_request_cpar_from_connection(js->gc));
1564 g_free(msg);
1565 if(js->unregistration_cb)
1566 js->unregistration_cb(account, FALSE, js->unregistration_user_data);
1567 } else {
1568 purple_notify_info(js->gc, _("Account successfully "
1569 "unregistered"), _("Account successfully unregistered"),
1570 NULL, purple_request_cpar_from_connection(js->gc));
1571 if(js->unregistration_cb)
1572 js->unregistration_cb(account, TRUE, js->unregistration_user_data);
1573 }
1574 }
1575
1576 static void jabber_unregister_account_cb(JabberStream *js) {
1577 JabberIq *iq;
1578 PurpleXmlNode *query;
1579
1580 g_return_if_fail(js->unregistration);
1581
1582 iq = jabber_iq_new_query(js, JABBER_IQ_SET, "jabber:iq:register");
1583
1584 query = purple_xmlnode_get_child_with_namespace(iq->node, "query", "jabber:iq:register");
1585
1586 purple_xmlnode_new_child(query, "remove");
1587 purple_xmlnode_set_attrib(iq->node, "to", js->user->domain);
1588
1589 jabber_iq_set_callback(iq, jabber_unregister_account_iq_cb, NULL);
1590 jabber_iq_send(iq);
1591 }
1592
1593 void jabber_unregister_account(PurpleAccount *account, PurpleAccountUnregistrationCb cb, void *user_data) {
1594 PurpleConnection *gc = purple_account_get_connection(account);
1595 JabberStream *js;
1596
1597 if (purple_connection_get_state(gc) != PURPLE_CONNECTION_CONNECTED) {
1598 if (purple_connection_get_state(gc) != PURPLE_CONNECTION_CONNECTING)
1599 jabber_login(account);
1600 js = purple_connection_get_protocol_data(gc);
1601 js->unregistration = TRUE;
1602 js->unregistration_cb = cb;
1603 js->unregistration_user_data = user_data;
1604 return;
1605 }
1606
1607 js = purple_connection_get_protocol_data(gc);
1608
1609 if (js->unregistration) {
1610 purple_debug_error("jabber", "Unregistration in process; ignoring duplicate request.\n");
1611 return;
1612 }
1613
1614 js->unregistration = TRUE;
1615 js->unregistration_cb = cb;
1616 js->unregistration_user_data = user_data;
1617
1618 jabber_unregister_account_cb(js);
1619 }
1620
1621 /* TODO: As Will pointed out in IRC, after being notified by the core to
1622 * shutdown, we should async. wait for the server to send us the stream
1623 * termination before destorying everything. That seems like it would require
1624 * changing the semantics of protocol's close(), so it's a good idea for 3.0.0.
1625 */
1626 void jabber_close(PurpleConnection *gc)
1627 {
1628 JabberStream *js = purple_connection_get_protocol_data(gc);
1629
1630 /* Close all of the open Jingle sessions on this stream */
1631 jingle_terminate_sessions(js);
1632
1633 if (js->bosh) {
1634 jabber_bosh_connection_destroy(js->bosh);
1635 js->bosh = NULL;
1636 } else if ((js->gsc && js->gsc->fd > 0) || js->fd > 0)
1637 jabber_send_raw(js, "</stream:stream>", -1);
1638
1639 if(js->gsc) {
1640 purple_ssl_close(js->gsc);
1641 } else if (js->fd > 0) {
1642 if(js->inpa) {
1643 purple_input_remove(js->inpa);
1644 js->inpa = 0;
1645 }
1646 close(js->fd);
1647 }
1648
1649 jabber_buddy_remove_all_pending_buddy_info_requests(js);
1650
1651 jabber_parser_free(js);
1652
1653 if(js->iq_callbacks)
1654 g_hash_table_destroy(js->iq_callbacks);
1655 if(js->buddies)
1656 g_hash_table_destroy(js->buddies);
1657 if(js->chats)
1658 g_hash_table_destroy(js->chats);
1659
1660 while(js->chat_servers) {
1661 g_free(js->chat_servers->data);
1662 js->chat_servers = g_list_delete_link(js->chat_servers, js->chat_servers);
1663 }
1664
1665 while(js->user_directories) {
1666 g_free(js->user_directories->data);
1667 js->user_directories = g_list_delete_link(js->user_directories, js->user_directories);
1668 }
1669
1670 while(js->bs_proxies) {
1671 JabberBytestreamsStreamhost *sh = js->bs_proxies->data;
1672 g_free(sh->jid);
1673 g_free(sh->host);
1674 g_free(sh->zeroconf);
1675 g_free(sh);
1676 js->bs_proxies = g_list_delete_link(js->bs_proxies, js->bs_proxies);
1677 }
1678
1679 purple_http_connection_set_destroy(js->http_conns);
1680
1681 g_free(js->stream_id);
1682 if(js->user)
1683 jabber_id_free(js->user);
1684 g_free(js->initial_avatar_hash);
1685 g_free(js->avatar_hash);
1686 g_free(js->caps_hash);
1687
1688 if (js->write_buffer)
1689 g_object_unref(G_OBJECT(js->write_buffer));
1690 if(js->writeh)
1691 purple_input_remove(js->writeh);
1692 if (js->auth_mech && js->auth_mech->dispose)
1693 js->auth_mech->dispose(js);
1694 #ifdef HAVE_CYRUS_SASL
1695 if(js->sasl)
1696 sasl_dispose(&js->sasl);
1697 if(js->sasl_mechs)
1698 g_string_free(js->sasl_mechs, TRUE);
1699 g_free(js->sasl_cb);
1700 /* Note: _not_ g_free. See auth_cyrus.c:jabber_sasl_cb_secret */
1701 free(js->sasl_secret);
1702 g_free(js->sasl_password);
1703 #endif
1704 g_free(js->serverFQDN);
1705 while(js->commands) {
1706 JabberAdHocCommands *cmd = js->commands->data;
1707 g_free(cmd->jid);
1708 g_free(cmd->node);
1709 g_free(cmd->name);
1710 g_free(cmd);
1711 js->commands = g_list_delete_link(js->commands, js->commands);
1712 }
1713 g_free(js->server_name);
1714 g_free(js->certificate_CN);
1715 g_free(js->gmail_last_time);
1716 g_free(js->gmail_last_tid);
1717 g_free(js->old_msg);
1718 g_free(js->old_avatarhash);
1719 g_free(js->old_artist);
1720 g_free(js->old_title);
1721 g_free(js->old_source);
1722 g_free(js->old_uri);
1723 g_free(js->old_track);
1724
1725 if (js->vcard_timer != 0)
1726 purple_timeout_remove(js->vcard_timer);
1727
1728 if (js->keepalive_timeout != 0)
1729 purple_timeout_remove(js->keepalive_timeout);
1730 if (js->inactivity_timer != 0)
1731 purple_timeout_remove(js->inactivity_timer);
1732 if (js->conn_close_timeout != 0)
1733 purple_timeout_remove(js->conn_close_timeout);
1734
1735 g_cancellable_cancel(js->cancellable);
1736 g_object_unref(G_OBJECT(js->cancellable));
1737
1738 g_free(js->stun_ip);
1739
1740 /* remove Google relay-related stuff */
1741 g_free(js->google_relay_token);
1742 g_free(js->google_relay_host);
1743
1744 g_free(js);
1745
1746 purple_connection_set_protocol_data(gc, NULL);
1747 }
1748
1749 void jabber_stream_set_state(JabberStream *js, JabberStreamState state)
1750 {
1751 #define JABBER_CONNECT_STEPS ((js->gsc || js->state == JABBER_STREAM_INITIALIZING_ENCRYPTION) ? 9 : 5)
1752
1753 js->state = state;
1754 switch(state) {
1755 case JABBER_STREAM_OFFLINE:
1756 break;
1757 case JABBER_STREAM_CONNECTING:
1758 purple_connection_update_progress(js->gc, _("Connecting"), 1,
1759 JABBER_CONNECT_STEPS);
1760 break;
1761 case JABBER_STREAM_INITIALIZING:
1762 purple_connection_update_progress(js->gc, _("Initializing Stream"),
1763 js->gsc ? 5 : 2, JABBER_CONNECT_STEPS);
1764 jabber_stream_init(js);
1765 break;
1766 case JABBER_STREAM_INITIALIZING_ENCRYPTION:
1767 purple_connection_update_progress(js->gc, _("Initializing SSL/TLS"),
1768 6, JABBER_CONNECT_STEPS);
1769 break;
1770 case JABBER_STREAM_AUTHENTICATING:
1771 purple_connection_update_progress(js->gc, _("Authenticating"),
1772 js->gsc ? 7 : 3, JABBER_CONNECT_STEPS);
1773 break;
1774 case JABBER_STREAM_POST_AUTH:
1775 purple_connection_update_progress(js->gc, _("Re-initializing Stream"),
1776 (js->gsc ? 8 : 4), JABBER_CONNECT_STEPS);
1777
1778 break;
1779 case JABBER_STREAM_CONNECTED:
1780 /* Send initial presence */
1781 jabber_presence_send(js, TRUE);
1782 /* Start up the inactivity timer */
1783 jabber_stream_restart_inactivity_timer(js);
1784
1785 purple_connection_set_state(js->gc, PURPLE_CONNECTION_CONNECTED);
1786 break;
1787 }
1788
1789 #undef JABBER_CONNECT_STEPS
1790 }
1791
1792 char *jabber_get_next_id(JabberStream *js)
1793 {
1794 return g_strdup_printf("purple%x", js->next_id++);
1795 }
1796
1797
1798 void jabber_idle_set(PurpleConnection *gc, int idle)
1799 {
1800 JabberStream *js = purple_connection_get_protocol_data(gc);
1801
1802 js->idle = idle ? time(NULL) - idle : idle;
1803
1804 /* send out an updated prescence */
1805 purple_debug_info("jabber", "sending updated presence for idle\n");
1806 jabber_presence_send(js, FALSE);
1807 }
1808
1809 void jabber_blocklist_parse_push(JabberStream *js, const char *from,
1810 JabberIqType type, const char *id,
1811 PurpleXmlNode *child)
1812 {
1813 JabberIq *result;
1814 PurpleXmlNode *item;
1815 PurpleAccount *account;
1816 gboolean is_block;
1817 GSList *deny;
1818
1819 if (!jabber_is_own_account(js, from)) {
1820 PurpleXmlNode *error, *x;
1821 result = jabber_iq_new(js, JABBER_IQ_ERROR);
1822 purple_xmlnode_set_attrib(result->node, "id", id);
1823 if (from)
1824 purple_xmlnode_set_attrib(result->node, "to", from);
1825
1826 error = purple_xmlnode_new_child(result->node, "error");
1827 purple_xmlnode_set_attrib(error, "type", "cancel");
1828 x = purple_xmlnode_new_child(error, "not-allowed");
1829 purple_xmlnode_set_namespace(x, NS_XMPP_STANZAS);
1830
1831 jabber_iq_send(result);
1832 return;
1833 }
1834
1835 account = purple_connection_get_account(js->gc);
1836 is_block = g_str_equal(child->name, "block");
1837
1838 item = purple_xmlnode_get_child(child, "item");
1839 if (!is_block && item == NULL) {
1840 /* Unblock everyone */
1841 purple_debug_info("jabber", "Received unblock push. Unblocking everyone.\n");
1842
1843 while ((deny = purple_account_privacy_get_denied(account)) != NULL) {
1844 purple_account_privacy_deny_remove(account, deny->data, TRUE);
1845 }
1846 } else if (item == NULL) {
1847 /* An empty <block/> is bogus */
1848 PurpleXmlNode *error, *x;
1849 result = jabber_iq_new(js, JABBER_IQ_ERROR);
1850 purple_xmlnode_set_attrib(result->node, "id", id);
1851
1852 error = purple_xmlnode_new_child(result->node, "error");
1853 purple_xmlnode_set_attrib(error, "type", "modify");
1854 x = purple_xmlnode_new_child(error, "bad-request");
1855 purple_xmlnode_set_namespace(x, NS_XMPP_STANZAS);
1856
1857 jabber_iq_send(result);
1858 return;
1859 } else {
1860 for ( ; item; item = purple_xmlnode_get_next_twin(item)) {
1861 const char *jid = purple_xmlnode_get_attrib(item, "jid");
1862 if (jid == NULL || *jid == '\0')
1863 continue;
1864
1865 if (is_block)
1866 purple_account_privacy_deny_add(account, jid, TRUE);
1867 else
1868 purple_account_privacy_deny_remove(account, jid, TRUE);
1869 }
1870 }
1871
1872 result = jabber_iq_new(js, JABBER_IQ_RESULT);
1873 purple_xmlnode_set_attrib(result->node, "id", id);
1874 jabber_iq_send(result);
1875 }
1876
1877 static void jabber_blocklist_parse(JabberStream *js, const char *from,
1878 JabberIqType type, const char *id,
1879 PurpleXmlNode *packet, gpointer data)
1880 {
1881 PurpleXmlNode *blocklist, *item;
1882 PurpleAccount *account;
1883 GSList *deny;
1884
1885 blocklist = purple_xmlnode_get_child_with_namespace(packet,
1886 "blocklist", NS_SIMPLE_BLOCKING);
1887 account = purple_connection_get_account(js->gc);
1888
1889 if (type == JABBER_IQ_ERROR || blocklist == NULL)
1890 return;
1891
1892 /* This is the only privacy method supported by XEP-0191 */
1893 purple_account_set_privacy_type(account, PURPLE_ACCOUNT_PRIVACY_DENY_USERS);
1894
1895 /*
1896 * TODO: When account->deny is something more than a hash table, this can
1897 * be re-written to find the set intersection and difference.
1898 */
1899 while ((deny = purple_account_privacy_get_denied(account)))
1900 purple_account_privacy_deny_remove(account, deny->data, TRUE);
1901
1902 item = purple_xmlnode_get_child(blocklist, "item");
1903 while (item != NULL) {
1904 const char *jid = purple_xmlnode_get_attrib(item, "jid");
1905 purple_account_privacy_deny_add(account, jid, TRUE);
1906 item = purple_xmlnode_get_next_twin(item);
1907 }
1908 }
1909
1910 void jabber_request_block_list(JabberStream *js)
1911 {
1912 JabberIq *iq;
1913 PurpleXmlNode *blocklist;
1914
1915 iq = jabber_iq_new(js, JABBER_IQ_GET);
1916
1917 blocklist = purple_xmlnode_new_child(iq->node, "blocklist");
1918 purple_xmlnode_set_namespace(blocklist, NS_SIMPLE_BLOCKING);
1919
1920 jabber_iq_set_callback(iq, jabber_blocklist_parse, NULL);
1921
1922 jabber_iq_send(iq);
1923 }
1924
1925 void jabber_add_deny(PurpleConnection *gc, const char *who)
1926 {
1927 JabberStream *js;
1928 JabberIq *iq;
1929 PurpleXmlNode *block, *item;
1930
1931 g_return_if_fail(who != NULL && *who != '\0');
1932
1933 js = purple_connection_get_protocol_data(gc);
1934 if (js == NULL)
1935 return;
1936
1937 if (js->server_caps & JABBER_CAP_GOOGLE_ROSTER)
1938 {
1939 jabber_google_roster_add_deny(js, who);
1940 return;
1941 }
1942
1943 if (!(js->server_caps & JABBER_CAP_BLOCKING))
1944 {
1945 purple_notify_error(NULL, _("Server doesn't support blocking"),
1946 _("Server doesn't support blocking"), NULL,
1947 purple_request_cpar_from_connection(gc));
1948 return;
1949 }
1950
1951 iq = jabber_iq_new(js, JABBER_IQ_SET);
1952
1953 block = purple_xmlnode_new_child(iq->node, "block");
1954 purple_xmlnode_set_namespace(block, NS_SIMPLE_BLOCKING);
1955
1956 item = purple_xmlnode_new_child(block, "item");
1957 purple_xmlnode_set_attrib(item, "jid", who);
1958
1959 jabber_iq_send(iq);
1960 }
1961
1962 void jabber_rem_deny(PurpleConnection *gc, const char *who)
1963 {
1964 JabberStream *js;
1965 JabberIq *iq;
1966 PurpleXmlNode *unblock, *item;
1967
1968 g_return_if_fail(who != NULL && *who != '\0');
1969
1970 js = purple_connection_get_protocol_data(gc);
1971 if (js == NULL)
1972 return;
1973
1974 if (js->server_caps & JABBER_CAP_GOOGLE_ROSTER)
1975 {
1976 jabber_google_roster_rem_deny(js, who);
1977 return;
1978 }
1979
1980 if (!(js->server_caps & JABBER_CAP_BLOCKING))
1981 return;
1982
1983 iq = jabber_iq_new(js, JABBER_IQ_SET);
1984
1985 unblock = purple_xmlnode_new_child(iq->node, "unblock");
1986 purple_xmlnode_set_namespace(unblock, NS_SIMPLE_BLOCKING);
1987
1988 item = purple_xmlnode_new_child(unblock, "item");
1989 purple_xmlnode_set_attrib(item, "jid", who);
1990
1991 jabber_iq_send(iq);
1992 }
1993
1994 void jabber_add_feature(const char *namespace, JabberFeatureEnabled cb) {
1995 JabberFeature *feat;
1996
1997 g_return_if_fail(namespace != NULL);
1998
1999 feat = g_new0(JabberFeature,1);
2000 feat->namespace = g_strdup(namespace);
2001 feat->is_enabled = cb;
2002
2003 /* try to remove just in case it already exists in the list */
2004 jabber_remove_feature(namespace);
2005
2006 jabber_features = g_list_append(jabber_features, feat);
2007 }
2008
2009 void jabber_remove_feature(const char *namespace) {
2010 GList *feature;
2011 for(feature = jabber_features; feature; feature = feature->next) {
2012 JabberFeature *feat = (JabberFeature*)feature->data;
2013 if(!strcmp(feat->namespace, namespace)) {
2014 g_free(feat->namespace);
2015 g_free(feature->data);
2016 jabber_features = g_list_delete_link(jabber_features, feature);
2017 break;
2018 }
2019 }
2020 }
2021
2022 static void jabber_features_destroy(void)
2023 {
2024 while (jabber_features) {
2025 JabberFeature *feature = jabber_features->data;
2026 g_free(feature->namespace);
2027 g_free(feature);
2028 jabber_features = g_list_delete_link(jabber_features, jabber_features);
2029 }
2030 }
2031
2032 gint
2033 jabber_identity_compare(gconstpointer a, gconstpointer b)
2034 {
2035 const JabberIdentity *ac;
2036 const JabberIdentity *bc;
2037 gint cat_cmp;
2038 gint typ_cmp;
2039
2040 ac = a;
2041 bc = b;
2042
2043 if ((cat_cmp = strcmp(ac->category, bc->category)) == 0) {
2044 if ((typ_cmp = strcmp(ac->type, bc->type)) == 0) {
2045 if (!ac->lang && !bc->lang) {
2046 return 0;
2047 } else if (ac->lang && !bc->lang) {
2048 return 1;
2049 } else if (!ac->lang && bc->lang) {
2050 return -1;
2051 } else {
2052 return strcmp(ac->lang, bc->lang);
2053 }
2054 } else {
2055 return typ_cmp;
2056 }
2057 } else {
2058 return cat_cmp;
2059 }
2060 }
2061
2062 void jabber_add_identity(const gchar *category, const gchar *type,
2063 const gchar *lang, const gchar *name)
2064 {
2065 GList *identity;
2066 JabberIdentity *ident;
2067
2068 /* both required according to XEP-0030 */
2069 g_return_if_fail(category != NULL);
2070 g_return_if_fail(type != NULL);
2071
2072 /* Check if this identity is already there... */
2073 for (identity = jabber_identities; identity; identity = identity->next) {
2074 JabberIdentity *id = identity->data;
2075 if (g_str_equal(id->category, category) &&
2076 g_str_equal(id->type, type) &&
2077 purple_strequal(id->lang, lang))
2078 return;
2079 }
2080
2081 ident = g_new0(JabberIdentity, 1);
2082 ident->category = g_strdup(category);
2083 ident->type = g_strdup(type);
2084 ident->lang = g_strdup(lang);
2085 ident->name = g_strdup(name);
2086 jabber_identities = g_list_insert_sorted(jabber_identities, ident,
2087 jabber_identity_compare);
2088 }
2089
2090 static void jabber_identities_destroy(void)
2091 {
2092 while (jabber_identities) {
2093 JabberIdentity *id = jabber_identities->data;
2094 g_free(id->category);
2095 g_free(id->type);
2096 g_free(id->lang);
2097 g_free(id->name);
2098 g_free(id);
2099 jabber_identities = g_list_delete_link(jabber_identities, jabber_identities);
2100 }
2101 }
2102
2103 gboolean jabber_stream_is_ssl(JabberStream *js)
2104 {
2105 return (js->bosh && jabber_bosh_connection_is_ssl(js->bosh)) ||
2106 (!js->bosh && js->gsc);
2107 }
2108
2109 static gboolean
2110 inactivity_cb(gpointer data)
2111 {
2112 JabberStream *js = data;
2113
2114 /* We want whatever is sent to set this. It's okay because
2115 * the eventloop unsets it via the return FALSE.
2116 */
2117 js->inactivity_timer = 0;
2118
2119 if (js->bosh)
2120 jabber_bosh_connection_send_keepalive(js->bosh);
2121 else
2122 jabber_send_raw(js, "\t", 1);
2123
2124 return FALSE;
2125 }
2126
2127 void jabber_stream_restart_inactivity_timer(JabberStream *js)
2128 {
2129 if (js->inactivity_timer != 0) {
2130 purple_timeout_remove(js->inactivity_timer);
2131 js->inactivity_timer = 0;
2132 }
2133
2134 g_return_if_fail(js->max_inactivity > 0);
2135
2136 js->inactivity_timer =
2137 purple_timeout_add_seconds(js->max_inactivity,
2138 inactivity_cb, js);
2139 }
2140
2141 const char *jabber_list_icon(PurpleAccount *a, PurpleBuddy *b)
2142 {
2143 return "jabber";
2144 }
2145
2146 const char* jabber_list_emblem(PurpleBuddy *b)
2147 {
2148 JabberStream *js;
2149 JabberBuddy *jb = NULL;
2150 PurpleConnection *gc = purple_account_get_connection(purple_buddy_get_account(b));
2151
2152 if(!gc)
2153 return NULL;
2154
2155 js = purple_connection_get_protocol_data(gc);
2156 if(js)
2157 jb = jabber_buddy_find(js, purple_buddy_get_name(b), FALSE);
2158
2159 if(!PURPLE_BUDDY_IS_ONLINE(b)) {
2160 if(jb && (jb->subscription & JABBER_SUB_PENDING ||
2161 !(jb->subscription & JABBER_SUB_TO)))
2162 return "not-authorized";
2163 }
2164
2165 if (jb) {
2166 JabberBuddyResource *jbr = jabber_buddy_find_resource(jb, NULL);
2167 if (jbr) {
2168 const gchar *client_type =
2169 jabber_resource_get_identity_category_type(jbr, "client");
2170
2171 if (client_type) {
2172 if (strcmp(client_type, "phone") == 0) {
2173 return "mobile";
2174 } else if (strcmp(client_type, "web") == 0) {
2175 return "external";
2176 } else if (strcmp(client_type, "handheld") == 0) {
2177 return "hiptop";
2178 } else if (strcmp(client_type, "bot") == 0) {
2179 return "bot";
2180 }
2181 /* the default value "pc" falls through and has no emblem */
2182 }
2183 }
2184 }
2185
2186 return NULL;
2187 }
2188
2189 char *jabber_status_text(PurpleBuddy *b)
2190 {
2191 char *ret = NULL;
2192 JabberBuddy *jb = NULL;
2193 PurpleAccount *account = purple_buddy_get_account(b);
2194 PurpleConnection *gc = purple_account_get_connection(account);
2195
2196 if (gc && purple_connection_get_protocol_data(gc))
2197 jb = jabber_buddy_find(purple_connection_get_protocol_data(gc), purple_buddy_get_name(b), FALSE);
2198
2199 if(jb && !PURPLE_BUDDY_IS_ONLINE(b) && (jb->subscription & JABBER_SUB_PENDING || !(jb->subscription & JABBER_SUB_TO))) {
2200 ret = g_strdup(_("Not Authorized"));
2201 } else if(jb && !PURPLE_BUDDY_IS_ONLINE(b) && jb->error_msg) {
2202 ret = g_strdup(jb->error_msg);
2203 } else {
2204 PurplePresence *presence = purple_buddy_get_presence(b);
2205 PurpleStatus *status = purple_presence_get_active_status(presence);
2206 const char *message;
2207
2208 if((message = purple_status_get_attr_string(status, "message"))) {
2209 ret = g_markup_escape_text(message, -1);
2210 } else if (purple_presence_is_status_primitive_active(presence, PURPLE_STATUS_TUNE)) {
2211 PurpleStatus *status = purple_presence_get_status(presence, "tune");
2212 const char *title = purple_status_get_attr_string(status, PURPLE_TUNE_TITLE);
2213 const char *artist = purple_status_get_attr_string(status, PURPLE_TUNE_ARTIST);
2214 const char *album = purple_status_get_attr_string(status, PURPLE_TUNE_ALBUM);
2215 ret = purple_util_format_song_info(title, artist, album, NULL);
2216 }
2217 }
2218
2219 return ret;
2220 }
2221
2222 static void
2223 jabber_tooltip_add_resource_text(JabberBuddyResource *jbr,
2224 PurpleNotifyUserInfo *user_info, gboolean multiple_resources)
2225 {
2226 char *text = NULL;
2227 char *res = NULL;
2228 char *label, *value;
2229 const char *state;
2230
2231 if(jbr->status) {
2232 text = g_markup_escape_text(jbr->status, -1);
2233 }
2234
2235 if(jbr->name)
2236 res = g_strdup_printf(" (%s)", jbr->name);
2237
2238 state = jabber_buddy_state_get_name(jbr->state);
2239 if (text != NULL && !purple_utf8_strcasecmp(state, text)) {
2240 g_free(text);
2241 text = NULL;
2242 }
2243
2244 label = g_strdup_printf("%s%s", _("Status"), (res ? res : ""));
2245 value = g_strdup_printf("%s%s%s", state, (text ? ": " : ""), (text ? text : ""));
2246
2247 purple_notify_user_info_add_pair_html(user_info, label, value);
2248 g_free(label);
2249 g_free(value);
2250 g_free(text);
2251
2252 /* if the resource is idle, show that */
2253 /* only show it if there is more than one resource available for
2254 the buddy, since the "general" idleness will be shown anyway,
2255 this way we can see see the idleness of lower-priority resources */
2256 if (jbr->idle && multiple_resources) {
2257 gchar *idle_str =
2258 purple_str_seconds_to_string(time(NULL) - jbr->idle);
2259 label = g_strdup_printf("%s%s", _("Idle"), (res ? res : ""));
2260 purple_notify_user_info_add_pair_plaintext(user_info, label, idle_str);
2261 g_free(idle_str);
2262 g_free(label);
2263 }
2264 g_free(res);
2265 }
2266
2267 void jabber_tooltip_text(PurpleBuddy *b, PurpleNotifyUserInfo *user_info, gboolean full)
2268 {
2269 JabberBuddy *jb;
2270 PurpleAccount *account;
2271 PurpleConnection *gc;
2272 JabberStream *js;
2273
2274 g_return_if_fail(b != NULL);
2275
2276 account = purple_buddy_get_account(b);
2277 g_return_if_fail(account != NULL);
2278
2279 gc = purple_account_get_connection(account);
2280 g_return_if_fail(gc != NULL);
2281
2282 js = purple_connection_get_protocol_data(gc);
2283 g_return_if_fail(js != NULL);
2284
2285 jb = jabber_buddy_find(js, purple_buddy_get_name(b), FALSE);
2286
2287 if(jb) {
2288 JabberBuddyResource *jbr = NULL;
2289 PurplePresence *presence = purple_buddy_get_presence(b);
2290 const char *sub;
2291 GList *l;
2292 const char *mood;
2293 gboolean multiple_resources =
2294 jb->resources && g_list_next(jb->resources);
2295 JabberBuddyResource *top_jbr = jabber_buddy_find_resource(jb, NULL);
2296
2297 /* resource-specific info for the top resource */
2298 if (top_jbr) {
2299 jabber_tooltip_add_resource_text(top_jbr, user_info,
2300 multiple_resources);
2301 }
2302
2303 for(l=jb->resources; l; l = l->next) {
2304 jbr = l->data;
2305 /* the remaining resources */
2306 if (jbr != top_jbr) {
2307 jabber_tooltip_add_resource_text(jbr, user_info,
2308 multiple_resources);
2309 }
2310 }
2311
2312 if (full) {
2313 PurpleStatus *status;
2314
2315 status = purple_presence_get_status(presence, "mood");
2316 mood = purple_status_get_attr_string(status, PURPLE_MOOD_NAME);
2317 if(mood && *mood) {
2318 const char *moodtext;
2319 /* find the mood */
2320 PurpleMood *moods = jabber_get_moods(account);
2321 const char *description = NULL;
2322
2323 for (; moods->mood ; moods++) {
2324 if (purple_strequal(moods->mood, mood)) {
2325 description = moods->description;
2326 break;
2327 }
2328 }
2329
2330 moodtext = purple_status_get_attr_string(status, PURPLE_MOOD_COMMENT);
2331 if(moodtext && *moodtext) {
2332 char *moodplustext =
2333 g_strdup_printf("%s (%s)", description ? _(description) : mood, moodtext);
2334
2335 purple_notify_user_info_add_pair_html(user_info, _("Mood"), moodplustext);
2336 g_free(moodplustext);
2337 } else
2338 purple_notify_user_info_add_pair_html(user_info, _("Mood"),
2339 description ? _(description) : mood);
2340 }
2341 if (purple_presence_is_status_primitive_active(presence, PURPLE_STATUS_TUNE)) {
2342 PurpleStatus *tune = purple_presence_get_status(presence, "tune");
2343 const char *title = purple_status_get_attr_string(tune, PURPLE_TUNE_TITLE);
2344 const char *artist = purple_status_get_attr_string(tune, PURPLE_TUNE_ARTIST);
2345 const char *album = purple_status_get_attr_string(tune, PURPLE_TUNE_ALBUM);
2346 char *playing = purple_util_format_song_info(title, artist, album, NULL);
2347 if (playing) {
2348 purple_notify_user_info_add_pair_html(user_info, _("Now Listening"), playing);
2349 g_free(playing);
2350 }
2351 }
2352
2353 if(jb->subscription & JABBER_SUB_FROM) {
2354 if(jb->subscription & JABBER_SUB_TO)
2355 sub = _("Both");
2356 else if(jb->subscription & JABBER_SUB_PENDING)
2357 sub = _("From (To pending)");
2358 else
2359 sub = _("From");
2360 } else {
2361 if(jb->subscription & JABBER_SUB_TO)
2362 sub = _("To");
2363 else if(jb->subscription & JABBER_SUB_PENDING)
2364 sub = _("None (To pending)");
2365 else
2366 sub = _("None");
2367 }
2368
2369 purple_notify_user_info_add_pair_html(user_info, _("Subscription"), sub);
2370
2371 }
2372
2373 if(!PURPLE_BUDDY_IS_ONLINE(b) && jb->error_msg) {
2374 purple_notify_user_info_add_pair_html(user_info, _("Error"), jb->error_msg);
2375 }
2376 }
2377 }
2378
2379 GList *jabber_status_types(PurpleAccount *account)
2380 {
2381 PurpleStatusType *type;
2382 GList *types = NULL;
2383 GValue *priority_value;
2384 GValue *buzz_enabled;
2385
2386 priority_value = purple_value_new(G_TYPE_INT);
2387 g_value_set_int(priority_value, 1);
2388 buzz_enabled = purple_value_new(G_TYPE_BOOLEAN);
2389 g_value_set_boolean(buzz_enabled, TRUE);
2390 type = purple_status_type_new_with_attrs(PURPLE_STATUS_AVAILABLE,
2391 jabber_buddy_state_get_status_id(JABBER_BUDDY_STATE_ONLINE),
2392 NULL, TRUE, TRUE, FALSE,
2393 "priority", _("Priority"), priority_value,
2394 "message", _("Message"), purple_value_new(G_TYPE_STRING),
2395 "mood", _("Mood"), purple_value_new(G_TYPE_STRING),
2396 "moodtext", _("Mood Text"), purple_value_new(G_TYPE_STRING),
2397 "nick", _("Nickname"), purple_value_new(G_TYPE_STRING),
2398 "buzz", _("Allow Buzz"), buzz_enabled,
2399 NULL);
2400 types = g_list_prepend(types, type);
2401
2402
2403 type = purple_status_type_new_with_attrs(PURPLE_STATUS_MOOD,
2404 "mood", NULL, TRUE, TRUE, TRUE,
2405 PURPLE_MOOD_NAME, _("Mood Name"), purple_value_new(G_TYPE_STRING),
2406 PURPLE_MOOD_COMMENT, _("Mood Comment"), purple_value_new(G_TYPE_STRING),
2407 NULL);
2408 types = g_list_prepend(types, type);
2409
2410 priority_value = purple_value_new(G_TYPE_INT);
2411 g_value_set_int(priority_value, 1);
2412 buzz_enabled = purple_value_new(G_TYPE_BOOLEAN);
2413 g_value_set_boolean(buzz_enabled, TRUE);
2414 type = purple_status_type_new_with_attrs(PURPLE_STATUS_AVAILABLE,
2415 jabber_buddy_state_get_status_id(JABBER_BUDDY_STATE_CHAT),
2416 _("Chatty"), TRUE, TRUE, FALSE,
2417 "priority", _("Priority"), priority_value,
2418 "message", _("Message"), purple_value_new(G_TYPE_STRING),
2419 "mood", _("Mood"), purple_value_new(G_TYPE_STRING),
2420 "moodtext", _("Mood Text"), purple_value_new(G_TYPE_STRING),
2421 "nick", _("Nickname"), purple_value_new(G_TYPE_STRING),
2422 "buzz", _("Allow Buzz"), buzz_enabled,
2423 NULL);
2424 types = g_list_prepend(types, type);
2425
2426 priority_value = purple_value_new(G_TYPE_INT);
2427 g_value_set_int(priority_value, 0);
2428 buzz_enabled = purple_value_new(G_TYPE_BOOLEAN);
2429 g_value_set_boolean(buzz_enabled, TRUE);
2430 type = purple_status_type_new_with_attrs(PURPLE_STATUS_AWAY,
2431 jabber_buddy_state_get_status_id(JABBER_BUDDY_STATE_AWAY),
2432 NULL, TRUE, TRUE, FALSE,
2433 "priority", _("Priority"), priority_value,
2434 "message", _("Message"), purple_value_new(G_TYPE_STRING),
2435 "mood", _("Mood"), purple_value_new(G_TYPE_STRING),
2436 "moodtext", _("Mood Text"), purple_value_new(G_TYPE_STRING),
2437 "nick", _("Nickname"), purple_value_new(G_TYPE_STRING),
2438 "buzz", _("Allow Buzz"), buzz_enabled,
2439 NULL);
2440 types = g_list_prepend(types, type);
2441
2442 priority_value = purple_value_new(G_TYPE_INT);
2443 g_value_set_int(priority_value, 0);
2444 buzz_enabled = purple_value_new(G_TYPE_BOOLEAN);
2445 g_value_set_boolean(buzz_enabled, TRUE);
2446 type = purple_status_type_new_with_attrs(PURPLE_STATUS_EXTENDED_AWAY,
2447 jabber_buddy_state_get_status_id(JABBER_BUDDY_STATE_XA),
2448 NULL, TRUE, TRUE, FALSE,
2449 "priority", _("Priority"), priority_value,
2450 "message", _("Message"), purple_value_new(G_TYPE_STRING),
2451 "mood", _("Mood"), purple_value_new(G_TYPE_STRING),
2452 "moodtext", _("Mood Text"), purple_value_new(G_TYPE_STRING),
2453 "nick", _("Nickname"), purple_value_new(G_TYPE_STRING),
2454 "buzz", _("Allow Buzz"), buzz_enabled,
2455 NULL);
2456 types = g_list_prepend(types, type);
2457
2458 priority_value = purple_value_new(G_TYPE_INT);
2459 g_value_set_int(priority_value, 0);
2460 type = purple_status_type_new_with_attrs(PURPLE_STATUS_UNAVAILABLE,
2461 jabber_buddy_state_get_status_id(JABBER_BUDDY_STATE_DND),
2462 _("Do Not Disturb"), TRUE, TRUE, FALSE,
2463 "priority", _("Priority"), priority_value,
2464 "message", _("Message"), purple_value_new(G_TYPE_STRING),
2465 "mood", _("Mood"), purple_value_new(G_TYPE_STRING),
2466 "moodtext", _("Mood Text"), purple_value_new(G_TYPE_STRING),
2467 "nick", _("Nickname"), purple_value_new(G_TYPE_STRING),
2468 NULL);
2469 types = g_list_prepend(types, type);
2470
2471 /*
2472 if(js->protocol_version == JABBER_PROTO_0_9)
2473 "Invisible"
2474 */
2475
2476 type = purple_status_type_new_with_attrs(PURPLE_STATUS_OFFLINE,
2477 jabber_buddy_state_get_status_id(JABBER_BUDDY_STATE_UNAVAILABLE),
2478 NULL, TRUE, TRUE, FALSE,
2479 "message", _("Message"), purple_value_new(G_TYPE_STRING),
2480 NULL);
2481 types = g_list_prepend(types, type);
2482
2483 type = purple_status_type_new_with_attrs(PURPLE_STATUS_TUNE,
2484 "tune", NULL, FALSE, TRUE, TRUE,
2485 PURPLE_TUNE_ARTIST, _("Tune Artist"), purple_value_new(G_TYPE_STRING),
2486 PURPLE_TUNE_TITLE, _("Tune Title"), purple_value_new(G_TYPE_STRING),
2487 PURPLE_TUNE_ALBUM, _("Tune Album"), purple_value_new(G_TYPE_STRING),
2488 PURPLE_TUNE_GENRE, _("Tune Genre"), purple_value_new(G_TYPE_STRING),
2489 PURPLE_TUNE_COMMENT, _("Tune Comment"), purple_value_new(G_TYPE_STRING),
2490 PURPLE_TUNE_TRACK, _("Tune Track"), purple_value_new(G_TYPE_STRING),
2491 PURPLE_TUNE_TIME, _("Tune Time"), purple_value_new(G_TYPE_INT),
2492 PURPLE_TUNE_YEAR, _("Tune Year"), purple_value_new(G_TYPE_INT),
2493 PURPLE_TUNE_URL, _("Tune URL"), purple_value_new(G_TYPE_STRING),
2494 NULL);
2495 types = g_list_prepend(types, type);
2496
2497 return g_list_reverse(types);
2498 }
2499
2500 static void
2501 jabber_password_change_result_cb(JabberStream *js, const char *from,
2502 JabberIqType type, const char *id,
2503 PurpleXmlNode *packet, gpointer data)
2504 {
2505 if (type == JABBER_IQ_RESULT) {
2506 purple_notify_info(js->gc, _("Password Changed"), _("Password "
2507 "Changed"), _("Your password has been changed."),
2508 purple_request_cpar_from_connection(js->gc));
2509
2510 purple_account_set_password(purple_connection_get_account(js->gc), (const char *)data, NULL, NULL);
2511 } else {
2512 char *msg = jabber_parse_error(js, packet, NULL);
2513
2514 purple_notify_error(js->gc, _("Error changing password"),
2515 _("Error changing password"), msg,
2516 purple_request_cpar_from_connection(js->gc));
2517 g_free(msg);
2518 }
2519
2520 g_free(data);
2521 }
2522
2523 static void jabber_password_change_cb(JabberStream *js,
2524 PurpleRequestFields *fields)
2525 {
2526 const char *p1, *p2;
2527 JabberIq *iq;
2528 PurpleXmlNode *query, *y;
2529
2530 p1 = purple_request_fields_get_string(fields, "password1");
2531 p2 = purple_request_fields_get_string(fields, "password2");
2532
2533 if(strcmp(p1, p2)) {
2534 purple_notify_error(js->gc, NULL,
2535 _("New passwords do not match."), NULL,
2536 purple_request_cpar_from_connection(js->gc));
2537 return;
2538 }
2539
2540 iq = jabber_iq_new_query(js, JABBER_IQ_SET, "jabber:iq:register");
2541
2542 purple_xmlnode_set_attrib(iq->node, "to", js->user->domain);
2543
2544 query = purple_xmlnode_get_child(iq->node, "query");
2545
2546 y = purple_xmlnode_new_child(query, "username");
2547 purple_xmlnode_insert_data(y, js->user->node, -1);
2548 y = purple_xmlnode_new_child(query, "password");
2549 purple_xmlnode_insert_data(y, p1, -1);
2550
2551 jabber_iq_set_callback(iq, jabber_password_change_result_cb, g_strdup(p1));
2552
2553 jabber_iq_send(iq);
2554 }
2555
2556 static void jabber_password_change(PurpleProtocolAction *action)
2557 {
2558
2559 PurpleConnection *gc = (PurpleConnection *) action->connection;
2560 JabberStream *js = purple_connection_get_protocol_data(gc);
2561 PurpleRequestFields *fields;
2562 PurpleRequestFieldGroup *group;
2563 PurpleRequestField *field;
2564
2565 fields = purple_request_fields_new();
2566 group = purple_request_field_group_new(NULL);
2567 purple_request_fields_add_group(fields, group);
2568
2569 field = purple_request_field_string_new("password1", _("Password"),
2570 "", FALSE);
2571 purple_request_field_string_set_masked(field, TRUE);
2572 purple_request_field_set_required(field, TRUE);
2573 purple_request_field_group_add_field(group, field);
2574
2575 field = purple_request_field_string_new("password2", _("Password (again)"),
2576 "", FALSE);
2577 purple_request_field_string_set_masked(field, TRUE);
2578 purple_request_field_set_required(field, TRUE);
2579 purple_request_field_group_add_field(group, field);
2580
2581 purple_request_fields(js->gc, _("Change XMPP Password"),
2582 _("Change XMPP Password"), _("Please enter your new password"),
2583 fields, _("OK"), G_CALLBACK(jabber_password_change_cb),
2584 _("Cancel"), NULL,
2585 purple_request_cpar_from_connection(gc), js);
2586 }
2587
2588 GList *jabber_get_actions(PurpleConnection *gc)
2589 {
2590 JabberStream *js = purple_connection_get_protocol_data(gc);
2591 GList *m = NULL;
2592 PurpleProtocolAction *act;
2593
2594 act = purple_protocol_action_new(_("Set User Info..."),
2595 jabber_setup_set_info);
2596 m = g_list_append(m, act);
2597
2598 /* if (js->account_options & CHANGE_PASSWORD) { */
2599 act = purple_protocol_action_new(_("Change Password..."),
2600 jabber_password_change);
2601 m = g_list_append(m, act);
2602 /* } */
2603
2604 act = purple_protocol_action_new(_("Search for Users..."),
2605 jabber_user_search_begin);
2606 m = g_list_append(m, act);
2607
2608 purple_debug_info("jabber", "jabber_get_actions: have pep: %s\n", js->pep?"YES":"NO");
2609
2610 if(js->pep)
2611 jabber_pep_init_actions(&m);
2612
2613 if(js->commands)
2614 jabber_adhoc_init_server_commands(js, &m);
2615
2616 return m;
2617 }
2618
2619 PurpleChat *jabber_find_blist_chat(PurpleAccount *account, const char *name)
2620 {
2621 PurpleBlistNode *gnode, *cnode;
2622 JabberID *jid;
2623
2624 if(!(jid = jabber_id_new(name)))
2625 return NULL;
2626
2627 for(gnode = purple_blist_get_root(); gnode;
2628 gnode = purple_blist_node_get_sibling_next(gnode)) {
2629 for(cnode = purple_blist_node_get_first_child(gnode);
2630 cnode;
2631 cnode = purple_blist_node_get_sibling_next(cnode)) {
2632 PurpleChat *chat = (PurpleChat*)cnode;
2633 const char *room, *server;
2634 GHashTable *components;
2635 if(!PURPLE_IS_CHAT(cnode))
2636 continue;
2637
2638 if (purple_chat_get_account(chat) != account)
2639 continue;
2640
2641 components = purple_chat_get_components(chat);
2642 if(!(room = g_hash_table_lookup(components, "room")))
2643 continue;
2644 if(!(server = g_hash_table_lookup(components, "server")))
2645 continue;
2646
2647 /* FIXME: Collate is wrong in a few cases here; this should be prepped */
2648 if(jid->node && jid->domain &&
2649 !g_utf8_collate(room, jid->node) && !g_utf8_collate(server, jid->domain)) {
2650 jabber_id_free(jid);
2651 return chat;
2652 }
2653 }
2654 }
2655 jabber_id_free(jid);
2656 return NULL;
2657 }
2658
2659 void jabber_convo_closed(PurpleConnection *gc, const char *who)
2660 {
2661 JabberStream *js = purple_connection_get_protocol_data(gc);
2662 JabberID *jid;
2663 JabberBuddy *jb;
2664 JabberBuddyResource *jbr;
2665
2666 if(!(jid = jabber_id_new(who)))
2667 return;
2668
2669 if((jb = jabber_buddy_find(js, who, TRUE)) &&
2670 (jbr = jabber_buddy_find_resource(jb, jid->resource))) {
2671 g_free(jbr->thread_id);
2672 jbr->thread_id = NULL;
2673 }
2674
2675 jabber_id_free(jid);
2676 }
2677
2678
2679 char *jabber_parse_error(JabberStream *js,
2680 PurpleXmlNode *packet,
2681 PurpleConnectionError *reason)
2682 {
2683 PurpleXmlNode *error;
2684 const char *code = NULL, *text = NULL;
2685 const char *xmlns = purple_xmlnode_get_namespace(packet);
2686 char *cdata = NULL;
2687
2688 #define SET_REASON(x) \
2689 if(reason != NULL) { *reason = x; }
2690
2691 if((error = purple_xmlnode_get_child(packet, "error"))) {
2692 PurpleXmlNode *t = purple_xmlnode_get_child_with_namespace(error, "text", NS_XMPP_STANZAS);
2693 if (t)
2694 cdata = purple_xmlnode_get_data(t);
2695 #if 0
2696 cdata = purple_xmlnode_get_data(error);
2697 #endif
2698 code = purple_xmlnode_get_attrib(error, "code");
2699
2700 /* Stanza errors */
2701 if(purple_xmlnode_get_child(error, "bad-request")) {
2702 text = _("Bad Request");
2703 } else if(purple_xmlnode_get_child(error, "conflict")) {
2704 SET_REASON(PURPLE_CONNECTION_ERROR_NAME_IN_USE);
2705 text = _("Conflict");
2706 } else if(purple_xmlnode_get_child(error, "feature-not-implemented")) {
2707 text = _("Feature Not Implemented");
2708 } else if(purple_xmlnode_get_child(error, "forbidden")) {
2709 text = _("Forbidden");
2710 } else if(purple_xmlnode_get_child(error, "gone")) {
2711 text = _("Gone");
2712 } else if(purple_xmlnode_get_child(error, "internal-server-error")) {
2713 text = _("Internal Server Error");
2714 } else if(purple_xmlnode_get_child(error, "item-not-found")) {
2715 text = _("Item Not Found");
2716 } else if(purple_xmlnode_get_child(error, "jid-malformed")) {
2717 text = _("Malformed XMPP ID");
2718 } else if(purple_xmlnode_get_child(error, "not-acceptable")) {
2719 text = _("Not Acceptable");
2720 } else if(purple_xmlnode_get_child(error, "not-allowed")) {
2721 text = _("Not Allowed");
2722 } else if(purple_xmlnode_get_child(error, "not-authorized")) {
2723 text = _("Not Authorized");
2724 } else if(purple_xmlnode_get_child(error, "payment-required")) {
2725 text = _("Payment Required");
2726 } else if(purple_xmlnode_get_child(error, "recipient-unavailable")) {
2727 text = _("Recipient Unavailable");
2728 } else if(purple_xmlnode_get_child(error, "redirect")) {
2729 /* XXX */
2730 } else if(purple_xmlnode_get_child(error, "registration-required")) {
2731 text = _("Registration Required");
2732 } else if(purple_xmlnode_get_child(error, "remote-server-not-found")) {
2733 text = _("Remote Server Not Found");
2734 } else if(purple_xmlnode_get_child(error, "remote-server-timeout")) {
2735 text = _("Remote Server Timeout");
2736 } else if(purple_xmlnode_get_child(error, "resource-constraint")) {
2737 text = _("Server Overloaded");
2738 } else if(purple_xmlnode_get_child(error, "service-unavailable")) {
2739 text = _("Service Unavailable");
2740 } else if(purple_xmlnode_get_child(error, "subscription-required")) {
2741 text = _("Subscription Required");
2742 } else if(purple_xmlnode_get_child(error, "unexpected-request")) {
2743 text = _("Unexpected Request");
2744 } else if(purple_xmlnode_get_child(error, "undefined-condition")) {
2745 text = _("Unknown Error");
2746 }
2747 } else if(xmlns && !strcmp(xmlns, NS_XMPP_SASL)) {
2748 /* Most common reason can be the default */
2749 SET_REASON(PURPLE_CONNECTION_ERROR_NETWORK_ERROR);
2750 if(purple_xmlnode_get_child(packet, "aborted")) {
2751 text = _("Authorization Aborted");
2752 } else if(purple_xmlnode_get_child(packet, "incorrect-encoding")) {
2753 text = _("Incorrect encoding in authorization");
2754 } else if(purple_xmlnode_get_child(packet, "invalid-authzid")) {
2755 text = _("Invalid authzid");
2756 } else if(purple_xmlnode_get_child(packet, "invalid-mechanism")) {
2757 text = _("Invalid Authorization Mechanism");
2758 } else if(purple_xmlnode_get_child(packet, "mechanism-too-weak")) {
2759 SET_REASON(PURPLE_CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE);
2760 text = _("Authorization mechanism too weak");
2761 } else if(purple_xmlnode_get_child(packet, "not-authorized")) {
2762 SET_REASON(PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED);
2763 /* Clear the pasword if it isn't being saved */
2764 if (!purple_account_get_remember_password(purple_connection_get_account(js->gc)))
2765 purple_account_set_password(purple_connection_get_account(js->gc), NULL, NULL, NULL);
2766 text = _("Not Authorized");
2767 } else if(purple_xmlnode_get_child(packet, "temporary-auth-failure")) {
2768 text = _("Temporary Authentication Failure");
2769 } else {
2770 SET_REASON(PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED);
2771 text = _("Authentication Failure");
2772 }
2773 } else if(!strcmp(packet->name, "stream:error") ||
2774 (!strcmp(packet->name, "error") && xmlns &&
2775 !strcmp(xmlns, NS_XMPP_STREAMS))) {
2776 /* Most common reason as default: */
2777 SET_REASON(PURPLE_CONNECTION_ERROR_NETWORK_ERROR);
2778 if(purple_xmlnode_get_child(packet, "bad-format")) {
2779 text = _("Bad Format");
2780 } else if(purple_xmlnode_get_child(packet, "bad-namespace-prefix")) {
2781 text = _("Bad Namespace Prefix");
2782 } else if(purple_xmlnode_get_child(packet, "conflict")) {
2783 SET_REASON(PURPLE_CONNECTION_ERROR_NAME_IN_USE);
2784 text = _("Resource Conflict");
2785 } else if(purple_xmlnode_get_child(packet, "connection-timeout")) {
2786 text = _("Connection Timeout");
2787 } else if(purple_xmlnode_get_child(packet, "host-gone")) {
2788 text = _("Host Gone");
2789 } else if(purple_xmlnode_get_child(packet, "host-unknown")) {
2790 text = _("Host Unknown");
2791 } else if(purple_xmlnode_get_child(packet, "improper-addressing")) {
2792 text = _("Improper Addressing");
2793 } else if(purple_xmlnode_get_child(packet, "internal-server-error")) {
2794 text = _("Internal Server Error");
2795 } else if(purple_xmlnode_get_child(packet, "invalid-id")) {
2796 text = _("Invalid ID");
2797 } else if(purple_xmlnode_get_child(packet, "invalid-namespace")) {
2798 text = _("Invalid Namespace");
2799 } else if(purple_xmlnode_get_child(packet, "invalid-xml")) {
2800 text = _("Invalid XML");
2801 } else if(purple_xmlnode_get_child(packet, "nonmatching-hosts")) {
2802 text = _("Non-matching Hosts");
2803 } else if(purple_xmlnode_get_child(packet, "not-authorized")) {
2804 text = _("Not Authorized");
2805 } else if(purple_xmlnode_get_child(packet, "policy-violation")) {
2806 text = _("Policy Violation");
2807 } else if(purple_xmlnode_get_child(packet, "remote-connection-failed")) {
2808 text = _("Remote Connection Failed");
2809 } else if(purple_xmlnode_get_child(packet, "resource-constraint")) {
2810 text = _("Resource Constraint");
2811 } else if(purple_xmlnode_get_child(packet, "restricted-xml")) {
2812 text = _("Restricted XML");
2813 } else if(purple_xmlnode_get_child(packet, "see-other-host")) {
2814 text = _("See Other Host");
2815 } else if(purple_xmlnode_get_child(packet, "system-shutdown")) {
2816 text = _("System Shutdown");
2817 } else if(purple_xmlnode_get_child(packet, "undefined-condition")) {
2818 text = _("Undefined Condition");
2819 } else if(purple_xmlnode_get_child(packet, "unsupported-encoding")) {
2820 text = _("Unsupported Encoding");
2821 } else if(purple_xmlnode_get_child(packet, "unsupported-stanza-type")) {
2822 text = _("Unsupported Stanza Type");
2823 } else if(purple_xmlnode_get_child(packet, "unsupported-version")) {
2824 text = _("Unsupported Version");
2825 } else if(purple_xmlnode_get_child(packet, "xml-not-well-formed")) {
2826 text = _("XML Not Well Formed");
2827 } else {
2828 text = _("Stream Error");
2829 }
2830 }
2831
2832 #undef SET_REASON
2833
2834 if(text || cdata) {
2835 char *ret = g_strdup_printf("%s%s%s", code ? code : "",
2836 code ? ": " : "", text ? text : cdata);
2837 g_free(cdata);
2838 return ret;
2839 } else {
2840 return NULL;
2841 }
2842 }
2843
2844 static PurpleCmdRet jabber_cmd_chat_config(PurpleConversation *conv,
2845 const char *cmd, char **args, char **error, void *data)
2846 {
2847 JabberChat *chat = jabber_chat_find_by_conv(PURPLE_CHAT_CONVERSATION(conv));
2848
2849 if (!chat)
2850 return PURPLE_CMD_RET_FAILED;
2851
2852 jabber_chat_request_room_configure(chat);
2853 return PURPLE_CMD_RET_OK;
2854 }
2855
2856 static PurpleCmdRet jabber_cmd_chat_register(PurpleConversation *conv,
2857 const char *cmd, char **args, char **error, void *data)
2858 {
2859 JabberChat *chat = jabber_chat_find_by_conv(PURPLE_CHAT_CONVERSATION(conv));
2860
2861 if (!chat)
2862 return PURPLE_CMD_RET_FAILED;
2863
2864 jabber_chat_register(chat);
2865 return PURPLE_CMD_RET_OK;
2866 }
2867
2868 static PurpleCmdRet jabber_cmd_chat_topic(PurpleConversation *conv,
2869 const char *cmd, char **args, char **error, void *data)
2870 {
2871 JabberChat *chat = jabber_chat_find_by_conv(PURPLE_CHAT_CONVERSATION(conv));
2872
2873 if (!chat)
2874 return PURPLE_CMD_RET_FAILED;
2875
2876 if (args && args[0] && *args[0])
2877 jabber_chat_change_topic(chat, args[0]);
2878 else {
2879 const char *cur = purple_chat_conversation_get_topic(PURPLE_CHAT_CONVERSATION(conv));
2880 char *buf, *tmp, *tmp2;
2881
2882 if (cur) {
2883 tmp = g_markup_escape_text(cur, -1);
2884 tmp2 = purple_markup_linkify(tmp);
2885 buf = g_strdup_printf(_("current topic is: %s"), tmp2);
2886 g_free(tmp);
2887 g_free(tmp2);
2888 } else
2889 buf = g_strdup(_("No topic is set"));
2890 purple_conversation_write_system_message(conv, buf, PURPLE_MESSAGE_NO_LOG);
2891 g_free(buf);
2892 }
2893
2894 return PURPLE_CMD_RET_OK;
2895 }
2896
2897 static PurpleCmdRet jabber_cmd_chat_nick(PurpleConversation *conv,
2898 const char *cmd, char **args, char **error, void *data)
2899 {
2900 JabberChat *chat = jabber_chat_find_by_conv(PURPLE_CHAT_CONVERSATION(conv));
2901
2902 if(!chat || !args || !args[0])
2903 return PURPLE_CMD_RET_FAILED;
2904
2905 if (!jabber_resourceprep_validate(args[0])) {
2906 *error = g_strdup(_("Invalid nickname"));
2907 return PURPLE_CMD_RET_FAILED;
2908 }
2909
2910 if (jabber_chat_change_nick(chat, args[0]))
2911 return PURPLE_CMD_RET_OK;
2912 else
2913 return PURPLE_CMD_RET_FAILED;
2914 }
2915
2916 static PurpleCmdRet jabber_cmd_chat_part(PurpleConversation *conv,
2917 const char *cmd, char **args, char **error, void *data)
2918 {
2919 JabberChat *chat = jabber_chat_find_by_conv(PURPLE_CHAT_CONVERSATION(conv));
2920
2921 if (!chat)
2922 return PURPLE_CMD_RET_FAILED;
2923
2924 jabber_chat_part(chat, args ? args[0] : NULL);
2925 return PURPLE_CMD_RET_OK;
2926 }
2927
2928 static PurpleCmdRet jabber_cmd_chat_ban(PurpleConversation *conv,
2929 const char *cmd, char **args, char **error, void *data)
2930 {
2931 JabberChat *chat = jabber_chat_find_by_conv(PURPLE_CHAT_CONVERSATION(conv));
2932
2933 if(!chat || !args || !args[0])
2934 return PURPLE_CMD_RET_FAILED;
2935
2936 if(!jabber_chat_ban_user(chat, args[0], args[1])) {
2937 *error = g_strdup_printf(_("Unable to ban user %s"), args[0]);
2938 return PURPLE_CMD_RET_FAILED;
2939 }
2940
2941 return PURPLE_CMD_RET_OK;
2942 }
2943
2944 static PurpleCmdRet jabber_cmd_chat_affiliate(PurpleConversation *conv,
2945 const char *cmd, char **args, char **error, void *data)
2946 {
2947 JabberChat *chat = jabber_chat_find_by_conv(PURPLE_CHAT_CONVERSATION(conv));
2948
2949 if (!chat || !args || !args[0])
2950 return PURPLE_CMD_RET_FAILED;
2951
2952 if (strcmp(args[0], "owner") != 0 &&
2953 strcmp(args[0], "admin") != 0 &&
2954 strcmp(args[0], "member") != 0 &&
2955 strcmp(args[0], "outcast") != 0 &&
2956 strcmp(args[0], "none") != 0) {
2957 *error = g_strdup_printf(_("Unknown affiliation: \"%s\""), args[0]);
2958 return PURPLE_CMD_RET_FAILED;
2959 }
2960
2961 if (args[1]) {
2962 int i;
2963 char **nicks = g_strsplit(args[1], " ", -1);
2964
2965 for (i = 0; nicks[i]; ++i)
2966 if (!jabber_chat_affiliate_user(chat, nicks[i], args[0])) {
2967 *error = g_strdup_printf(_("Unable to affiliate user %s as \"%s\""), nicks[i], args[0]);
2968 g_strfreev(nicks);
2969 return PURPLE_CMD_RET_FAILED;
2970 }
2971
2972 g_strfreev(nicks);
2973 } else {
2974 jabber_chat_affiliation_list(chat, args[0]);
2975 }
2976
2977 return PURPLE_CMD_RET_OK;
2978 }
2979
2980 static PurpleCmdRet jabber_cmd_chat_role(PurpleConversation *conv,
2981 const char *cmd, char **args, char **error, void *data)
2982 {
2983 JabberChat *chat = jabber_chat_find_by_conv(PURPLE_CHAT_CONVERSATION(conv));
2984
2985 if (!chat || !args || !args[0])
2986 return PURPLE_CMD_RET_FAILED;
2987
2988 if (strcmp(args[0], "moderator") != 0 &&
2989 strcmp(args[0], "participant") != 0 &&
2990 strcmp(args[0], "visitor") != 0 &&
2991 strcmp(args[0], "none") != 0) {
2992 *error = g_strdup_printf(_("Unknown role: \"%s\""), args[0]);
2993 return PURPLE_CMD_RET_FAILED;
2994 }
2995
2996 if (args[1]) {
2997 int i;
2998 char **nicks = g_strsplit(args[1], " ", -1);
2999
3000 for (i = 0; nicks[i]; i++)
3001 if (!jabber_chat_role_user(chat, nicks[i], args[0], NULL)) {
3002 *error = g_strdup_printf(_("Unable to set role \"%s\" for user: %s"),
3003 args[0], nicks[i]);
3004 g_strfreev(nicks);
3005 return PURPLE_CMD_RET_FAILED;
3006 }
3007
3008 g_strfreev(nicks);
3009 } else {
3010 jabber_chat_role_list(chat, args[0]);
3011 }
3012 return PURPLE_CMD_RET_OK;
3013 }
3014
3015 static PurpleCmdRet jabber_cmd_chat_invite(PurpleConversation *conv,
3016 const char *cmd, char **args, char **error, void *data)
3017 {
3018 if(!args || !args[0])
3019 return PURPLE_CMD_RET_FAILED;
3020
3021 jabber_chat_invite(purple_conversation_get_connection(conv),
3022 purple_chat_conversation_get_id(PURPLE_CHAT_CONVERSATION(conv)), args[1] ? args[1] : "",
3023 args[0]);
3024
3025 return PURPLE_CMD_RET_OK;
3026 }
3027
3028 static PurpleCmdRet jabber_cmd_chat_join(PurpleConversation *conv,
3029 const char *cmd, char **args, char **error, void *data)
3030 {
3031 JabberChat *chat = jabber_chat_find_by_conv(PURPLE_CHAT_CONVERSATION(conv));
3032 GHashTable *components;
3033 JabberID *jid = NULL;
3034 const char *room = NULL, *server = NULL, *handle = NULL;
3035
3036 if (!chat || !args || !args[0])
3037 return PURPLE_CMD_RET_FAILED;
3038
3039 components = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, NULL);
3040
3041 if (strchr(args[0], '@'))
3042 jid = jabber_id_new(args[0]);
3043 if (jid) {
3044 room = jid->node;
3045 server = jid->domain;
3046 handle = jid->resource ? jid->resource : chat->handle;
3047 } else {
3048 /* If jabber_id_new failed, the user may have just passed in
3049 * a room name. For backward compatibility, handle that here.
3050 */
3051 if (strchr(args[0], '@')) {
3052 *error = g_strdup(_("Invalid XMPP ID"));
3053 return PURPLE_CMD_RET_FAILED;
3054 }
3055
3056 room = args[0];
3057 server = chat->server;
3058 handle = chat->handle;
3059 }
3060
3061 g_hash_table_insert(components, "room", (gpointer)room);
3062 g_hash_table_insert(components, "server", (gpointer)server);
3063 g_hash_table_insert(components, "handle", (gpointer)handle);
3064
3065 if (args[1])
3066 g_hash_table_insert(components, "password", args[1]);
3067
3068 jabber_chat_join(purple_conversation_get_connection(conv), components);
3069
3070 g_hash_table_destroy(components);
3071 jabber_id_free(jid);
3072 return PURPLE_CMD_RET_OK;
3073 }
3074
3075 static PurpleCmdRet jabber_cmd_chat_kick(PurpleConversation *conv,
3076 const char *cmd, char **args, char **error, void *data)
3077 {
3078 JabberChat *chat = jabber_chat_find_by_conv(PURPLE_CHAT_CONVERSATION(conv));
3079
3080 if(!chat || !args || !args[0])
3081 return PURPLE_CMD_RET_FAILED;
3082
3083 if(!jabber_chat_role_user(chat, args[0], "none", args[1])) {
3084 *error = g_strdup_printf(_("Unable to kick user %s"), args[0]);
3085 return PURPLE_CMD_RET_FAILED;
3086 }
3087
3088 return PURPLE_CMD_RET_OK;
3089 }
3090
3091 static PurpleCmdRet jabber_cmd_chat_msg(PurpleConversation *conv,
3092 const char *cmd, char **args, char **error, void *data)
3093 {
3094 JabberChat *chat = jabber_chat_find_by_conv(PURPLE_CHAT_CONVERSATION(conv));
3095 char *who;
3096
3097 if (!chat)
3098 return PURPLE_CMD_RET_FAILED;
3099
3100 who = g_strdup_printf("%s@%s/%s", chat->room, chat->server, args[0]);
3101
3102 jabber_message_send_im(purple_conversation_get_connection(conv),
3103 purple_message_new_outgoing(who, args[1], 0));
3104
3105 g_free(who);
3106 return PURPLE_CMD_RET_OK;
3107 }
3108
3109 static PurpleCmdRet jabber_cmd_ping(PurpleConversation *conv,
3110 const char *cmd, char **args, char **error, void *data)
3111 {
3112 PurpleAccount *account;
3113 PurpleConnection *pc;
3114
3115 if(!args || !args[0])
3116 return PURPLE_CMD_RET_FAILED;
3117
3118 account = purple_conversation_get_account(conv);
3119 pc = purple_account_get_connection(account);
3120
3121 if(!jabber_ping_jid(purple_connection_get_protocol_data(pc), args[0])) {
3122 *error = g_strdup_printf(_("Unable to ping user %s"), args[0]);
3123 return PURPLE_CMD_RET_FAILED;
3124 }
3125
3126 return PURPLE_CMD_RET_OK;
3127 }
3128
3129 static gboolean _jabber_send_buzz(JabberStream *js, const char *username, char **error) {
3130
3131 JabberBuddy *jb;
3132 JabberBuddyResource *jbr;
3133 PurpleConnection *gc = js->gc;
3134 PurpleBuddy *buddy =
3135 purple_blist_find_buddy(purple_connection_get_account(gc), username);
3136 const gchar *alias =
3137 buddy ? purple_buddy_get_contact_alias(buddy) : username;
3138
3139 if(!username)
3140 return FALSE;
3141
3142 jb = jabber_buddy_find(js, username, FALSE);
3143 if(!jb) {
3144 *error = g_strdup_printf(_("Unable to buzz, because there is nothing "
3145 "known about %s."), alias);
3146 return FALSE;
3147 }
3148
3149 jbr = jabber_buddy_find_resource(jb, NULL);
3150 if (!jbr) {
3151 *error = g_strdup_printf(_("Unable to buzz, because %s might be offline."),
3152 alias);
3153 return FALSE;
3154 }
3155
3156 if (jabber_resource_has_capability(jbr, NS_ATTENTION)) {
3157 PurpleXmlNode *buzz, *msg = purple_xmlnode_new("message");
3158 gchar *to;
3159
3160 to = g_strdup_printf("%s/%s", username, jbr->name);
3161 purple_xmlnode_set_attrib(msg, "to", to);
3162 g_free(to);
3163
3164 /* avoid offline storage */
3165 purple_xmlnode_set_attrib(msg, "type", "headline");
3166
3167 buzz = purple_xmlnode_new_child(msg, "attention");
3168 purple_xmlnode_set_namespace(buzz, NS_ATTENTION);
3169
3170 jabber_send(js, msg);
3171 purple_xmlnode_free(msg);
3172
3173 return TRUE;
3174 } else {
3175 *error = g_strdup_printf(_("Unable to buzz, because %s does "
3176 "not support it or does not wish to receive buzzes now."), alias);
3177 return FALSE;
3178 }
3179 }
3180
3181 static PurpleCmdRet jabber_cmd_buzz(PurpleConversation *conv,
3182 const char *cmd, char **args, char **error, void *data)
3183 {
3184 PurpleAccount *account = purple_conversation_get_account(conv);
3185 JabberStream *js = purple_connection_get_protocol_data(purple_account_get_connection(account));
3186 const gchar *who;
3187 gchar *description;
3188 PurpleBuddy *buddy;
3189 const char *alias;
3190 PurpleAttentionType *attn =
3191 purple_get_attention_type_from_code(account, 0);
3192
3193 if (!args || !args[0]) {
3194 /* use the buddy from conversation, if it's a one-to-one conversation */
3195 if (PURPLE_IS_IM_CONVERSATION(conv)) {
3196 who = purple_conversation_get_name(conv);
3197 } else {
3198 return PURPLE_CMD_RET_FAILED;
3199 }
3200 } else {
3201 who = args[0];
3202 }
3203
3204 buddy = purple_blist_find_buddy(account, who);
3205 if (buddy != NULL)
3206 alias = purple_buddy_get_contact_alias(buddy);
3207 else
3208 alias = who;
3209
3210 description =
3211 g_strdup_printf(purple_attention_type_get_outgoing_desc(attn), alias);
3212 purple_conversation_write_system_message(conv, description,
3213 PURPLE_MESSAGE_NOTIFY);
3214 g_free(description);
3215 return _jabber_send_buzz(js, who, error) ? PURPLE_CMD_RET_OK : PURPLE_CMD_RET_FAILED;
3216 }
3217
3218 GList *jabber_attention_types(PurpleAccount *account)
3219 {
3220 static GList *types = NULL;
3221
3222 if (!types) {
3223 types = g_list_append(types, purple_attention_type_new("Buzz", _("Buzz"),
3224 _("%s has buzzed you!"), _("Buzzing %s...")));
3225 }
3226
3227 return types;
3228 }
3229
3230 gboolean jabber_send_attention(PurpleConnection *gc, const char *username, guint code)
3231 {
3232 JabberStream *js = purple_connection_get_protocol_data(gc);
3233 gchar *error = NULL;
3234
3235 if (!_jabber_send_buzz(js, username, &error)) {
3236 PurpleAccount *account = purple_connection_get_account(gc);
3237 PurpleConversation *conv =
3238 purple_conversations_find_with_account(username, account);
3239 purple_debug_error("jabber", "jabber_send_attention: jabber_cmd_buzz failed with error: %s\n", error ? error : "(NULL)");
3240
3241 if (conv) {
3242 purple_conversation_write_system_message(conv,
3243 error, PURPLE_MESSAGE_ERROR);
3244 }
3245
3246 g_free(error);
3247 return FALSE;
3248 }
3249
3250 return TRUE;
3251 }
3252
3253
3254 gboolean jabber_offline_message(const PurpleBuddy *buddy)
3255 {
3256 return TRUE;
3257 }
3258
3259 #ifdef USE_VV
3260 gboolean
3261 jabber_audio_enabled(JabberStream *js, const char *namespace)
3262 {
3263 PurpleMediaManager *manager = purple_media_manager_get();
3264 PurpleMediaCaps caps = purple_media_manager_get_ui_caps(manager);
3265
3266 return (caps & (PURPLE_MEDIA_CAPS_AUDIO | PURPLE_MEDIA_CAPS_AUDIO_SINGLE_DIRECTION));
3267 }
3268
3269 gboolean
3270 jabber_video_enabled(JabberStream *js, const char *namespace)
3271 {
3272 PurpleMediaManager *manager = purple_media_manager_get();
3273 PurpleMediaCaps caps = purple_media_manager_get_ui_caps(manager);
3274
3275 return (caps & (PURPLE_MEDIA_CAPS_VIDEO | PURPLE_MEDIA_CAPS_VIDEO_SINGLE_DIRECTION));
3276 }
3277
3278 typedef struct {
3279 PurpleAccount *account;
3280 gchar *who;
3281 PurpleMediaSessionType type;
3282
3283 } JabberMediaRequest;
3284
3285 static void
3286 jabber_media_cancel_cb(JabberMediaRequest *request,
3287 PurpleRequestFields *fields)
3288 {
3289 g_free(request->who);
3290 g_free(request);
3291 }
3292
3293 static void
3294 jabber_media_ok_cb(JabberMediaRequest *request, PurpleRequestFields *fields)
3295 {
3296 PurpleRequestField *field =
3297 purple_request_fields_get_field(fields, "resource");
3298 const gchar *selected = purple_request_field_choice_get_value(field);
3299 gchar *who = g_strdup_printf("%s/%s", request->who, selected);
3300 jabber_initiate_media(request->account, who, request->type);
3301
3302 g_free(who);
3303 g_free(request->who);
3304 g_free(request);
3305 }
3306 #endif
3307
3308 gboolean
3309 jabber_initiate_media(PurpleAccount *account, const char *who,
3310 PurpleMediaSessionType type)
3311 {
3312 #ifdef USE_VV
3313 PurpleConnection *gc = purple_account_get_connection(account);
3314 JabberStream *js = purple_connection_get_protocol_data(gc);
3315 JabberBuddy *jb;
3316 JabberBuddyResource *jbr = NULL;
3317 char *resource = NULL;
3318
3319 if (!js) {
3320 purple_debug_error("jabber",
3321 "jabber_initiate_media: NULL stream\n");
3322 return FALSE;
3323 }
3324
3325 jb = jabber_buddy_find(js, who, FALSE);
3326
3327 if(!jb || !jb->resources ||
3328 (((resource = jabber_get_resource(who)) != NULL)
3329 && (jbr = jabber_buddy_find_resource(jb, resource)) == NULL)) {
3330 /* no resources online, we're trying to initiate with someone
3331 * whose presence we're not subscribed to, or
3332 * someone who is offline. Let's inform the user */
3333 char *msg;
3334
3335 if(!jb) {
3336 msg = g_strdup_printf(_("Unable to initiate media with %s: invalid JID"), who);
3337 } else if(jb->subscription & JABBER_SUB_TO && !jb->resources) {
3338 msg = g_strdup_printf(_("Unable to initiate media with %s: user is not online"), who);
3339 } else if(resource) {
3340 msg = g_strdup_printf(_("Unable to initiate media with %s: resource is not online"), who);
3341 } else {
3342 msg = g_strdup_printf(_("Unable to initiate media with %s: not subscribed to user presence"), who);
3343 }
3344
3345 purple_notify_error(account, _("Media Initiation Failed"),
3346 _("Media Initiation Failed"), msg,
3347 purple_request_cpar_from_connection(gc));
3348 g_free(msg);
3349 g_free(resource);
3350 return FALSE;
3351 } else if(jbr != NULL) {
3352 /* they've specified a resource, no need to ask or
3353 * default or anything, just do it */
3354
3355 g_free(resource);
3356
3357 if (type & PURPLE_MEDIA_AUDIO &&
3358 !jabber_resource_has_capability(jbr,
3359 JINGLE_APP_RTP_SUPPORT_AUDIO) &&
3360 jabber_resource_has_capability(jbr, NS_GOOGLE_VOICE))
3361 return jabber_google_session_initiate(js, who, type);
3362 else
3363 return jingle_rtp_initiate_media(js, who, type);
3364 } else if(!jb->resources->next) {
3365 /* only 1 resource online (probably our most common case)
3366 * so no need to ask who to initiate with */
3367 gchar *name;
3368 gboolean result;
3369 jbr = jb->resources->data;
3370 name = g_strdup_printf("%s/%s", who, jbr->name);
3371 result = jabber_initiate_media(account, name, type);
3372 g_free(name);
3373 return result;
3374 } else {
3375 /* we've got multiple resources,
3376 * we need to pick one to initiate with */
3377 GList *l;
3378 char *msg;
3379 PurpleRequestFields *fields;
3380 PurpleRequestField *field = purple_request_field_choice_new(
3381 "resource", _("Resource"), 0);
3382 PurpleRequestFieldGroup *group;
3383 JabberMediaRequest *request;
3384
3385 purple_request_field_choice_set_data_destructor(field, g_free);
3386
3387 for(l = jb->resources; l; l = l->next)
3388 {
3389 JabberBuddyResource *ljbr = l->data;
3390 PurpleMediaCaps caps;
3391 gchar *name;
3392 name = g_strdup_printf("%s/%s", who, ljbr->name);
3393 caps = jabber_get_media_caps(account, name);
3394 g_free(name);
3395
3396 if ((type & PURPLE_MEDIA_AUDIO) &&
3397 (type & PURPLE_MEDIA_VIDEO)) {
3398 if (caps & PURPLE_MEDIA_CAPS_AUDIO_VIDEO) {
3399 jbr = ljbr;
3400 purple_request_field_choice_add(field,
3401 jbr->name, g_strdup(jbr->name));
3402 }
3403 } else if (type & (PURPLE_MEDIA_AUDIO) &&
3404 (caps & PURPLE_MEDIA_CAPS_AUDIO)) {
3405 jbr = ljbr;
3406 purple_request_field_choice_add(field,
3407 jbr->name, g_strdup(jbr->name));
3408 }else if (type & (PURPLE_MEDIA_VIDEO) &&
3409 (caps & PURPLE_MEDIA_CAPS_VIDEO)) {
3410 jbr = ljbr;
3411 purple_request_field_choice_add(field,
3412 jbr->name, g_strdup(jbr->name));
3413 }
3414 }
3415
3416 if (jbr == NULL) {
3417 purple_debug_error("jabber",
3418 "No resources available\n");
3419 return FALSE;
3420 }
3421
3422 if (g_list_length(purple_request_field_choice_get_elements(
3423 field)) <= 2) {
3424 gchar *name;
3425 gboolean result;
3426 purple_request_field_destroy(field);
3427 name = g_strdup_printf("%s/%s", who, jbr->name);
3428 result = jabber_initiate_media(account, name, type);
3429 g_free(name);
3430 return result;
3431 }
3432
3433 msg = g_strdup_printf(_("Please select the resource of %s with which you would like to start a media session."), who);
3434 fields = purple_request_fields_new();
3435 group = purple_request_field_group_new(NULL);
3436 request = g_new0(JabberMediaRequest, 1);
3437 request->account = account;
3438 request->who = g_strdup(who);
3439 request->type = type;
3440
3441 purple_request_field_group_add_field(group, field);
3442 purple_request_fields_add_group(fields, group);
3443 purple_request_fields(account, _("Select a Resource"), msg,
3444 NULL, fields, _("Initiate Media"),
3445 G_CALLBACK(jabber_media_ok_cb), _("Cancel"),
3446 G_CALLBACK(jabber_media_cancel_cb),
3447 purple_request_cpar_from_account(account),
3448 request);
3449
3450 g_free(msg);
3451 return TRUE;
3452 }
3453 #endif
3454 return FALSE;
3455 }
3456
3457 PurpleMediaCaps jabber_get_media_caps(PurpleAccount *account, const char *who)
3458 {
3459 #ifdef USE_VV
3460 PurpleConnection *gc = purple_account_get_connection(account);
3461 JabberStream *js = purple_connection_get_protocol_data(gc);
3462 JabberBuddy *jb;
3463 JabberBuddyResource *jbr;
3464 PurpleMediaCaps total = PURPLE_MEDIA_CAPS_NONE;
3465 gchar *resource;
3466 GList *specific = NULL, *l;
3467
3468 if (!js) {
3469 purple_debug_info("jabber",
3470 "jabber_can_do_media: NULL stream\n");
3471 return FALSE;
3472 }
3473
3474 jb = jabber_buddy_find(js, who, FALSE);
3475
3476 if (!jb || !jb->resources) {
3477 /* no resources online, we're trying to get caps for someone
3478 * whose presence we're not subscribed to, or
3479 * someone who is offline. */
3480 return total;
3481
3482 } else if ((resource = jabber_get_resource(who)) != NULL) {
3483 /* they've specified a resource, no need to ask or
3484 * default or anything, just do it */
3485 jbr = jabber_buddy_find_resource(jb, resource);
3486 g_free(resource);
3487
3488 if (!jbr) {
3489 purple_debug_error("jabber", "jabber_get_media_caps:"
3490 " Can't find resource %s\n", who);
3491 return total;
3492 }
3493
3494 l = specific = g_list_prepend(specific, jbr);
3495
3496 } else {
3497 /* we've got multiple resources, combine their caps */
3498 l = jb->resources;
3499 }
3500
3501 for (; l; l = l->next) {
3502 PurpleMediaCaps caps = PURPLE_MEDIA_CAPS_NONE;
3503 jbr = l->data;
3504
3505 if (jabber_resource_has_capability(jbr,
3506 JINGLE_APP_RTP_SUPPORT_AUDIO))
3507 caps |= PURPLE_MEDIA_CAPS_AUDIO_SINGLE_DIRECTION |
3508 PURPLE_MEDIA_CAPS_AUDIO;
3509 if (jabber_resource_has_capability(jbr,
3510 JINGLE_APP_RTP_SUPPORT_VIDEO))
3511 caps |= PURPLE_MEDIA_CAPS_VIDEO_SINGLE_DIRECTION |
3512 PURPLE_MEDIA_CAPS_VIDEO;
3513 if (caps & PURPLE_MEDIA_CAPS_AUDIO && caps &
3514 PURPLE_MEDIA_CAPS_VIDEO)
3515 caps |= PURPLE_MEDIA_CAPS_AUDIO_VIDEO;
3516 if (caps != PURPLE_MEDIA_CAPS_NONE) {
3517 if (!jabber_resource_has_capability(jbr,
3518 JINGLE_TRANSPORT_ICEUDP) &&
3519 !jabber_resource_has_capability(jbr,
3520 JINGLE_TRANSPORT_RAWUDP)) {
3521 purple_debug_info("jingle-rtp", "Buddy doesn't "
3522 "support the same transport types\n");
3523 caps = PURPLE_MEDIA_CAPS_NONE;
3524 } else
3525 caps |= PURPLE_MEDIA_CAPS_MODIFY_SESSION |
3526 PURPLE_MEDIA_CAPS_CHANGE_DIRECTION;
3527 }
3528 if (jabber_resource_has_capability(jbr, NS_GOOGLE_VOICE)) {
3529 caps |= PURPLE_MEDIA_CAPS_AUDIO;
3530 if (jabber_resource_has_capability(jbr, NS_GOOGLE_VIDEO))
3531 caps |= PURPLE_MEDIA_CAPS_AUDIO_VIDEO;
3532 }
3533
3534 total |= caps;
3535 }
3536
3537 if (specific) {
3538 g_list_free(specific);
3539 }
3540
3541 return total;
3542 #else
3543 return PURPLE_MEDIA_CAPS_NONE;
3544 #endif
3545 }
3546
3547 gboolean jabber_can_receive_file(PurpleConnection *gc, const char *who)
3548 {
3549 JabberStream *js = purple_connection_get_protocol_data(gc);
3550
3551 if (js) {
3552 JabberBuddy *jb = jabber_buddy_find(js, who, FALSE);
3553 GList *iter;
3554 gboolean has_resources_without_caps = FALSE;
3555
3556 /* if we didn't find a JabberBuddy, we don't have presence for this
3557 buddy, let's assume they can receive files, disco should tell us
3558 when actually trying */
3559 if (jb == NULL)
3560 return TRUE;
3561
3562 /* find out if there is any resources without caps */
3563 for (iter = jb->resources; iter ; iter = g_list_next(iter)) {
3564 JabberBuddyResource *jbr = (JabberBuddyResource *) iter->data;
3565
3566 if (!jabber_resource_know_capabilities(jbr)) {
3567 has_resources_without_caps = TRUE;
3568 }
3569 }
3570
3571 if (has_resources_without_caps) {
3572 /* there is at least one resource which we don't have caps for,
3573 let's assume they can receive files... */
3574 return TRUE;
3575 } else {
3576 /* we have caps for all the resources, see if at least one has
3577 right caps */
3578 for (iter = jb->resources; iter ; iter = g_list_next(iter)) {
3579 JabberBuddyResource *jbr = (JabberBuddyResource *) iter->data;
3580
3581 if (jabber_resource_has_capability(jbr, NS_SI_FILE_TRANSFER)
3582 && (jabber_resource_has_capability(jbr,
3583 NS_BYTESTREAMS)
3584 || jabber_resource_has_capability(jbr, NS_IBB))) {
3585 return TRUE;
3586 }
3587 }
3588 return FALSE;
3589 }
3590 } else {
3591 return TRUE;
3592 }
3593 }
3594
3595 static PurpleCmdRet
3596 jabber_cmd_mood(PurpleConversation *conv,
3597 const char *cmd, char **args, char **error, void *data)
3598 {
3599 PurpleAccount *account = purple_conversation_get_account(conv);
3600 JabberStream *js = purple_connection_get_protocol_data(purple_account_get_connection(account));
3601
3602 if (js->pep) {
3603 gboolean ret;
3604
3605 if (!args || !args[0]) {
3606 /* No arguments; unset mood */
3607 ret = jabber_mood_set(js, NULL, NULL);
3608 } else {
3609 /* At least one argument. Relying on the list of arguments
3610 * being NULL-terminated.
3611 */
3612 ret = jabber_mood_set(js, args[0], args[1]);
3613 if (!ret) {
3614 /* Let's try again */
3615 char *tmp = g_strjoin(" ", args[0], args[1], NULL);
3616 ret = jabber_mood_set(js, "undefined", tmp);
3617 g_free(tmp);
3618 }
3619 }
3620
3621 if (ret) {
3622 return PURPLE_CMD_RET_OK;
3623 } else {
3624 purple_conversation_write_system_message(conv,
3625 _("Failed to specify mood"),
3626 PURPLE_MESSAGE_ERROR);
3627 return PURPLE_CMD_RET_FAILED;
3628 }
3629 } else {
3630 /* account does not support PEP, can't set a mood */
3631 purple_conversation_write_system_message(conv,
3632 _("Account does not support PEP, can't set mood"),
3633 PURPLE_MESSAGE_ERROR);
3634 return PURPLE_CMD_RET_FAILED;
3635 }
3636 }
3637
3638 static void
3639 jabber_register_commands(PurpleProtocol *protocol)
3640 {
3641 GSList *commands = NULL;
3642 PurpleCmdId id;
3643 const gchar *proto_id = purple_protocol_get_id(protocol);
3644
3645 id = purple_cmd_register("config", "", PURPLE_CMD_P_PROTOCOL,
3646 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_PROTOCOL_ONLY, proto_id,
3647 jabber_cmd_chat_config, _("config: Configure a chat room."),
3648 NULL);
3649 commands = g_slist_prepend(commands, GUINT_TO_POINTER(id));
3650
3651 id = purple_cmd_register("configure", "", PURPLE_CMD_P_PROTOCOL,
3652 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_PROTOCOL_ONLY, proto_id,
3653 jabber_cmd_chat_config, _("configure: Configure a chat room."),
3654 NULL);
3655 commands = g_slist_prepend(commands, GUINT_TO_POINTER(id));
3656
3657 id = purple_cmd_register("nick", "s", PURPLE_CMD_P_PROTOCOL,
3658 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_PROTOCOL_ONLY, proto_id,
3659 jabber_cmd_chat_nick, _("nick &lt;new nickname&gt;: "
3660 "Change your nickname."), NULL);
3661 commands = g_slist_prepend(commands, GUINT_TO_POINTER(id));
3662
3663 id = purple_cmd_register("part", "s", PURPLE_CMD_P_PROTOCOL,
3664 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_PROTOCOL_ONLY |
3665 PURPLE_CMD_FLAG_ALLOW_WRONG_ARGS, proto_id, jabber_cmd_chat_part,
3666 _("part [message]: Leave the room."), NULL);
3667 commands = g_slist_prepend(commands, GUINT_TO_POINTER(id));
3668
3669 id = purple_cmd_register("register", "", PURPLE_CMD_P_PROTOCOL,
3670 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_PROTOCOL_ONLY, proto_id,
3671 jabber_cmd_chat_register,
3672 _("register: Register with a chat room."), NULL);
3673 commands = g_slist_prepend(commands, GUINT_TO_POINTER(id));
3674
3675 /* XXX: there needs to be a core /topic cmd, methinks */
3676 id = purple_cmd_register("topic", "s", PURPLE_CMD_P_PROTOCOL,
3677 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_PROTOCOL_ONLY |
3678 PURPLE_CMD_FLAG_ALLOW_WRONG_ARGS, proto_id, jabber_cmd_chat_topic,
3679 _("topic [new topic]: View or change the topic."), NULL);
3680 commands = g_slist_prepend(commands, GUINT_TO_POINTER(id));
3681
3682 id = purple_cmd_register("ban", "ws", PURPLE_CMD_P_PROTOCOL,
3683 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_PROTOCOL_ONLY |
3684 PURPLE_CMD_FLAG_ALLOW_WRONG_ARGS, proto_id, jabber_cmd_chat_ban,
3685 _("ban &lt;user&gt; [reason]: Ban a user from the room."),
3686 NULL);
3687 commands = g_slist_prepend(commands, GUINT_TO_POINTER(id));
3688
3689 id = purple_cmd_register("affiliate", "ws", PURPLE_CMD_P_PROTOCOL,
3690 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_PROTOCOL_ONLY |
3691 PURPLE_CMD_FLAG_ALLOW_WRONG_ARGS, proto_id,
3692 jabber_cmd_chat_affiliate, _("affiliate "
3693 "&lt;owner|admin|member|outcast|none&gt; [nick1] [nick2] ...: "
3694 "Get the users with an affiliation or set users' affiliation "
3695 "with the room."), NULL);
3696 commands = g_slist_prepend(commands, GUINT_TO_POINTER(id));
3697
3698 id = purple_cmd_register("role", "ws", PURPLE_CMD_P_PROTOCOL,
3699 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_PROTOCOL_ONLY |
3700 PURPLE_CMD_FLAG_ALLOW_WRONG_ARGS, proto_id, jabber_cmd_chat_role,
3701 _("role &lt;moderator|participant|visitor|none&gt; [nick1] "
3702 "[nick2] ...: Get the users with a role or set users' role "
3703 "with the room."), NULL);
3704 commands = g_slist_prepend(commands, GUINT_TO_POINTER(id));
3705
3706 id = purple_cmd_register("invite", "ws", PURPLE_CMD_P_PROTOCOL,
3707 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_PROTOCOL_ONLY |
3708 PURPLE_CMD_FLAG_ALLOW_WRONG_ARGS, proto_id, jabber_cmd_chat_invite,
3709 _("invite &lt;user&gt; [message]: Invite a user to the room."),
3710 NULL);
3711 commands = g_slist_prepend(commands, GUINT_TO_POINTER(id));
3712
3713 id = purple_cmd_register("join", "ws", PURPLE_CMD_P_PROTOCOL,
3714 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_PROTOCOL_ONLY |
3715 PURPLE_CMD_FLAG_ALLOW_WRONG_ARGS, proto_id, jabber_cmd_chat_join,
3716 _("join: &lt;room[@server]&gt; [password]: Join a chat."),
3717 NULL);
3718 commands = g_slist_prepend(commands, GUINT_TO_POINTER(id));
3719
3720 id = purple_cmd_register("kick", "ws", PURPLE_CMD_P_PROTOCOL,
3721 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_PROTOCOL_ONLY |
3722 PURPLE_CMD_FLAG_ALLOW_WRONG_ARGS, proto_id, jabber_cmd_chat_kick,
3723 _("kick &lt;user&gt; [reason]: Kick a user from the room."),
3724 NULL);
3725 commands = g_slist_prepend(commands, GUINT_TO_POINTER(id));
3726
3727 id = purple_cmd_register("msg", "ws", PURPLE_CMD_P_PROTOCOL,
3728 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_PROTOCOL_ONLY, proto_id,
3729 jabber_cmd_chat_msg, _("msg &lt;user&gt; &lt;message&gt;: "
3730 "Send a private message to another user."), NULL);
3731 commands = g_slist_prepend(commands, GUINT_TO_POINTER(id));
3732
3733 id = purple_cmd_register("ping", "w", PURPLE_CMD_P_PROTOCOL,
3734 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_IM |
3735 PURPLE_CMD_FLAG_PROTOCOL_ONLY, proto_id, jabber_cmd_ping,
3736 _("ping &lt;jid&gt;: Ping a user/component/server."), NULL);
3737 commands = g_slist_prepend(commands, GUINT_TO_POINTER(id));
3738
3739 id = purple_cmd_register("buzz", "w", PURPLE_CMD_P_PROTOCOL,
3740 PURPLE_CMD_FLAG_IM | PURPLE_CMD_FLAG_PROTOCOL_ONLY |
3741 PURPLE_CMD_FLAG_ALLOW_WRONG_ARGS, proto_id, jabber_cmd_buzz,
3742 _("buzz: Buzz a user to get their attention"), NULL);
3743 commands = g_slist_prepend(commands, GUINT_TO_POINTER(id));
3744
3745 id = purple_cmd_register("mood", "ws", PURPLE_CMD_P_PROTOCOL,
3746 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_IM |
3747 PURPLE_CMD_FLAG_PROTOCOL_ONLY | PURPLE_CMD_FLAG_ALLOW_WRONG_ARGS,
3748 proto_id, jabber_cmd_mood,
3749 _("mood &lt;mood&gt; [text]: Set current user mood"), NULL);
3750 commands = g_slist_prepend(commands, GUINT_TO_POINTER(id));
3751
3752 g_hash_table_insert(jabber_cmds, protocol, commands);
3753 }
3754
3755 static void cmds_free_func(gpointer value)
3756 {
3757 GSList *commands = value;
3758 while (commands) {
3759 purple_cmd_unregister(GPOINTER_TO_UINT(commands->data));
3760 commands = g_slist_delete_link(commands, commands);
3761 }
3762 }
3763
3764 static void jabber_unregister_commands(PurpleProtocol *protocol)
3765 {
3766 g_hash_table_remove(jabber_cmds, protocol);
3767 }
3768
3769 #if 0
3770 /* IPC functions */
3771
3772 /**
3773 * IPC function for determining if a contact supports a certain feature.
3774 *
3775 * @param account The PurpleAccount
3776 * @param jid The full JID of the contact.
3777 * @param feature The feature's namespace.
3778 *
3779 * @return TRUE if supports feature; else FALSE.
3780 */
3781 static gboolean
3782 jabber_ipc_contact_has_feature(PurpleAccount *account, const gchar *jid,
3783 const gchar *feature)
3784 {
3785 PurpleConnection *gc = purple_account_get_connection(account);
3786 JabberStream *js;
3787 JabberBuddy *jb;
3788 JabberBuddyResource *jbr;
3789 gchar *resource;
3790
3791 if (!purple_account_is_connected(account))
3792 return FALSE;
3793 js = purple_connection_get_protocol_data(gc);
3794
3795 if (!(resource = jabber_get_resource(jid)) ||
3796 !(jb = jabber_buddy_find(js, jid, FALSE)) ||
3797 !(jbr = jabber_buddy_find_resource(jb, resource))) {
3798 g_free(resource);
3799 return FALSE;
3800 }
3801
3802 g_free(resource);
3803
3804 return jabber_resource_has_capability(jbr, feature);
3805 }
3806
3807 static void
3808 jabber_ipc_add_feature(const gchar *feature)
3809 {
3810 if (!feature)
3811 return;
3812 jabber_add_feature(feature, 0);
3813
3814 /* send presence with new caps info for all connected accounts */
3815 jabber_caps_broadcast_change();
3816 }
3817 #endif
3818
3819 static PurpleAccount *find_acct(const char *protocol, const char *acct_id)
3820 {
3821 PurpleAccount *acct = NULL;
3822
3823 /* If we have a specific acct, use it */
3824 if (acct_id) {
3825 acct = purple_accounts_find(acct_id, protocol);
3826 if (acct && !purple_account_is_connected(acct))
3827 acct = NULL;
3828 } else { /* Otherwise find an active account for the protocol */
3829 GList *l = purple_accounts_get_all();
3830 while (l) {
3831 if (!strcmp(protocol, purple_account_get_protocol_id(l->data))
3832 && purple_account_is_connected(l->data)) {
3833 acct = l->data;
3834 break;
3835 }
3836 l = l->next;
3837 }
3838 }
3839
3840 return acct;
3841 }
3842
3843 static gboolean xmpp_uri_handler(const char *proto, const char *user, GHashTable *params)
3844 {
3845 char *acct_id = params ? g_hash_table_lookup(params, "account") : NULL;
3846 PurpleAccount *acct;
3847
3848 if (g_ascii_strcasecmp(proto, "xmpp"))
3849 return FALSE;
3850
3851 acct = find_acct(proto, acct_id);
3852
3853 if (!acct)
3854 return FALSE;
3855
3856 /* xmpp:romeo@montague.net?message;subject=Test%20Message;body=Here%27s%20a%20test%20message */
3857 /* params is NULL if the URI has no '?' (or anything after it) */
3858 if (!params || g_hash_table_lookup_extended(params, "message", NULL, NULL)) {
3859 char *body = g_hash_table_lookup(params, "body");
3860 if (user && *user) {
3861 PurpleIMConversation *im =
3862 purple_im_conversation_new(acct, user);
3863 purple_conversation_present(PURPLE_CONVERSATION(im));
3864 if (body && *body)
3865 purple_conversation_send_confirm(PURPLE_CONVERSATION(im), body);
3866 }
3867 } else if (g_hash_table_lookup_extended(params, "roster", NULL, NULL)) {
3868 char *name = g_hash_table_lookup(params, "name");
3869 if (user && *user)
3870 purple_blist_request_add_buddy(acct, user, NULL, name);
3871 } else if (g_hash_table_lookup_extended(params, "join", NULL, NULL)) {
3872 PurpleConnection *gc = purple_account_get_connection(acct);
3873 if (user && *user) {
3874 GHashTable *params = jabber_chat_info_defaults(gc, user);
3875 jabber_chat_join(gc, params);
3876 }
3877 return TRUE;
3878 }
3879
3880 return FALSE;
3881 }
3882
3883 static void
3884 jabber_do_init(void)
3885 {
3886 GHashTable *ui_info = purple_core_get_ui_info();
3887 const gchar *ui_type;
3888 const gchar *type = "pc"; /* default client type, if unknown or
3889 unspecified */
3890 const gchar *ui_name = NULL;
3891 #ifdef HAVE_CYRUS_SASL
3892 /* We really really only want to do this once per process */
3893 static gboolean sasl_initialized = FALSE;
3894 #ifdef _WIN32
3895 UINT old_error_mode;
3896 gchar *sasldir;
3897 #endif
3898 int ret;
3899 #endif
3900
3901 /* XXX - If any other plugin wants SASL this won't be good ... */
3902 #ifdef HAVE_CYRUS_SASL
3903 if (!sasl_initialized) {
3904 sasl_initialized = TRUE;
3905 #ifdef _WIN32
3906 sasldir = g_build_filename(wpurple_bin_dir(), "sasl2", NULL);
3907 sasl_set_path(SASL_PATH_TYPE_PLUGIN, sasldir);
3908 g_free(sasldir);
3909 /* Suppress error popups for failing to load sasl plugins */
3910 old_error_mode = SetErrorMode(SEM_FAILCRITICALERRORS);
3911 #endif
3912 if ((ret = sasl_client_init(NULL)) != SASL_OK) {
3913 purple_debug_error("xmpp", "Error (%d) initializing SASL.\n", ret);
3914 }
3915 #ifdef _WIN32
3916 /* Restore the original error mode */
3917 SetErrorMode(old_error_mode);
3918 #endif
3919 }
3920 #endif
3921
3922 jabber_cmds = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, cmds_free_func);
3923
3924 ui_type = ui_info ? g_hash_table_lookup(ui_info, "client_type") : NULL;
3925 if (ui_type) {
3926 if (strcmp(ui_type, "pc") == 0 ||
3927 strcmp(ui_type, "console") == 0 ||
3928 strcmp(ui_type, "phone") == 0 ||
3929 strcmp(ui_type, "handheld") == 0 ||
3930 strcmp(ui_type, "web") == 0 ||
3931 strcmp(ui_type, "bot") == 0) {
3932 type = ui_type;
3933 }
3934 }
3935
3936 if (ui_info)
3937 ui_name = g_hash_table_lookup(ui_info, "name");
3938 if (ui_name == NULL)
3939 ui_name = PACKAGE;
3940
3941 jabber_add_identity("client", type, NULL, ui_name);
3942
3943 /* initialize jabber_features list */
3944 jabber_add_feature(NS_LAST_ACTIVITY, NULL);
3945 jabber_add_feature(NS_OOB_IQ_DATA, NULL);
3946 jabber_add_feature(NS_ENTITY_TIME, NULL);
3947 jabber_add_feature("jabber:iq:version", NULL);
3948 jabber_add_feature("jabber:x:conference", NULL);
3949 jabber_add_feature(NS_BYTESTREAMS, NULL);
3950 jabber_add_feature("http://jabber.org/protocol/caps", NULL);
3951 jabber_add_feature("http://jabber.org/protocol/chatstates", NULL);
3952 jabber_add_feature(NS_DISCO_INFO, NULL);
3953 jabber_add_feature(NS_DISCO_ITEMS, NULL);
3954 jabber_add_feature(NS_IBB, NULL);
3955 jabber_add_feature("http://jabber.org/protocol/muc", NULL);
3956 jabber_add_feature("http://jabber.org/protocol/muc#user", NULL);
3957 jabber_add_feature("http://jabber.org/protocol/si", NULL);
3958 jabber_add_feature(NS_SI_FILE_TRANSFER, NULL);
3959 jabber_add_feature(NS_XHTML_IM, NULL);
3960 jabber_add_feature(NS_PING, NULL);
3961
3962 /* Buzz/Attention */
3963 jabber_add_feature(NS_ATTENTION, jabber_buzz_isenabled);
3964
3965 /* Bits Of Binary */
3966 jabber_add_feature(NS_BOB, NULL);
3967
3968 /* Jingle features! */
3969 jabber_add_feature(JINGLE, NULL);
3970
3971 #ifdef USE_VV
3972 jabber_add_feature(NS_GOOGLE_PROTOCOL_SESSION, jabber_audio_enabled);
3973 jabber_add_feature(NS_GOOGLE_VOICE, jabber_audio_enabled);
3974 jabber_add_feature(NS_GOOGLE_VIDEO, jabber_video_enabled);
3975 jabber_add_feature(NS_GOOGLE_CAMERA, jabber_video_enabled);
3976 jabber_add_feature(JINGLE_APP_RTP, NULL);
3977 jabber_add_feature(JINGLE_APP_RTP_SUPPORT_AUDIO, jabber_audio_enabled);
3978 jabber_add_feature(JINGLE_APP_RTP_SUPPORT_VIDEO, jabber_video_enabled);
3979 jabber_add_feature(JINGLE_TRANSPORT_RAWUDP, NULL);
3980 jabber_add_feature(JINGLE_TRANSPORT_ICEUDP, NULL);
3981
3982 g_signal_connect(G_OBJECT(purple_media_manager_get()), "ui-caps-changed",
3983 G_CALLBACK(jabber_caps_broadcast_change), NULL);
3984 #endif
3985
3986 /* reverse order of unload_plugin */
3987 jabber_iq_init();
3988 jabber_presence_init();
3989 jabber_caps_init();
3990 /* PEP things should be init via jabber_pep_init, not here */
3991 jabber_pep_init();
3992 jabber_data_init();
3993 jabber_bosh_init();
3994
3995 /* TODO: Implement adding and retrieving own features via IPC API */
3996
3997 jabber_ibb_init();
3998 jabber_si_init();
3999
4000 jabber_auth_init();
4001 }
4002
4003 static void
4004 jabber_do_uninit(void)
4005 {
4006 /* reverse order of jabber_do_init */
4007 jabber_bosh_uninit();
4008 jabber_data_uninit();
4009 jabber_si_uninit();
4010 jabber_ibb_uninit();
4011 /* PEP things should be uninit via jabber_pep_uninit, not here */
4012 jabber_pep_uninit();
4013 jabber_caps_uninit();
4014 jabber_presence_uninit();
4015 jabber_iq_uninit();
4016
4017 #ifdef USE_VV
4018 g_signal_handlers_disconnect_by_func(G_OBJECT(purple_media_manager_get()),
4019 G_CALLBACK(jabber_caps_broadcast_change), NULL);
4020 #endif
4021
4022 jabber_auth_uninit();
4023 jabber_features_destroy();
4024 jabber_identities_destroy();
4025
4026 g_hash_table_destroy(jabber_cmds);
4027 jabber_cmds = NULL;
4028 }
4029
4030 static void jabber_init_protocol(PurpleProtocol *protocol)
4031 {
4032 ++plugin_ref;
4033
4034 if (plugin_ref == 1)
4035 jabber_do_init();
4036
4037 jabber_register_commands(protocol);
4038
4039 #if 0
4040 /* IPC functions */
4041 purple_plugin_ipc_register(plugin, "contact_has_feature", PURPLE_CALLBACK(jabber_ipc_contact_has_feature),
4042 purple_marshal_BOOLEAN__POINTER_POINTER_POINTER,
4043 G_TYPE_BOOLEAN, 3,
4044 PURPLE_TYPE_ACCOUNT, G_TYPE_STRING, G_TYPE_STRING);
4045
4046 purple_plugin_ipc_register(plugin, "add_feature", PURPLE_CALLBACK(jabber_ipc_add_feature),
4047 purple_marshal_VOID__POINTER,
4048 G_TYPE_NONE, 1, G_TYPE_STRING);
4049
4050 purple_plugin_ipc_register(plugin, "register_namespace_watcher",
4051 PURPLE_CALLBACK(jabber_iq_signal_register),
4052 purple_marshal_VOID__POINTER_POINTER,
4053 G_TYPE_NONE, 2,
4054 G_TYPE_STRING, /* node */
4055 G_TYPE_STRING); /* namespace */
4056
4057 purple_plugin_ipc_register(plugin, "unregister_namespace_watcher",
4058 PURPLE_CALLBACK(jabber_iq_signal_unregister),
4059 purple_marshal_VOID__POINTER_POINTER,
4060 G_TYPE_NONE, 2,
4061 G_TYPE_STRING, /* node */
4062 G_TYPE_STRING); /* namespace */
4063 #endif
4064
4065 purple_signal_register(protocol, "jabber-register-namespace-watcher",
4066 purple_marshal_VOID__POINTER_POINTER,
4067 G_TYPE_NONE, 2,
4068 G_TYPE_STRING, /* node */
4069 G_TYPE_STRING); /* namespace */
4070
4071 purple_signal_register(protocol, "jabber-unregister-namespace-watcher",
4072 purple_marshal_VOID__POINTER_POINTER,
4073 G_TYPE_NONE, 2,
4074 G_TYPE_STRING, /* node */
4075 G_TYPE_STRING); /* namespace */
4076
4077 purple_signal_connect(protocol, "jabber-register-namespace-watcher",
4078 protocol, PURPLE_CALLBACK(jabber_iq_signal_register), NULL);
4079 purple_signal_connect(protocol, "jabber-unregister-namespace-watcher",
4080 protocol, PURPLE_CALLBACK(jabber_iq_signal_unregister), NULL);
4081
4082
4083 purple_signal_register(protocol, "jabber-receiving-xmlnode",
4084 purple_marshal_VOID__POINTER_POINTER, G_TYPE_NONE, 2,
4085 PURPLE_TYPE_CONNECTION,
4086 G_TYPE_POINTER); /* pointer to a PurpleXmlNode* */
4087
4088 purple_signal_register(protocol, "jabber-sending-xmlnode",
4089 purple_marshal_VOID__POINTER_POINTER, G_TYPE_NONE, 2,
4090 PURPLE_TYPE_CONNECTION,
4091 G_TYPE_POINTER); /* pointer to a PurpleXmlNode* */
4092
4093 /*
4094 * Do not remove this or the plugin will fail. Completely. You have been
4095 * warned!
4096 */
4097 purple_signal_connect_priority(protocol, "jabber-sending-xmlnode",
4098 protocol, PURPLE_CALLBACK(jabber_send_signal_cb),
4099 NULL, PURPLE_SIGNAL_PRIORITY_HIGHEST);
4100
4101 purple_signal_register(protocol, "jabber-sending-text",
4102 purple_marshal_VOID__POINTER_POINTER, G_TYPE_NONE, 2,
4103 PURPLE_TYPE_CONNECTION,
4104 G_TYPE_POINTER); /* pointer to a string */
4105
4106 purple_signal_register(protocol, "jabber-receiving-message",
4107 purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_POINTER_POINTER,
4108 G_TYPE_BOOLEAN, 6,
4109 PURPLE_TYPE_CONNECTION,
4110 G_TYPE_STRING, /* type */
4111 G_TYPE_STRING, /* id */
4112 G_TYPE_STRING, /* from */
4113 G_TYPE_STRING, /* to */
4114 PURPLE_TYPE_XMLNODE);
4115
4116 purple_signal_register(protocol, "jabber-receiving-iq",
4117 purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_POINTER,
4118 G_TYPE_BOOLEAN, 5,
4119 PURPLE_TYPE_CONNECTION,
4120 G_TYPE_STRING, /* type */
4121 G_TYPE_STRING, /* id */
4122 G_TYPE_STRING, /* from */
4123 PURPLE_TYPE_XMLNODE);
4124
4125 purple_signal_register(protocol, "jabber-watched-iq",
4126 purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER_POINTER,
4127 G_TYPE_BOOLEAN, 5,
4128 PURPLE_TYPE_CONNECTION,
4129 G_TYPE_STRING, /* type */
4130 G_TYPE_STRING, /* id */
4131 G_TYPE_STRING, /* from */
4132 PURPLE_TYPE_XMLNODE); /* child */
4133
4134 purple_signal_register(protocol, "jabber-receiving-presence",
4135 purple_marshal_BOOLEAN__POINTER_POINTER_POINTER_POINTER,
4136 G_TYPE_BOOLEAN, 4,
4137 PURPLE_TYPE_CONNECTION,
4138 G_TYPE_STRING, /* type */
4139 G_TYPE_STRING, /* from */
4140 PURPLE_TYPE_XMLNODE);
4141 }
4142
4143 static void jabber_uninit_protocol(PurpleProtocol *protocol)
4144 {
4145 g_return_if_fail(plugin_ref > 0);
4146
4147 purple_signals_unregister_by_instance(protocol);
4148 #if 0
4149 purple_plugin_ipc_unregister_all(plugin);
4150 #endif
4151 jabber_unregister_commands(protocol);
4152
4153 --plugin_ref;
4154 if (plugin_ref == 0)
4155 jabber_do_uninit();
4156 }
4157
4158 static void
4159 jabber_protocol_init(PurpleProtocol *protocol)
4160 {
4161 protocol->id = "prpl-jabber";
4162 protocol->name = "XMPP";
4163 protocol->options = OPT_PROTO_CHAT_TOPIC | OPT_PROTO_UNIQUE_CHATNAME |
4164 OPT_PROTO_MAIL_CHECK |
4165 #ifdef HAVE_CYRUS_SASL
4166 OPT_PROTO_PASSWORD_OPTIONAL |
4167 #endif
4168 OPT_PROTO_SLASH_COMMANDS_NATIVE;
4169
4170 protocol->icon_spec = purple_buddy_icon_spec_new("png",
4171 32, 32, 96, 96, 0,
4172 PURPLE_ICON_SCALE_SEND |
4173 PURPLE_ICON_SCALE_DISPLAY);
4174 }
4175
4176 static void
4177 jabber_protocol_class_init(PurpleProtocolClass *klass)
4178 {
4179 klass->login = jabber_login;
4180 klass->close = jabber_close;
4181 klass->status_types = jabber_status_types;
4182 klass->list_icon = jabber_list_icon;
4183 }
4184
4185 static void
4186 jabber_protocol_client_iface_init(PurpleProtocolClientIface *client_iface)
4187 {
4188 client_iface->get_actions = jabber_get_actions;
4189 client_iface->list_emblem = jabber_list_emblem;
4190 client_iface->status_text = jabber_status_text;
4191 client_iface->tooltip_text = jabber_tooltip_text;
4192 client_iface->blist_node_menu = jabber_blist_node_menu;
4193 client_iface->convo_closed = jabber_convo_closed;
4194 client_iface->normalize = jabber_normalize;
4195 client_iface->find_blist_chat = jabber_find_blist_chat;
4196 client_iface->offline_message = jabber_offline_message;
4197 client_iface->get_moods = jabber_get_moods;
4198 }
4199
4200 static void
4201 jabber_protocol_server_iface_init(PurpleProtocolServerIface *server_iface)
4202 {
4203 server_iface->register_user = jabber_register_account;
4204 server_iface->unregister_user = jabber_unregister_account;
4205 server_iface->set_info = jabber_set_info;
4206 server_iface->get_info = jabber_buddy_get_info;
4207 server_iface->set_status = jabber_set_status;
4208 server_iface->set_idle = jabber_idle_set;
4209 server_iface->add_buddy = jabber_roster_add_buddy;
4210 server_iface->remove_buddy = jabber_roster_remove_buddy;
4211 server_iface->keepalive = jabber_keepalive;
4212 server_iface->alias_buddy = jabber_roster_alias_change;
4213 server_iface->group_buddy = jabber_roster_group_change;
4214 server_iface->rename_group = jabber_roster_group_rename;
4215 server_iface->set_buddy_icon = jabber_set_buddy_icon;
4216 server_iface->send_raw = jabber_protocol_send_raw;
4217 }
4218
4219 static void
4220 jabber_protocol_im_iface_init(PurpleProtocolIMIface *im_iface)
4221 {
4222 im_iface->send = jabber_message_send_im;
4223 im_iface->send_typing = jabber_send_typing;
4224 }
4225
4226 static void
4227 jabber_protocol_chat_iface_init(PurpleProtocolChatIface *chat_iface)
4228 {
4229 chat_iface->info = jabber_chat_info;
4230 chat_iface->info_defaults = jabber_chat_info_defaults;
4231 chat_iface->join = jabber_chat_join;
4232 chat_iface->get_name = jabber_get_chat_name;
4233 chat_iface->invite = jabber_chat_invite;
4234 chat_iface->leave = jabber_chat_leave;
4235 chat_iface->send = jabber_message_send_chat;
4236 chat_iface->get_user_real_name = jabber_chat_user_real_name;
4237 chat_iface->set_topic = jabber_chat_set_topic;
4238 }
4239
4240 static void
4241 jabber_protocol_privacy_iface_init(PurpleProtocolPrivacyIface *privacy_iface)
4242 {
4243 privacy_iface->add_deny = jabber_add_deny;
4244 privacy_iface->rem_deny = jabber_rem_deny;
4245 }
4246
4247 static void
4248 jabber_protocol_roomlist_iface_init(PurpleProtocolRoomlistIface *roomlist_iface)
4249 {
4250 roomlist_iface->get_list = jabber_roomlist_get_list;
4251 roomlist_iface->cancel = jabber_roomlist_cancel;
4252 roomlist_iface->room_serialize = jabber_roomlist_room_serialize;
4253 }
4254
4255 static void
4256 jabber_protocol_attention_iface_init(PurpleProtocolAttentionIface *attention_iface)
4257 {
4258 attention_iface->send = jabber_send_attention;
4259 attention_iface->get_types = jabber_attention_types;
4260 }
4261
4262 static void
4263 jabber_protocol_media_iface_init(PurpleProtocolMediaIface *media_iface)
4264 {
4265 media_iface->initiate_session = jabber_initiate_media;
4266 media_iface->get_caps = jabber_get_media_caps;
4267 }
4268
4269 static void
4270 jabber_protocol_xfer_iface_init(PurpleProtocolXferIface *xfer_iface)
4271 {
4272 xfer_iface->can_receive = jabber_can_receive_file;
4273 xfer_iface->send = jabber_si_xfer_send;
4274 xfer_iface->new_xfer = jabber_si_new_xfer;
4275 }
4276
4277 PURPLE_DEFINE_TYPE_EXTENDED(
4278 JabberProtocol, jabber_protocol, PURPLE_TYPE_PROTOCOL, G_TYPE_FLAG_ABSTRACT,
4279
4280 PURPLE_IMPLEMENT_INTERFACE_STATIC(PURPLE_TYPE_PROTOCOL_CLIENT_IFACE,
4281 jabber_protocol_client_iface_init)
4282
4283 PURPLE_IMPLEMENT_INTERFACE_STATIC(PURPLE_TYPE_PROTOCOL_SERVER_IFACE,
4284 jabber_protocol_server_iface_init)
4285
4286 PURPLE_IMPLEMENT_INTERFACE_STATIC(PURPLE_TYPE_PROTOCOL_IM_IFACE,
4287 jabber_protocol_im_iface_init)
4288
4289 PURPLE_IMPLEMENT_INTERFACE_STATIC(PURPLE_TYPE_PROTOCOL_CHAT_IFACE,
4290 jabber_protocol_chat_iface_init)
4291
4292 PURPLE_IMPLEMENT_INTERFACE_STATIC(PURPLE_TYPE_PROTOCOL_PRIVACY_IFACE,
4293 jabber_protocol_privacy_iface_init)
4294
4295 PURPLE_IMPLEMENT_INTERFACE_STATIC(PURPLE_TYPE_PROTOCOL_ROOMLIST_IFACE,
4296 jabber_protocol_roomlist_iface_init)
4297
4298 PURPLE_IMPLEMENT_INTERFACE_STATIC(PURPLE_TYPE_PROTOCOL_ATTENTION_IFACE,
4299 jabber_protocol_attention_iface_init)
4300
4301 PURPLE_IMPLEMENT_INTERFACE_STATIC(PURPLE_TYPE_PROTOCOL_MEDIA_IFACE,
4302 jabber_protocol_media_iface_init)
4303
4304 PURPLE_IMPLEMENT_INTERFACE_STATIC(PURPLE_TYPE_PROTOCOL_XFER_IFACE,
4305 jabber_protocol_xfer_iface_init)
4306 );
4307
4308 static PurplePluginInfo *
4309 plugin_query(GError **error)
4310 {
4311 return purple_plugin_info_new(
4312 "id", "prpl-xmpp",
4313 "name", "XMPP Protocols",
4314 "version", DISPLAY_VERSION,
4315 "category", N_("Protocol"),
4316 "summary", N_("XMPP and GTalk Protocols Plugin"),
4317 "description", N_("XMPP and GTalk Protocols Plugin"),
4318 "website", PURPLE_WEBSITE,
4319 "abi-version", PURPLE_ABI_VERSION,
4320 "flags", PURPLE_PLUGIN_INFO_FLAGS_INTERNAL |
4321 PURPLE_PLUGIN_INFO_FLAGS_AUTO_LOAD,
4322 NULL
4323 );
4324 }
4325
4326 static gboolean
4327 plugin_load(PurplePlugin *plugin, GError **error)
4328 {
4329 jingle_session_register_type(plugin);
4330
4331 jingle_transport_register_type(plugin);
4332 jingle_iceudp_register_type(plugin);
4333 jingle_rawudp_register_type(plugin);
4334 jingle_google_p2p_register_type(plugin);
4335
4336 jingle_content_register_type(plugin);
4337 #ifdef USE_VV
4338 jingle_rtp_register_type(plugin);
4339 #endif
4340
4341 jabber_protocol_register_type(plugin);
4342
4343 gtalk_protocol_register_type(plugin);
4344 xmpp_protocol_register_type(plugin);
4345
4346 xmpp_protocol = purple_protocols_add(XMPP_TYPE_PROTOCOL, error);
4347 if (!xmpp_protocol)
4348 return FALSE;
4349
4350 gtalk_protocol = purple_protocols_add(GTALK_TYPE_PROTOCOL, error);
4351 if (!gtalk_protocol)
4352 return FALSE;
4353
4354 purple_signal_connect(purple_get_core(), "uri-handler", xmpp_protocol,
4355 PURPLE_CALLBACK(xmpp_uri_handler), NULL);
4356 purple_signal_connect(purple_get_core(), "uri-handler", gtalk_protocol,
4357 PURPLE_CALLBACK(xmpp_uri_handler), NULL);
4358
4359 jabber_init_protocol(xmpp_protocol);
4360 jabber_init_protocol(gtalk_protocol);
4361
4362 return TRUE;
4363 }
4364
4365 static gboolean
4366 plugin_unload(PurplePlugin *plugin, GError **error)
4367 {
4368 jabber_uninit_protocol(gtalk_protocol);
4369 jabber_uninit_protocol(xmpp_protocol);
4370
4371 if (!purple_protocols_remove(gtalk_protocol, error))
4372 return FALSE;
4373
4374 if (!purple_protocols_remove(xmpp_protocol, error))
4375 return FALSE;
4376
4377 return TRUE;
4378 }
4379
4380 PURPLE_PLUGIN_INIT(jabber, plugin_query, plugin_load, plugin_unload);
Git mirror of Pidgin's Mercurial repository