source: irc_im.c @ 720f7a9

Last change on this file since 720f7a9 was f892236, checked in by dequis <dx@…>, at 2016-03-20T03:58:05Z

Send new away message when message changes

Send new away message when away-notify is enabled and the status
changes (e.g. "Away" to "Mobile") or the status message changes
without returning from away.

Fixes IRC clients with away-notify persisting old away messages.

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