Mercurial > pidgin.yaz
annotate src/protocols/jabber/jabber.c @ 12508:5cfc53ead482
[gaim-migrate @ 14820]
patch from Simon Wilkinson to add Cyrus SASL support for jabber
Give him credit if it works flawlessly. Blame me if it doesn't, as the
patch was against 1.3.1 (yeah, I've been sitting on it for that long), and
I had to merge it to HEAD, and clean up a bunch of warnings
committer: Tailor Script <tailor@pidgin.im>
author | Nathan Walp <nwalp@pidgin.im> |
---|---|
date | Sat, 17 Dec 2005 02:24:05 +0000 |
parents | 51898e3031e6 |
children | 9d9030dfd689 |
rev | line source |
---|---|
2086 | 1 /* |
7014 | 2 * gaim - Jabber Protocol Plugin |
2086 | 3 * |
7014 | 4 * Copyright (C) 2003, Nathan Walp <faceprint@faceprint.com> |
2086 | 5 * |
6 * This program is free software; you can redistribute it and/or modify | |
7 * it under the terms of the GNU General Public License as published by | |
8 * the Free Software Foundation; either version 2 of the License, or | |
9 * (at your option) any later version. | |
7014 | 10 * |
2086 | 11 * This program is distributed in the hope that it will be useful, |
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 * GNU General Public License for more details. | |
15 * | |
16 * You should have received a copy of the GNU General Public License | |
17 * along with this program; if not, write to the Free Software | |
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
19 * | |
20 */ | |
5872
059d95c67cda
[gaim-migrate @ 6304]
Christian Hammond <chipx86@chipx86.com>
parents:
5685
diff
changeset
|
21 #include "internal.h" |
059d95c67cda
[gaim-migrate @ 6304]
Christian Hammond <chipx86@chipx86.com>
parents:
5685
diff
changeset
|
22 |
7014 | 23 #include "account.h" |
24 #include "accountopt.h" | |
9030 | 25 #include "blist.h" |
9130 | 26 #include "cmds.h" |
10740 | 27 #include "connection.h" |
7014 | 28 #include "debug.h" |
11387 | 29 #include "dnssrv.h" |
7014 | 30 #include "message.h" |
7072 | 31 #include "notify.h" |
8713 | 32 #include "pluginpref.h" |
7014 | 33 #include "prpl.h" |
7072 | 34 #include "request.h" |
7014 | 35 #include "server.h" |
7095
c8bf2da398e3
[gaim-migrate @ 7660]
Christian Hammond <chipx86@chipx86.com>
parents:
7072
diff
changeset
|
36 #include "util.h" |
9943 | 37 #include "version.h" |
5872
059d95c67cda
[gaim-migrate @ 6304]
Christian Hammond <chipx86@chipx86.com>
parents:
5685
diff
changeset
|
38 |
7014 | 39 #include "auth.h" |
40 #include "buddy.h" | |
41 #include "chat.h" | |
8312 | 42 #include "disco.h" |
7014 | 43 #include "iq.h" |
44 #include "jutil.h" | |
45 #include "message.h" | |
46 #include "parser.h" | |
47 #include "presence.h" | |
48 #include "jabber.h" | |
49 #include "roster.h" | |
9466 | 50 #include "si.h" |
7923 | 51 #include "xdata.h" |
5872
059d95c67cda
[gaim-migrate @ 6304]
Christian Hammond <chipx86@chipx86.com>
parents:
5685
diff
changeset
|
52 |
7014 | 53 #define JABBER_CONNECT_STEPS (js->gsc ? 8 : 5) |
2086 | 54 |
5205
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
55 static GaimPlugin *my_protocol = NULL; |
4249 | 56 |
7014 | 57 static void jabber_stream_init(JabberStream *js) |
58 { | |
59 char *open_stream; | |
3340 | 60 |
7014 | 61 open_stream = g_strdup_printf("<stream:stream to='%s' " |
62 "xmlns='jabber:client' " | |
7395 | 63 "xmlns:stream='http://etherx.jabber.org/streams' " |
64 "version='1.0'>", | |
7291 | 65 js->user->domain); |
3311 | 66 |
7642 | 67 jabber_send_raw(js, open_stream, -1); |
2086 | 68 |
7014 | 69 g_free(open_stream); |
2086 | 70 } |
71 | |
7395 | 72 static void |
73 jabber_session_initialized_cb(JabberStream *js, xmlnode *packet, gpointer data) | |
3311 | 74 { |
7014 | 75 const char *type = xmlnode_get_attrib(packet, "type"); |
76 if(type && !strcmp(type, "result")) { | |
77 jabber_stream_set_state(js, JABBER_STREAM_CONNECTED); | |
78 } else { | |
79 gaim_connection_error(js->gc, _("Error initializing session")); | |
3311 | 80 } |
81 } | |
82 | |
7014 | 83 static void jabber_session_init(JabberStream *js) |
3311 | 84 { |
7014 | 85 JabberIq *iq = jabber_iq_new(js, JABBER_IQ_SET); |
86 xmlnode *session; | |
3311 | 87 |
7395 | 88 jabber_iq_set_callback(iq, jabber_session_initialized_cb, NULL); |
3311 | 89 |
7014 | 90 session = xmlnode_new_child(iq->node, "session"); |
91 xmlnode_set_attrib(session, "xmlns", "urn:ietf:params:xml:ns:xmpp-session"); | |
3311 | 92 |
7014 | 93 jabber_iq_send(iq); |
3311 | 94 } |
95 | |
7395 | 96 static void jabber_bind_result_cb(JabberStream *js, xmlnode *packet, |
97 gpointer data) | |
98 { | |
8401 | 99 const char *type = xmlnode_get_attrib(packet, "type"); |
100 xmlnode *bind; | |
101 | |
102 if(type && !strcmp(type, "result") && | |
103 (bind = xmlnode_get_child_with_namespace(packet, "bind", "urn:ietf:params:xml:ns:xmpp-bind"))) { | |
104 xmlnode *jid; | |
105 char *full_jid; | |
106 if((jid = xmlnode_get_child(bind, "jid")) && (full_jid = xmlnode_get_data(jid))) { | |
10289 | 107 JabberBuddy *my_jb = NULL; |
8401 | 108 jabber_id_free(js->user); |
109 if(!(js->user = jabber_id_new(full_jid))) { | |
110 gaim_connection_error(js->gc, _("Invalid response from server.")); | |
111 } | |
10289 | 112 if((my_jb = jabber_buddy_find(js, full_jid, TRUE))) |
113 my_jb->subscription |= JABBER_SUB_BOTH; | |
10504 | 114 g_free(full_jid); |
8401 | 115 } |
116 } else { | |
117 char *msg = jabber_parse_error(js, packet); | |
118 gaim_connection_error(js->gc, msg); | |
119 g_free(msg); | |
120 } | |
7395 | 121 |
122 jabber_session_init(js); | |
123 } | |
124 | |
125 static void jabber_stream_features_parse(JabberStream *js, xmlnode *packet) | |
126 { | |
8296 | 127 if(xmlnode_get_child(packet, "starttls")) { |
128 if(jabber_process_starttls(js, packet)) | |
129 return; | |
130 } | |
131 | |
10988 | 132 if(js->registration) { |
133 jabber_register_start(js); | |
134 } else if(xmlnode_get_child(packet, "mechanisms")) { | |
7395 | 135 jabber_auth_start(js, packet); |
136 } else if(xmlnode_get_child(packet, "bind")) { | |
137 xmlnode *bind, *resource; | |
138 JabberIq *iq = jabber_iq_new(js, JABBER_IQ_SET); | |
139 bind = xmlnode_new_child(iq->node, "bind"); | |
140 xmlnode_set_attrib(bind, "xmlns", "urn:ietf:params:xml:ns:xmpp-bind"); | |
141 resource = xmlnode_new_child(bind, "resource"); | |
142 xmlnode_insert_data(resource, js->user->resource, -1); | |
143 | |
144 jabber_iq_set_callback(iq, jabber_bind_result_cb, NULL); | |
145 | |
146 jabber_iq_send(iq); | |
8296 | 147 } else /* if(xmlnode_get_child_with_namespace(packet, "auth")) */ { |
148 /* If we get an empty stream:features packet, or we explicitly get | |
149 * an auth feature with namespace http://jabber.org/features/iq-auth | |
150 * we should revert back to iq:auth authentication, even though we're | |
151 * connecting to an XMPP server. */ | |
152 js->auth_type = JABBER_AUTH_IQ_AUTH; | |
153 jabber_stream_set_state(js, JABBER_STREAM_AUTHENTICATING); | |
7395 | 154 } |
155 } | |
156 | |
7014 | 157 static void jabber_stream_handle_error(JabberStream *js, xmlnode *packet) |
3311 | 158 { |
8401 | 159 char *msg = jabber_parse_error(js, packet); |
3311 | 160 |
8401 | 161 gaim_connection_error(js->gc, msg); |
162 g_free(msg); | |
2086 | 163 } |
164 | |
7014 | 165 static void tls_init(JabberStream *js); |
2086 | 166 |
7014 | 167 void jabber_process_packet(JabberStream *js, xmlnode *packet) |
2086 | 168 { |
7014 | 169 if(!strcmp(packet->name, "iq")) { |
7395 | 170 jabber_iq_parse(js, packet); |
7014 | 171 } else if(!strcmp(packet->name, "presence")) { |
172 jabber_presence_parse(js, packet); | |
173 } else if(!strcmp(packet->name, "message")) { | |
174 jabber_message_parse(js, packet); | |
175 } else if(!strcmp(packet->name, "stream:features")) { | |
7395 | 176 jabber_stream_features_parse(js, packet); |
7014 | 177 } else if(!strcmp(packet->name, "stream:error")) { |
178 jabber_stream_handle_error(js, packet); | |
179 } else if(!strcmp(packet->name, "challenge")) { | |
180 if(js->state == JABBER_STREAM_AUTHENTICATING) | |
181 jabber_auth_handle_challenge(js, packet); | |
182 } else if(!strcmp(packet->name, "success")) { | |
183 if(js->state == JABBER_STREAM_AUTHENTICATING) | |
184 jabber_auth_handle_success(js, packet); | |
185 } else if(!strcmp(packet->name, "failure")) { | |
186 if(js->state == JABBER_STREAM_AUTHENTICATING) | |
187 jabber_auth_handle_failure(js, packet); | |
188 } else if(!strcmp(packet->name, "proceed")) { | |
189 if(js->state == JABBER_STREAM_AUTHENTICATING && !js->gsc) | |
190 tls_init(js); | |
191 } else { | |
192 gaim_debug(GAIM_DEBUG_WARNING, "jabber", "Unknown packet: %s\n", | |
193 packet->name); | |
2086 | 194 } |
195 } | |
196 | |
7642 | 197 void jabber_send_raw(JabberStream *js, const char *data, int len) |
2086 | 198 { |
7014 | 199 int ret; |
2086 | 200 |
7014 | 201 /* because printing a tab to debug every minute gets old */ |
202 if(strcmp(data, "\t")) | |
8401 | 203 gaim_debug(GAIM_DEBUG_MISC, "jabber", "Sending%s: %s\n", |
7014 | 204 js->gsc ? " (ssl)" : "", data); |
2086 | 205 |
12508 | 206 /* If we've got a security layer, we need to encode the data, |
207 * splitting it on the maximum buffer length negotiated */ | |
208 | |
209 #ifdef HAVE_CYRUS_SASL | |
210 if (js->sasl_maxbuf>0) { | |
211 int pos; | |
212 | |
213 if (!js->gsc && js->fd<0) | |
214 return; | |
215 pos = 0; | |
216 if (len == -1) | |
217 len = strlen(data); | |
218 while (pos < len) { | |
219 int towrite; | |
220 const char *out; | |
221 unsigned olen; | |
222 | |
223 if ((len - pos) < js->sasl_maxbuf) | |
224 towrite = len - pos; | |
225 else | |
226 towrite = js->sasl_maxbuf; | |
227 | |
228 sasl_encode(js->sasl, &data[pos], towrite, &out, &olen); | |
229 pos += towrite; | |
230 | |
231 if (js->gsc) | |
232 ret = gaim_ssl_write(js->gsc, out, olen); | |
233 else | |
234 ret = write(js->fd, out, olen); | |
235 if (ret < 0) | |
236 gaim_connection_error(js->gc, _("Write error")); | |
237 } | |
238 return; | |
239 } | |
240 #endif | |
241 | |
7014 | 242 if(js->gsc) { |
7642 | 243 ret = gaim_ssl_write(js->gsc, data, len == -1 ? strlen(data) : len); |
7014 | 244 } else { |
8013 | 245 if(js->fd < 0) |
246 return; | |
7642 | 247 ret = write(js->fd, data, len == -1 ? strlen(data) : len); |
2814
f4f9e5a01890
[gaim-migrate @ 2827]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2800
diff
changeset
|
248 } |
f4f9e5a01890
[gaim-migrate @ 2827]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2800
diff
changeset
|
249 |
7014 | 250 if(ret < 0) |
251 gaim_connection_error(js->gc, _("Write error")); | |
252 | |
2814
f4f9e5a01890
[gaim-migrate @ 2827]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2800
diff
changeset
|
253 } |
f4f9e5a01890
[gaim-migrate @ 2827]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2800
diff
changeset
|
254 |
7014 | 255 void jabber_send(JabberStream *js, xmlnode *packet) |
2086 | 256 { |
7014 | 257 char *txt; |
7642 | 258 int len; |
2086 | 259 |
7642 | 260 txt = xmlnode_to_str(packet, &len); |
261 jabber_send_raw(js, txt, len); | |
7014 | 262 g_free(txt); |
2086 | 263 } |
264 | |
7014 | 265 static void jabber_keepalive(GaimConnection *gc) |
2086 | 266 { |
7642 | 267 jabber_send_raw(gc->proto_data, "\t", -1); |
2086 | 268 } |
269 | |
7014 | 270 static void |
271 jabber_recv_cb_ssl(gpointer data, GaimSslConnection *gsc, | |
6764 | 272 GaimInputCondition cond) |
273 { | |
7014 | 274 GaimConnection *gc = data; |
275 JabberStream *js = gc->proto_data; | |
6764 | 276 int len; |
7014 | 277 static char buf[4096]; |
6768 | 278 |
7014 | 279 if(!g_list_find(gaim_connections_get_all(), gc)) { |
6768 | 280 gaim_ssl_close(gsc); |
281 return; | |
282 } | |
283 | |
7014 | 284 if((len = gaim_ssl_read(gsc, buf, sizeof(buf) - 1)) > 0) { |
6764 | 285 buf[len] = '\0'; |
7014 | 286 gaim_debug(GAIM_DEBUG_INFO, "jabber", "Recv (ssl)(%d): %s\n", len, buf); |
287 jabber_parser_process(js, buf, len); | |
7177 | 288 } else { |
289 gaim_connection_error(gc, _("Read Error")); | |
2086 | 290 } |
291 } | |
292 | |
7014 | 293 static void |
294 jabber_recv_cb(gpointer data, gint source, GaimInputCondition condition) | |
2086 | 295 { |
5572 | 296 GaimConnection *gc = data; |
7014 | 297 JabberStream *js = gc->proto_data; |
298 int len; | |
299 static char buf[4096]; | |
2086 | 300 |
7014 | 301 if(!g_list_find(gaim_connections_get_all(), gc)) |
302 return; | |
2956 | 303 |
7014 | 304 if((len = read(js->fd, buf, sizeof(buf) - 1)) > 0) { |
12508 | 305 #ifdef HAVE_CYRUS_SASL |
306 if (js->sasl_maxbuf>0) { | |
307 const char *out; | |
308 int olen; | |
309 sasl_decode(js->sasl, buf, len, &out, &olen); | |
310 if (olen>0) { | |
311 gaim_debug(GAIM_DEBUG_INFO, "jabber", "RecvSASL (%d): %s\n", olen, out); | |
312 jabber_parser_process(js,out,olen); | |
313 } | |
314 return; | |
315 } | |
316 #endif | |
7014 | 317 buf[len] = '\0'; |
318 gaim_debug(GAIM_DEBUG_INFO, "jabber", "Recv (%d): %s\n", len, buf); | |
319 jabber_parser_process(js, buf, len); | |
7177 | 320 } else { |
321 gaim_connection_error(gc, _("Read Error")); | |
7014 | 322 } |
2086 | 323 } |
324 | |
7014 | 325 static void |
326 jabber_login_callback_ssl(gpointer data, GaimSslConnection *gsc, | |
6764 | 327 GaimInputCondition cond) |
328 { | |
329 GaimConnection *gc = data; | |
7014 | 330 JabberStream *js = gc->proto_data; |
6764 | 331 |
7014 | 332 if(!g_list_find(gaim_connections_get_all(), gc)) { |
6764 | 333 gaim_ssl_close(gsc); |
334 return; | |
335 } | |
336 | |
7014 | 337 js->gsc = gsc; |
6764 | 338 |
7014 | 339 if(js->state == JABBER_STREAM_CONNECTING) |
7642 | 340 jabber_send_raw(js, "<?xml version='1.0' ?>", -1); |
6764 | 341 |
7014 | 342 jabber_stream_set_state(js, JABBER_STREAM_INITIALIZING); |
343 gaim_ssl_input_add(gsc, jabber_recv_cb_ssl, gc); | |
6764 | 344 } |
345 | |
7014 | 346 |
347 static void | |
348 jabber_login_callback(gpointer data, gint source, GaimInputCondition cond) | |
6764 | 349 { |
5572 | 350 GaimConnection *gc = data; |
7014 | 351 JabberStream *js = gc->proto_data; |
2086 | 352 |
8783 | 353 if (source < 0) { |
354 gaim_connection_error(gc, _("Couldn't connect to host")); | |
355 return; | |
356 } | |
357 | |
7014 | 358 if(!g_list_find(gaim_connections_get_all(), gc)) { |
2086 | 359 close(source); |
360 return; | |
361 } | |
362 | |
7014 | 363 js->fd = source; |
2956 | 364 |
7014 | 365 if(js->state == JABBER_STREAM_CONNECTING) |
7642 | 366 jabber_send_raw(js, "<?xml version='1.0' ?>", -1); |
2300
d2686f757d6e
[gaim-migrate @ 2310]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2289
diff
changeset
|
367 |
7014 | 368 jabber_stream_set_state(js, JABBER_STREAM_INITIALIZING); |
369 gc->inpa = gaim_input_add(js->fd, GAIM_INPUT_READ, jabber_recv_cb, gc); | |
370 } | |
2086 | 371 |
7014 | 372 static void |
7426 | 373 jabber_ssl_connect_failure(GaimSslConnection *gsc, GaimSslErrorType error, |
374 gpointer data) | |
375 { | |
376 GaimConnection *gc = data; | |
8360 | 377 JabberStream *js = gc->proto_data; |
7426 | 378 |
379 switch(error) { | |
8362 | 380 case GAIM_SSL_CONNECT_FAILED: |
381 gaim_connection_error(gc, _("Connection Failed")); | |
382 break; | |
7426 | 383 case GAIM_SSL_HANDSHAKE_FAILED: |
384 gaim_connection_error(gc, _("SSL Handshake Failed")); | |
385 break; | |
386 } | |
8360 | 387 |
388 js->gsc = NULL; | |
7426 | 389 } |
390 | |
7427 | 391 static void tls_init(JabberStream *js) |
392 { | |
393 gaim_input_remove(js->gc->inpa); | |
394 js->gc->inpa = 0; | |
395 js->gsc = gaim_ssl_connect_fd(js->gc->account, js->fd, | |
396 jabber_login_callback_ssl, jabber_ssl_connect_failure, js->gc); | |
397 } | |
398 | |
11387 | 399 static void jabber_login_connect(JabberStream *js, const char *server, int port) |
400 { | |
401 int rc; | |
402 | |
403 rc = gaim_proxy_connect(js->gc->account, server, | |
404 port, jabber_login_callback, js->gc); | |
405 | |
406 if (rc != 0) | |
407 gaim_connection_error(js->gc, _("Unable to create socket")); | |
408 } | |
409 | |
410 static void srv_resolved_cb(struct srv_response *resp, int results, gpointer data) | |
411 { | |
412 JabberStream *js = (JabberStream*)data; | |
413 int config_port = gaim_account_get_int(js->gc->account, "port", 0); | |
414 | |
415 if(results) { | |
416 jabber_login_connect(js, resp->hostname, config_port ? config_port : resp->port); | |
417 g_free(resp); | |
418 } else { | |
419 jabber_login_connect(js, js->user->domain, config_port); | |
420 } | |
421 } | |
422 | |
423 | |
7427 | 424 |
7426 | 425 static void |
11837 | 426 jabber_login(GaimAccount *account) |
2086 | 427 { |
7014 | 428 GaimConnection *gc = gaim_account_get_connection(account); |
429 const char *connect_server = gaim_account_get_string(account, | |
430 "connect_server", ""); | |
431 JabberStream *js; | |
10289 | 432 JabberBuddy *my_jb = NULL; |
2086 | 433 |
7014 | 434 gc->flags |= GAIM_CONNECTION_HTML; |
435 js = gc->proto_data = g_new0(JabberStream, 1); | |
436 js->gc = gc; | |
8013 | 437 js->fd = -1; |
8312 | 438 js->iq_callbacks = g_hash_table_new_full(g_str_hash, g_str_equal, |
439 g_free, g_free); | |
440 js->disco_callbacks = g_hash_table_new_full(g_str_hash, g_str_equal, | |
7395 | 441 g_free, g_free); |
7014 | 442 js->buddies = g_hash_table_new_full(g_str_hash, g_str_equal, |
7116 | 443 g_free, (GDestroyNotify)jabber_buddy_free); |
7014 | 444 js->chats = g_hash_table_new_full(g_str_hash, g_str_equal, |
8396 | 445 g_free, (GDestroyNotify)jabber_chat_free); |
8043 | 446 js->chat_servers = g_list_append(NULL, g_strdup("conference.jabber.org")); |
7014 | 447 js->user = jabber_id_new(gaim_account_get_username(account)); |
7322 | 448 js->next_id = g_random_int(); |
5613 | 449 |
7310 | 450 if(!js->user) { |
451 gaim_connection_error(gc, _("Invalid Jabber ID")); | |
452 return; | |
453 } | |
454 | |
7147 | 455 if(!js->user->resource) { |
456 char *me; | |
11939
85c25a32bb48
[gaim-migrate @ 14230]
Etan Reisner <pidgin@unreliablesource.net>
parents:
11837
diff
changeset
|
457 js->user->resource = g_strdup("Home"); |
7147 | 458 if(!js->user->node) { |
459 js->user->node = js->user->domain; | |
460 js->user->domain = g_strdup("jabber.org"); | |
461 } | |
462 me = g_strdup_printf("%s@%s/%s", js->user->node, js->user->domain, | |
463 js->user->resource); | |
464 gaim_account_set_username(account, me); | |
465 g_free(me); | |
7145 | 466 } |
467 | |
10289 | 468 if((my_jb = jabber_buddy_find(js, gaim_account_get_username(account), TRUE))) |
469 my_jb->subscription |= JABBER_SUB_BOTH; | |
470 | |
7014 | 471 jabber_stream_set_state(js, JABBER_STREAM_CONNECTING); |
2956 | 472 |
11387 | 473 /* if they've got old-ssl mode going, we probably want to ignore SRV lookups */ |
474 if(gaim_account_get_bool(js->gc->account, "old_ssl", FALSE)) { | |
7630 | 475 if(gaim_ssl_is_supported()) { |
11387 | 476 js->gsc = gaim_ssl_connect(js->gc->account, |
477 connect_server[0] ? connect_server : js->user->domain, | |
478 gaim_account_get_int(account, "port", 5223), jabber_login_callback_ssl, | |
479 jabber_ssl_connect_failure, js->gc); | |
7630 | 480 } else { |
11387 | 481 gaim_connection_error(js->gc, _("SSL support unavailable")); |
7630 | 482 } |
3311 | 483 } |
3770 | 484 |
11387 | 485 /* no old-ssl, so if they've specified a connect server, we'll use that, otherwise we'll |
486 * invoke the magic of SRV lookups, to figure out host and port */ | |
7014 | 487 if(!js->gsc) { |
11387 | 488 if(connect_server[0]) { |
489 jabber_login_connect(js, connect_server, gaim_account_get_int(account, "port", 5222)); | |
490 } else { | |
491 gaim_srv_resolve("xmpp-client", "tcp", js->user->domain, srv_resolved_cb, js); | |
492 } | |
2956 | 493 } |
2086 | 494 } |
495 | |
11387 | 496 |
7072 | 497 static gboolean |
498 conn_close_cb(gpointer data) | |
499 { | |
500 JabberStream *js = data; | |
10740 | 501 GaimAccount *account = gaim_connection_get_account(js->gc); |
502 | |
503 gaim_account_disconnect(account); | |
504 | |
7072 | 505 return FALSE; |
506 } | |
507 | |
508 static void | |
509 jabber_connection_schedule_close(JabberStream *js) | |
510 { | |
8273
f24172f53650
[gaim-migrate @ 8997]
Christian Hammond <chipx86@chipx86.com>
parents:
8194
diff
changeset
|
511 gaim_timeout_add(0, conn_close_cb, js); |
7072 | 512 } |
513 | |
514 static void | |
7395 | 515 jabber_registration_result_cb(JabberStream *js, xmlnode *packet, gpointer data) |
7072 | 516 { |
517 const char *type = xmlnode_get_attrib(packet, "type"); | |
518 char *buf; | |
519 | |
520 if(!strcmp(type, "result")) { | |
521 buf = g_strdup_printf(_("Registration of %s@%s successful"), | |
522 js->user->node, js->user->domain); | |
523 gaim_notify_info(NULL, _("Registration Successful"), | |
524 _("Registration Successful"), buf); | |
525 g_free(buf); | |
526 } else { | |
8401 | 527 char *msg = jabber_parse_error(js, packet); |
7072 | 528 |
8401 | 529 if(!msg) |
530 msg = g_strdup(_("Unknown Error")); | |
7072 | 531 |
532 gaim_notify_error(NULL, _("Registration Failed"), | |
8401 | 533 _("Registration Failed"), msg); |
534 g_free(msg); | |
7072 | 535 } |
536 jabber_connection_schedule_close(js); | |
537 } | |
538 | |
539 static void | |
540 jabber_register_cb(JabberStream *js, GaimRequestFields *fields) | |
541 { | |
542 GList *groups, *flds; | |
543 xmlnode *query, *y; | |
544 JabberIq *iq; | |
7264 | 545 char *username; |
7072 | 546 |
547 iq = jabber_iq_new_query(js, JABBER_IQ_SET, "jabber:iq:register"); | |
548 query = xmlnode_get_child(iq->node, "query"); | |
549 | |
550 for(groups = gaim_request_fields_get_groups(fields); groups; | |
551 groups = groups->next) { | |
552 for(flds = gaim_request_field_group_get_fields(groups->data); | |
553 flds; flds = flds->next) { | |
554 GaimRequestField *field = flds->data; | |
555 const char *id = gaim_request_field_get_id(field); | |
556 const char *value = gaim_request_field_string_get_value(field); | |
557 | |
558 if(!strcmp(id, "username")) { | |
559 y = xmlnode_new_child(query, "username"); | |
560 } else if(!strcmp(id, "password")) { | |
561 y = xmlnode_new_child(query, "password"); | |
562 } else if(!strcmp(id, "name")) { | |
563 y = xmlnode_new_child(query, "name"); | |
564 } else if(!strcmp(id, "email")) { | |
565 y = xmlnode_new_child(query, "email"); | |
566 } else if(!strcmp(id, "nick")) { | |
567 y = xmlnode_new_child(query, "nick"); | |
568 } else if(!strcmp(id, "first")) { | |
569 y = xmlnode_new_child(query, "first"); | |
570 } else if(!strcmp(id, "last")) { | |
571 y = xmlnode_new_child(query, "last"); | |
572 } else if(!strcmp(id, "address")) { | |
573 y = xmlnode_new_child(query, "address"); | |
574 } else if(!strcmp(id, "city")) { | |
575 y = xmlnode_new_child(query, "city"); | |
576 } else if(!strcmp(id, "state")) { | |
577 y = xmlnode_new_child(query, "state"); | |
578 } else if(!strcmp(id, "zip")) { | |
579 y = xmlnode_new_child(query, "zip"); | |
580 } else if(!strcmp(id, "phone")) { | |
581 y = xmlnode_new_child(query, "phone"); | |
582 } else if(!strcmp(id, "url")) { | |
583 y = xmlnode_new_child(query, "url"); | |
584 } else if(!strcmp(id, "date")) { | |
585 y = xmlnode_new_child(query, "date"); | |
586 } else { | |
587 continue; | |
588 } | |
589 xmlnode_insert_data(y, value, -1); | |
7264 | 590 if(!strcmp(id, "username")) { |
591 if(js->user->node) | |
592 g_free(js->user->node); | |
593 js->user->node = g_strdup(value); | |
594 } | |
7072 | 595 } |
596 } | |
597 | |
7264 | 598 username = g_strdup_printf("%s@%s/%s", js->user->node, js->user->domain, |
599 js->user->resource); | |
600 gaim_account_set_username(js->gc->account, username); | |
601 g_free(username); | |
602 | |
7395 | 603 jabber_iq_set_callback(iq, jabber_registration_result_cb, NULL); |
7072 | 604 |
605 jabber_iq_send(iq); | |
606 | |
607 } | |
608 | |
609 static void | |
610 jabber_register_cancel_cb(JabberStream *js, GaimRequestFields *fields) | |
611 { | |
612 jabber_connection_schedule_close(js); | |
613 } | |
614 | |
7923 | 615 static void jabber_register_x_data_cb(JabberStream *js, xmlnode *result, gpointer data) |
616 { | |
617 xmlnode *query; | |
618 JabberIq *iq; | |
619 | |
620 iq = jabber_iq_new_query(js, JABBER_IQ_SET, "jabber:iq:register"); | |
621 query = xmlnode_get_child(iq->node, "query"); | |
622 | |
623 xmlnode_insert_child(query, result); | |
624 | |
625 jabber_iq_set_callback(iq, jabber_registration_result_cb, NULL); | |
626 jabber_iq_send(iq); | |
627 } | |
628 | |
7072 | 629 void jabber_register_parse(JabberStream *js, xmlnode *packet) |
630 { | |
631 if(js->registration) { | |
632 GaimRequestFields *fields; | |
633 GaimRequestFieldGroup *group; | |
634 GaimRequestField *field; | |
7923 | 635 xmlnode *query, *x, *y; |
7072 | 636 char *instructions; |
637 | |
638 /* get rid of the login thingy */ | |
639 gaim_connection_set_state(js->gc, GAIM_CONNECTED); | |
640 | |
641 query = xmlnode_get_child(packet, "query"); | |
642 | |
643 if(xmlnode_get_child(query, "registered")) { | |
644 gaim_notify_error(NULL, _("Already Registered"), | |
645 _("Already Registered"), NULL); | |
646 jabber_connection_schedule_close(js); | |
647 return; | |
648 } | |
649 | |
8398 | 650 if((x = xmlnode_get_child_with_namespace(packet, "x", |
651 "jabber:x:data"))) { | |
652 jabber_x_data_request(js, x, jabber_register_x_data_cb, NULL); | |
653 return; | |
654 } else if((x = xmlnode_get_child_with_namespace(packet, "x", | |
655 "jabber:x:oob"))) { | |
656 xmlnode *url; | |
7923 | 657 |
8398 | 658 if((url = xmlnode_get_child(x, "url"))) { |
659 char *href; | |
660 if((href = xmlnode_get_data(url))) { | |
10240
95ca0db2d01d
[gaim-migrate @ 11377]
Herman Bloggs <hermanator12002@yahoo.com>
parents:
10216
diff
changeset
|
661 gaim_notify_uri(NULL, href); |
8398 | 662 g_free(href); |
663 js->gc->wants_to_die = TRUE; | |
664 jabber_connection_schedule_close(js); | |
665 return; | |
666 } | |
7923 | 667 } |
668 } | |
669 | |
670 /* as a last resort, use the old jabber:iq:register syntax */ | |
671 | |
7072 | 672 fields = gaim_request_fields_new(); |
673 group = gaim_request_field_group_new(NULL); | |
674 gaim_request_fields_add_group(fields, group); | |
675 | |
676 field = gaim_request_field_string_new("username", _("Username"), | |
677 js->user->node, FALSE); | |
678 gaim_request_field_group_add_field(group, field); | |
679 | |
680 field = gaim_request_field_string_new("password", _("Password"), | |
10740 | 681 gaim_connection_get_password(js->gc), FALSE); |
7072 | 682 gaim_request_field_string_set_masked(field, TRUE); |
683 gaim_request_field_group_add_field(group, field); | |
684 | |
685 if(xmlnode_get_child(query, "name")) { | |
686 field = gaim_request_field_string_new("name", _("Name"), | |
687 gaim_account_get_alias(js->gc->account), FALSE); | |
688 gaim_request_field_group_add_field(group, field); | |
689 } | |
690 if(xmlnode_get_child(query, "email")) { | |
691 field = gaim_request_field_string_new("email", _("E-Mail"), | |
692 NULL, FALSE); | |
693 gaim_request_field_group_add_field(group, field); | |
694 } | |
695 if(xmlnode_get_child(query, "nick")) { | |
696 field = gaim_request_field_string_new("nick", _("Nickname"), | |
697 NULL, FALSE); | |
698 gaim_request_field_group_add_field(group, field); | |
699 } | |
700 if(xmlnode_get_child(query, "first")) { | |
701 field = gaim_request_field_string_new("first", _("First Name"), | |
702 NULL, FALSE); | |
703 gaim_request_field_group_add_field(group, field); | |
704 } | |
705 if(xmlnode_get_child(query, "last")) { | |
706 field = gaim_request_field_string_new("last", _("Last Name"), | |
707 NULL, FALSE); | |
708 gaim_request_field_group_add_field(group, field); | |
709 } | |
710 if(xmlnode_get_child(query, "address")) { | |
711 field = gaim_request_field_string_new("address", _("Address"), | |
712 NULL, FALSE); | |
713 gaim_request_field_group_add_field(group, field); | |
714 } | |
715 if(xmlnode_get_child(query, "city")) { | |
716 field = gaim_request_field_string_new("city", _("City"), | |
717 NULL, FALSE); | |
718 gaim_request_field_group_add_field(group, field); | |
719 } | |
720 if(xmlnode_get_child(query, "state")) { | |
721 field = gaim_request_field_string_new("state", _("State"), | |
722 NULL, FALSE); | |
723 gaim_request_field_group_add_field(group, field); | |
724 } | |
725 if(xmlnode_get_child(query, "zip")) { | |
726 field = gaim_request_field_string_new("zip", _("Postal Code"), | |
727 NULL, FALSE); | |
728 gaim_request_field_group_add_field(group, field); | |
729 } | |
730 if(xmlnode_get_child(query, "phone")) { | |
731 field = gaim_request_field_string_new("phone", _("Phone"), | |
732 NULL, FALSE); | |
733 gaim_request_field_group_add_field(group, field); | |
734 } | |
735 if(xmlnode_get_child(query, "url")) { | |
736 field = gaim_request_field_string_new("url", _("URL"), | |
737 NULL, FALSE); | |
738 gaim_request_field_group_add_field(group, field); | |
739 } | |
740 if(xmlnode_get_child(query, "date")) { | |
741 field = gaim_request_field_string_new("date", _("Date"), | |
742 NULL, FALSE); | |
743 gaim_request_field_group_add_field(group, field); | |
744 } | |
745 | |
746 if((y = xmlnode_get_child(query, "instructions"))) | |
747 instructions = xmlnode_get_data(y); | |
748 else | |
749 instructions = g_strdup(_("Please fill out the information below " | |
750 "to register your new account.")); | |
751 | |
752 gaim_request_fields(js->gc, _("Register New Jabber Account"), | |
753 _("Register New Jabber Account"), instructions, fields, | |
754 _("Register"), G_CALLBACK(jabber_register_cb), | |
755 _("Cancel"), G_CALLBACK(jabber_register_cancel_cb), js); | |
756 } | |
757 } | |
758 | |
8016 | 759 void jabber_register_start(JabberStream *js) |
7072 | 760 { |
761 JabberIq *iq; | |
762 | |
763 iq = jabber_iq_new_query(js, JABBER_IQ_GET, "jabber:iq:register"); | |
764 jabber_iq_send(iq); | |
765 } | |
766 | |
767 static void jabber_register_account(GaimAccount *account) | |
768 { | |
769 GaimConnection *gc = gaim_account_get_connection(account); | |
770 JabberStream *js; | |
10289 | 771 JabberBuddy *my_jb = NULL; |
7072 | 772 const char *connect_server = gaim_account_get_string(account, |
773 "connect_server", ""); | |
774 const char *server; | |
775 int rc; | |
776 | |
777 js = gc->proto_data = g_new0(JabberStream, 1); | |
778 js->gc = gc; | |
779 js->registration = TRUE; | |
8312 | 780 js->iq_callbacks = g_hash_table_new_full(g_str_hash, g_str_equal, |
781 g_free, g_free); | |
782 js->disco_callbacks = g_hash_table_new_full(g_str_hash, g_str_equal, | |
7395 | 783 g_free, g_free); |
7072 | 784 js->user = jabber_id_new(gaim_account_get_username(account)); |
7322 | 785 js->next_id = g_random_int(); |
7072 | 786 |
7310 | 787 if(!js->user) { |
788 gaim_connection_error(gc, _("Invalid Jabber ID")); | |
789 return; | |
790 } | |
791 | |
7147 | 792 if(!js->user->resource) { |
793 char *me; | |
11939
85c25a32bb48
[gaim-migrate @ 14230]
Etan Reisner <pidgin@unreliablesource.net>
parents:
11837
diff
changeset
|
794 js->user->resource = g_strdup("Home"); |
7147 | 795 if(!js->user->node) { |
796 js->user->node = js->user->domain; | |
797 js->user->domain = g_strdup("jabber.org"); | |
798 } | |
799 me = g_strdup_printf("%s@%s/%s", js->user->node, js->user->domain, | |
800 js->user->resource); | |
801 gaim_account_set_username(account, me); | |
802 g_free(me); | |
803 } | |
804 | |
10289 | 805 if((my_jb = jabber_buddy_find(js, gaim_account_get_username(account), TRUE))) |
806 my_jb->subscription |= JABBER_SUB_BOTH; | |
807 | |
7072 | 808 server = connect_server[0] ? connect_server : js->user->domain; |
809 | |
810 jabber_stream_set_state(js, JABBER_STREAM_CONNECTING); | |
811 | |
7630 | 812 if(gaim_account_get_bool(account, "old_ssl", FALSE)) { |
813 if(gaim_ssl_is_supported()) { | |
814 js->gsc = gaim_ssl_connect(account, server, | |
815 gaim_account_get_int(account, "port", 5222), | |
816 jabber_login_callback_ssl, jabber_ssl_connect_failure, gc); | |
817 } else { | |
818 gaim_connection_error(gc, _("SSL support unavailable")); | |
819 } | |
7072 | 820 } |
821 | |
822 if(!js->gsc) { | |
823 rc = gaim_proxy_connect(account, server, | |
824 gaim_account_get_int(account, "port", 5222), | |
825 jabber_login_callback, gc); | |
826 | |
827 if (rc != 0) | |
828 gaim_connection_error(gc, _("Unable to create socket")); | |
829 } | |
830 } | |
831 | |
5572 | 832 static void jabber_close(GaimConnection *gc) |
2086 | 833 { |
7014 | 834 JabberStream *js = gc->proto_data; |
2956 | 835 |
7642 | 836 jabber_send_raw(js, "</stream:stream>", -1); |
3311 | 837 |
7014 | 838 if(js->gsc) { |
839 gaim_ssl_close(js->gsc); | |
8360 | 840 } else if (js->fd > 0) { |
7072 | 841 if(js->gc->inpa) |
842 gaim_input_remove(js->gc->inpa); | |
7014 | 843 close(js->fd); |
844 } | |
3311 | 845 |
7587 | 846 if(js->context) |
847 g_markup_parse_context_free(js->context); | |
8312 | 848 if(js->iq_callbacks) |
849 g_hash_table_destroy(js->iq_callbacks); | |
850 if(js->disco_callbacks) | |
851 g_hash_table_destroy(js->disco_callbacks); | |
7072 | 852 if(js->buddies) |
853 g_hash_table_destroy(js->buddies); | |
854 if(js->chats) | |
855 g_hash_table_destroy(js->chats); | |
8043 | 856 while(js->chat_servers) { |
857 g_free(js->chat_servers->data); | |
858 js->chat_servers = g_list_delete_link(js->chat_servers, js->chat_servers); | |
859 } | |
11675 | 860 while(js->user_directories) { |
861 g_free(js->user_directories->data); | |
862 js->user_directories = g_list_delete_link(js->user_directories, js->user_directories); | |
863 } | |
7014 | 864 if(js->stream_id) |
865 g_free(js->stream_id); | |
7587 | 866 if(js->user) |
867 jabber_id_free(js->user); | |
10189 | 868 if(js->avatar_hash) |
869 g_free(js->avatar_hash); | |
12508 | 870 #ifdef HAVE_CYRUS_SASL |
871 if(js->sasl) | |
872 sasl_dispose(&js->sasl); | |
873 if(js->sasl_mechs) | |
874 g_string_free(js->sasl_mechs, TRUE); | |
875 if(js->sasl_cb) | |
876 g_free(js->sasl_cb); | |
877 #endif | |
7014 | 878 g_free(js); |
11389 | 879 |
880 gc->proto_data = NULL; | |
5093 | 881 } |
882 | |
7014 | 883 void jabber_stream_set_state(JabberStream *js, JabberStreamState state) |
3105 | 884 { |
9954 | 885 GaimPresence *gpresence; |
886 GaimStatus *status; | |
887 | |
7014 | 888 js->state = state; |
889 switch(state) { | |
890 case JABBER_STREAM_OFFLINE: | |
891 break; | |
892 case JABBER_STREAM_CONNECTING: | |
893 gaim_connection_update_progress(js->gc, _("Connecting"), 1, | |
894 JABBER_CONNECT_STEPS); | |
895 break; | |
896 case JABBER_STREAM_INITIALIZING: | |
897 gaim_connection_update_progress(js->gc, _("Initializing Stream"), | |
898 js->gsc ? 5 : 2, JABBER_CONNECT_STEPS); | |
899 jabber_stream_init(js); | |
900 jabber_parser_setup(js); | |
901 break; | |
902 case JABBER_STREAM_AUTHENTICATING: | |
903 gaim_connection_update_progress(js->gc, _("Authenticating"), | |
904 js->gsc ? 6 : 3, JABBER_CONNECT_STEPS); | |
8296 | 905 if(js->protocol_version == JABBER_PROTO_0_9 && js->registration) { |
906 jabber_register_start(js); | |
907 } else if(js->auth_type == JABBER_AUTH_IQ_AUTH) { | |
908 jabber_auth_start_old(js); | |
8016 | 909 } |
7014 | 910 break; |
911 case JABBER_STREAM_REINITIALIZING: | |
912 gaim_connection_update_progress(js->gc, _("Re-initializing Stream"), | |
913 6, JABBER_CONNECT_STEPS); | |
914 jabber_stream_init(js); | |
915 break; | |
916 case JABBER_STREAM_CONNECTED: | |
917 jabber_roster_request(js); | |
9954 | 918 gpresence = gaim_account_get_presence(js->gc->account); |
919 status = gaim_presence_get_active_status(gpresence); | |
10216 | 920 jabber_presence_send(js->gc->account, status); |
10941 | 921 gaim_connection_set_state(js->gc, GAIM_CONNECTED); |
8312 | 922 jabber_disco_items_server(js); |
7014 | 923 break; |
3105 | 924 } |
925 } | |
926 | |
7014 | 927 char *jabber_get_next_id(JabberStream *js) |
2086 | 928 { |
7322 | 929 return g_strdup_printf("gaim%x", js->next_id++); |
2086 | 930 } |
931 | |
7923 | 932 |
933 static void jabber_idle_set(GaimConnection *gc, int idle) | |
3340 | 934 { |
7014 | 935 JabberStream *js = gc->proto_data; |
3340 | 936 |
7014 | 937 js->idle = idle ? time(NULL) - idle : idle; |
3314 | 938 } |
939 | |
6695 | 940 static const char *jabber_list_icon(GaimAccount *a, GaimBuddy *b) |
2086 | 941 { |
4687 | 942 return "jabber"; |
943 } | |
4916 | 944 |
9954 | 945 static void jabber_list_emblems(GaimBuddy *b, const char **se, const char **sw, |
946 const char **nw, const char **ne) | |
4916 | 947 { |
7014 | 948 JabberStream *js; |
949 JabberBuddy *jb; | |
950 | |
951 if(!b->account->gc) | |
952 return; | |
953 js = b->account->gc->proto_data; | |
954 jb = jabber_buddy_find(js, b->name, FALSE); | |
5135 | 955 |
956 if(!GAIM_BUDDY_IS_ONLINE(b)) { | |
7014 | 957 if(jb && jb->error_msg) |
4927 | 958 *nw = "error"; |
5135 | 959 |
7014 | 960 if(jb && (jb->subscription & JABBER_SUB_PENDING || |
961 !(jb->subscription & JABBER_SUB_TO))) | |
5135 | 962 *se = "notauthorized"; |
963 else | |
964 *se = "offline"; | |
4916 | 965 } else { |
9954 | 966 GaimStatusType *status_type = gaim_status_get_type(gaim_presence_get_active_status(gaim_buddy_get_presence(b))); |
967 | |
11522 | 968 if(gaim_status_type_get_primitive(status_type) > GAIM_STATUS_AVAILABLE) { |
9954 | 969 *se = gaim_status_type_get_id(status_type); |
970 if(!strcmp(*se, "xa")) | |
7014 | 971 *se = "extendedaway"; |
4916 | 972 } |
2086 | 973 } |
4916 | 974 } |
2086 | 975 |
7014 | 976 static char *jabber_status_text(GaimBuddy *b) |
2205
cff4fbe01c7b
[gaim-migrate @ 2215]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2170
diff
changeset
|
977 { |
7014 | 978 JabberBuddy *jb = jabber_buddy_find(b->account->gc->proto_data, b->name, |
979 FALSE); | |
980 char *ret = NULL; | |
5234 | 981 |
7014 | 982 if(jb && !GAIM_BUDDY_IS_ONLINE(b) && (jb->subscription & JABBER_SUB_PENDING || !(jb->subscription & JABBER_SUB_TO))) { |
983 ret = g_strdup(_("Not Authorized")); | |
984 } else if(jb && !GAIM_BUDDY_IS_ONLINE(b) && jb->error_msg) { | |
985 ret = g_strdup(jb->error_msg); | |
2956 | 986 } else { |
7095
c8bf2da398e3
[gaim-migrate @ 7660]
Christian Hammond <chipx86@chipx86.com>
parents:
7072
diff
changeset
|
987 char *stripped; |
c8bf2da398e3
[gaim-migrate @ 7660]
Christian Hammond <chipx86@chipx86.com>
parents:
7072
diff
changeset
|
988 |
9954 | 989 if(!(stripped = gaim_markup_strip_html(jabber_buddy_get_status_msg(jb)))) { |
990 GaimStatus *status = gaim_presence_get_active_status(gaim_buddy_get_presence(b)); | |
2956 | 991 |
9954 | 992 if(!gaim_status_is_available(status)) |
993 stripped = g_strdup(gaim_status_get_name(status)); | |
994 } | |
2086 | 995 |
7014 | 996 if(stripped) { |
997 ret = g_markup_escape_text(stripped, -1); | |
998 g_free(stripped); | |
999 } | |
2086 | 1000 } |
1001 | |
7014 | 1002 return ret; |
2956 | 1003 } |
1004 | |
6695 | 1005 static char *jabber_tooltip_text(GaimBuddy *b) |
4744 | 1006 { |
11609 | 1007 JabberBuddy *jb; |
1008 GString *ret; | |
1009 | |
1010 g_return_val_if_fail(b != NULL, NULL); | |
1011 g_return_val_if_fail(b->account != NULL, NULL); | |
1012 g_return_val_if_fail(b->account->gc != NULL, NULL); | |
1013 g_return_val_if_fail(b->account->gc->proto_data != NULL, NULL); | |
1014 | |
1015 jb = jabber_buddy_find(b->account->gc->proto_data, b->name, | |
7014 | 1016 FALSE); |
11609 | 1017 ret = g_string_new(""); |
7014 | 1018 |
8194 | 1019 if(jb) { |
11609 | 1020 JabberBuddyResource *jbr = NULL; |
8194 | 1021 const char *sub; |
11609 | 1022 GList *l; |
1023 | |
8194 | 1024 if(jb->subscription & JABBER_SUB_FROM) { |
1025 if(jb->subscription & JABBER_SUB_TO) | |
1026 sub = _("Both"); | |
1027 else if(jb->subscription & JABBER_SUB_PENDING) | |
1028 sub = _("From (To pending)"); | |
1029 else | |
1030 sub = _("From"); | |
1031 } else { | |
1032 if(jb->subscription & JABBER_SUB_TO) | |
1033 sub = _("To"); | |
1034 else if(jb->subscription & JABBER_SUB_PENDING) | |
1035 sub = _("None (To pending)"); | |
1036 else | |
1037 sub = _("None"); | |
1038 } | |
8591 | 1039 g_string_append_printf(ret, "\n<b>%s:</b> %s", _("Subscription"), sub); |
8194 | 1040 |
11609 | 1041 for(l=jb->resources; l; l = l->next) { |
8194 | 1042 char *text = NULL; |
11609 | 1043 char *res = NULL; |
1044 | |
1045 jbr = l->data; | |
1046 | |
8194 | 1047 if(jbr->status) { |
11646 | 1048 char *tmp; |
1049 text = gaim_strreplace(jbr->status, "\n", "<br />\n"); | |
1050 tmp = gaim_markup_strip_html(text); | |
1051 g_free(text); | |
1052 text = g_markup_escape_text(tmp, -1); | |
1053 g_free(tmp); | |
8194 | 1054 } |
1055 | |
11609 | 1056 if(jbr->name) |
11610 | 1057 res = g_strdup_printf(" (%s)", jbr->name); |
11609 | 1058 |
1059 g_string_append_printf(ret, "\n<b>%s%s:</b> %s%s%s", | |
8194 | 1060 _("Status"), |
11609 | 1061 res ? res : "", |
9954 | 1062 jabber_buddy_state_get_name(jbr->state), |
8194 | 1063 text ? ": " : "", |
1064 text ? text : ""); | |
1065 if(text) | |
1066 g_free(text); | |
11609 | 1067 if(res) |
1068 g_free(res); | |
1069 } | |
1070 | |
1071 if(!GAIM_BUDDY_IS_ONLINE(b) && jb->error_msg) { | |
8591 | 1072 g_string_append_printf(ret, "\n<b>%s:</b> %s", |
8194 | 1073 _("Error"), jb->error_msg); |
1074 } | |
4745 | 1075 } |
4744 | 1076 |
8591 | 1077 return g_string_free(ret, FALSE); |
4732 | 1078 } |
1079 | |
9954 | 1080 static GList *jabber_status_types(GaimAccount *account) |
7014 | 1081 { |
9954 | 1082 GaimStatusType *type; |
1083 GList *types = NULL; | |
11568 | 1084 GaimValue *priority_value; |
9954 | 1085 |
9980 | 1086 type = gaim_status_type_new_with_attrs(GAIM_STATUS_OFFLINE, "offline", |
1087 _("Offline"), FALSE, TRUE, FALSE, "message", _("Message"), | |
1088 gaim_value_new(GAIM_TYPE_STRING), NULL); | |
9954 | 1089 types = g_list_append(types, type); |
1090 | |
11568 | 1091 priority_value = gaim_value_new(GAIM_TYPE_INT); |
11569 | 1092 gaim_value_set_int(priority_value, 1); |
10486 | 1093 type = gaim_status_type_new_with_attrs(GAIM_STATUS_AVAILABLE, "available", |
1094 _("Available"), TRUE, TRUE, FALSE, "priority", _("Priority"), | |
11568 | 1095 priority_value, "message", _("Message"), |
9980 | 1096 gaim_value_new(GAIM_TYPE_STRING), NULL); |
1097 types = g_list_append(types, type); | |
1098 | |
11568 | 1099 priority_value = gaim_value_new(GAIM_TYPE_INT); |
11569 | 1100 gaim_value_set_int(priority_value, 1); |
9980 | 1101 type = gaim_status_type_new_with_attrs(GAIM_STATUS_AVAILABLE, "chat", |
1102 _("Chatty"), TRUE, TRUE, FALSE, "priority", _("Priority"), | |
11568 | 1103 priority_value, "message", _("Message"), |
9980 | 1104 gaim_value_new(GAIM_TYPE_STRING), NULL); |
9954 | 1105 types = g_list_append(types, type); |
2086 | 1106 |
11568 | 1107 priority_value = gaim_value_new(GAIM_TYPE_INT); |
11569 | 1108 gaim_value_set_int(priority_value, 0); |
9980 | 1109 type = gaim_status_type_new_with_attrs(GAIM_STATUS_AWAY, "away", |
1110 _("Away"), TRUE, TRUE, FALSE, "priority", _("Priority"), | |
11568 | 1111 priority_value, "message", _("Message"), |
9980 | 1112 gaim_value_new(GAIM_TYPE_STRING), NULL); |
9954 | 1113 types = g_list_append(types, type); |
1114 | |
11568 | 1115 priority_value = gaim_value_new(GAIM_TYPE_INT); |
11569 | 1116 gaim_value_set_int(priority_value, 0); |
9980 | 1117 type = gaim_status_type_new_with_attrs(GAIM_STATUS_EXTENDED_AWAY, "xa", |
1118 _("Extended Away"), TRUE, TRUE, FALSE, "priority", _("Priority"), | |
11568 | 1119 priority_value, "message", _("Message"), |
9980 | 1120 gaim_value_new(GAIM_TYPE_STRING), NULL); |
9954 | 1121 types = g_list_append(types, type); |
1122 | |
11568 | 1123 priority_value = gaim_value_new(GAIM_TYPE_INT); |
11569 | 1124 gaim_value_set_int(priority_value, 0); |
9980 | 1125 type = gaim_status_type_new_with_attrs(GAIM_STATUS_UNAVAILABLE, "dnd", |
1126 _("Do Not Disturb"), TRUE, TRUE, FALSE, "priority", _("Priority"), | |
11568 | 1127 priority_value, "message", _("Message"), |
9980 | 1128 gaim_value_new(GAIM_TYPE_STRING), NULL); |
9954 | 1129 types = g_list_append(types, type); |
1130 | |
1131 /* | |
8166 | 1132 if(js->protocol_version == JABBER_PROTO_0_9) |
1133 m = g_list_append(m, _("Invisible")); | |
10009 | 1134 */ |
2086 | 1135 |
9954 | 1136 return types; |
2086 | 1137 } |
1138 | |
7395 | 1139 static void |
1140 jabber_password_change_result_cb(JabberStream *js, xmlnode *packet, | |
1141 gpointer data) | |
7124 | 1142 { |
1143 const char *type; | |
1144 | |
1145 type = xmlnode_get_attrib(packet, "type"); | |
1146 | |
9414 | 1147 if(type && !strcmp(type, "result")) { |
7124 | 1148 gaim_notify_info(js->gc, _("Password Changed"), _("Password Changed"), |
1149 _("Your password has been changed.")); | |
1150 } else { | |
8401 | 1151 char *msg = jabber_parse_error(js, packet); |
7124 | 1152 |
8401 | 1153 gaim_notify_error(js->gc, _("Error changing password"), |
1154 _("Error changing password"), msg); | |
1155 g_free(msg); | |
7124 | 1156 } |
1157 } | |
1158 | |
1159 static void jabber_password_change_cb(JabberStream *js, | |
1160 GaimRequestFields *fields) | |
1161 { | |
1162 const char *p1, *p2; | |
1163 JabberIq *iq; | |
1164 xmlnode *query, *y; | |
1165 | |
1166 p1 = gaim_request_fields_get_string(fields, "password1"); | |
1167 p2 = gaim_request_fields_get_string(fields, "password2"); | |
1168 | |
1169 if(strcmp(p1, p2)) { | |
1170 gaim_notify_error(js->gc, NULL, _("New passwords do not match."), NULL); | |
1171 return; | |
1172 } | |
1173 | |
1174 iq = jabber_iq_new_query(js, JABBER_IQ_SET, "jabber:iq:register"); | |
1175 | |
1176 xmlnode_set_attrib(iq->node, "to", js->user->domain); | |
1177 | |
1178 query = xmlnode_get_child(iq->node, "query"); | |
1179 | |
1180 y = xmlnode_new_child(query, "username"); | |
1181 xmlnode_insert_data(y, js->user->node, -1); | |
1182 y = xmlnode_new_child(query, "password"); | |
1183 xmlnode_insert_data(y, p1, -1); | |
1184 | |
7395 | 1185 jabber_iq_set_callback(iq, jabber_password_change_result_cb, NULL); |
7124 | 1186 |
1187 jabber_iq_send(iq); | |
1188 | |
1189 gaim_account_set_password(js->gc->account, p1); | |
1190 } | |
1191 | |
9015 | 1192 static void jabber_password_change(GaimPluginAction *action) |
7124 | 1193 { |
9015 | 1194 |
1195 GaimConnection *gc = (GaimConnection *) action->context; | |
7124 | 1196 JabberStream *js = gc->proto_data; |
1197 GaimRequestFields *fields; | |
1198 GaimRequestFieldGroup *group; | |
1199 GaimRequestField *field; | |
1200 | |
1201 fields = gaim_request_fields_new(); | |
1202 group = gaim_request_field_group_new(NULL); | |
1203 gaim_request_fields_add_group(fields, group); | |
1204 | |
1205 field = gaim_request_field_string_new("password1", _("Password"), | |
1206 "", FALSE); | |
1207 gaim_request_field_string_set_masked(field, TRUE); | |
1208 gaim_request_field_group_add_field(group, field); | |
1209 | |
1210 field = gaim_request_field_string_new("password2", _("Password (again)"), | |
1211 "", FALSE); | |
1212 gaim_request_field_string_set_masked(field, TRUE); | |
1213 gaim_request_field_group_add_field(group, field); | |
1214 | |
1215 gaim_request_fields(js->gc, _("Change Jabber Password"), | |
1216 _("Change Jabber Password"), _("Please enter your new password"), | |
1217 fields, _("OK"), G_CALLBACK(jabber_password_change_cb), | |
1218 _("Cancel"), NULL, js); | |
1219 } | |
1220 | |
9015 | 1221 static GList *jabber_actions(GaimPlugin *plugin, gpointer context) |
2956 | 1222 { |
1223 GList *m = NULL; | |
9015 | 1224 GaimPluginAction *act; |
4333 | 1225 |
12243
d3cb077caf3e
[gaim-migrate @ 14545]
Richard Laager <rlaager@wiktel.com>
parents:
12143
diff
changeset
|
1226 act = gaim_plugin_action_new(_("Set User Info..."), |
12286
255e6912607b
[gaim-migrate @ 14590]
Etan Reisner <pidgin@unreliablesource.net>
parents:
12284
diff
changeset
|
1227 jabber_setup_set_info); |
9015 | 1228 m = g_list_append(m, act); |
4333 | 1229 |
8296 | 1230 /* if (js->protocol_options & CHANGE_PASSWORD) { */ |
12243
d3cb077caf3e
[gaim-migrate @ 14545]
Richard Laager <rlaager@wiktel.com>
parents:
12143
diff
changeset
|
1231 act = gaim_plugin_action_new(_("Change Password..."), |
12286
255e6912607b
[gaim-migrate @ 14590]
Etan Reisner <pidgin@unreliablesource.net>
parents:
12284
diff
changeset
|
1232 jabber_password_change); |
9015 | 1233 m = g_list_append(m, act); |
8296 | 1234 /* } */ |
2956 | 1235 |
12243
d3cb077caf3e
[gaim-migrate @ 14545]
Richard Laager <rlaager@wiktel.com>
parents:
12143
diff
changeset
|
1236 act = gaim_plugin_action_new(_("Search for Users..."), |
12286
255e6912607b
[gaim-migrate @ 14590]
Etan Reisner <pidgin@unreliablesource.net>
parents:
12284
diff
changeset
|
1237 jabber_user_search_begin); |
11675 | 1238 m = g_list_append(m, act); |
1239 | |
2956 | 1240 return m; |
1241 } | |
1242 | |
7999 | 1243 static GaimChat *jabber_find_blist_chat(GaimAccount *account, const char *name) |
1244 { | |
1245 GaimBlistNode *gnode, *cnode; | |
1246 JabberID *jid; | |
1247 | |
1248 if(!(jid = jabber_id_new(name))) | |
1249 return NULL; | |
1250 | |
1251 for(gnode = gaim_get_blist()->root; gnode; gnode = gnode->next) { | |
1252 for(cnode = gnode->child; cnode; cnode = cnode->next) { | |
1253 GaimChat *chat = (GaimChat*)cnode; | |
1254 const char *room, *server; | |
1255 if(!GAIM_BLIST_NODE_IS_CHAT(cnode)) | |
1256 continue; | |
1257 | |
1258 if(chat->account != account) | |
8011 | 1259 continue; |
7999 | 1260 |
1261 if(!(room = g_hash_table_lookup(chat->components, "room"))) | |
1262 continue; | |
1263 if(!(server = g_hash_table_lookup(chat->components, "server"))) | |
1264 continue; | |
1265 | |
8158 | 1266 if(jid->node && jid->domain && |
1267 !g_utf8_collate(room, jid->node) && !g_utf8_collate(server, jid->domain)) { | |
7999 | 1268 jabber_id_free(jid); |
1269 return chat; | |
1270 } | |
1271 } | |
1272 } | |
1273 jabber_id_free(jid); | |
1274 return NULL; | |
1275 } | |
1276 | |
8400 | 1277 static void jabber_convo_closed(GaimConnection *gc, const char *who) |
1278 { | |
1279 JabberStream *js = gc->proto_data; | |
1280 JabberID *jid; | |
1281 JabberBuddy *jb; | |
1282 JabberBuddyResource *jbr; | |
1283 | |
1284 if(!(jid = jabber_id_new(who))) | |
1285 return; | |
1286 | |
1287 if((jb = jabber_buddy_find(js, who, TRUE)) && | |
1288 (jbr = jabber_buddy_find_resource(jb, jid->resource))) { | |
1289 if(jbr->thread_id) { | |
1290 g_free(jbr->thread_id); | |
1291 jbr->thread_id = NULL; | |
1292 } | |
1293 } | |
1294 | |
1295 jabber_id_free(jid); | |
1296 } | |
1297 | |
8401 | 1298 |
1299 char *jabber_parse_error(JabberStream *js, xmlnode *packet) | |
1300 { | |
1301 xmlnode *error; | |
1302 const char *code = NULL, *text = NULL; | |
1303 const char *xmlns = xmlnode_get_attrib(packet, "xmlns"); | |
1304 char *cdata = NULL; | |
1305 | |
1306 if((error = xmlnode_get_child(packet, "error"))) { | |
1307 cdata = xmlnode_get_data(error); | |
1308 code = xmlnode_get_attrib(error, "code"); | |
1309 | |
1310 /* Stanza errors */ | |
1311 if(xmlnode_get_child(error, "bad-request")) { | |
1312 text = _("Bad Request"); | |
1313 } else if(xmlnode_get_child(error, "conflict")) { | |
1314 text = _("Conflict"); | |
1315 } else if(xmlnode_get_child(error, "feature-not-implemented")) { | |
1316 text = _("Feature Not Implemented"); | |
1317 } else if(xmlnode_get_child(error, "forbidden")) { | |
1318 text = _("Forbidden"); | |
1319 } else if(xmlnode_get_child(error, "gone")) { | |
1320 text = _("Gone"); | |
1321 } else if(xmlnode_get_child(error, "internal-server-error")) { | |
1322 text = _("Internal Server Error"); | |
1323 } else if(xmlnode_get_child(error, "item-not-found")) { | |
1324 text = _("Item Not Found"); | |
1325 } else if(xmlnode_get_child(error, "jid-malformed")) { | |
1326 text = _("Malformed Jabber ID"); | |
1327 } else if(xmlnode_get_child(error, "not-acceptable")) { | |
1328 text = _("Not Acceptable"); | |
1329 } else if(xmlnode_get_child(error, "not-allowed")) { | |
1330 text = _("Not Allowed"); | |
1331 } else if(xmlnode_get_child(error, "not-authorized")) { | |
1332 text = _("Not Authorized"); | |
1333 } else if(xmlnode_get_child(error, "payment-required")) { | |
1334 text = _("Payment Required"); | |
1335 } else if(xmlnode_get_child(error, "recipient-unavailable")) { | |
1336 text = _("Recipient Unavailable"); | |
1337 } else if(xmlnode_get_child(error, "redirect")) { | |
1338 /* XXX */ | |
1339 } else if(xmlnode_get_child(error, "registration-required")) { | |
1340 text = _("Registration Required"); | |
1341 } else if(xmlnode_get_child(error, "remote-server-not-found")) { | |
1342 text = _("Remote Server Not Found"); | |
1343 } else if(xmlnode_get_child(error, "remote-server-timeout")) { | |
1344 text = _("Remote Server Timeout"); | |
1345 } else if(xmlnode_get_child(error, "resource-constraint")) { | |
1346 text = _("Server Overloaded"); | |
1347 } else if(xmlnode_get_child(error, "service-unavailable")) { | |
1348 text = _("Service Unavailable"); | |
1349 } else if(xmlnode_get_child(error, "subscription-required")) { | |
1350 text = _("Subscription Required"); | |
1351 } else if(xmlnode_get_child(error, "unexpected-request")) { | |
1352 text = _("Unexpected Request"); | |
1353 } else if(xmlnode_get_child(error, "undefined-condition")) { | |
1354 text = _("Unknown Error"); | |
1355 } | |
1356 } else if(xmlns && !strcmp(xmlns, "urn:ietf:params:xml:ns:xmpp-sasl")) { | |
1357 if(xmlnode_get_child(packet, "aborted")) { | |
1358 js->gc->wants_to_die = TRUE; | |
1359 text = _("Authorization Aborted"); | |
1360 } else if(xmlnode_get_child(error, "incorrect-encoding")) { | |
1361 text = _("Incorrect encoding in authorization"); | |
1362 } else if(xmlnode_get_child(error, "invalid-authzid")) { | |
1363 js->gc->wants_to_die = TRUE; | |
1364 text = _("Invalid authzid"); | |
1365 } else if(xmlnode_get_child(error, "invalid-mechanism")) { | |
1366 js->gc->wants_to_die = TRUE; | |
1367 text = _("Invalid Authorization Mechanism"); | |
1368 } else if(xmlnode_get_child(error, "mechanism-too-weak")) { | |
1369 js->gc->wants_to_die = TRUE; | |
1370 text = _("Authorization mechanism too weak"); | |
1371 } else if(xmlnode_get_child(error, "not-authorized")) { | |
1372 js->gc->wants_to_die = TRUE; | |
1373 text = _("Not Authorized"); | |
1374 } else if(xmlnode_get_child(error, "temporary-auth-failure")) { | |
1375 text = _("Temporary Authentication Failure"); | |
1376 } else { | |
1377 text = _("Authentication Failure"); | |
1378 } | |
8402 | 1379 } else if(!strcmp(packet->name, "stream:error")) { |
1380 if(xmlnode_get_child(packet, "bad-format")) { | |
1381 text = _("Bad Format"); | |
1382 } else if(xmlnode_get_child(packet, "bad-namespace-prefix")) { | |
1383 text = _("Bad Namespace Prefix"); | |
1384 } else if(xmlnode_get_child(packet, "conflict")) { | |
1385 js->gc->wants_to_die = TRUE; | |
1386 text = _("Resource Conflict"); | |
1387 } else if(xmlnode_get_child(packet, "connection-timeout")) { | |
1388 text = _("Connection Timeout"); | |
1389 } else if(xmlnode_get_child(packet, "host-gone")) { | |
1390 text = _("Host Gone"); | |
1391 } else if(xmlnode_get_child(packet, "host-unknown")) { | |
1392 text = _("Host Unknown"); | |
1393 } else if(xmlnode_get_child(packet, "improper-addressing")) { | |
1394 text = _("Improper Addressing"); | |
1395 } else if(xmlnode_get_child(packet, "internal-server-error")) { | |
1396 text = _("Internal Server Error"); | |
1397 } else if(xmlnode_get_child(packet, "invalid-id")) { | |
1398 text = _("Invalid ID"); | |
1399 } else if(xmlnode_get_child(packet, "invalid-namespace")) { | |
1400 text = _("Invalid Namespace"); | |
1401 } else if(xmlnode_get_child(packet, "invalid-xml")) { | |
1402 text = _("Invalid XML"); | |
1403 } else if(xmlnode_get_child(packet, "nonmatching-hosts")) { | |
1404 text = _("Non-matching Hosts"); | |
1405 } else if(xmlnode_get_child(packet, "not-authorized")) { | |
1406 text = _("Not Authorized"); | |
1407 } else if(xmlnode_get_child(packet, "policy-violation")) { | |
1408 text = _("Policy Violation"); | |
1409 } else if(xmlnode_get_child(packet, "remote-connection-failed")) { | |
1410 text = _("Remote Connection Failed"); | |
1411 } else if(xmlnode_get_child(packet, "resource-constraint")) { | |
1412 text = _("Resource Constraint"); | |
1413 } else if(xmlnode_get_child(packet, "restricted-xml")) { | |
1414 text = _("Restricted XML"); | |
1415 } else if(xmlnode_get_child(packet, "see-other-host")) { | |
1416 text = _("See Other Host"); | |
1417 } else if(xmlnode_get_child(packet, "system-shutdown")) { | |
1418 text = _("System Shutdown"); | |
1419 } else if(xmlnode_get_child(packet, "undefined-condition")) { | |
1420 text = _("Undefined Condition"); | |
1421 } else if(xmlnode_get_child(packet, "unsupported-encoding")) { | |
1422 text = _("Unsupported Encoding"); | |
1423 } else if(xmlnode_get_child(packet, "unsupported-stanza-type")) { | |
1424 text = _("Unsupported Stanza Type"); | |
1425 } else if(xmlnode_get_child(packet, "unsupported-version")) { | |
1426 text = _("Unsupported Version"); | |
1427 } else if(xmlnode_get_child(packet, "xml-not-well-formed")) { | |
1428 text = _("XML Not Well Formed"); | |
1429 } else { | |
1430 text = _("Stream Error"); | |
1431 } | |
8401 | 1432 } |
1433 | |
1434 if(text || cdata) { | |
1435 char *ret = g_strdup_printf("%s%s%s", code ? code : "", | |
1436 code ? ": " : "", text ? text : cdata); | |
1437 g_free(cdata); | |
1438 return ret; | |
1439 } else { | |
1440 return NULL; | |
1441 } | |
1442 } | |
1443 | |
9130 | 1444 static GaimCmdRet jabber_cmd_chat_config(GaimConversation *conv, |
9597 | 1445 const char *cmd, char **args, char **error, void *data) |
9130 | 1446 { |
1447 JabberChat *chat = jabber_chat_find_by_conv(conv); | |
1448 jabber_chat_request_room_configure(chat); | |
1449 return GAIM_CMD_RET_OK; | |
1450 } | |
1451 | |
1452 static GaimCmdRet jabber_cmd_chat_register(GaimConversation *conv, | |
9597 | 1453 const char *cmd, char **args, char **error, void *data) |
9130 | 1454 { |
1455 JabberChat *chat = jabber_chat_find_by_conv(conv); | |
1456 jabber_chat_register(chat); | |
1457 return GAIM_CMD_RET_OK; | |
1458 } | |
1459 | |
1460 static GaimCmdRet jabber_cmd_chat_topic(GaimConversation *conv, | |
9597 | 1461 const char *cmd, char **args, char **error, void *data) |
9130 | 1462 { |
1463 JabberChat *chat = jabber_chat_find_by_conv(conv); | |
1464 jabber_chat_change_topic(chat, args ? args[0] : NULL); | |
1465 return GAIM_CMD_RET_OK; | |
1466 } | |
1467 | |
1468 static GaimCmdRet jabber_cmd_chat_nick(GaimConversation *conv, | |
9597 | 1469 const char *cmd, char **args, char **error, void *data) |
9130 | 1470 { |
1471 JabberChat *chat = jabber_chat_find_by_conv(conv); | |
1472 | |
1473 if(!args || !args[0]) | |
1474 return GAIM_CMD_RET_FAILED; | |
1475 | |
1476 jabber_chat_change_nick(chat, args[0]); | |
1477 return GAIM_CMD_RET_OK; | |
1478 } | |
1479 | |
1480 static GaimCmdRet jabber_cmd_chat_part(GaimConversation *conv, | |
9597 | 1481 const char *cmd, char **args, char **error, void *data) |
9130 | 1482 { |
1483 JabberChat *chat = jabber_chat_find_by_conv(conv); | |
1484 jabber_chat_part(chat, args ? args[0] : NULL); | |
1485 return GAIM_CMD_RET_OK; | |
1486 } | |
1487 | |
9152 | 1488 static GaimCmdRet jabber_cmd_chat_ban(GaimConversation *conv, |
9597 | 1489 const char *cmd, char **args, char **error, void *data) |
9152 | 1490 { |
1491 JabberChat *chat = jabber_chat_find_by_conv(conv); | |
1492 | |
1493 if(!args || !args[0]) | |
1494 return GAIM_CMD_RET_FAILED; | |
1495 | |
1496 if(!jabber_chat_ban_user(chat, args[0], args[1])) { | |
1497 *error = g_strdup_printf(_("Unable to ban user %s"), args[0]); | |
1498 return GAIM_CMD_RET_FAILED; | |
1499 } | |
1500 | |
1501 return GAIM_CMD_RET_OK; | |
1502 } | |
1503 | |
11393 | 1504 static GaimCmdRet jabber_cmd_chat_affiliate(GaimConversation *conv, |
1505 const char *cmd, char **args, char **error, void *data) | |
1506 { | |
1507 JabberChat *chat = jabber_chat_find_by_conv(conv); | |
1508 | |
1509 if (!args || !args[0] || !args[1]) | |
1510 return GAIM_CMD_RET_FAILED; | |
1511 | |
1512 if ( | |
1513 strcmp(args[1], "owner") != 0 && | |
1514 strcmp(args[1], "admin") != 0 && | |
1515 strcmp(args[1], "member") != 0 && | |
1516 strcmp(args[1], "outcast") != 0 && | |
1517 strcmp(args[1], "none") != 0 | |
1518 ) { | |
1519 *error = g_strdup_printf(_("Unknown affiliation: \"%s\""), args[1]); | |
1520 return GAIM_CMD_RET_FAILED; | |
1521 } | |
1522 | |
1523 if (!jabber_chat_affiliate_user(chat, args[0], args[1])) { | |
1524 *error = g_strdup_printf(_("Unable to affiliate user %s as \"%s\""), args[0], args[1]); | |
1525 return GAIM_CMD_RET_FAILED; | |
1526 } | |
1527 | |
1528 return GAIM_CMD_RET_OK; | |
1529 } | |
1530 | |
9152 | 1531 static GaimCmdRet jabber_cmd_chat_invite(GaimConversation *conv, |
9597 | 1532 const char *cmd, char **args, char **error, void *data) |
9152 | 1533 { |
1534 if(!args || !args[0]) | |
1535 return GAIM_CMD_RET_FAILED; | |
1536 | |
1537 jabber_chat_invite(gaim_conversation_get_gc(conv), | |
1538 gaim_conv_chat_get_id(GAIM_CONV_CHAT(conv)), args[1] ? args[1] : "", | |
1539 args[0]); | |
1540 | |
1541 return GAIM_CMD_RET_OK; | |
1542 } | |
1543 | |
1544 static GaimCmdRet jabber_cmd_chat_join(GaimConversation *conv, | |
9597 | 1545 const char *cmd, char **args, char **error, void *data) |
9152 | 1546 { |
1547 JabberChat *chat = jabber_chat_find_by_conv(conv); | |
1548 GHashTable *components; | |
1549 | |
1550 if(!args || !args[0]) | |
1551 return GAIM_CMD_RET_FAILED; | |
1552 | |
1553 components = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, NULL); | |
1554 | |
1555 g_hash_table_replace(components, "room", args[0]); | |
1556 g_hash_table_replace(components, "server", chat->server); | |
1557 g_hash_table_replace(components, "handle", chat->handle); | |
1558 if(args[1]) | |
1559 g_hash_table_replace(components, "password", args[1]); | |
1560 | |
1561 jabber_chat_join(gaim_conversation_get_gc(conv), components); | |
1562 | |
1563 g_hash_table_destroy(components); | |
1564 return GAIM_CMD_RET_OK; | |
1565 } | |
1566 | |
1567 static GaimCmdRet jabber_cmd_chat_kick(GaimConversation *conv, | |
9597 | 1568 const char *cmd, char **args, char **error, void *data) |
9152 | 1569 { |
1570 JabberChat *chat = jabber_chat_find_by_conv(conv); | |
1571 | |
1572 if(!args || !args[0]) | |
1573 return GAIM_CMD_RET_FAILED; | |
1574 | |
1575 if(!jabber_chat_kick_user(chat, args[0], args[1])) { | |
1576 *error = g_strdup_printf(_("Unable to kick user %s"), args[0]); | |
1577 return GAIM_CMD_RET_FAILED; | |
1578 } | |
1579 | |
1580 return GAIM_CMD_RET_OK; | |
1581 } | |
1582 | |
1583 static GaimCmdRet jabber_cmd_chat_msg(GaimConversation *conv, | |
9597 | 1584 const char *cmd, char **args, char **error, void *data) |
9152 | 1585 { |
1586 JabberChat *chat = jabber_chat_find_by_conv(conv); | |
1587 char *who; | |
1588 | |
1589 who = g_strdup_printf("%s@%s/%s", chat->room, chat->server, args[0]); | |
1590 | |
1591 jabber_message_send_im(gaim_conversation_get_gc(conv), who, args[1], 0); | |
1592 | |
1593 g_free(who); | |
1594 return GAIM_CMD_RET_OK; | |
1595 } | |
1596 | |
9130 | 1597 static void jabber_register_commands(void) |
1598 { | |
1599 gaim_cmd_register("config", "", GAIM_CMD_P_PRPL, | |
9597 | 1600 GAIM_CMD_FLAG_CHAT | GAIM_CMD_FLAG_PRPL_ONLY, |
1601 "prpl-jabber", jabber_cmd_chat_config, | |
1602 _("config: Configure a chat room."), NULL); | |
9130 | 1603 gaim_cmd_register("configure", "", GAIM_CMD_P_PRPL, |
9597 | 1604 GAIM_CMD_FLAG_CHAT | GAIM_CMD_FLAG_PRPL_ONLY, |
1605 "prpl-jabber", jabber_cmd_chat_config, | |
1606 _("configure: Configure a chat room."), NULL); | |
9130 | 1607 gaim_cmd_register("nick", "s", GAIM_CMD_P_PRPL, |
9597 | 1608 GAIM_CMD_FLAG_CHAT | GAIM_CMD_FLAG_PRPL_ONLY, |
1609 "prpl-jabber", jabber_cmd_chat_nick, | |
1610 _("nick <new nickname>: Change your nickname."), | |
1611 NULL); | |
9130 | 1612 gaim_cmd_register("part", "s", GAIM_CMD_P_PRPL, |
9597 | 1613 GAIM_CMD_FLAG_CHAT | GAIM_CMD_FLAG_PRPL_ONLY | |
1614 GAIM_CMD_FLAG_ALLOW_WRONG_ARGS, "prpl-jabber", | |
1615 jabber_cmd_chat_part, _("part [room]: Leave the room."), | |
1616 NULL); | |
9130 | 1617 gaim_cmd_register("register", "", GAIM_CMD_P_PRPL, |
9597 | 1618 GAIM_CMD_FLAG_CHAT | GAIM_CMD_FLAG_PRPL_ONLY, |
1619 "prpl-jabber", jabber_cmd_chat_register, | |
1620 _("register: Register with a chat room."), NULL); | |
9130 | 1621 /* XXX: there needs to be a core /topic cmd, methinks */ |
1622 gaim_cmd_register("topic", "s", GAIM_CMD_P_PRPL, | |
9597 | 1623 GAIM_CMD_FLAG_CHAT | GAIM_CMD_FLAG_PRPL_ONLY | |
1624 GAIM_CMD_FLAG_ALLOW_WRONG_ARGS, "prpl-jabber", | |
1625 jabber_cmd_chat_topic, | |
1626 _("topic [new topic]: View or change the topic."), | |
1627 NULL); | |
9152 | 1628 gaim_cmd_register("ban", "ws", GAIM_CMD_P_PRPL, |
9597 | 1629 GAIM_CMD_FLAG_CHAT | GAIM_CMD_FLAG_PRPL_ONLY | |
1630 GAIM_CMD_FLAG_ALLOW_WRONG_ARGS, "prpl-jabber", | |
1631 jabber_cmd_chat_ban, | |
1632 _("ban <user> [room]: Ban a user from the room."), | |
1633 NULL); | |
11393 | 1634 gaim_cmd_register("affiliate", "ws", GAIM_CMD_P_PRPL, |
1635 GAIM_CMD_FLAG_CHAT | GAIM_CMD_FLAG_PRPL_ONLY | | |
1636 GAIM_CMD_FLAG_ALLOW_WRONG_ARGS, "prpl-jabber", | |
1637 jabber_cmd_chat_affiliate, | |
1638 _("affiliate <user> <owner|admin|member|outcast|none>: Set a user's affiliation with the room."), | |
1639 NULL); | |
9152 | 1640 gaim_cmd_register("invite", "ws", GAIM_CMD_P_PRPL, |
9597 | 1641 GAIM_CMD_FLAG_CHAT | GAIM_CMD_FLAG_PRPL_ONLY | |
1642 GAIM_CMD_FLAG_ALLOW_WRONG_ARGS, "prpl-jabber", | |
1643 jabber_cmd_chat_invite, | |
11158
2c930d591492
[gaim-migrate @ 13245]
Etan Reisner <pidgin@unreliablesource.net>
parents:
11033
diff
changeset
|
1644 _("invite <user> [message]: Invite a user to the room."), |
9597 | 1645 NULL); |
9152 | 1646 gaim_cmd_register("join", "ws", GAIM_CMD_P_PRPL, |
9597 | 1647 GAIM_CMD_FLAG_CHAT | GAIM_CMD_FLAG_PRPL_ONLY | |
1648 GAIM_CMD_FLAG_ALLOW_WRONG_ARGS, "prpl-jabber", | |
1649 jabber_cmd_chat_join, | |
1650 _("join: <room> [server]: Join a chat on this server."), | |
1651 NULL); | |
9152 | 1652 gaim_cmd_register("kick", "ws", GAIM_CMD_P_PRPL, |
9597 | 1653 GAIM_CMD_FLAG_CHAT | GAIM_CMD_FLAG_PRPL_ONLY | |
1654 GAIM_CMD_FLAG_ALLOW_WRONG_ARGS, "prpl-jabber", | |
1655 jabber_cmd_chat_kick, | |
1656 _("kick <user> [room]: Kick a user from the room."), | |
1657 NULL); | |
9152 | 1658 gaim_cmd_register("msg", "ws", GAIM_CMD_P_PRPL, |
9597 | 1659 GAIM_CMD_FLAG_CHAT | GAIM_CMD_FLAG_PRPL_ONLY, |
1660 "prpl-jabber", jabber_cmd_chat_msg, | |
1661 _("msg <user> <message>: Send a private message to another user."), | |
1662 NULL); | |
9130 | 1663 } |
1664 | |
5205
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1665 static GaimPluginProtocolInfo prpl_info = |
2086 | 1666 { |
12508 | 1667 OPT_PROTO_CHAT_TOPIC | OPT_PROTO_UNIQUE_CHATNAME | |
1668 OPT_PROTO_PASSWORD_OPTIONAL, | |
9475 | 1669 NULL, /* user_splits */ |
1670 NULL, /* protocol_options */ | |
10189 | 1671 {"jpeg,gif,png", 0, 0, 96, 96, GAIM_ICON_SCALE_DISPLAY}, /* icon_spec */ |
9475 | 1672 jabber_list_icon, /* list_icon */ |
1673 jabber_list_emblems, /* list_emblems */ | |
1674 jabber_status_text, /* status_text */ | |
1675 jabber_tooltip_text, /* tooltip_text */ | |
9954 | 1676 jabber_status_types, /* status_types */ |
9475 | 1677 jabber_blist_node_menu, /* blist_node_menu */ |
1678 jabber_chat_info, /* chat_info */ | |
9754 | 1679 jabber_chat_info_defaults, /* chat_info_defaults */ |
9475 | 1680 jabber_login, /* login */ |
1681 jabber_close, /* close */ | |
1682 jabber_message_send_im, /* send_im */ | |
1683 jabber_set_info, /* set_info */ | |
1684 jabber_send_typing, /* send_typing */ | |
1685 jabber_buddy_get_info, /* get_info */ | |
10216 | 1686 jabber_presence_send, /* set_away */ |
9475 | 1687 jabber_idle_set, /* set_idle */ |
1688 NULL, /* change_passwd */ | |
1689 jabber_roster_add_buddy, /* add_buddy */ | |
1690 NULL, /* add_buddies */ | |
1691 jabber_roster_remove_buddy, /* remove_buddy */ | |
1692 NULL, /* remove_buddies */ | |
1693 NULL, /* add_permit */ | |
1694 NULL, /* add_deny */ | |
1695 NULL, /* rem_permit */ | |
1696 NULL, /* rem_deny */ | |
1697 NULL, /* set_permit_deny */ | |
1698 jabber_chat_join, /* join_chat */ | |
1699 NULL, /* reject_chat */ | |
9917 | 1700 jabber_get_chat_name, /* get_chat_name */ |
9475 | 1701 jabber_chat_invite, /* chat_invite */ |
1702 jabber_chat_leave, /* chat_leave */ | |
1703 NULL, /* chat_whisper */ | |
1704 jabber_message_send_chat, /* chat_send */ | |
1705 jabber_keepalive, /* keepalive */ | |
1706 jabber_register_account, /* register_user */ | |
1707 jabber_buddy_get_info_chat, /* get_cb_info */ | |
1708 NULL, /* get_cb_away */ | |
1709 jabber_roster_alias_change, /* alias_buddy */ | |
1710 jabber_roster_group_change, /* group_buddy */ | |
1711 jabber_roster_group_rename, /* rename_group */ | |
1712 NULL, /* buddy_free */ | |
1713 jabber_convo_closed, /* convo_closed */ | |
1714 jabber_normalize, /* normalize */ | |
10189 | 1715 jabber_set_buddy_icon, /* set_buddy_icon */ |
9475 | 1716 NULL, /* remove_group */ |
1717 jabber_chat_buddy_real_name, /* get_cb_real_name */ | |
1718 jabber_chat_set_topic, /* set_chat_topic */ | |
1719 jabber_find_blist_chat, /* find_blist_chat */ | |
1720 jabber_roomlist_get_list, /* roomlist_get_list */ | |
1721 jabber_roomlist_cancel, /* roomlist_cancel */ | |
1722 NULL, /* roomlist_expand_category */ | |
1723 NULL, /* can_receive_file */ | |
12143
cbebda5f019c
[gaim-migrate @ 14444]
Richard Laager <rlaager@wiktel.com>
parents:
11939
diff
changeset
|
1724 jabber_si_xfer_send, /* send_file */ |
cbebda5f019c
[gaim-migrate @ 14444]
Richard Laager <rlaager@wiktel.com>
parents:
11939
diff
changeset
|
1725 jabber_si_new_xfer, /* new_xfer */ |
cbebda5f019c
[gaim-migrate @ 14444]
Richard Laager <rlaager@wiktel.com>
parents:
11939
diff
changeset
|
1726 NULL /* whiteboard operations */ |
5205
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1727 }; |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1728 |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1729 static GaimPluginInfo info = |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1730 { |
9943 | 1731 GAIM_PLUGIN_MAGIC, |
1732 GAIM_MAJOR_VERSION, | |
1733 GAIM_MINOR_VERSION, | |
5205
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1734 GAIM_PLUGIN_PROTOCOL, /**< type */ |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1735 NULL, /**< ui_requirement */ |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1736 0, /**< flags */ |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1737 NULL, /**< dependencies */ |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1738 GAIM_PRIORITY_DEFAULT, /**< priority */ |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1739 |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1740 "prpl-jabber", /**< id */ |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1741 "Jabber", /**< name */ |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1742 VERSION, /**< version */ |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1743 /** summary */ |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1744 N_("Jabber Protocol Plugin"), |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1745 /** description */ |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1746 N_("Jabber Protocol Plugin"), |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1747 NULL, /**< author */ |
6371
8f94cce8faa5
[gaim-migrate @ 6876]
Christian Hammond <chipx86@chipx86.com>
parents:
6357
diff
changeset
|
1748 GAIM_WEBSITE, /**< homepage */ |
5205
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1749 |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1750 NULL, /**< load */ |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1751 NULL, /**< unload */ |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1752 NULL, /**< destroy */ |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1753 |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1754 NULL, /**< ui_info */ |
8993 | 1755 &prpl_info, /**< extra_info */ |
10487 | 1756 NULL, /**< prefs_info */ |
9015 | 1757 jabber_actions |
5205
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1758 }; |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1759 |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1760 static void |
5920
7d385de2f9cd
[gaim-migrate @ 6360]
Christian Hammond <chipx86@chipx86.com>
parents:
5894
diff
changeset
|
1761 init_plugin(GaimPlugin *plugin) |
5205
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1762 { |
5638
0bdfa28c678e
[gaim-migrate @ 6047]
Christian Hammond <chipx86@chipx86.com>
parents:
5613
diff
changeset
|
1763 GaimAccountUserSplit *split; |
0bdfa28c678e
[gaim-migrate @ 6047]
Christian Hammond <chipx86@chipx86.com>
parents:
5613
diff
changeset
|
1764 GaimAccountOption *option; |
0bdfa28c678e
[gaim-migrate @ 6047]
Christian Hammond <chipx86@chipx86.com>
parents:
5613
diff
changeset
|
1765 |
0bdfa28c678e
[gaim-migrate @ 6047]
Christian Hammond <chipx86@chipx86.com>
parents:
5613
diff
changeset
|
1766 split = gaim_account_user_split_new(_("Server"), "jabber.org", '@'); |
0bdfa28c678e
[gaim-migrate @ 6047]
Christian Hammond <chipx86@chipx86.com>
parents:
5613
diff
changeset
|
1767 prpl_info.user_splits = g_list_append(prpl_info.user_splits, split); |
0bdfa28c678e
[gaim-migrate @ 6047]
Christian Hammond <chipx86@chipx86.com>
parents:
5613
diff
changeset
|
1768 |
11939
85c25a32bb48
[gaim-migrate @ 14230]
Etan Reisner <pidgin@unreliablesource.net>
parents:
11837
diff
changeset
|
1769 split = gaim_account_user_split_new(_("Resource"), "Home", '/'); |
5638
0bdfa28c678e
[gaim-migrate @ 6047]
Christian Hammond <chipx86@chipx86.com>
parents:
5613
diff
changeset
|
1770 prpl_info.user_splits = g_list_append(prpl_info.user_splits, split); |
0bdfa28c678e
[gaim-migrate @ 6047]
Christian Hammond <chipx86@chipx86.com>
parents:
5613
diff
changeset
|
1771 |
7630 | 1772 option = gaim_account_option_bool_new(_("Use TLS if available"), "use_tls", |
1773 TRUE); | |
1774 prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, | |
1775 option); | |
1776 | |
10941 | 1777 option = gaim_account_option_bool_new(_("Require TLS"), "require_tls", TRUE); |
1778 prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option); | |
1779 | |
1780 option = gaim_account_option_bool_new(_("Force old (port 5223) SSL"), "old_ssl", FALSE); | |
7124 | 1781 prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, |
1782 option); | |
6764 | 1783 |
8086 | 1784 option = gaim_account_option_bool_new( |
1785 _("Allow plaintext auth over unencrypted streams"), | |
1786 "auth_plain_in_clear", FALSE); | |
1787 prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, | |
1788 option); | |
1789 | |
11387 | 1790 option = gaim_account_option_int_new(_("Connect port"), "port", 5222); |
5638
0bdfa28c678e
[gaim-migrate @ 6047]
Christian Hammond <chipx86@chipx86.com>
parents:
5613
diff
changeset
|
1791 prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, |
7014 | 1792 option); |
5638
0bdfa28c678e
[gaim-migrate @ 6047]
Christian Hammond <chipx86@chipx86.com>
parents:
5613
diff
changeset
|
1793 |
5685
43ea75092684
[gaim-migrate @ 6106]
Christian Hammond <chipx86@chipx86.com>
parents:
5681
diff
changeset
|
1794 option = gaim_account_option_string_new(_("Connect server"), |
7014 | 1795 "connect_server", NULL); |
5638
0bdfa28c678e
[gaim-migrate @ 6047]
Christian Hammond <chipx86@chipx86.com>
parents:
5613
diff
changeset
|
1796 prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, |
7014 | 1797 option); |
5205
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1798 |
fefad67de2c7
[gaim-migrate @ 5573]
Christian Hammond <chipx86@chipx86.com>
parents:
5174
diff
changeset
|
1799 my_protocol = plugin; |
7014 | 1800 |
10487 | 1801 gaim_prefs_remove("/plugins/prpl/jabber"); |
9130 | 1802 |
12508 | 1803 /* XXX - If any other plugin wants SASL this won't be good ... */ |
1804 #ifdef HAVE_CYRUS_SASL | |
1805 sasl_client_init(NULL); | |
1806 #endif | |
9130 | 1807 jabber_register_commands(); |
2086 | 1808 } |
1809 | |
5920
7d385de2f9cd
[gaim-migrate @ 6360]
Christian Hammond <chipx86@chipx86.com>
parents:
5894
diff
changeset
|
1810 GAIM_INIT_PLUGIN(jabber, init_plugin, info); |