1 /***************************************************************************\
2 * *
3 * BitlBee - An IRC to IM gateway *
4 * Jabber module - Conference rooms *
5 * *
6 * Copyright 2007-2012 Wilmer van der Gaast <wilmer@gaast.net> *
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 along *
19 * with this program; if not, write to the Free Software Foundation, Inc., *
20 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
21 * *
22 \***************************************************************************/
23
24 #include "jabber.h"
25 #include "sha1.h"
26
27 static xt_status jabber_chat_join_failed(struct im_connection *ic, struct xt_node *node, struct xt_node *orig);
28 static xt_status jabber_chat_self_message(struct im_connection *ic, struct xt_node *node, struct xt_node *orig);
29
jabber_chat_join(struct im_connection * ic,const char * room,const char * nick,const char * password,gboolean always_use_nicks)30 struct groupchat *jabber_chat_join(struct im_connection *ic, const char *room, const char *nick, const char *password,
31 gboolean always_use_nicks)
32 {
33 struct jabber_chat *jc;
34 struct xt_node *node;
35 struct groupchat *c;
36 char *roomjid;
37
38 roomjid = g_strdup_printf("%s/%s", room, nick);
39 node = xt_new_node("x", NULL, NULL);
40 xt_add_attr(node, "xmlns", XMLNS_MUC);
41 if (password) {
42 xt_add_child(node, xt_new_node("password", password, NULL));
43 }
44 node = jabber_make_packet("presence", NULL, roomjid, node);
45 jabber_cache_add(ic, node, jabber_chat_join_failed);
46
47 if (!jabber_write_packet(ic, node)) {
48 g_free(roomjid);
49 return NULL;
50 }
51
52 jc = g_new0(struct jabber_chat, 1);
53 jc->name = jabber_normalize(room);
54
55 if ((jc->me = jabber_buddy_add(ic, roomjid)) == NULL) {
56 g_free(roomjid);
57 g_free(jc->name);
58 g_free(jc);
59 return NULL;
60 }
61
62 if (always_use_nicks) {
63 jc->flags = JCFLAG_ALWAYS_USE_NICKS;
64 }
65
66 /* roomjid isn't normalized yet, and we need an original version
67 of the nick to send a proper presence update. */
68 jc->my_full_jid = roomjid;
69
70 c = imcb_chat_new(ic, room);
71 c->data = jc;
72
73 return c;
74 }
75
jabber_chat_with(struct im_connection * ic,char * who)76 struct groupchat *jabber_chat_with(struct im_connection *ic, char *who)
77 {
78 struct jabber_data *jd = ic->proto_data;
79 struct jabber_chat *jc;
80 struct groupchat *c;
81 sha1_state_t sum;
82 double now = gettime();
83 char *uuid, *rjid, *cserv;
84
85 sha1_init(&sum);
86 sha1_append(&sum, (uint8_t *) ic->acc->user, strlen(ic->acc->user));
87 sha1_append(&sum, (uint8_t *) &now, sizeof(now));
88 sha1_append(&sum, (uint8_t *) who, strlen(who));
89 uuid = sha1_random_uuid(&sum);
90
91 if (jd->flags & JFLAG_GTALK) {
92 cserv = g_strdup("groupchat.google.com");
93 } else {
94 /* Guess... */
95 cserv = g_strdup_printf("conference.%s", jd->server);
96 }
97
98 rjid = g_strdup_printf("private-chat-%s@%s", uuid, cserv);
99 g_free(uuid);
100 g_free(cserv);
101
102 c = jabber_chat_join(ic, rjid, jd->username, NULL, FALSE);
103 g_free(rjid);
104 if (c == NULL) {
105 return NULL;
106 }
107
108 jc = c->data;
109 jc->invite = g_strdup(who);
110
111 return c;
112 }
113
jabber_chat_join_failed(struct im_connection * ic,struct xt_node * node,struct xt_node * orig)114 static xt_status jabber_chat_join_failed(struct im_connection *ic, struct xt_node *node, struct xt_node *orig)
115 {
116 struct jabber_error *err;
117 struct jabber_buddy *bud;
118 char *room;
119
120 room = xt_find_attr(orig, "to");
121 bud = jabber_buddy_by_jid(ic, room, 0);
122 err = jabber_error_parse(xt_find_node(node->children, "error"), XMLNS_STANZA_ERROR);
123 if (err) {
124 imcb_error(ic, "Error joining groupchat %s: %s%s%s", room, err->code,
125 err->text ? ": " : "", err->text ? err->text : "");
126 jabber_error_free(err);
127 }
128 if (bud) {
129 struct groupchat *c = jabber_chat_by_jid(ic, bud->bare_jid);
130 if (c) {
131 jabber_chat_free(c);
132 }
133 }
134
135 return XT_HANDLED;
136 }
137
jabber_chat_self_message(struct im_connection * ic,struct xt_node * node,struct xt_node * orig)138 static xt_status jabber_chat_self_message(struct im_connection *ic, struct xt_node *node, struct xt_node *orig)
139 {
140 /* This is a self message sent by this bitlbee - just drop it */
141 return XT_ABORT;
142 }
143
jabber_chat_by_jid(struct im_connection * ic,const char * name)144 struct groupchat *jabber_chat_by_jid(struct im_connection *ic, const char *name)
145 {
146 char *normalized = jabber_normalize(name);
147 GSList *l;
148 struct groupchat *ret;
149 struct jabber_chat *jc;
150
151 for (l = ic->groupchats; l; l = l->next) {
152 ret = l->data;
153 jc = ret->data;
154 if (strcmp(normalized, jc->name) == 0) {
155 break;
156 }
157 }
158 g_free(normalized);
159
160 return l ? ret : NULL;
161 }
162
jabber_chat_free(struct groupchat * c)163 void jabber_chat_free(struct groupchat *c)
164 {
165 struct jabber_chat *jc = c->data;
166
167 jabber_buddy_remove_bare(c->ic, jc->name);
168
169 g_free(jc->last_sent_message);
170 g_free(jc->my_full_jid);
171 g_free(jc->name);
172 g_free(jc->invite);
173 g_free(jc);
174
175 imcb_chat_free(c);
176 }
177
jabber_chat_msg(struct groupchat * c,char * message,int flags)178 int jabber_chat_msg(struct groupchat *c, char *message, int flags)
179 {
180 struct im_connection *ic = c->ic;
181 struct jabber_chat *jc = c->data;
182 struct xt_node *node;
183
184 jc->flags |= JCFLAG_MESSAGE_SENT;
185
186 node = xt_new_node("body", message, NULL);
187 node = jabber_make_packet("message", "groupchat", jc->name, node);
188
189 jabber_cache_add(ic, node, jabber_chat_self_message);
190
191 g_free(jc->last_sent_message);
192 jc->last_sent_message = g_strdup(message);
193
194 return !jabber_write_packet(ic, node);
195 }
196
jabber_chat_topic(struct groupchat * c,char * topic)197 int jabber_chat_topic(struct groupchat *c, char *topic)
198 {
199 struct im_connection *ic = c->ic;
200 struct jabber_chat *jc = c->data;
201 struct xt_node *node;
202
203 node = xt_new_node("subject", topic, NULL);
204 node = jabber_make_packet("message", "groupchat", jc->name, node);
205
206 if (!jabber_write_packet(ic, node)) {
207 xt_free_node(node);
208 return 0;
209 }
210 xt_free_node(node);
211
212 return 1;
213 }
214
jabber_chat_leave(struct groupchat * c,const char * reason)215 int jabber_chat_leave(struct groupchat *c, const char *reason)
216 {
217 struct im_connection *ic = c->ic;
218 struct jabber_chat *jc = c->data;
219 struct xt_node *node;
220
221 node = xt_new_node("x", NULL, NULL);
222 xt_add_attr(node, "xmlns", XMLNS_MUC);
223 node = jabber_make_packet("presence", "unavailable", jc->my_full_jid, node);
224
225 if (!jabber_write_packet(ic, node)) {
226 xt_free_node(node);
227 return 0;
228 }
229 xt_free_node(node);
230
231 return 1;
232 }
233
jabber_chat_invite(struct groupchat * c,char * who,char * message)234 void jabber_chat_invite(struct groupchat *c, char *who, char *message)
235 {
236 struct xt_node *node;
237 struct im_connection *ic = c->ic;
238 struct jabber_chat *jc = c->data;
239
240 node = xt_new_node("reason", message, NULL);
241
242 node = xt_new_node("invite", NULL, node);
243 xt_add_attr(node, "to", who);
244
245 node = xt_new_node("x", NULL, node);
246 xt_add_attr(node, "xmlns", XMLNS_MUC_USER);
247
248 node = jabber_make_packet("message", NULL, jc->name, node);
249
250 jabber_write_packet(ic, node);
251
252 xt_free_node(node);
253 }
254
jabber_chat_has_other_resources(struct im_connection * ic,struct jabber_buddy * bud)255 static int jabber_chat_has_other_resources(struct im_connection *ic, struct jabber_buddy *bud)
256 {
257 struct jabber_buddy *cur;
258
259 for (cur = jabber_buddy_by_jid(ic, bud->bare_jid, GET_BUDDY_FIRST); cur; cur = cur->next) {
260 if (cur != bud && jabber_compare_jid(cur->ext_jid, bud->ext_jid)) {
261 return TRUE;
262 }
263 }
264
265 return FALSE;
266 }
267
268 /* Not really the same syntax as the normal pkt_ functions, but this isn't
269 called by the xmltree parser directly and this way I can add some extra
270 parameters so we won't have to repeat too many things done by the caller
271 already. */
jabber_chat_pkt_presence(struct im_connection * ic,struct jabber_buddy * bud,struct xt_node * node)272 void jabber_chat_pkt_presence(struct im_connection *ic, struct jabber_buddy *bud, struct xt_node *node)
273 {
274 struct groupchat *chat;
275 struct xt_node *c;
276 char *type = xt_find_attr(node, "type");
277 struct jabber_data *jd = ic->proto_data;
278 struct jabber_chat *jc;
279 char *s;
280
281 if ((chat = jabber_chat_by_jid(ic, bud->bare_jid)) == NULL) {
282 /* How could this happen?? We could do kill( self, 11 )
283 now or just wait for the OS to do it. :-) */
284 return;
285 }
286
287 jc = chat->data;
288
289 if (type == NULL && !(bud->flags & JBFLAG_IS_CHATROOM)) {
290 bud->flags |= JBFLAG_IS_CHATROOM;
291 /* If this one wasn't set yet, this buddy just joined the chat.
292 Slightly hackish way of finding out eh? ;-) */
293
294 /* This is pretty messy... Here it sets ext_jid to the real
295 JID of the participant. Works for non-anonymized channels.
296 Might break if someone joins a chat twice, though. */
297 for (c = node->children; (c = xt_find_node(c, "x")); c = c->next) {
298 if ((s = xt_find_attr(c, "xmlns")) &&
299 (strcmp(s, XMLNS_MUC_USER) == 0)) {
300 struct xt_node *item;
301
302 item = xt_find_node(c->children, "item");
303 if ((s = xt_find_attr(item, "jid"))) {
304 /* Yay, found what we need. :-) */
305 bud->ext_jid = jabber_normalize(s);
306 break;
307 }
308 }
309 }
310
311 /* Make up some other handle, if necessary. */
312 if (bud->ext_jid == NULL) {
313 if (bud == jc->me) {
314 bud->ext_jid = g_strdup(jd->me);
315 } else {
316 int i;
317
318 /* Don't want the nick to be at the end, so let's
319 think of some slightly different notation to use
320 for anonymous groupchat participants in BitlBee. */
321 bud->ext_jid = g_strdup_printf("%s=%s", bud->resource, bud->bare_jid);
322
323 /* And strip any unwanted characters. */
324 for (i = 0; bud->resource[i]; i++) {
325 if (bud->ext_jid[i] == '=' || bud->ext_jid[i] == '@') {
326 bud->ext_jid[i] = '_';
327 }
328 }
329 }
330 bud->flags |= JBFLAG_IS_ANONYMOUS;
331 } else if (bud == jc->me) {
332 g_free(bud->ext_jid);
333 bud->ext_jid = g_strdup(jd->me);
334 }
335
336 if (bud != jc->me && bud->flags & JBFLAG_IS_ANONYMOUS) {
337 /* If JIDs are anonymized, add them to the local
338 list for the duration of this chat. */
339 imcb_add_buddy(ic, bud->ext_jid, NULL);
340 imcb_buddy_nick_hint(ic, bud->ext_jid, bud->resource);
341 }
342
343 if (bud == jc->me && jc->invite != NULL) {
344 char *msg = g_strdup_printf("Please join me in room %s", jc->name);
345 jabber_chat_invite(chat, jc->invite, msg);
346 g_free(jc->invite);
347 g_free(msg);
348 jc->invite = NULL;
349 }
350
351 s = strchr(bud->ext_jid, '/');
352 if (s) {
353 *s = 0; /* Should NEVER be NULL, but who knows... */
354 }
355
356 imcb_chat_add_buddy(chat, bud->ext_jid);
357
358 if (bud != jc->me && (jc->flags & JCFLAG_ALWAYS_USE_NICKS) && !(bud->flags & JBFLAG_IS_ANONYMOUS)) {
359 imcb_buddy_nick_change(ic, bud->ext_jid, bud->resource);
360 }
361
362 if (s) {
363 *s = '/';
364 }
365 } else if (type) { /* type can only be NULL or "unavailable" in this function */
366 if ((bud->flags & JBFLAG_IS_CHATROOM) && bud->ext_jid && !jabber_chat_has_other_resources(ic, bud)) {
367 char *reason = NULL;
368 char *status = NULL;
369 char *status_text = NULL;
370
371 if ((c = xt_find_node_by_attr(node->children, "x", "xmlns", XMLNS_MUC_USER))) {
372 struct xt_node *c2 = c->children;
373
374 while ((c2 = xt_find_node(c2, "status"))) {
375 char *code = xt_find_attr(c2, "code");
376 if (g_strcmp0(code, "301") == 0) {
377 status = "Banned";
378 break;
379 } else if (g_strcmp0(code, "303") == 0) {
380 /* This could be handled in a cleverer way,
381 * but let's just show a literal part/join for now */
382 status = "Changing nicks";
383 break;
384 } else if (g_strcmp0(code, "307") == 0) {
385 status = "Kicked";
386 break;
387 }
388 c2 = c2->next;
389 }
390
391 /* Sometimes the status message is in presence/x/item/reason */
392 if ((c2 = xt_find_path(c, "item/reason")) && c2->text && c2->text_len) {
393 status_text = c2->text;
394 }
395 }
396
397 /* Sometimes the status message is right inside <presence> */
398 if ((c = xt_find_node(node->children, "status")) && c->text && c->text_len) {
399 status_text = c->text;
400 }
401
402 if (status_text && status) {
403 reason = g_strdup_printf("%s: %s", status, status_text);
404 } else {
405 reason = g_strdup(status_text ? : status);
406 }
407
408 s = strchr(bud->ext_jid, '/');
409 if (s) {
410 *s = 0;
411 }
412 imcb_chat_remove_buddy(chat, bud->ext_jid, reason);
413 if (bud != jc->me && bud->flags & JBFLAG_IS_ANONYMOUS) {
414 imcb_remove_buddy(ic, bud->ext_jid, reason);
415 }
416 if (s) {
417 *s = '/';
418 }
419
420 g_free(reason);
421 }
422
423 if (bud == jc->me) {
424 jabber_chat_free(chat);
425 }
426 }
427 }
428
jabber_chat_pkt_message(struct im_connection * ic,struct jabber_buddy * bud,struct xt_node * node)429 void jabber_chat_pkt_message(struct im_connection *ic, struct jabber_buddy *bud, struct xt_node *node)
430 {
431 struct xt_node *subject = xt_find_node(node->children, "subject");
432 struct xt_node *body = xt_find_node(node->children, "body");
433 struct groupchat *chat = NULL;
434 struct jabber_chat *jc = NULL;
435 char *from = NULL;
436 char *nick = NULL;
437 char *final_from = NULL;
438 char *bare_jid = NULL;
439 guint32 flags = 0;
440
441 from = (bud) ? bud->full_jid : xt_find_attr(node, "from");
442
443 if (from) {
444 nick = strchr(from, '/');
445 if (nick) {
446 *nick = 0;
447 }
448 chat = jabber_chat_by_jid(ic, from);
449 if (nick) {
450 *nick = '/';
451 nick++;
452 }
453 }
454
455 jc = (chat) ? chat->data : NULL;
456
457 if (!bud) {
458 struct xt_node *c;
459 char *s;
460
461 /* Try some clever stuff to find out the real JID here */
462 c = xt_find_node_by_attr(node->children, "delay", "xmlns", XMLNS_DELAY);
463
464 if (c && ((s = xt_find_attr(c, "from")) ||
465 (s = xt_find_attr(c, "from_jid")))) {
466 /* This won't be useful if it's the MUC JID */
467 if (!(jc && jabber_compare_jid(s, jc->name))) {
468 /* Hopefully this one makes more sense! */
469 bud = jabber_buddy_by_jid(ic, s, GET_BUDDY_FIRST | GET_BUDDY_CREAT);
470 }
471 }
472
473 }
474
475 if (subject && chat) {
476 char empty[1] = "";
477 char *subject_text = subject->text_len > 0 ? subject->text : empty;
478 if (g_strcmp0(chat->topic, subject_text) != 0) {
479 bare_jid = (bud) ? jabber_get_bare_jid(bud->ext_jid) : NULL;
480 imcb_chat_topic(chat, bare_jid, subject_text,
481 jabber_get_timestamp(node));
482 g_free(bare_jid);
483 bare_jid = NULL;
484 }
485 }
486
487 if (body == NULL || body->text_len == 0) {
488 /* Meh. Empty messages aren't very interesting, no matter
489 how much some servers love to send them. */
490 return;
491 }
492
493 if (chat == NULL) {
494 if (nick == NULL) {
495 imcb_log(ic, "System message from unknown groupchat %s: %s", from, body->text);
496 } else {
497 imcb_log(ic, "Groupchat message from unknown JID %s: %s", from, body->text);
498 }
499
500 return;
501 } else if (chat != NULL && bud == NULL && nick == NULL) {
502 imcb_chat_log(chat, "From conference server: %s", body->text);
503 return;
504 } else if (jc && jc->flags & JCFLAG_MESSAGE_SENT && bud == jc->me) {
505 if (jabber_cache_handle_packet(ic, node) == XT_ABORT) {
506 /* Self message marked by this bitlbee, don't show it */
507 return;
508 } else if (xt_find_attr(node, "id") == NULL &&
509 g_strcmp0(body->text, jc->last_sent_message) == 0) {
510 /* Some misbehaving servers (like slack) eat the ids and echo anyway.
511 * Try to detect those cases by comparing against the last sent message. */
512 return;
513 }
514 }
515
516 if (bud) {
517 bare_jid = jabber_get_bare_jid(bud->ext_jid ? bud->ext_jid : bud->full_jid);
518 final_from = bare_jid;
519 if (bud == jc->me || (g_strcasecmp(final_from, ic->acc->user) == 0)) {
520 flags = OPT_SELFMESSAGE;
521 }
522 } else {
523 final_from = nick;
524 }
525
526 imcb_chat_msg(chat, final_from, body->text, flags, jabber_get_timestamp(node));
527
528 g_free(bare_jid);
529 }
530