source: protocols/purple/purple.c @ 05aba55

Last change on this file since 05aba55 was 05aba55, checked in by dequis <dx@…>, at 2015-12-01T04:55:21Z

purple: Implement PurpleNotifyUiOps.notify_message

Which has no connection context. Luckily local_bee exists, and libpurple
only supports only one irc user per process.

This sucks.

And yesterday I was naively thinking (again) that local_bee might not be
needed, that maybe we can do things properly. Of course it only took a
look at that one reverted commit (56985aa) to remember that life is
unfair, and that, under Moloch, everyone is irresistably incentivized to
ignore the things that unite us in favor of forever picking at the
things that divide us in exactly the way that is most likely to make
them more divisive. That being said, I think all these hacks are going
to look nicer once I sandbox the whole thing in a separate process with
one IM account per process, as opposed to one irc use per process. Then
we'll be able to rely on global state exclusively, which is saner.

  • Property mode set to 100644
File size: 43.0 KB
Line 
1/***************************************************************************\
2*                                                                           *
3*  BitlBee - An IRC to IM gateway                                           *
4*  libpurple module - Main file                                             *
5*                                                                           *
6*  Copyright 2009-2012 Wilmer van der Gaast <wilmer@gaast.net>              *
7*                                                                           *
8*  This program is free software; you can redistribute it and/or modify     *
9*  it under the terms of the GNU General Public License as published by     *
10*  the Free Software Foundation; either version 2 of the License, or        *
11*  (at your option) any later version.                                      *
12*                                                                           *
13*  This program is distributed in the hope that it will be useful,          *
14*  but WITHOUT ANY WARRANTY; without even the implied warranty of           *
15*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            *
16*  GNU General Public License for more details.                             *
17*                                                                           *
18*  You should have received a copy of the GNU General Public License along  *
19*  with this program; if not, write to the Free Software Foundation, Inc.,  *
20*  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.              *
21*                                                                           *
22\***************************************************************************/
23
24#include "bitlbee.h"
25#include "bpurple.h"
26#include "help.h"
27
28#include <stdarg.h>
29
30#include <glib.h>
31#include <purple.h>
32
33GSList *purple_connections;
34
35/* This makes me VERY sad... :-( But some libpurple callbacks come in without
36   any context so this is the only way to get that. Don't want to support
37   libpurple in daemon mode anyway. */
38static bee_t *local_bee;
39
40static char *set_eval_display_name(set_t *set, char *value);
41
42void purple_request_input_callback(guint id, struct im_connection *ic,
43                                   const char *message, const char *who);
44
45/* purple_request_input specific stuff */
46typedef void (*ri_callback_t)(gpointer, const gchar *);
47
48struct request_input_data {
49        ri_callback_t data_callback;
50        void *user_data;
51        struct im_connection *ic;
52        char *buddy;
53        guint id;
54};
55
56struct im_connection *purple_ic_by_pa(PurpleAccount *pa)
57{
58        GSList *i;
59        struct purple_data *pd;
60
61        for (i = purple_connections; i; i = i->next) {
62                pd = ((struct im_connection *) i->data)->proto_data;
63                if (pd->account == pa) {
64                        return i->data;
65                }
66        }
67
68        return NULL;
69}
70
71static struct im_connection *purple_ic_by_gc(PurpleConnection *gc)
72{
73        return purple_ic_by_pa(purple_connection_get_account(gc));
74}
75
76static gboolean purple_menu_cmp(const char *a, const char *b)
77{
78        while (*a && *b) {
79                while (*a == '_') {
80                        a++;
81                }
82                while (*b == '_') {
83                        b++;
84                }
85                if (g_ascii_tolower(*a) != g_ascii_tolower(*b)) {
86                        return FALSE;
87                }
88
89                a++;
90                b++;
91        }
92
93        return (*a == '\0' && *b == '\0');
94}
95
96static void purple_init(account_t *acc)
97{
98        PurplePlugin *prpl = purple_plugins_find_with_id((char *) acc->prpl->data);
99        PurplePluginProtocolInfo *pi = prpl->info->extra_info;
100        PurpleAccount *pa;
101        GList *i, *st;
102        set_t *s;
103        char help_title[64];
104        GString *help;
105        static gboolean dir_fixed = FALSE;
106
107        /* Layer violation coming up: Making an exception for libpurple here.
108           Dig in the IRC state a bit to get a username. Ideally we should
109           check if s/he identified but this info doesn't seem *that* important.
110           It's just that fecking libpurple can't *not* store this shit.
111
112           Remember that libpurple is not really meant to be used on public
113           servers anyway! */
114        if (!dir_fixed) {
115                PurpleCertificatePool *pool;
116                irc_t *irc = acc->bee->ui_data;
117                char *dir;
118
119                dir = g_strdup_printf("%s/purple/%s", global.conf->configdir, irc->user->nick);
120                purple_util_set_user_dir(dir);
121                g_free(dir);
122
123                purple_blist_load();
124                purple_prefs_load();
125
126                if (proxytype == PROXY_SOCKS4A) {
127                        /* do this here after loading prefs. yes, i know, it sucks */
128                        purple_prefs_set_bool("/purple/proxy/socks4_remotedns", TRUE);
129                }
130
131                /* re-create the certificate cache directory */
132                pool = purple_certificate_find_pool("x509", "tls_peers");
133                dir = purple_certificate_pool_mkpath(pool, NULL);
134                purple_build_dir(dir, 0700);
135                g_free(dir);
136
137                dir_fixed = TRUE;
138        }
139
140        help = g_string_new("");
141        g_string_printf(help, "BitlBee libpurple module %s (%s).\n\nSupported settings:",
142                        (char *) acc->prpl->name, prpl->info->name);
143
144        if (pi->user_splits) {
145                GList *l;
146                g_string_append_printf(help, "\n* username: Username");
147                for (l = pi->user_splits; l; l = l->next) {
148                        g_string_append_printf(help, "%c%s",
149                                               purple_account_user_split_get_separator(l->data),
150                                               purple_account_user_split_get_text(l->data));
151                }
152        }
153
154        /* Convert all protocol_options into per-account setting variables. */
155        for (i = pi->protocol_options; i; i = i->next) {
156                PurpleAccountOption *o = i->data;
157                const char *name;
158                char *def = NULL;
159                set_eval eval = NULL;
160                void *eval_data = NULL;
161                GList *io = NULL;
162                GSList *opts = NULL;
163
164                name = purple_account_option_get_setting(o);
165
166                switch (purple_account_option_get_type(o)) {
167                case PURPLE_PREF_STRING:
168                        def = g_strdup(purple_account_option_get_default_string(o));
169
170                        g_string_append_printf(help, "\n* %s (%s), %s, default: %s",
171                                               name, purple_account_option_get_text(o),
172                                               "string", def);
173
174                        break;
175
176                case PURPLE_PREF_INT:
177                        def = g_strdup_printf("%d", purple_account_option_get_default_int(o));
178                        eval = set_eval_int;
179
180                        g_string_append_printf(help, "\n* %s (%s), %s, default: %s",
181                                               name, purple_account_option_get_text(o),
182                                               "integer", def);
183
184                        break;
185
186                case PURPLE_PREF_BOOLEAN:
187                        if (purple_account_option_get_default_bool(o)) {
188                                def = g_strdup("true");
189                        } else {
190                                def = g_strdup("false");
191                        }
192                        eval = set_eval_bool;
193
194                        g_string_append_printf(help, "\n* %s (%s), %s, default: %s",
195                                               name, purple_account_option_get_text(o),
196                                               "boolean", def);
197
198                        break;
199
200                case PURPLE_PREF_STRING_LIST:
201                        def = g_strdup(purple_account_option_get_default_list_value(o));
202
203                        g_string_append_printf(help, "\n* %s (%s), %s, default: %s",
204                                               name, purple_account_option_get_text(o),
205                                               "list", def);
206                        g_string_append(help, "\n  Possible values: ");
207
208                        for (io = purple_account_option_get_list(o); io; io = io->next) {
209                                PurpleKeyValuePair *kv = io->data;
210                                opts = g_slist_append(opts, kv->value);
211                                /* TODO: kv->value is not a char*, WTF? */
212                                if (strcmp(kv->value, kv->key) != 0) {
213                                        g_string_append_printf(help, "%s (%s), ", (char *) kv->value, kv->key);
214                                } else {
215                                        g_string_append_printf(help, "%s, ", (char *) kv->value);
216                                }
217                        }
218                        g_string_truncate(help, help->len - 2);
219                        eval = set_eval_list;
220                        eval_data = opts;
221
222                        break;
223
224                default:
225                        /** No way to talk to the user right now, invent one when
226                        this becomes important.
227                        irc_rootmsg( acc->irc, "Setting with unknown type: %s (%d) Expect stuff to break..\n",
228                                     name, purple_account_option_get_type( o ) );
229                        */
230                        g_string_append_printf(help, "\n* [%s] UNSUPPORTED (type %d)",
231                                               name, purple_account_option_get_type(o));
232                        name = NULL;
233                }
234
235                if (name != NULL) {
236                        s = set_add(&acc->set, name, def, eval, acc);
237                        s->flags |= ACC_SET_OFFLINE_ONLY;
238                        s->eval_data = eval_data;
239                        g_free(def);
240                }
241        }
242
243        g_snprintf(help_title, sizeof(help_title), "purple %s", (char *) acc->prpl->name);
244        help_add_mem(&global.help, help_title, help->str);
245        g_string_free(help, TRUE);
246
247        s = set_add(&acc->set, "display_name", NULL, set_eval_display_name, acc);
248        s->flags |= ACC_SET_ONLINE_ONLY;
249
250        if (pi->options & OPT_PROTO_MAIL_CHECK) {
251                s = set_add(&acc->set, "mail_notifications", "false", set_eval_bool, acc);
252                s->flags |= ACC_SET_OFFLINE_ONLY;
253
254                s = set_add(&acc->set, "mail_notifications_handle", NULL, NULL, acc);
255                s->flags |= ACC_SET_OFFLINE_ONLY | SET_NULL_OK;
256        }
257
258        if (strcmp(prpl->info->name, "Gadu-Gadu") == 0) {
259                s = set_add(&acc->set, "gg_sync_contacts", "true", set_eval_bool, acc);
260        }
261
262        /* Go through all away states to figure out if away/status messages
263           are possible. */
264        pa = purple_account_new(acc->user, (char *) acc->prpl->data);
265        for (st = purple_account_get_status_types(pa); st; st = st->next) {
266                PurpleStatusPrimitive prim = purple_status_type_get_primitive(st->data);
267
268                if (prim == PURPLE_STATUS_AVAILABLE) {
269                        if (purple_status_type_get_attr(st->data, "message")) {
270                                acc->flags |= ACC_FLAG_STATUS_MESSAGE;
271                        }
272                } else if (prim != PURPLE_STATUS_OFFLINE) {
273                        if (purple_status_type_get_attr(st->data, "message")) {
274                                acc->flags |= ACC_FLAG_AWAY_MESSAGE;
275                        }
276                }
277        }
278        purple_accounts_remove(pa);
279}
280
281static void purple_sync_settings(account_t *acc, PurpleAccount *pa)
282{
283        PurplePlugin *prpl = purple_plugins_find_with_id(pa->protocol_id);
284        PurplePluginProtocolInfo *pi = prpl->info->extra_info;
285        GList *i;
286
287        for (i = pi->protocol_options; i; i = i->next) {
288                PurpleAccountOption *o = i->data;
289                const char *name;
290                set_t *s;
291
292                name = purple_account_option_get_setting(o);
293                s = set_find(&acc->set, name);
294                if (s->value == NULL) {
295                        continue;
296                }
297
298                switch (purple_account_option_get_type(o)) {
299                case PURPLE_PREF_STRING:
300                case PURPLE_PREF_STRING_LIST:
301                        purple_account_set_string(pa, name, set_getstr(&acc->set, name));
302                        break;
303
304                case PURPLE_PREF_INT:
305                        purple_account_set_int(pa, name, set_getint(&acc->set, name));
306                        break;
307
308                case PURPLE_PREF_BOOLEAN:
309                        purple_account_set_bool(pa, name, set_getbool(&acc->set, name));
310                        break;
311
312                default:
313                        break;
314                }
315        }
316
317        if (pi->options & OPT_PROTO_MAIL_CHECK) {
318                purple_account_set_check_mail(pa, set_getbool(&acc->set, "mail_notifications"));
319        }
320}
321
322static void purple_login(account_t *acc)
323{
324        struct im_connection *ic = imcb_new(acc);
325        struct purple_data *pd;
326
327        if ((local_bee != NULL && local_bee != acc->bee) ||
328            (global.conf->runmode == RUNMODE_DAEMON && !getenv("BITLBEE_DEBUG"))) {
329                imcb_error(ic,  "Daemon mode detected. Do *not* try to use libpurple in daemon mode! "
330                           "Please use inetd or ForkDaemon mode instead.");
331                imc_logout(ic, FALSE);
332                return;
333        }
334        local_bee = acc->bee;
335
336        /* For now this is needed in the _connected() handlers if using
337           GLib event handling, to make sure we're not handling events
338           on dead connections. */
339        purple_connections = g_slist_prepend(purple_connections, ic);
340
341        ic->proto_data = pd = g_new0(struct purple_data, 1);
342        pd->account = purple_account_new(acc->user, (char *) acc->prpl->data);
343        pd->input_requests = g_hash_table_new_full(g_direct_hash, g_direct_equal,
344                                                   NULL, g_free);
345        pd->next_request_id = 0;
346        purple_account_set_password(pd->account, acc->pass);
347        purple_sync_settings(acc, pd->account);
348
349        purple_account_set_enabled(pd->account, "BitlBee", TRUE);
350
351        if (set_getbool(&acc->set, "mail_notifications") && set_getstr(&acc->set, "mail_notifications_handle")) {
352                imcb_add_buddy(ic, set_getstr(&acc->set, "mail_notifications_handle"), NULL);
353        }
354}
355
356static void purple_logout(struct im_connection *ic)
357{
358        struct purple_data *pd = ic->proto_data;
359
360        if (!pd) {
361                return;
362        }
363
364        while (ic->groupchats) {
365                imcb_chat_free(ic->groupchats->data);
366        }
367
368        purple_account_set_enabled(pd->account, "BitlBee", FALSE);
369        purple_connections = g_slist_remove(purple_connections, ic);
370        purple_accounts_remove(pd->account);
371        g_hash_table_destroy(pd->input_requests);
372        g_free(pd);
373}
374
375static int purple_buddy_msg(struct im_connection *ic, char *who, char *message, int flags)
376{
377        PurpleConversation *conv;
378        struct purple_data *pd = ic->proto_data;
379
380        if (!strncmp(who, PURPLE_REQUEST_HANDLE, sizeof(PURPLE_REQUEST_HANDLE) - 1)) {
381                guint request_id = atoi(who + sizeof(PURPLE_REQUEST_HANDLE));
382                purple_request_input_callback(request_id, ic, message, who);
383                return 1;
384        }
385
386        if ((conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM,
387                                                          who, pd->account)) == NULL) {
388                conv = purple_conversation_new(PURPLE_CONV_TYPE_IM,
389                                               pd->account, who);
390        }
391
392        purple_conv_im_send(purple_conversation_get_im_data(conv), message);
393
394        return 1;
395}
396
397static GList *purple_away_states(struct im_connection *ic)
398{
399        struct purple_data *pd = ic->proto_data;
400        GList *st, *ret = NULL;
401
402        for (st = purple_account_get_status_types(pd->account); st; st = st->next) {
403                PurpleStatusPrimitive prim = purple_status_type_get_primitive(st->data);
404                if (prim != PURPLE_STATUS_AVAILABLE && prim != PURPLE_STATUS_OFFLINE) {
405                        ret = g_list_append(ret, (void *) purple_status_type_get_name(st->data));
406                }
407        }
408
409        return ret;
410}
411
412static void purple_set_away(struct im_connection *ic, char *state_txt, char *message)
413{
414        struct purple_data *pd = ic->proto_data;
415        GList *status_types = purple_account_get_status_types(pd->account), *st;
416        PurpleStatusType *pst = NULL;
417        GList *args = NULL;
418
419        for (st = status_types; st; st = st->next) {
420                pst = st->data;
421
422                if (state_txt == NULL &&
423                    purple_status_type_get_primitive(pst) == PURPLE_STATUS_AVAILABLE) {
424                        break;
425                }
426
427                if (state_txt != NULL &&
428                    g_strcasecmp(state_txt, purple_status_type_get_name(pst)) == 0) {
429                        break;
430                }
431        }
432
433        if (message && purple_status_type_get_attr(pst, "message")) {
434                args = g_list_append(args, "message");
435                args = g_list_append(args, message);
436        }
437
438        purple_account_set_status_list(pd->account,
439                                       st ? purple_status_type_get_id(pst) : "away",
440                                       TRUE, args);
441
442        g_list_free(args);
443}
444
445static char *set_eval_display_name(set_t *set, char *value)
446{
447        account_t *acc = set->data;
448        struct im_connection *ic = acc->ic;
449
450        if (ic) {
451                imcb_log(ic, "Changing display_name not currently supported with libpurple!");
452        }
453
454        return NULL;
455}
456
457/* Bad bad gadu-gadu, not saving buddy list by itself */
458static void purple_gg_buddylist_export(PurpleConnection *gc)
459{
460        struct im_connection *ic = purple_ic_by_gc(gc);
461
462        if (set_getstr(&ic->acc->set, "gg_sync_contacts")) {
463                GList *actions = gc->prpl->info->actions(gc->prpl, gc);
464                GList *p;
465                for (p = g_list_first(actions); p; p = p->next) {
466                        if (((PurplePluginAction *) p->data) &&
467                            purple_menu_cmp(((PurplePluginAction *) p->data)->label,
468                                            "Upload buddylist to Server") == 0) {
469                                PurplePluginAction action;
470                                action.plugin = gc->prpl;
471                                action.context = gc;
472                                action.user_data = NULL;
473                                ((PurplePluginAction *) p->data)->callback(&action);
474                                break;
475                        }
476                }
477                g_list_free(actions);
478        }
479}
480
481static void purple_gg_buddylist_import(PurpleConnection *gc)
482{
483        struct im_connection *ic = purple_ic_by_gc(gc);
484
485        if (set_getstr(&ic->acc->set, "gg_sync_contacts")) {
486                GList *actions = gc->prpl->info->actions(gc->prpl, gc);
487                GList *p;
488                for (p = g_list_first(actions); p; p = p->next) {
489                        if (((PurplePluginAction *) p->data) &&
490                            purple_menu_cmp(((PurplePluginAction *) p->data)->label,
491                                            "Download buddylist from Server") == 0) {
492                                PurplePluginAction action;
493                                action.plugin = gc->prpl;
494                                action.context = gc;
495                                action.user_data = NULL;
496                                ((PurplePluginAction *) p->data)->callback(&action);
497                                break;
498                        }
499                }
500                g_list_free(actions);
501        }
502}
503
504static void purple_add_buddy(struct im_connection *ic, char *who, char *group)
505{
506        PurpleBuddy *pb;
507        PurpleGroup *pg = NULL;
508        struct purple_data *pd = ic->proto_data;
509
510        if (group && !(pg = purple_find_group(group))) {
511                pg = purple_group_new(group);
512                purple_blist_add_group(pg, NULL);
513        }
514
515        pb = purple_buddy_new(pd->account, who, NULL);
516        purple_blist_add_buddy(pb, NULL, pg, NULL);
517        purple_account_add_buddy(pd->account, pb);
518
519        purple_gg_buddylist_export(pd->account->gc);
520}
521
522static void purple_remove_buddy(struct im_connection *ic, char *who, char *group)
523{
524        PurpleBuddy *pb;
525        struct purple_data *pd = ic->proto_data;
526
527        pb = purple_find_buddy(pd->account, who);
528        if (pb != NULL) {
529                PurpleGroup *group;
530
531                group = purple_buddy_get_group(pb);
532                purple_account_remove_buddy(pd->account, pb, group);
533
534                purple_blist_remove_buddy(pb);
535        }
536
537        purple_gg_buddylist_export(pd->account->gc);
538}
539
540static void purple_add_permit(struct im_connection *ic, char *who)
541{
542        struct purple_data *pd = ic->proto_data;
543
544        purple_privacy_permit_add(pd->account, who, FALSE);
545}
546
547static void purple_add_deny(struct im_connection *ic, char *who)
548{
549        struct purple_data *pd = ic->proto_data;
550
551        purple_privacy_deny_add(pd->account, who, FALSE);
552}
553
554static void purple_rem_permit(struct im_connection *ic, char *who)
555{
556        struct purple_data *pd = ic->proto_data;
557
558        purple_privacy_permit_remove(pd->account, who, FALSE);
559}
560
561static void purple_rem_deny(struct im_connection *ic, char *who)
562{
563        struct purple_data *pd = ic->proto_data;
564
565        purple_privacy_deny_remove(pd->account, who, FALSE);
566}
567
568static void purple_get_info(struct im_connection *ic, char *who)
569{
570        struct purple_data *pd = ic->proto_data;
571
572        serv_get_info(purple_account_get_connection(pd->account), who);
573}
574
575static void purple_keepalive(struct im_connection *ic)
576{
577}
578
579static int purple_send_typing(struct im_connection *ic, char *who, int flags)
580{
581        PurpleTypingState state = PURPLE_NOT_TYPING;
582        struct purple_data *pd = ic->proto_data;
583
584        if (flags & OPT_TYPING) {
585                state = PURPLE_TYPING;
586        } else if (flags & OPT_THINKING) {
587                state = PURPLE_TYPED;
588        }
589
590        serv_send_typing(purple_account_get_connection(pd->account), who, state);
591
592        return 1;
593}
594
595static void purple_chat_msg(struct groupchat *gc, char *message, int flags)
596{
597        PurpleConversation *pc = gc->data;
598
599        purple_conv_chat_send(purple_conversation_get_chat_data(pc), message);
600}
601
602struct groupchat *purple_chat_with(struct im_connection *ic, char *who)
603{
604        /* No, "of course" this won't work this way. Or in fact, it almost
605           does, but it only lets you send msgs to it, you won't receive
606           any. Instead, we have to click the virtual menu item.
607        PurpleAccount *pa = ic->proto_data;
608        PurpleConversation *pc;
609        PurpleConvChat *pcc;
610        struct groupchat *gc;
611
612        gc = imcb_chat_new( ic, "BitlBee-libpurple groupchat" );
613        gc->data = pc = purple_conversation_new( PURPLE_CONV_TYPE_CHAT, pa, "BitlBee-libpurple groupchat" );
614        pc->ui_data = gc;
615
616        pcc = PURPLE_CONV_CHAT( pc );
617        purple_conv_chat_add_user( pcc, ic->acc->user, "", 0, TRUE );
618        purple_conv_chat_invite_user( pcc, who, "Please join my chat", FALSE );
619        //purple_conv_chat_add_user( pcc, who, "", 0, TRUE );
620        */
621
622        /* There went my nice afternoon. :-( */
623
624        struct purple_data *pd = ic->proto_data;
625        PurplePlugin *prpl = purple_plugins_find_with_id(pd->account->protocol_id);
626        PurplePluginProtocolInfo *pi = prpl->info->extra_info;
627        PurpleBuddy *pb = purple_find_buddy(pd->account, who);
628        PurpleMenuAction *mi;
629        GList *menu;
630
631        void (*callback)(PurpleBlistNode *, gpointer); /* FFFFFFFFFFFFFUUUUUUUUUUUUUU */
632
633        if (!pb || !pi || !pi->blist_node_menu) {
634                return NULL;
635        }
636
637        menu = pi->blist_node_menu(&pb->node);
638        while (menu) {
639                mi = menu->data;
640                if (purple_menu_cmp(mi->label, "initiate chat") ||
641                    purple_menu_cmp(mi->label, "initiate conference")) {
642                        break;
643                }
644                menu = menu->next;
645        }
646
647        if (menu == NULL) {
648                return NULL;
649        }
650
651        /* Call the fucker. */
652        callback = (void *) mi->callback;
653        callback(&pb->node, menu->data);
654
655        return NULL;
656}
657
658void purple_chat_invite(struct groupchat *gc, char *who, char *message)
659{
660        PurpleConversation *pc = gc->data;
661        PurpleConvChat *pcc = PURPLE_CONV_CHAT(pc);
662        struct purple_data *pd = gc->ic->proto_data;
663
664        serv_chat_invite(purple_account_get_connection(pd->account),
665                         purple_conv_chat_get_id(pcc),
666                         message && *message ? message : "Please join my chat",
667                         who);
668}
669
670void purple_chat_kick(struct groupchat *gc, char *who, const char *message)
671{
672        PurpleConversation *pc = gc->data;
673        char *str = g_strdup_printf("kick %s %s", who, message);
674
675        purple_conversation_do_command(pc, str, NULL, NULL);
676        g_free(str);
677}
678
679void purple_chat_leave(struct groupchat *gc)
680{
681        PurpleConversation *pc = gc->data;
682
683        purple_conversation_destroy(pc);
684}
685
686struct groupchat *purple_chat_join(struct im_connection *ic, const char *room, const char *nick, const char *password,
687                                   set_t **sets)
688{
689        struct purple_data *pd = ic->proto_data;
690        PurplePlugin *prpl = purple_plugins_find_with_id(pd->account->protocol_id);
691        PurplePluginProtocolInfo *pi = prpl->info->extra_info;
692        GHashTable *chat_hash;
693        PurpleConversation *conv;
694        GList *info, *l;
695
696        if (!pi->chat_info || !pi->chat_info_defaults ||
697            !(info = pi->chat_info(purple_account_get_connection(pd->account)))) {
698                imcb_error(ic, "Joining chatrooms not supported by this protocol");
699                return NULL;
700        }
701
702        if ((conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT,
703                                                          room, pd->account))) {
704                purple_conversation_destroy(conv);
705        }
706
707        chat_hash = pi->chat_info_defaults(
708                purple_account_get_connection(pd->account), room
709        );
710
711        for (l = info; l; l = l->next) {
712                struct proto_chat_entry *pce = l->data;
713
714                if (strcmp(pce->identifier, "handle") == 0) {
715                        g_hash_table_replace(chat_hash, "handle", g_strdup(nick));
716                } else if (strcmp(pce->identifier, "password") == 0) {
717                        g_hash_table_replace(chat_hash, "password", g_strdup(password));
718                } else if (strcmp(pce->identifier, "passwd") == 0) {
719                        g_hash_table_replace(chat_hash, "passwd", g_strdup(password));
720                }
721
722                g_free(pce);
723        }
724
725        g_list_free(info);
726
727        serv_join_chat(purple_account_get_connection(pd->account), chat_hash);
728
729        g_hash_table_destroy(chat_hash);
730
731        return imcb_chat_new(ic, room);
732}
733
734void purple_transfer_request(struct im_connection *ic, file_transfer_t *ft, char *handle);
735
736static void purple_ui_init();
737
738GHashTable *prplcb_ui_info()
739{
740        static GHashTable *ret;
741
742        if (ret == NULL) {
743                ret = g_hash_table_new(g_str_hash, g_str_equal);
744                g_hash_table_insert(ret, "name", "BitlBee");
745                g_hash_table_insert(ret, "version", BITLBEE_VERSION);
746        }
747
748        return ret;
749}
750
751static PurpleCoreUiOps bee_core_uiops =
752{
753        NULL,
754        NULL,
755        purple_ui_init,
756        NULL,
757        prplcb_ui_info,
758};
759
760static void prplcb_conn_progress(PurpleConnection *gc, const char *text, size_t step, size_t step_count)
761{
762        struct im_connection *ic = purple_ic_by_gc(gc);
763
764        imcb_log(ic, "%s", text);
765}
766
767static void prplcb_conn_connected(PurpleConnection *gc)
768{
769        struct im_connection *ic = purple_ic_by_gc(gc);
770        const char *dn;
771        set_t *s;
772
773        imcb_connected(ic);
774
775        if ((dn = purple_connection_get_display_name(gc)) &&
776            (s = set_find(&ic->acc->set, "display_name"))) {
777                g_free(s->value);
778                s->value = g_strdup(dn);
779        }
780
781        // user list needs to be requested for Gadu-Gadu
782        purple_gg_buddylist_import(gc);
783
784        if (gc->flags & PURPLE_CONNECTION_HTML) {
785                ic->flags |= OPT_DOES_HTML;
786        }
787}
788
789static void prplcb_conn_disconnected(PurpleConnection *gc)
790{
791        struct im_connection *ic = purple_ic_by_gc(gc);
792
793        if (ic != NULL) {
794                imc_logout(ic, !gc->wants_to_die);
795        }
796}
797
798static void prplcb_conn_notice(PurpleConnection *gc, const char *text)
799{
800        struct im_connection *ic = purple_ic_by_gc(gc);
801
802        if (ic != NULL) {
803                imcb_log(ic, "%s", text);
804        }
805}
806
807static void prplcb_conn_report_disconnect_reason(PurpleConnection *gc, PurpleConnectionError reason, const char *text)
808{
809        struct im_connection *ic = purple_ic_by_gc(gc);
810
811        /* PURPLE_CONNECTION_ERROR_NAME_IN_USE means concurrent login,
812           should probably handle that. */
813        if (ic != NULL) {
814                imcb_error(ic, "%s", text);
815        }
816}
817
818static PurpleConnectionUiOps bee_conn_uiops =
819{
820        prplcb_conn_progress,
821        prplcb_conn_connected,
822        prplcb_conn_disconnected,
823        prplcb_conn_notice,
824        NULL,
825        NULL,
826        NULL,
827        prplcb_conn_report_disconnect_reason,
828};
829
830static void prplcb_blist_update(PurpleBuddyList *list, PurpleBlistNode *node)
831{
832        if (node->type == PURPLE_BLIST_BUDDY_NODE) {
833                PurpleBuddy *bud = (PurpleBuddy *) node;
834                PurpleGroup *group = purple_buddy_get_group(bud);
835                struct im_connection *ic = purple_ic_by_pa(bud->account);
836                PurpleStatus *as;
837                int flags = 0;
838
839                if (ic == NULL) {
840                        return;
841                }
842
843                if (bud->server_alias) {
844                        imcb_rename_buddy(ic, bud->name, bud->server_alias);
845                } else if (bud->alias) {
846                        imcb_rename_buddy(ic, bud->name, bud->alias);
847                }
848
849                if (group) {
850                        imcb_add_buddy(ic, bud->name, purple_group_get_name(group));
851                }
852
853                flags |= purple_presence_is_online(bud->presence) ? OPT_LOGGED_IN : 0;
854                flags |= purple_presence_is_available(bud->presence) ? 0 : OPT_AWAY;
855
856                as = purple_presence_get_active_status(bud->presence);
857
858                imcb_buddy_status(ic, bud->name, flags, purple_status_get_name(as),
859                                  purple_status_get_attr_string(as, "message"));
860
861                imcb_buddy_times(ic, bud->name,
862                                 purple_presence_get_login_time(bud->presence),
863                                 purple_presence_get_idle_time(bud->presence));
864        }
865}
866
867static void prplcb_blist_new(PurpleBlistNode *node)
868{
869        if (node->type == PURPLE_BLIST_BUDDY_NODE) {
870                PurpleBuddy *bud = (PurpleBuddy *) node;
871                struct im_connection *ic = purple_ic_by_pa(bud->account);
872
873                if (ic == NULL) {
874                        return;
875                }
876
877                imcb_add_buddy(ic, bud->name, NULL);
878
879                prplcb_blist_update(NULL, node);
880        }
881}
882
883static void prplcb_blist_remove(PurpleBuddyList *list, PurpleBlistNode *node)
884{
885/*
886        PurpleBuddy *bud = (PurpleBuddy*) node;
887
888        if( node->type == PURPLE_BLIST_BUDDY_NODE )
889        {
890                struct im_connection *ic = purple_ic_by_pa( bud->account );
891
892                if( ic == NULL )
893                        return;
894
895                imcb_remove_buddy( ic, bud->name, NULL );
896        }
897*/
898}
899
900static PurpleBlistUiOps bee_blist_uiops =
901{
902        NULL,
903        prplcb_blist_new,
904        NULL,
905        prplcb_blist_update,
906        prplcb_blist_remove,
907};
908
909void prplcb_conv_new(PurpleConversation *conv)
910{
911        if (conv->type == PURPLE_CONV_TYPE_CHAT) {
912                struct im_connection *ic = purple_ic_by_pa(conv->account);
913                struct groupchat *gc;
914
915                gc = bee_chat_by_title(ic->bee, ic, conv->name);
916
917                if (!gc) {
918                        gc = imcb_chat_new(ic, conv->name);
919                        if (conv->title != NULL) {
920                                imcb_chat_name_hint(gc, conv->title);
921                        }
922                }
923
924                /* don't set the topic if it's just the name */
925                if (conv->title != NULL && strcmp(conv->name, conv->title) != 0) {
926                        imcb_chat_topic(gc, NULL, conv->title, 0);
927                }
928
929                conv->ui_data = gc;
930                gc->data = conv;
931
932                /* libpurple brokenness: Whatever. Show that we join right away,
933                   there's no clear "This is you!" signaling in _add_users so
934                   don't even try. */
935                imcb_chat_add_buddy(gc, gc->ic->acc->user);
936        }
937}
938
939void prplcb_conv_free(PurpleConversation *conv)
940{
941        struct groupchat *gc = conv->ui_data;
942
943        imcb_chat_free(gc);
944}
945
946void prplcb_conv_add_users(PurpleConversation *conv, GList *cbuddies, gboolean new_arrivals)
947{
948        struct groupchat *gc = conv->ui_data;
949        GList *b;
950
951        for (b = cbuddies; b; b = b->next) {
952                PurpleConvChatBuddy *pcb = b->data;
953
954                imcb_chat_add_buddy(gc, pcb->name);
955        }
956}
957
958void prplcb_conv_del_users(PurpleConversation *conv, GList *cbuddies)
959{
960        struct groupchat *gc = conv->ui_data;
961        GList *b;
962
963        for (b = cbuddies; b; b = b->next) {
964                imcb_chat_remove_buddy(gc, b->data, "");
965        }
966}
967
968void prplcb_conv_chat_msg(PurpleConversation *conv, const char *who, const char *message, PurpleMessageFlags flags,
969                          time_t mtime)
970{
971        struct groupchat *gc = conv->ui_data;
972        PurpleBuddy *buddy;
973
974        /* ..._SEND means it's an outgoing message, no need to echo those. */
975        if (flags & PURPLE_MESSAGE_SEND) {
976                return;
977        }
978
979        buddy = purple_find_buddy(conv->account, who);
980        if (buddy != NULL) {
981                who = purple_buddy_get_name(buddy);
982        }
983
984        imcb_chat_msg(gc, who, (char *) message, 0, mtime);
985}
986
987static void prplcb_conv_im(PurpleConversation *conv, const char *who, const char *message, PurpleMessageFlags flags,
988                           time_t mtime)
989{
990        struct im_connection *ic = purple_ic_by_pa(conv->account);
991        PurpleBuddy *buddy;
992
993        /* ..._SEND means it's an outgoing message, no need to echo those. */
994        if (flags & PURPLE_MESSAGE_SEND) {
995                return;
996        }
997
998        buddy = purple_find_buddy(conv->account, who);
999        if (buddy != NULL) {
1000                who = purple_buddy_get_name(buddy);
1001        }
1002
1003        imcb_buddy_msg(ic, (char *) who, (char *) message, 0, mtime);
1004}
1005
1006/* No, this is not a ui_op but a signal. */
1007static void prplcb_buddy_typing(PurpleAccount *account, const char *who, gpointer null)
1008{
1009        PurpleConversation *conv;
1010        PurpleConvIm *im;
1011        int state;
1012
1013        if ((conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, who, account)) == NULL) {
1014                return;
1015        }
1016
1017        im = PURPLE_CONV_IM(conv);
1018        switch (purple_conv_im_get_typing_state(im)) {
1019        case PURPLE_TYPING:
1020                state = OPT_TYPING;
1021                break;
1022        case PURPLE_TYPED:
1023                state = OPT_THINKING;
1024                break;
1025        default:
1026                state = 0;
1027        }
1028
1029        imcb_buddy_typing(purple_ic_by_pa(account), who, state);
1030}
1031
1032static PurpleConversationUiOps bee_conv_uiops =
1033{
1034        prplcb_conv_new,           /* create_conversation  */
1035        prplcb_conv_free,          /* destroy_conversation */
1036        prplcb_conv_chat_msg,      /* write_chat           */
1037        prplcb_conv_im,            /* write_im             */
1038        NULL,                      /* write_conv           */
1039        prplcb_conv_add_users,     /* chat_add_users       */
1040        NULL,                      /* chat_rename_user     */
1041        prplcb_conv_del_users,     /* chat_remove_users    */
1042        NULL,                      /* chat_update_user     */
1043        NULL,                      /* present              */
1044        NULL,                      /* has_focus            */
1045        NULL,                      /* custom_smiley_add    */
1046        NULL,                      /* custom_smiley_write  */
1047        NULL,                      /* custom_smiley_close  */
1048        NULL,                      /* send_confirm         */
1049};
1050
1051struct prplcb_request_action_data {
1052        void *user_data, *bee_data;
1053        PurpleRequestActionCb yes, no;
1054        int yes_i, no_i;
1055};
1056
1057static void prplcb_request_action_yes(void *data)
1058{
1059        struct prplcb_request_action_data *pqad = data;
1060
1061        if (pqad->yes) {
1062                pqad->yes(pqad->user_data, pqad->yes_i);
1063        }
1064}
1065
1066static void prplcb_request_action_no(void *data)
1067{
1068        struct prplcb_request_action_data *pqad = data;
1069
1070        if (pqad->no) {
1071                pqad->no(pqad->user_data, pqad->no_i);
1072        }
1073}
1074
1075/* q->free() callback from query_del()*/
1076static void prplcb_request_action_free(void *data)
1077{
1078        struct prplcb_request_action_data *pqad = data;
1079
1080        pqad->bee_data = NULL;
1081        purple_request_close(PURPLE_REQUEST_ACTION, pqad);
1082}
1083
1084static void *prplcb_request_action(const char *title, const char *primary, const char *secondary,
1085                                   int default_action, PurpleAccount *account, const char *who,
1086                                   PurpleConversation *conv, void *user_data, size_t action_count,
1087                                   va_list actions)
1088{
1089        struct prplcb_request_action_data *pqad;
1090        int i;
1091        char *q;
1092
1093        pqad = g_new0(struct prplcb_request_action_data, 1);
1094
1095        for (i = 0; i < action_count; i++) {
1096                char *caption;
1097                void *fn;
1098
1099                caption = va_arg(actions, char*);
1100                fn = va_arg(actions, void*);
1101
1102                if (strstr(caption, "Accept") || strstr(caption, "OK")) {
1103                        pqad->yes = fn;
1104                        pqad->yes_i = i;
1105                } else if (strstr(caption, "Reject") || strstr(caption, "Cancel")) {
1106                        pqad->no = fn;
1107                        pqad->no_i = i;
1108                }
1109        }
1110
1111        pqad->user_data = user_data;
1112
1113        /* TODO: IRC stuff here :-( */
1114        q = g_strdup_printf("Request: %s\n\n%s\n\n%s", title, primary, secondary);
1115        pqad->bee_data = query_add(local_bee->ui_data, purple_ic_by_pa(account), q,
1116                                   prplcb_request_action_yes, prplcb_request_action_no,
1117                                   prplcb_request_action_free, pqad);
1118
1119        g_free(q);
1120
1121        return pqad;
1122}
1123
1124/* So it turns out some requests have no account context at all, because
1125 * libpurple hates us. This means that query_del_by_conn() won't remove those
1126 * on logout, and will segfault if the user replies. That's why this exists.
1127 */
1128static void prplcb_close_request(PurpleRequestType type, void *data)
1129{
1130        struct prplcb_request_action_data *pqad;
1131        struct request_input_data *ri;
1132        struct purple_data *pd;
1133
1134        if (!data) {
1135                return;
1136        }
1137
1138        switch (type) {
1139        case PURPLE_REQUEST_ACTION:
1140                pqad = data;
1141                /* if this is null, it's because query_del was run already */
1142                if (pqad->bee_data) {
1143                        query_del(local_bee->ui_data, pqad->bee_data);
1144                }
1145                g_free(pqad);
1146                break;
1147        case PURPLE_REQUEST_INPUT:
1148                ri = data;
1149                pd = ri->ic->proto_data;
1150                imcb_remove_buddy(ri->ic, ri->buddy, NULL);
1151                g_free(ri->buddy);
1152                g_hash_table_remove(pd->input_requests, GUINT_TO_POINTER(ri->id));
1153                break;
1154        default:
1155                g_free(data);
1156                break;
1157        }
1158
1159}
1160
1161void* prplcb_request_input(const char *title, const char *primary,
1162        const char *secondary, const char *default_value, gboolean multiline,
1163        gboolean masked, gchar *hint, const char *ok_text, GCallback ok_cb,
1164        const char *cancel_text, GCallback cancel_cb, PurpleAccount *account,
1165        const char *who, PurpleConversation *conv, void *user_data)
1166{
1167        struct im_connection *ic = purple_ic_by_pa(account);
1168        struct purple_data *pd = ic->proto_data;
1169        struct request_input_data *ri = g_new0(struct request_input_data, 1);
1170        guint id = pd->next_request_id++;
1171
1172        ri->id = id;
1173        ri->ic = ic;
1174        ri->buddy = g_strdup_printf("%s_%u", PURPLE_REQUEST_HANDLE, id);
1175        ri->data_callback = (ri_callback_t) ok_cb;
1176        ri->user_data = user_data;
1177        g_hash_table_insert(pd->input_requests, GUINT_TO_POINTER(id), ri);
1178
1179        imcb_add_buddy(ic, ri->buddy, NULL);
1180        imcb_buddy_msg(ic, ri->buddy, secondary, 0, 0);
1181
1182        return ri;
1183}
1184
1185void purple_request_input_callback(guint id, struct im_connection *ic,
1186                                   const char *message, const char *who)
1187{
1188        struct purple_data *pd = ic->proto_data;
1189        struct request_input_data *ri;
1190
1191        if (!(ri = g_hash_table_lookup(pd->input_requests, GUINT_TO_POINTER(id)))) {
1192                return;
1193        }
1194
1195        ri->data_callback(ri->user_data, message);
1196
1197        purple_request_close(PURPLE_REQUEST_INPUT, ri);
1198}
1199
1200
1201static PurpleRequestUiOps bee_request_uiops =
1202{
1203        prplcb_request_input,
1204        NULL,
1205        prplcb_request_action,
1206        NULL,
1207        NULL,
1208        prplcb_close_request,
1209        NULL,
1210};
1211
1212static void prplcb_privacy_permit_added(PurpleAccount *account, const char *name)
1213{
1214        struct im_connection *ic = purple_ic_by_pa(account);
1215
1216        if (!g_slist_find_custom(ic->permit, name, (GCompareFunc) ic->acc->prpl->handle_cmp)) {
1217                ic->permit = g_slist_prepend(ic->permit, g_strdup(name));
1218        }
1219}
1220
1221static void prplcb_privacy_permit_removed(PurpleAccount *account, const char *name)
1222{
1223        struct im_connection *ic = purple_ic_by_pa(account);
1224        void *n;
1225
1226        n = g_slist_find_custom(ic->permit, name, (GCompareFunc) ic->acc->prpl->handle_cmp);
1227        ic->permit = g_slist_remove(ic->permit, n);
1228}
1229
1230static void prplcb_privacy_deny_added(PurpleAccount *account, const char *name)
1231{
1232        struct im_connection *ic = purple_ic_by_pa(account);
1233
1234        if (!g_slist_find_custom(ic->deny, name, (GCompareFunc) ic->acc->prpl->handle_cmp)) {
1235                ic->deny = g_slist_prepend(ic->deny, g_strdup(name));
1236        }
1237}
1238
1239static void prplcb_privacy_deny_removed(PurpleAccount *account, const char *name)
1240{
1241        struct im_connection *ic = purple_ic_by_pa(account);
1242        void *n;
1243
1244        n = g_slist_find_custom(ic->deny, name, (GCompareFunc) ic->acc->prpl->handle_cmp);
1245        ic->deny = g_slist_remove(ic->deny, n);
1246}
1247
1248static PurplePrivacyUiOps bee_privacy_uiops =
1249{
1250        prplcb_privacy_permit_added,
1251        prplcb_privacy_permit_removed,
1252        prplcb_privacy_deny_added,
1253        prplcb_privacy_deny_removed,
1254};
1255
1256static void prplcb_debug_print(PurpleDebugLevel level, const char *category, const char *arg_s)
1257{
1258        fprintf(stderr, "DEBUG %s: %s", category, arg_s);
1259}
1260
1261static PurpleDebugUiOps bee_debug_uiops =
1262{
1263        prplcb_debug_print,
1264};
1265
1266static guint prplcb_ev_timeout_add(guint interval, GSourceFunc func, gpointer udata)
1267{
1268        return b_timeout_add(interval, (b_event_handler) func, udata);
1269}
1270
1271static guint prplcb_ev_input_add(int fd, PurpleInputCondition cond, PurpleInputFunction func, gpointer udata)
1272{
1273        return b_input_add(fd, cond | B_EV_FLAG_FORCE_REPEAT, (b_event_handler) func, udata);
1274}
1275
1276static gboolean prplcb_ev_remove(guint id)
1277{
1278        b_event_remove((gint) id);
1279        return TRUE;
1280}
1281
1282static PurpleEventLoopUiOps glib_eventloops =
1283{
1284        prplcb_ev_timeout_add,
1285        prplcb_ev_remove,
1286        prplcb_ev_input_add,
1287        prplcb_ev_remove,
1288};
1289
1290/* Absolutely no connection context at all. Thanks purple! brb crying */
1291static void *prplcb_notify_message(PurpleNotifyMsgType type, const char *title,
1292                                   const char *primary, const char *secondary)
1293{
1294        char *text = g_strdup_printf("%s%s - %s%s%s",
1295                (type == PURPLE_NOTIFY_MSG_ERROR) ? "Error: " : "",
1296                title,
1297                primary ?: "",
1298                (primary && secondary) ? " - " : "",
1299                secondary ?: ""
1300        );
1301
1302        if (local_bee->ui->log) {
1303                local_bee->ui->log(local_bee, "purple", text);
1304        }
1305
1306        g_free(text);
1307
1308        return NULL;
1309}
1310
1311static void *prplcb_notify_email(PurpleConnection *gc, const char *subject, const char *from,
1312                                 const char *to, const char *url)
1313{
1314        struct im_connection *ic = purple_ic_by_gc(gc);
1315
1316        imcb_notify_email(ic, "Received e-mail from %s for %s: %s <%s>", from, to, subject, url);
1317
1318        return NULL;
1319}
1320
1321static void *prplcb_notify_userinfo(PurpleConnection *gc, const char *who, PurpleNotifyUserInfo *user_info)
1322{
1323        struct im_connection *ic = purple_ic_by_gc(gc);
1324        GString *info = g_string_new("");
1325        GList *l = purple_notify_user_info_get_entries(user_info);
1326        char *key;
1327        const char *value;
1328        int n;
1329
1330        while (l) {
1331                PurpleNotifyUserInfoEntry *e = l->data;
1332
1333                switch (purple_notify_user_info_entry_get_type(e)) {
1334                case PURPLE_NOTIFY_USER_INFO_ENTRY_PAIR:
1335                case PURPLE_NOTIFY_USER_INFO_ENTRY_SECTION_HEADER:
1336                        key = g_strdup(purple_notify_user_info_entry_get_label(e));
1337                        value = purple_notify_user_info_entry_get_value(e);
1338
1339                        if (key) {
1340                                strip_html(key);
1341                                g_string_append_printf(info, "%s: ", key);
1342
1343                                if (value) {
1344                                        n = strlen(value) - 1;
1345                                        while (g_ascii_isspace(value[n])) {
1346                                                n--;
1347                                        }
1348                                        g_string_append_len(info, value, n + 1);
1349                                }
1350                                g_string_append_c(info, '\n');
1351                                g_free(key);
1352                        }
1353
1354                        break;
1355                case PURPLE_NOTIFY_USER_INFO_ENTRY_SECTION_BREAK:
1356                        g_string_append(info, "------------------------\n");
1357                        break;
1358                }
1359
1360                l = l->next;
1361        }
1362
1363        imcb_log(ic, "User %s info:\n%s", who, info->str);
1364        g_string_free(info, TRUE);
1365
1366        return NULL;
1367}
1368
1369static PurpleNotifyUiOps bee_notify_uiops =
1370{
1371        prplcb_notify_message,
1372        prplcb_notify_email,
1373        NULL,
1374        NULL,
1375        NULL,
1376        NULL,
1377        prplcb_notify_userinfo,
1378};
1379
1380static void *prplcb_account_request_authorize(PurpleAccount *account, const char *remote_user,
1381                                              const char *id, const char *alias, const char *message, gboolean on_list,
1382                                              PurpleAccountRequestAuthorizationCb authorize_cb,
1383                                              PurpleAccountRequestAuthorizationCb deny_cb, void *user_data)
1384{
1385        struct im_connection *ic = purple_ic_by_pa(account);
1386        char *q;
1387
1388        if (alias) {
1389                q = g_strdup_printf("%s (%s) wants to add you to his/her contact "
1390                                    "list. (%s)", alias, remote_user, message);
1391        } else {
1392                q = g_strdup_printf("%s wants to add you to his/her contact "
1393                                    "list. (%s)", remote_user, message);
1394        }
1395
1396        imcb_ask_with_free(ic, q, user_data, authorize_cb, deny_cb, NULL);
1397        g_free(q);
1398
1399        return NULL;
1400}
1401
1402static PurpleAccountUiOps bee_account_uiops =
1403{
1404        NULL,
1405        NULL,
1406        NULL,
1407        prplcb_account_request_authorize,
1408        NULL,
1409};
1410
1411extern PurpleXferUiOps bee_xfer_uiops;
1412
1413static void purple_ui_init()
1414{
1415        purple_connections_set_ui_ops(&bee_conn_uiops);
1416        purple_blist_set_ui_ops(&bee_blist_uiops);
1417        purple_conversations_set_ui_ops(&bee_conv_uiops);
1418        purple_request_set_ui_ops(&bee_request_uiops);
1419        purple_privacy_set_ui_ops(&bee_privacy_uiops);
1420        purple_notify_set_ui_ops(&bee_notify_uiops);
1421        purple_accounts_set_ui_ops(&bee_account_uiops);
1422        purple_xfers_set_ui_ops(&bee_xfer_uiops);
1423
1424        if (getenv("BITLBEE_DEBUG")) {
1425                purple_debug_set_ui_ops(&bee_debug_uiops);
1426        }
1427}
1428
1429void purple_initmodule()
1430{
1431        struct prpl funcs;
1432        GList *prots;
1433        GString *help;
1434        char *dir;
1435
1436        g_assert((int) B_EV_IO_READ == (int) PURPLE_INPUT_READ);
1437        g_assert((int) B_EV_IO_WRITE == (int) PURPLE_INPUT_WRITE);
1438
1439        dir = g_strdup_printf("%s/purple", global.conf->configdir);
1440        purple_util_set_user_dir(dir);
1441        g_free(dir);
1442
1443        purple_debug_set_enabled(FALSE);
1444        purple_core_set_ui_ops(&bee_core_uiops);
1445        purple_eventloop_set_ui_ops(&glib_eventloops);
1446        if (!purple_core_init("BitlBee")) {
1447                /* Initializing the core failed. Terminate. */
1448                fprintf(stderr, "libpurple initialization failed.\n");
1449                abort();
1450        }
1451
1452        if (proxytype != PROXY_NONE) {
1453                PurpleProxyInfo *pi = purple_global_proxy_get_info();
1454                switch (proxytype) {
1455                case PROXY_SOCKS4A:
1456                case PROXY_SOCKS4:
1457                        purple_proxy_info_set_type(pi, PURPLE_PROXY_SOCKS4);
1458                        break;
1459                case PROXY_SOCKS5:
1460                        purple_proxy_info_set_type(pi, PURPLE_PROXY_SOCKS5);
1461                        break;
1462                case PROXY_HTTP:
1463                        purple_proxy_info_set_type(pi, PURPLE_PROXY_HTTP);
1464                        break;
1465                }
1466                purple_proxy_info_set_host(pi, proxyhost);
1467                purple_proxy_info_set_port(pi, proxyport);
1468                purple_proxy_info_set_username(pi, proxyuser);
1469                purple_proxy_info_set_password(pi, proxypass);
1470        }
1471
1472        purple_set_blist(purple_blist_new());
1473
1474        /* No, really. So far there were ui_ops for everything, but now suddenly
1475           one needs to use signals for typing notification stuff. :-( */
1476        purple_signal_connect(purple_conversations_get_handle(), "buddy-typing",
1477                              &funcs, PURPLE_CALLBACK(prplcb_buddy_typing), NULL);
1478        purple_signal_connect(purple_conversations_get_handle(), "buddy-typed",
1479                              &funcs, PURPLE_CALLBACK(prplcb_buddy_typing), NULL);
1480        purple_signal_connect(purple_conversations_get_handle(), "buddy-typing-stopped",
1481                              &funcs, PURPLE_CALLBACK(prplcb_buddy_typing), NULL);
1482
1483        memset(&funcs, 0, sizeof(funcs));
1484        funcs.login = purple_login;
1485        funcs.init = purple_init;
1486        funcs.logout = purple_logout;
1487        funcs.buddy_msg = purple_buddy_msg;
1488        funcs.away_states = purple_away_states;
1489        funcs.set_away = purple_set_away;
1490        funcs.add_buddy = purple_add_buddy;
1491        funcs.remove_buddy = purple_remove_buddy;
1492        funcs.add_permit = purple_add_permit;
1493        funcs.add_deny = purple_add_deny;
1494        funcs.rem_permit = purple_rem_permit;
1495        funcs.rem_deny = purple_rem_deny;
1496        funcs.get_info = purple_get_info;
1497        funcs.keepalive = purple_keepalive;
1498        funcs.send_typing = purple_send_typing;
1499        funcs.handle_cmp = g_strcasecmp;
1500        /* TODO(wilmer): Set these only for protocols that support them? */
1501        funcs.chat_msg = purple_chat_msg;
1502        funcs.chat_with = purple_chat_with;
1503        funcs.chat_invite = purple_chat_invite;
1504        funcs.chat_kick = purple_chat_kick;
1505        funcs.chat_leave = purple_chat_leave;
1506        funcs.chat_join = purple_chat_join;
1507        funcs.transfer_request = purple_transfer_request;
1508
1509        help = g_string_new("BitlBee libpurple module supports the following IM protocols:\n");
1510
1511        /* Add a protocol entry to BitlBee's structures for every protocol
1512           supported by this libpurple instance. */
1513        for (prots = purple_plugins_get_protocols(); prots; prots = prots->next) {
1514                PurplePlugin *prot = prots->data;
1515                struct prpl *ret;
1516
1517                /* If we already have this one (as a native module), don't
1518                   add a libpurple duplicate. */
1519                if (find_protocol(prot->info->id)) {
1520                        continue;
1521                }
1522
1523                ret = g_memdup(&funcs, sizeof(funcs));
1524                ret->name = ret->data = prot->info->id;
1525                if (strncmp(ret->name, "prpl-", 5) == 0) {
1526                        ret->name += 5;
1527                }
1528                register_protocol(ret);
1529
1530                g_string_append_printf(help, "\n* %s (%s)", ret->name, prot->info->name);
1531
1532                /* libpurple doesn't define a protocol called OSCAR, but we
1533                   need it to be compatible with normal BitlBee. */
1534                if (g_strcasecmp(prot->info->id, "prpl-aim") == 0) {
1535                        ret = g_memdup(&funcs, sizeof(funcs));
1536                        ret->name = "oscar";
1537                        ret->data = prot->info->id;
1538                        register_protocol(ret);
1539                }
1540        }
1541
1542        g_string_append(help, "\n\nFor used protocols, more information about available "
1543                        "settings can be found using \x02help purple <protocol name>\x02 "
1544                        "(create an account using that protocol first!)");
1545
1546        /* Add a simple dynamically-generated help item listing all
1547           the supported protocols. */
1548        help_add_mem(&global.help, "purple", help->str);
1549        g_string_free(help, TRUE);
1550}
Note: See TracBrowser for help on using the repository browser.