source: irc_im.c @ 830864d

Last change on this file since 830864d was 830864d, checked in by dequis <dx@…>, at 2015-03-15T09:31:18Z

WIP placeholder channels with hipchat implementation

i was going to clean this up and split in two commits but uhhh...
maybe some other day, i'm tired now

not very tested and i'm not 100% happy about the design, but sucks way
less than what i had in the hip-cat branch

feedback still appreciated.

this adds channels to the channel list without creating groupchats for
them, allowing users to /join them. what the hip-cat branch did before
but with proper api and hopefully less dumb behavior

it still 'leaks' them intentionally, just like it did before, but now it
prevents saving them to the xml so yay

also slightly improved channel name generation, refactored
bee_irc_chat_name_hint into three or four functions, and so on

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