source: protocols/jabber/conference.c @ b097945

Last change on this file since b097945 was a04705b, checked in by dequis <dx@…>, at 2016-12-26T23:07:56Z

jabber: Workaround for servers (like slack) that send echoes without id

Just comparing the body of the last sent message. This isn't foolproof
and sending several messages quickly can make it fail, but it's less
annoying than before. The correct solution is still to fix the server.

In the case of slack I still recommend using the irc gateway instead.

  • Property mode set to 100644
File size: 14.9 KB
Line 
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
27static xt_status jabber_chat_join_failed(struct im_connection *ic, struct xt_node *node, struct xt_node *orig);
28static xt_status jabber_chat_self_message(struct im_connection *ic, struct xt_node *node, struct xt_node *orig);
29
30struct 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
76struct 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
114static 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
138static 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
144struct 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
163void 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
178int 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
197int 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
215int 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
234void 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
255static 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. */
272void 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                }
332
333                if (bud != jc->me && bud->flags & JBFLAG_IS_ANONYMOUS) {
334                        /* If JIDs are anonymized, add them to the local
335                           list for the duration of this chat. */
336                        imcb_add_buddy(ic, bud->ext_jid, NULL);
337                        imcb_buddy_nick_hint(ic, bud->ext_jid, bud->resource);
338                }
339
340                if (bud == jc->me && jc->invite != NULL) {
341                        char *msg = g_strdup_printf("Please join me in room %s", jc->name);
342                        jabber_chat_invite(chat, jc->invite, msg);
343                        g_free(jc->invite);
344                        g_free(msg);
345                        jc->invite = NULL;
346                }
347
348                s = strchr(bud->ext_jid, '/');
349                if (s) {
350                        *s = 0; /* Should NEVER be NULL, but who knows... */
351                }
352
353                if (bud != jc->me && (jc->flags & JCFLAG_ALWAYS_USE_NICKS) && !(bud->flags & JBFLAG_IS_ANONYMOUS)) {
354                        imcb_buddy_nick_change(ic, bud->ext_jid, bud->resource);
355                }
356
357                imcb_chat_add_buddy(chat, bud->ext_jid);
358                if (s) {
359                        *s = '/';
360                }
361        } else if (type) { /* type can only be NULL or "unavailable" in this function */
362                if ((bud->flags & JBFLAG_IS_CHATROOM) && bud->ext_jid && !jabber_chat_has_other_resources(ic, bud)) {
363                        char *reason = NULL;
364                        char *status = NULL;
365                        char *status_text = NULL;
366                       
367                        if ((c = xt_find_node_by_attr(node->children, "x", "xmlns", XMLNS_MUC_USER))) {
368                                struct xt_node *c2 = c->children;
369
370                                while ((c2 = xt_find_node(c2, "status"))) {
371                                        char *code = xt_find_attr(c2, "code");
372                                        if (g_strcmp0(code, "301") == 0) {
373                                                status = "Banned";
374                                                break;
375                                        } else if (g_strcmp0(code, "303") == 0) {
376                                                /* This could be handled in a cleverer way,
377                                                 * but let's just show a literal part/join for now */
378                                                status = "Changing nicks";
379                                                break;
380                                        } else if (g_strcmp0(code, "307") == 0) {
381                                                status = "Kicked";
382                                                break;
383                                        }
384                                        c2 = c2->next;
385                                }
386
387                                /* Sometimes the status message is in presence/x/item/reason */
388                                if ((c2 = xt_find_path(c, "item/reason")) && c2->text && c2->text_len) {
389                                        status_text = c2->text;
390                                }
391                        }
392
393                        /* Sometimes the status message is right inside <presence> */
394                        if ((c = xt_find_node(node->children, "status")) && c->text && c->text_len) {
395                                status_text = c->text;
396                        }
397
398                        if (status_text && status) {
399                                reason = g_strdup_printf("%s: %s", status, status_text);
400                        } else {
401                                reason = g_strdup(status_text ? : status);
402                        }
403
404                        s = strchr(bud->ext_jid, '/');
405                        if (s) {
406                                *s = 0;
407                        }
408                        imcb_chat_remove_buddy(chat, bud->ext_jid, reason);
409                        if (bud != jc->me && bud->flags & JBFLAG_IS_ANONYMOUS) {
410                                imcb_remove_buddy(ic, bud->ext_jid, reason);
411                        }
412                        if (s) {
413                                *s = '/';
414                        }
415
416                        g_free(reason);
417                }
418
419                if (bud == jc->me) {
420                        jabber_chat_free(chat);
421                }
422        }
423}
424
425void jabber_chat_pkt_message(struct im_connection *ic, struct jabber_buddy *bud, struct xt_node *node)
426{
427        struct xt_node *subject = xt_find_node(node->children, "subject");
428        struct xt_node *body = xt_find_node(node->children, "body");
429        struct groupchat *chat = NULL;
430        struct jabber_chat *jc = NULL;
431        char *from = NULL;
432        char *nick = NULL;
433        char *final_from = NULL;
434        char *bare_jid = NULL;
435        guint32 flags = 0;
436
437        from = (bud) ? bud->full_jid : xt_find_attr(node, "from");
438
439        if (from) {
440                nick = strchr(from, '/');
441                if (nick) {
442                        *nick = 0;
443                }
444                chat = jabber_chat_by_jid(ic, from);
445                if (nick) {
446                        *nick = '/';
447                        nick++;
448                }
449        }
450
451        jc = (chat) ? chat->data : NULL;
452
453        if (!bud) {
454                struct xt_node *c;
455                char *s;
456
457                /* Try some clever stuff to find out the real JID here */
458                c = xt_find_node_by_attr(node->children, "delay", "xmlns", XMLNS_DELAY);
459
460                if (c && ((s = xt_find_attr(c, "from")) ||
461                          (s = xt_find_attr(c, "from_jid")))) {
462                        /* This won't be useful if it's the MUC JID */
463                        if (!(jc && jabber_compare_jid(s, jc->name))) {
464                                /* Hopefully this one makes more sense! */
465                                bud = jabber_buddy_by_jid(ic, s, GET_BUDDY_FIRST | GET_BUDDY_CREAT);
466                        }
467                }
468
469        }
470
471        if (subject && chat) {
472                char empty[1] = "";
473                char *subject_text = subject->text_len > 0 ? subject->text : empty;
474                if (g_strcmp0(chat->topic, subject_text) != 0) {
475                        bare_jid = (bud) ? jabber_get_bare_jid(bud->ext_jid) : NULL;
476                        imcb_chat_topic(chat, bare_jid, subject_text,
477                                        jabber_get_timestamp(node));
478                        g_free(bare_jid);
479                        bare_jid = NULL;
480                }
481        }
482
483        if (body == NULL || body->text_len == 0) {
484                /* Meh. Empty messages aren't very interesting, no matter
485                   how much some servers love to send them. */
486                return;
487        }
488
489        if (chat == NULL) {
490                if (nick == NULL) {
491                        imcb_log(ic, "System message from unknown groupchat %s: %s", from, body->text);
492                } else {
493                        imcb_log(ic, "Groupchat message from unknown JID %s: %s", from, body->text);
494                }
495
496                return;
497        } else if (chat != NULL && bud == NULL && nick == NULL) {
498                imcb_chat_log(chat, "From conference server: %s", body->text);
499                return;
500        } else if (jc && jc->flags & JCFLAG_MESSAGE_SENT && bud == jc->me) {
501                if (jabber_cache_handle_packet(ic, node) == XT_ABORT) {
502                        /* Self message marked by this bitlbee, don't show it */
503                        return;
504                } else if (xt_find_attr(node, "id") == NULL &&
505                           g_strcmp0(body->text, jc->last_sent_message) == 0) {
506                        /* Some misbehaving servers (like slack) eat the ids and echo anyway.
507                         * Try to detect those cases by comparing against the last sent message. */
508                        return;
509                }
510        }
511
512        if (bud) {
513                bare_jid = jabber_get_bare_jid(bud->ext_jid ? bud->ext_jid : bud->full_jid);
514                final_from = bare_jid;
515                if (bud == jc->me || (g_strcasecmp(final_from, ic->acc->user) == 0)) {
516                        flags = OPT_SELFMESSAGE;
517                }
518        } else {
519                final_from = nick;
520        }
521
522        imcb_chat_msg(chat, final_from, body->text, flags, jabber_get_timestamp(node));
523
524        g_free(bare_jid);
525}
Note: See TracBrowser for help on using the repository browser.