source: irc_im.c @ 7801298

Last change on this file since 7801298 was 7801298, checked in by dequis <dx@…>, at 2016-12-27T17:24:50Z

Per-account handle_unknown

Credit for the idea goes to russian XMPP spammers. Thanks!

  • Property mode set to 100644
File size: 27.9 KB
Line 
1/********************************************************************\
2  * BitlBee -- An IRC to other IM-networks gateway                     *
3  *                                                                    *
4  * Copyright 2002-2012 Wilmer van der Gaast and others                *
5  \********************************************************************/
6
7/* Some glue to put the IRC and the IM stuff together.                  */
8
9/*
10  This program is free software; you can redistribute it and/or modify
11  it under the terms of the GNU General Public License as published by
12  the Free Software Foundation; either version 2 of the License, or
13  (at your option) any later version.
14
15  This program is distributed in the hope that it will be useful,
16  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  GNU General Public License for more details.
19
20  You should have received a copy of the GNU General Public License with
21  the Debian GNU/Linux distribution in /usr/share/common-licenses/GPL;
22  if not, write to the Free Software Foundation, Inc., 51 Franklin St.,
23  Fifth Floor, Boston, MA  02110-1301  USA
24*/
25
26#include "bitlbee.h"
27#include "dcc.h"
28
29/* IM->IRC callbacks: Simple IM/buddy-related stuff. */
30
31static const struct irc_user_funcs irc_user_im_funcs;
32
33static void bee_irc_imc_connected(struct im_connection *ic)
34{
35        irc_t *irc = (irc_t *) ic->bee->ui_data;
36
37        irc_channel_auto_joins(irc, ic->acc);
38}
39
40static void bee_irc_imc_disconnected(struct im_connection *ic)
41{
42        /* Maybe try to send /QUITs here instead of later on. */
43}
44
45static gboolean bee_irc_user_new(bee_t *bee, bee_user_t *bu)
46{
47        irc_user_t *iu;
48        irc_t *irc = (irc_t *) bee->ui_data;
49        char nick[MAX_NICK_LENGTH + 1], *s;
50
51        memset(nick, 0, MAX_NICK_LENGTH + 1);
52        strncpy(nick, nick_get(bu), MAX_NICK_LENGTH);
53
54        bu->ui_data = iu = irc_user_new(irc, nick);
55        iu->bu = bu;
56
57        if (set_getbool(&irc->b->set, "private")) {
58                iu->last_channel = NULL;
59        } else {
60                iu->last_channel = irc_channel_with_user(irc, iu);
61        }
62
63        if ((s = strchr(bu->handle, '@'))) {
64                iu->host = g_strdup(s + 1);
65                iu->user = g_strndup(bu->handle, s - bu->handle);
66        } else {
67                iu->user = g_strdup(bu->handle);
68                if (bu->ic->acc->server) {
69                        iu->host = g_strdup(bu->ic->acc->server);
70                } else {
71                        char *s;
72                        for (s = bu->ic->acc->tag; g_ascii_isalnum(*s); s++) {
73                                ;
74                        }
75                        /* Only use the tag if we got to the end of the string.
76                           (So allow alphanumerics only. Hopefully not too
77                           restrictive.) */
78                        if (*s) {
79                                iu->host = g_strdup(bu->ic->acc->prpl->name);
80                        } else {
81                                iu->host = g_strdup(bu->ic->acc->tag);
82                        }
83                }
84        }
85
86        /* Sanitize */
87        str_reject_chars(iu->user, " ", '_');
88        str_reject_chars(iu->host, " ", '_');
89
90        if (bu->flags & BEE_USER_LOCAL) {
91                char *s = set_getstr(&bu->ic->acc->set, "handle_unknown") ? :
92                          set_getstr(&bee->set, "handle_unknown");
93
94                if (g_strcasecmp(s, "add_private") == 0) {
95                        iu->last_channel = NULL;
96                } else if (g_strcasecmp(s, "add_channel") == 0) {
97                        iu->last_channel = irc->default_channel;
98                }
99        }
100
101        iu->f = &irc_user_im_funcs;
102
103        return TRUE;
104}
105
106static gboolean bee_irc_user_free(bee_t *bee, bee_user_t *bu)
107{
108        return irc_user_free(bee->ui_data, (irc_user_t *) bu->ui_data);
109}
110
111static gboolean bee_irc_user_status(bee_t *bee, bee_user_t *bu, bee_user_t *old)
112{
113        irc_t *irc = bee->ui_data;
114        irc_user_t *iu = bu->ui_data;
115
116        /* Do this outside the if below since away state can change without
117           the online state changing. */
118        iu->flags &= ~IRC_USER_AWAY;
119        if (bu->flags & BEE_USER_AWAY || !(bu->flags & BEE_USER_ONLINE)) {
120                iu->flags |= IRC_USER_AWAY;
121        }
122
123        if ((bu->flags & BEE_USER_ONLINE) != (old->flags & BEE_USER_ONLINE)) {
124                if (bu->flags & BEE_USER_ONLINE) {
125                        if (g_hash_table_lookup(irc->watches, iu->key)) {
126                                irc_send_num(irc, 600, "%s %s %s %d :%s", iu->nick, iu->user,
127                                             iu->host, (int) time(NULL), "logged online");
128                        }
129                } else {
130                        if (g_hash_table_lookup(irc->watches, iu->key)) {
131                                irc_send_num(irc, 601, "%s %s %s %d :%s", iu->nick, iu->user,
132                                             iu->host, (int) time(NULL), "logged offline");
133                        }
134
135                        /* Send a QUIT since those will also show up in any
136                           query windows the user may have, plus it's only
137                           one QUIT instead of possibly many (in case of
138                           multiple control chans). If there's a channel that
139                           shows offline people, a JOIN will follow. */
140                        if (set_getbool(&bee->set, "offline_user_quits")) {
141                                irc_user_quit(iu, "Leaving...");
142                        }
143                }
144        }
145
146        /* Reset this one since the info may have changed. */
147        iu->away_reply_timeout = 0;
148
149        bee_irc_channel_update(irc, NULL, iu);
150
151        /* If away-notify enabled, send status updates when:
152         * Away or Online state changes
153         * Status changes (e.g. "Away" to "Mobile")
154         * Status message changes
155         */
156        if ((irc->caps & CAP_AWAY_NOTIFY) &&
157            ((bu->flags & BEE_USER_AWAY) != (old->flags & BEE_USER_AWAY) ||
158             (bu->flags & BEE_USER_ONLINE) != (old->flags & BEE_USER_ONLINE) ||
159             (g_strcmp0(bu->status, old->status) != 0) ||
160             (g_strcmp0(bu->status_msg, old->status_msg) != 0))) {
161                irc_send_away_notify(iu);
162        }
163
164        return TRUE;
165}
166
167void bee_irc_channel_update(irc_t *irc, irc_channel_t *ic, irc_user_t *iu)
168{
169        GSList *l;
170
171        if (ic == NULL) {
172                for (l = irc->channels; l; l = l->next) {
173                        ic = l->data;
174                        /* TODO: Just add a type flag or so.. */
175                        if (ic->f == irc->default_channel->f &&
176                            (ic->flags & IRC_CHANNEL_JOINED)) {
177                                bee_irc_channel_update(irc, ic, iu);
178                        }
179                }
180                return;
181        }
182        if (iu == NULL) {
183                for (l = irc->users; l; l = l->next) {
184                        iu = l->data;
185                        if (iu->bu) {
186                                bee_irc_channel_update(irc, ic, l->data);
187                        }
188                }
189                return;
190        }
191
192        if (!irc_channel_wants_user(ic, iu)) {
193                irc_channel_del_user(ic, iu, IRC_CDU_PART, NULL);
194        } else {
195                struct irc_control_channel *icc = ic->data;
196                int mode = 0;
197
198                if (!(iu->bu->flags & BEE_USER_ONLINE)) {
199                        mode = icc->modes[0];
200                } else if (iu->bu->flags & BEE_USER_AWAY) {
201                        mode = icc->modes[1];
202                } else if (iu->bu->flags & BEE_USER_SPECIAL) {
203                        mode = icc->modes[2];
204                } else {
205                        mode = icc->modes[3];
206                }
207
208                if (!mode) {
209                        irc_channel_del_user(ic, iu, IRC_CDU_PART, NULL);
210                } else {
211                        irc_channel_add_user(ic, iu);
212                        irc_channel_user_set_mode(ic, iu, mode);
213                }
214        }
215}
216
217static gboolean bee_irc_user_msg(bee_t *bee, bee_user_t *bu, const char *msg_, guint32 flags, time_t sent_at)
218{
219        irc_t *irc = bee->ui_data;
220        irc_user_t *iu = (irc_user_t *) bu->ui_data;
221        irc_user_t *src_iu = iu;
222        irc_user_t *dst_iu = irc->user;
223        const char *dst;
224        char *prefix = NULL;
225        char *wrapped, *ts = NULL;
226        char *msg = g_strdup(msg_);
227        char *message_type = "PRIVMSG";
228        GSList *l;
229
230        if (sent_at > 0 && set_getbool(&irc->b->set, "display_timestamps")) {
231                ts = irc_format_timestamp(irc, sent_at);
232        }
233
234        dst = irc_user_msgdest(iu);
235
236        if (flags & OPT_SELFMESSAGE) {
237                char *setting = set_getstr(&irc->b->set, "self_messages");
238
239                if (is_bool(setting)) {
240                        if (bool2int(setting)) {
241                                /* set to true, send it with src/dst flipped */
242                               
243                                dst_iu = iu;
244                                src_iu = irc->user;
245
246                                if (dst == irc->user->nick) {
247                                        dst = dst_iu->nick;
248                                }
249                        } else {
250                                /* set to false, skip the message completely */
251                                goto cleanup;
252                        }
253                } else if (g_strncasecmp(setting, "prefix", 6) == 0) {
254                        /* third state, prefix, loosely imitates the znc privmsg_prefix module */
255
256                        g_free(msg);
257                        if (g_strncasecmp(msg_, "/me ", 4) == 0) {
258                                msg = g_strdup_printf("/me -> %s", msg_ + 4);
259                        } else {
260                                msg = g_strdup_printf("-> %s", msg_);
261                        }
262
263                        if (g_strcasecmp(setting, "prefix_notice") == 0) {
264                                message_type = "NOTICE";
265                        }
266                }
267
268        }
269
270        if (dst != dst_iu->nick) {
271                /* if not messaging directly (control channel), call user by name */
272                prefix = g_strdup_printf("%s%s%s", dst_iu->nick, set_getstr(&bee->set, "to_char"), ts ? : "");
273        } else {
274                prefix = ts;
275                ts = NULL;      /* don't double-free */
276        }
277
278        for (l = irc_plugins; l; l = l->next) {
279                irc_plugin_t *p = l->data;
280                if (p->filter_msg_in) {
281                        char *s = p->filter_msg_in(iu, msg, 0);
282                        if (s) {
283                                if (s != msg) {
284                                        g_free(msg);
285                                }
286                                msg = s;
287                        } else {
288                                /* Modules can swallow messages. */
289                                goto cleanup;
290                        }
291                }
292        }
293
294        if ((g_strcasecmp(set_getstr(&bee->set, "strip_html"), "always") == 0) ||
295            ((bu->ic->flags & OPT_DOES_HTML) && set_getbool(&bee->set, "strip_html"))) {
296                char *s = g_strdup(msg);
297                strip_html(s);
298                g_free(msg);
299                msg = s;
300        }
301
302        wrapped = word_wrap(msg, IRC_WORD_WRAP);
303        irc_send_msg(src_iu, message_type, dst, wrapped, prefix);
304        g_free(wrapped);
305
306cleanup:
307        g_free(prefix);
308        g_free(msg);
309        g_free(ts);
310
311        return TRUE;
312}
313
314static gboolean bee_irc_user_typing(bee_t *bee, bee_user_t *bu, guint32 flags)
315{
316        irc_t *irc = (irc_t *) bee->ui_data;
317
318        if (set_getbool(&bee->set, "typing_notice")) {
319                irc_send_msg_f((irc_user_t *) bu->ui_data, "PRIVMSG", irc->user->nick,
320                               "\001TYPING %d\001", (flags >> 8) & 3);
321        } else {
322                return FALSE;
323        }
324
325        return TRUE;
326}
327
328static gboolean bee_irc_user_action_response(bee_t *bee, bee_user_t *bu, const char *action, char * const args[],
329                                             void *data)
330{
331        irc_t *irc = (irc_t *) bee->ui_data;
332        GString *msg = g_string_new("\001");
333
334        g_string_append(msg, action);
335        while (*args) {
336                if (strchr(*args, ' ')) {
337                        g_string_append_printf(msg, " \"%s\"", *args);
338                } else {
339                        g_string_append_printf(msg, " %s", *args);
340                }
341                args++;
342        }
343        g_string_append_c(msg, '\001');
344
345        irc_send_msg((irc_user_t *) bu->ui_data, "NOTICE", irc->user->nick, msg->str, NULL);
346
347        g_string_free(msg, TRUE);
348
349        return TRUE;
350}
351
352static gboolean bee_irc_user_nick_update(irc_user_t *iu, gboolean offline_only);
353
354static gboolean bee_irc_user_fullname(bee_t *bee, bee_user_t *bu)
355{
356        irc_user_t *iu = (irc_user_t *) bu->ui_data;
357        char *s;
358
359        if (iu->fullname != iu->nick) {
360                g_free(iu->fullname);
361        }
362        iu->fullname = g_strdup(bu->fullname);
363
364        /* Strip newlines (unlikely, but IRC-unfriendly so they must go)
365           TODO(wilmer): Do the same with away msgs again! */
366        for (s = iu->fullname; *s; s++) {
367                if (g_ascii_isspace(*s)) {
368                        *s = ' ';
369                }
370        }
371
372        if ((bu->ic->flags & OPT_LOGGED_IN) && set_getbool(&bee->set, "display_namechanges")) {
373                /* People don't like this /NOTICE. Meh, let's go back to the old one.
374                char *msg = g_strdup_printf( "<< \002BitlBee\002 - Changed name to `%s' >>", iu->fullname );
375                irc_send_msg( iu, "NOTICE", irc->user->nick, msg, NULL );
376                */
377                imcb_log(bu->ic, "User `%s' changed name to `%s'", iu->nick, iu->fullname);
378        }
379
380        bee_irc_user_nick_update(iu, TRUE);
381
382        return TRUE;
383}
384
385static gboolean bee_irc_user_nick_hint(bee_t *bee, bee_user_t *bu, const char *hint)
386{
387        bee_irc_user_nick_update((irc_user_t *) bu->ui_data, TRUE);
388
389        return TRUE;
390}
391
392static gboolean bee_irc_user_nick_change(bee_t *bee, bee_user_t *bu, const char *nick)
393{
394        bee_irc_user_nick_update((irc_user_t *) bu->ui_data, FALSE);
395
396        return TRUE;
397}
398
399static gboolean bee_irc_user_group(bee_t *bee, bee_user_t *bu)
400{
401        irc_user_t *iu = (irc_user_t *) bu->ui_data;
402        irc_t *irc = (irc_t *) bee->ui_data;
403
404        bee_irc_channel_update(irc, NULL, iu);
405        bee_irc_user_nick_update(iu, FALSE);
406
407        return TRUE;
408}
409
410static gboolean bee_irc_user_nick_update(irc_user_t *iu, gboolean offline_only)
411{
412        bee_user_t *bu = iu->bu;
413        char *newnick;
414
415        if (offline_only && bu->flags & BEE_USER_ONLINE) {
416                /* Ignore if the user is visible already. */
417                return TRUE;
418        }
419
420        if (nick_saved(bu)) {
421                /* The user already assigned a nickname to this person. */
422                return TRUE;
423        }
424
425        newnick = nick_get(bu);
426
427        if (strcmp(iu->nick, newnick) != 0) {
428                nick_dedupe(bu, newnick);
429                irc_user_set_nick(iu, newnick);
430        }
431
432        return TRUE;
433}
434
435void bee_irc_user_nick_reset(irc_user_t *iu)
436{
437        bee_user_t *bu = iu->bu;
438
439        if (bu == FALSE) {
440                return;
441        }
442
443        nick_del(bu);
444        bee_irc_user_nick_update(iu, FALSE);
445
446}
447
448/* IRC->IM calls */
449
450static gboolean bee_irc_user_privmsg_cb(gpointer data, gint fd, b_input_condition cond);
451
452static gboolean bee_irc_user_privmsg(irc_user_t *iu, const char *msg)
453{
454        const char *away;
455
456        if (iu->bu == NULL) {
457                return FALSE;
458        }
459
460        if (iu->last_channel == NULL &&
461            (away = irc_user_get_away(iu)) &&
462            time(NULL) >= iu->away_reply_timeout) {
463                irc_send_num(iu->irc, 301, "%s :%s", iu->nick, away);
464                iu->away_reply_timeout = time(NULL) +
465                                         set_getint(&iu->irc->b->set, "away_reply_timeout");
466        }
467
468        if (iu->pastebuf == NULL) {
469                iu->pastebuf = g_string_new(msg);
470        } else {
471                b_event_remove(iu->pastebuf_timer);
472                g_string_append_printf(iu->pastebuf, "\n%s", msg);
473        }
474
475        if (set_getbool(&iu->irc->b->set, "paste_buffer")) {
476                int delay;
477
478                if ((delay = set_getint(&iu->irc->b->set, "paste_buffer_delay")) <= 5) {
479                        delay *= 1000;
480                }
481
482                iu->pastebuf_timer = b_timeout_add(delay, bee_irc_user_privmsg_cb, iu);
483
484                return TRUE;
485        } else {
486                bee_irc_user_privmsg_cb(iu, 0, 0);
487
488                return TRUE;
489        }
490}
491
492static gboolean bee_irc_user_privmsg_cb(gpointer data, gint fd, b_input_condition cond)
493{
494        irc_user_t *iu = data;
495        char *msg;
496        GSList *l;
497
498        msg = g_string_free(iu->pastebuf, FALSE);
499        iu->pastebuf = NULL;
500        iu->pastebuf_timer = 0;
501
502        for (l = irc_plugins; l; l = l->next) {
503                irc_plugin_t *p = l->data;
504                if (p->filter_msg_out) {
505                        char *s = p->filter_msg_out(iu, msg, 0);
506                        if (s) {
507                                if (s != msg) {
508                                        g_free(msg);
509                                }
510                                msg = s;
511                        } else {
512                                /* Modules can swallow messages. */
513                                iu->pastebuf = NULL;
514                                g_free(msg);
515                                return FALSE;
516                        }
517                }
518        }
519
520        bee_user_msg(iu->irc->b, iu->bu, msg, 0);
521
522        g_free(msg);
523
524        return FALSE;
525}
526
527static gboolean bee_irc_user_ctcp(irc_user_t *iu, char *const *ctcp)
528{
529        if (ctcp[1] && g_strcasecmp(ctcp[0], "DCC") == 0
530            && g_strcasecmp(ctcp[1], "SEND") == 0) {
531                if (iu->bu && iu->bu->ic && iu->bu->ic->acc->prpl->transfer_request) {
532                        file_transfer_t *ft = dcc_request(iu->bu->ic, ctcp);
533                        if (ft) {
534                                iu->bu->ic->acc->prpl->transfer_request(iu->bu->ic, ft, iu->bu->handle);
535                        }
536
537                        return TRUE;
538                }
539        } else if (g_strcasecmp(ctcp[0], "TYPING") == 0) {
540                if (iu->bu && iu->bu->ic && iu->bu->ic->acc->prpl->send_typing && ctcp[1]) {
541                        int st = ctcp[1][0];
542                        if (st >= '0' && st <= '2') {
543                                st <<= 8;
544                                iu->bu->ic->acc->prpl->send_typing(iu->bu->ic, iu->bu->handle, st);
545                        }
546
547                        return TRUE;
548                }
549        } else if (g_strcasecmp(ctcp[0], "HELP") == 0 && iu->bu) {
550                GString *supp = g_string_new("Supported CTCPs:");
551                GList *l;
552
553                if (iu->bu->ic && iu->bu->ic->acc->prpl->transfer_request) {
554                        g_string_append(supp, " DCC SEND,");
555                }
556                if (iu->bu->ic && iu->bu->ic->acc->prpl->send_typing) {
557                        g_string_append(supp, " TYPING,");
558                }
559                if (iu->bu->ic->acc->prpl->buddy_action_list) {
560                        for (l = iu->bu->ic->acc->prpl->buddy_action_list(iu->bu); l; l = l->next) {
561                                struct buddy_action *ba = l->data;
562                                g_string_append_printf(supp, " %s (%s),",
563                                                       ba->name, ba->description);
564                        }
565                }
566                g_string_truncate(supp, supp->len - 1);
567                irc_send_msg_f(iu, "NOTICE", iu->irc->user->nick, "\001HELP %s\001", supp->str);
568                g_string_free(supp, TRUE);
569        } else if (iu->bu && iu->bu->ic && iu->bu->ic->acc->prpl->buddy_action) {
570                iu->bu->ic->acc->prpl->buddy_action(iu->bu, ctcp[0], ctcp + 1, NULL);
571        }
572
573        return FALSE;
574}
575
576static const struct irc_user_funcs irc_user_im_funcs = {
577        bee_irc_user_privmsg,
578        bee_irc_user_ctcp,
579};
580
581
582/* IM->IRC: Groupchats */
583const struct irc_channel_funcs irc_channel_im_chat_funcs;
584
585static gboolean bee_irc_chat_new(bee_t *bee, struct groupchat *c)
586{
587        irc_t *irc = bee->ui_data;
588        irc_channel_t *ic;
589        char *topic;
590        GSList *l;
591        int i;
592
593        /* Try to find a channel that expects to receive a groupchat.
594           This flag is set earlier in our current call trace. */
595        for (l = irc->channels; l; l = l->next) {
596                ic = l->data;
597                if (ic->flags & IRC_CHANNEL_CHAT_PICKME) {
598                        break;
599                }
600        }
601
602        /* If we found none, just generate some stupid name. */
603        if (l == NULL) {
604                for (i = 0; i <= 999; i++) {
605                        char name[16];
606                        sprintf(name, "#chat_%03d", i);
607                        if ((ic = irc_channel_new(irc, name))) {
608                                break;
609                        }
610                }
611        }
612
613        if (ic == NULL) {
614                return FALSE;
615        }
616
617        c->ui_data = ic;
618        ic->data = c;
619
620        topic = g_strdup_printf(
621                "BitlBee groupchat: \"%s\". Please keep in mind that root-commands won't work here. Have fun!",
622                c->title);
623        irc_channel_set_topic(ic, topic, irc->root);
624        g_free(topic);
625
626        return TRUE;
627}
628
629static gboolean bee_irc_chat_free(bee_t *bee, struct groupchat *c)
630{
631        irc_channel_t *ic = c->ui_data;
632
633        if (ic == NULL) {
634                return FALSE;
635        }
636
637        ic->data = NULL;
638        c->ui_data = NULL;
639        irc_channel_del_user(ic, ic->irc->user, IRC_CDU_KICK, "Chatroom closed by server");
640
641        return TRUE;
642}
643
644static gboolean bee_irc_chat_log(bee_t *bee, struct groupchat *c, const char *text)
645{
646        irc_channel_t *ic = c->ui_data;
647
648        if (ic == NULL) {
649                return FALSE;
650        }
651
652        irc_channel_printf(ic, "%s", text);
653
654        return TRUE;
655}
656
657static gboolean bee_irc_chat_msg(bee_t *bee, struct groupchat *c, bee_user_t *bu, const char *msg, guint32 flags, time_t sent_at)
658{
659        irc_t *irc = bee->ui_data;
660        irc_user_t *iu = flags & OPT_SELFMESSAGE ? irc->user : bu->ui_data;
661        irc_channel_t *ic = c->ui_data;
662        char *wrapped, *ts = NULL;
663
664        if (ic == NULL) {
665                return FALSE;
666        }
667
668        if (sent_at > 0 && set_getbool(&bee->set, "display_timestamps")) {
669                ts = irc_format_timestamp(irc, sent_at);
670        }
671
672        wrapped = word_wrap(msg, IRC_WORD_WRAP);
673        irc_send_msg(iu, "PRIVMSG", ic->name, wrapped, ts);
674        g_free(ts);
675        g_free(wrapped);
676
677        return TRUE;
678}
679
680static gboolean bee_irc_chat_add_user(bee_t *bee, struct groupchat *c, bee_user_t *bu)
681{
682        irc_t *irc = bee->ui_data;
683        irc_channel_t *ic = c->ui_data;
684
685        if (ic == NULL) {
686                return FALSE;
687        }
688
689        irc_channel_add_user(ic, bu == bee->user ? irc->user : bu->ui_data);
690
691        return TRUE;
692}
693
694static gboolean bee_irc_chat_remove_user(bee_t *bee, struct groupchat *c, bee_user_t *bu, const char *reason)
695{
696        irc_t *irc = bee->ui_data;
697        irc_channel_t *ic = c->ui_data;
698
699        if (ic == NULL || bu == NULL) {
700                return FALSE;
701        }
702
703        /* TODO: Possible bug here: If a module removes $user here instead of just
704           using imcb_chat_free() and the channel was IRC_CHANNEL_TEMP, we get into
705           a broken state around here. */
706        irc_channel_del_user(ic, bu == bee->user ? irc->user : bu->ui_data, IRC_CDU_PART, reason);
707
708        return TRUE;
709}
710
711static gboolean bee_irc_chat_topic(bee_t *bee, struct groupchat *c, const char *new, bee_user_t *bu)
712{
713        irc_channel_t *ic = c->ui_data;
714        irc_t *irc = bee->ui_data;
715        irc_user_t *iu;
716
717        if (ic == NULL) {
718                return FALSE;
719        }
720
721        if (bu == NULL) {
722                iu = irc->root;
723        } else if (bu == bee->user) {
724                iu = irc->user;
725        } else {
726                iu = bu->ui_data;
727        }
728
729        irc_channel_set_topic(ic, new, iu);
730
731        return TRUE;
732}
733
734static gboolean bee_irc_chat_name_hint(bee_t *bee, struct groupchat *c, const char *name)
735{
736        return irc_channel_name_hint(c->ui_data, name);
737}
738
739static gboolean bee_irc_chat_invite(bee_t *bee, bee_user_t *bu, const char *name, const char *msg)
740{
741        char *channel, *s;
742        irc_t *irc = bee->ui_data;
743        irc_user_t *iu = bu->ui_data;
744        irc_channel_t *chan;
745
746        if (strchr(CTYPES, name[0])) {
747                channel = g_strdup(name);
748        } else {
749                channel = g_strdup_printf("#%s", name);
750        }
751
752        if ((s = strchr(channel, '@'))) {
753                *s = '\0';
754        }
755
756        if (strlen(channel) > MAX_NICK_LENGTH) {
757                /* If the channel name is very long (like those insane GTalk
758                   UUID names), try if we can use the inviter's nick. */
759                s = g_strdup_printf("#%s", iu->nick);
760                if (irc_channel_by_name(irc, s) == NULL) {
761                        g_free(channel);
762                        channel = s;
763                } else {
764                        g_free(s);
765                }
766        }
767
768        if ((chan = irc_channel_new(irc, channel)) &&
769            set_setstr(&chan->set, "type", "chat") &&
770            set_setstr(&chan->set, "chat_type", "room") &&
771            set_setstr(&chan->set, "account", bu->ic->acc->tag) &&
772            set_setstr(&chan->set, "room", (char *) name)) {
773                /* I'm assuming that if the user didn't "chat add" the room
774                   himself but got invited, it's temporary, so make this a
775                   temporary mapping that is removed as soon as we /PART. */
776                chan->flags |= IRC_CHANNEL_TEMP;
777        } else {
778                irc_channel_free(chan);
779                chan = NULL;
780        }
781        g_free(channel);
782
783        irc_send_msg_f(iu, "PRIVMSG", irc->user->nick, "<< \002BitlBee\002 - Invitation to chatroom %s >>", name);
784        if (msg) {
785                irc_send_msg(iu, "PRIVMSG", irc->user->nick, msg, NULL);
786        }
787        if (chan) {
788                irc_send_msg_f(iu, "PRIVMSG", irc->user->nick, "To join the room, just /join %s", chan->name);
789                irc_send_invite(iu, chan);
790        }
791
792        return TRUE;
793}
794
795/* IRC->IM */
796static gboolean bee_irc_channel_chat_privmsg_cb(gpointer data, gint fd, b_input_condition cond);
797
798static gboolean bee_irc_channel_chat_privmsg(irc_channel_t *ic, const char *msg)
799{
800        struct groupchat *c = ic->data;
801        char *trans = NULL, *s;
802
803        if (c == NULL) {
804                return FALSE;
805        }
806
807        if (set_getbool(&ic->set, "translate_to_nicks")) {
808                char nick[MAX_NICK_LENGTH + 1];
809                irc_user_t *iu;
810
811                strncpy(nick, msg, MAX_NICK_LENGTH);
812                nick[MAX_NICK_LENGTH] = '\0';
813                if ((s = strchr(nick, ':')) || (s = strchr(nick, ','))) {
814                        *s = '\0';
815                        if ((iu = irc_user_by_name(ic->irc, nick)) && iu->bu &&
816                            iu->bu->nick && irc_channel_has_user(ic, iu)) {
817                                trans = g_strconcat(iu->bu->nick, msg + (s - nick), NULL);
818                                msg = trans;
819                        }
820                }
821        }
822
823        if (set_getbool(&ic->irc->b->set, "paste_buffer")) {
824                int delay;
825
826                if (ic->pastebuf == NULL) {
827                        ic->pastebuf = g_string_new(msg);
828                } else {
829                        b_event_remove(ic->pastebuf_timer);
830                        g_string_append_printf(ic->pastebuf, "\n%s", msg);
831                }
832
833                if ((delay = set_getint(&ic->irc->b->set, "paste_buffer_delay")) <= 5) {
834                        delay *= 1000;
835                }
836
837                ic->pastebuf_timer = b_timeout_add(delay, bee_irc_channel_chat_privmsg_cb, ic);
838
839                g_free(trans);
840                return TRUE;
841        } else {
842                bee_chat_msg(ic->irc->b, c, msg, 0);
843        }
844
845        g_free(trans);
846        return TRUE;
847}
848
849static gboolean bee_irc_channel_chat_privmsg_cb(gpointer data, gint fd, b_input_condition cond)
850{
851        irc_channel_t *ic = data;
852
853        if (ic->data) {
854                bee_chat_msg(ic->irc->b, ic->data, ic->pastebuf->str, 0);
855        }
856
857        g_string_free(ic->pastebuf, TRUE);
858        ic->pastebuf = 0;
859        ic->pastebuf_timer = 0;
860
861        return FALSE;
862}
863
864static gboolean bee_irc_channel_chat_join(irc_channel_t *ic)
865{
866        char *acc_s, *room;
867        account_t *acc;
868
869        if (strcmp(set_getstr(&ic->set, "chat_type"), "room") != 0) {
870                return TRUE;
871        }
872
873        if ((acc_s = set_getstr(&ic->set, "account")) &&
874            (room = set_getstr(&ic->set, "room")) &&
875            (acc = account_get(ic->irc->b, acc_s)) &&
876            acc->ic && (acc->ic->flags & OPT_LOGGED_IN) &&
877            acc->prpl->chat_join) {
878                char *nick;
879                struct groupchat *gc;
880
881                if (!(nick = set_getstr(&ic->set, "nick"))) {
882                        nick = ic->irc->user->nick;
883                }
884
885                ic->flags |= IRC_CHANNEL_CHAT_PICKME;
886                gc = acc->prpl->chat_join(acc->ic, room, nick, NULL, &ic->set);
887                ic->flags &= ~IRC_CHANNEL_CHAT_PICKME;
888
889                if (!gc) {
890                        irc_send_num(ic->irc, 403, "%s :Error joining channel (check control channel?)", ic->name);
891                }
892
893                return FALSE;
894        } else {
895                irc_send_num(ic->irc, 403, "%s :Can't join channel, account offline?", ic->name);
896                return FALSE;
897        }
898}
899
900static gboolean bee_irc_channel_chat_part(irc_channel_t *ic, const char *msg)
901{
902        struct groupchat *c = ic->data;
903
904        if (c && c->ic->acc->prpl->chat_leave) {
905                c->ic->acc->prpl->chat_leave(c);
906        }
907
908        if (!(ic->flags & IRC_CHANNEL_TEMP)) {
909                /* Remove the reference.
910                 * We only need it for temp channels that are being freed */
911                ic->data = NULL;
912        }
913
914        return TRUE;
915}
916
917static gboolean bee_irc_channel_chat_topic(irc_channel_t *ic, const char *new)
918{
919        struct groupchat *c = ic->data;
920
921        if (c == NULL) {
922                return FALSE;
923        }
924
925        if (c->ic->acc->prpl->chat_topic == NULL) {
926                irc_send_num(ic->irc, 482, "%s :IM network does not support channel topics", ic->name);
927        } else {
928                /* TODO: Need more const goodness here, sigh */
929                char *topic = g_strdup(new);
930                c->ic->acc->prpl->chat_topic(c, topic);
931                g_free(topic);
932        }
933
934        /* Whatever happened, the IM module should ack the topic change. */
935        return FALSE;
936}
937
938static gboolean bee_irc_channel_chat_invite(irc_channel_t *ic, irc_user_t *iu)
939{
940        struct groupchat *c = ic->data;
941        bee_user_t *bu = iu->bu;
942
943        if (bu == NULL) {
944                return FALSE;
945        }
946
947        if (c) {
948                if (iu->bu->ic != c->ic) {
949                        irc_send_num(ic->irc, 482, "%s :Can't mix different IM networks in one groupchat", ic->name);
950                } else if (c->ic->acc->prpl->chat_invite) {
951                        c->ic->acc->prpl->chat_invite(c, iu->bu->handle, NULL);
952                } else {
953                        irc_send_num(ic->irc, 482, "%s :IM protocol does not support room invitations", ic->name);
954                }
955        } else if (bu->ic->acc->prpl->chat_with &&
956                   strcmp(set_getstr(&ic->set, "chat_type"), "groupchat") == 0) {
957                ic->flags |= IRC_CHANNEL_CHAT_PICKME;
958                iu->bu->ic->acc->prpl->chat_with(bu->ic, bu->handle);
959                ic->flags &= ~IRC_CHANNEL_CHAT_PICKME;
960        } else {
961                irc_send_num(ic->irc, 482, "%s :IM protocol does not support room invitations", ic->name);
962        }
963
964        return TRUE;
965}
966
967static void bee_irc_channel_chat_kick(irc_channel_t *ic, irc_user_t *iu, const char *msg)
968{
969        struct groupchat *c = ic->data;
970        bee_user_t *bu = iu->bu;
971
972        if ((c == NULL) || (bu == NULL)) {
973                return;
974        }
975
976        if (!c->ic->acc->prpl->chat_kick) {
977                irc_send_num(ic->irc, 482, "%s :IM protocol does not support room kicking", ic->name);
978                return;
979        }
980
981        c->ic->acc->prpl->chat_kick(c, iu->bu->handle, msg);
982}
983
984static char *set_eval_room_account(set_t *set, char *value);
985static char *set_eval_chat_type(set_t *set, char *value);
986
987static gboolean bee_irc_channel_init(irc_channel_t *ic)
988{
989        set_t *s;
990
991        set_add(&ic->set, "account", NULL, set_eval_room_account, ic);
992        set_add(&ic->set, "chat_type", "groupchat", set_eval_chat_type, ic);
993
994        s = set_add(&ic->set, "nick", NULL, NULL, ic);
995        s->flags |= SET_NULL_OK;
996
997        set_add(&ic->set, "room", NULL, NULL, ic);
998        set_add(&ic->set, "translate_to_nicks", "true", set_eval_bool, ic);
999
1000        /* chat_type == groupchat */
1001        ic->flags |= IRC_CHANNEL_TEMP;
1002
1003        return TRUE;
1004}
1005
1006static char *set_eval_room_account(set_t *set, char *value)
1007{
1008        struct irc_channel *ic = set->data;
1009        account_t *acc, *oa;
1010
1011        if (!(acc = account_get(ic->irc->b, value))) {
1012                return SET_INVALID;
1013        } else if (!acc->prpl->chat_join && acc->prpl != &protocol_missing) {
1014                irc_rootmsg(ic->irc, "Named chatrooms not supported on that account.");
1015                return SET_INVALID;
1016        }
1017
1018        if (set->value && (oa = account_get(ic->irc->b, set->value)) &&
1019            oa->prpl->chat_free_settings) {
1020                oa->prpl->chat_free_settings(oa, &ic->set);
1021        }
1022
1023        if (acc->prpl->chat_add_settings) {
1024                acc->prpl->chat_add_settings(acc, &ic->set);
1025        }
1026
1027        return g_strdup(acc->tag);
1028}
1029
1030static char *set_eval_chat_type(set_t *set, char *value)
1031{
1032        struct irc_channel *ic = set->data;
1033
1034        if (strcmp(value, "groupchat") == 0) {
1035                ic->flags |= IRC_CHANNEL_TEMP;
1036        } else if (strcmp(value, "room") == 0) {
1037                ic->flags &= ~IRC_CHANNEL_TEMP;
1038        } else {
1039                return NULL;
1040        }
1041
1042        return value;
1043}
1044
1045static gboolean bee_irc_channel_free(irc_channel_t *ic)
1046{
1047        struct groupchat *c = ic->data;
1048
1049        set_del(&ic->set, "account");
1050        set_del(&ic->set, "chat_type");
1051        set_del(&ic->set, "nick");
1052        set_del(&ic->set, "room");
1053        set_del(&ic->set, "translate_to_nicks");
1054
1055        ic->flags &= ~IRC_CHANNEL_TEMP;
1056
1057        /* That one still points at this channel. Don't. */
1058        if (c) {
1059                c->ui_data = NULL;
1060        }
1061
1062        return TRUE;
1063}
1064
1065const struct irc_channel_funcs irc_channel_im_chat_funcs = {
1066        bee_irc_channel_chat_privmsg,
1067        bee_irc_channel_chat_join,
1068        bee_irc_channel_chat_part,
1069        bee_irc_channel_chat_topic,
1070        bee_irc_channel_chat_invite,
1071        bee_irc_channel_chat_kick,
1072
1073        bee_irc_channel_init,
1074        bee_irc_channel_free,
1075};
1076
1077
1078/* IM->IRC: File transfers */
1079static file_transfer_t *bee_irc_ft_in_start(bee_t *bee, bee_user_t *bu, const char *file_name, size_t file_size)
1080{
1081        return dccs_send_start(bu->ic, (irc_user_t *) bu->ui_data, file_name, file_size);
1082}
1083
1084static gboolean bee_irc_ft_out_start(struct im_connection *ic, file_transfer_t *ft)
1085{
1086        return dccs_recv_start(ft);
1087}
1088
1089static void bee_irc_ft_close(struct im_connection *ic, file_transfer_t *ft)
1090{
1091        return dcc_close(ft);
1092}
1093
1094static void bee_irc_ft_finished(struct im_connection *ic, file_transfer_t *file)
1095{
1096        dcc_file_transfer_t *df = file->priv;
1097
1098        if (file->bytes_transferred >= file->file_size) {
1099                dcc_finish(file);
1100        } else {
1101                df->proto_finished = TRUE;
1102        }
1103}
1104
1105static void bee_irc_log(bee_t *bee, const char *tag, const char *msg)
1106{
1107        irc_t *irc = (irc_t *) bee->ui_data;
1108
1109        irc_rootmsg(irc, "%s - %s", tag, msg);
1110}
1111
1112const struct bee_ui_funcs irc_ui_funcs = {
1113        bee_irc_imc_connected,
1114        bee_irc_imc_disconnected,
1115
1116        bee_irc_user_new,
1117        bee_irc_user_free,
1118        bee_irc_user_fullname,
1119        bee_irc_user_nick_hint,
1120        bee_irc_user_group,
1121        bee_irc_user_status,
1122        bee_irc_user_msg,
1123        bee_irc_user_typing,
1124        bee_irc_user_action_response,
1125
1126        bee_irc_chat_new,
1127        bee_irc_chat_free,
1128        bee_irc_chat_log,
1129        bee_irc_chat_msg,
1130        bee_irc_chat_add_user,
1131        bee_irc_chat_remove_user,
1132        bee_irc_chat_topic,
1133        bee_irc_chat_name_hint,
1134        bee_irc_chat_invite,
1135
1136        bee_irc_ft_in_start,
1137        bee_irc_ft_out_start,
1138        bee_irc_ft_close,
1139        bee_irc_ft_finished,
1140
1141        bee_irc_log,
1142        bee_irc_user_nick_change,
1143};
Note: See TracBrowser for help on using the repository browser.