source: protocols/yahoo/yahoo.c @ 07874be

Last change on this file since 07874be was f7d12f7, checked in by Wilmer van der Gaast <wilmer@…>, at 2010-08-05T20:20:44Z

Some fixes for compiler warnings that only show up when compiling with -O2,
and some additions to the Debian package description.
  • Property mode set to 100644
File size: 24.7 KB
Line 
1/*
2 * libyahoo2 wrapper to BitlBee
3 *
4 * Mostly Copyright 2004-2010 Wilmer van der Gaast <wilmer@gaast.net>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19 *
20 */
21
22
23#include <errno.h>
24#include <string.h>
25#include <stdlib.h>
26#include <stdio.h>
27#include <time.h>
28#include <sys/stat.h>
29#include <ctype.h>
30#include "nogaim.h"
31#include "yahoo2.h"
32#include "yahoo2_callbacks.h"
33
34#define BYAHOO_DEFAULT_GROUP "Buddies"
35
36/* A hack to handle removal of buddies not in the group "Buddies" correctly */
37struct byahoo_buddygroups
38{
39        char *buddy;
40        char *group;
41};
42
43struct byahoo_data
44{
45        int y2_id;
46        int current_status;
47        gboolean logged_in;
48        GSList *buddygroups;
49};
50
51struct byahoo_input_data
52{
53        int h;
54        void *d;
55};
56
57struct byahoo_conf_invitation
58{
59        char *name;
60        struct groupchat *c;
61        int yid;
62        YList *members;
63        struct im_connection *ic;
64};
65
66static GSList *byahoo_inputs = NULL;
67static int byahoo_chat_id = 0;
68
69static char *byahoo_strip( const char *in )
70{
71        int len;
72       
73        /* This should get rid of the markup noise at the beginning of the string. */
74        while( *in )
75        {
76                if( g_strncasecmp( in, "<font", 5 ) == 0 ||
77                    g_strncasecmp( in, "<fade", 5 ) == 0 ||
78                    g_strncasecmp( in, "<alt", 4 ) == 0 )
79                {
80                        char *s = strchr( in, '>' );
81                        if( !s )
82                                break;
83                       
84                        in = s + 1;
85                }
86                else if( strncmp( in, "\e[", 2 ) == 0 )
87                {
88                        const char *s;
89                       
90                        for( s = in + 2; *s && *s != 'm'; s ++ );
91                       
92                        if( *s != 'm' )
93                                break;
94                       
95                        in = s + 1;
96                }
97                else
98                {
99                        break;
100                }
101        }
102       
103        /* This is supposed to get rid of the noise at the end of the line. */
104        len = strlen( in );
105        while( len > 0 && ( in[len-1] == '>' || in[len-1] == 'm' ) )
106        {
107                int blen = len;
108                const char *search;
109               
110                if( in[len-1] == '>' )
111                        search = "</";
112                else
113                        search = "\e[";
114               
115                len -= 3;
116                while( len > 0 && strncmp( in + len, search, 2 ) != 0 )
117                        len --;
118               
119                if( len <= 0 && strncmp( in, search, 2 ) != 0 )
120                {
121                        len = blen;
122                        break;
123                }
124        }
125       
126        return( g_strndup( in, len ) );
127}
128
129static void byahoo_init( account_t *acc )
130{
131        set_add( &acc->set, "mail_notifications", "false", set_eval_bool, acc );
132       
133        acc->flags |= ACC_FLAG_AWAY_MESSAGE | ACC_FLAG_STATUS_MESSAGE;
134}
135
136static void byahoo_login( account_t *acc )
137{
138        struct im_connection *ic = imcb_new( acc );
139        struct byahoo_data *yd = ic->proto_data = g_new0( struct byahoo_data, 1 );
140        char *s;
141       
142        yd->logged_in = FALSE;
143        yd->current_status = YAHOO_STATUS_AVAILABLE;
144       
145        if( ( s = strchr( acc->user, '@' ) ) && g_strcasecmp( s, "@yahoo.com" ) == 0 )
146                imcb_error( ic, "Your Yahoo! username should just be a username. "
147                                "Do not include any @domain part." );
148       
149        imcb_log( ic, "Connecting" );
150        yd->y2_id = yahoo_init( acc->user, acc->pass );
151        yahoo_login( yd->y2_id, yd->current_status );
152}
153
154static void byahoo_logout( struct im_connection *ic )
155{
156        struct byahoo_data *yd = (struct byahoo_data *) ic->proto_data;
157        GSList *l;
158       
159        while( ic->groupchats )
160                imcb_chat_free( ic->groupchats->data );
161       
162        for( l = yd->buddygroups; l; l = l->next )
163        {
164                struct byahoo_buddygroups *bg = l->data;
165               
166                g_free( bg->buddy );
167                g_free( bg->group );
168                g_free( bg );
169        }
170        g_slist_free( yd->buddygroups );
171       
172        yahoo_logoff( yd->y2_id );
173       
174        g_free( yd );
175}
176
177static void byahoo_get_info(struct im_connection *ic, char *who) 
178{
179        /* Just make an URL and let the user fetch the info */
180        imcb_log(ic, "%s\n%s: %s%s", _("User Info"), 
181                        _("For now, fetch yourself"), yahoo_get_profile_url(),
182                        who);
183}
184
185static int byahoo_buddy_msg( struct im_connection *ic, char *who, char *what, int flags )
186{
187        struct byahoo_data *yd = ic->proto_data;
188       
189        yahoo_send_im( yd->y2_id, NULL, who, what, 1, 0 );
190       
191        return 1;
192}
193
194static int byahoo_send_typing( struct im_connection *ic, char *who, int typing )
195{
196        struct byahoo_data *yd = ic->proto_data;
197       
198        yahoo_send_typing( yd->y2_id, NULL, who, ( typing & OPT_TYPING ) != 0 );
199       
200        return 1;
201}
202
203static void byahoo_set_away( struct im_connection *ic, char *state, char *msg )
204{
205        struct byahoo_data *yd = (struct byahoo_data *) ic->proto_data;
206       
207        if( state && msg == NULL )
208        {
209                /* Use these states only if msg doesn't contain additional
210                   info since away messages are only supported with CUSTOM. */
211                if( g_strcasecmp( state, "Be Right Back" ) == 0 )
212                        yd->current_status = YAHOO_STATUS_BRB;
213                else if( g_strcasecmp( state, "Busy" ) == 0 )
214                        yd->current_status = YAHOO_STATUS_BUSY;
215                else if( g_strcasecmp( state, "Not At Home" ) == 0 )
216                        yd->current_status = YAHOO_STATUS_NOTATHOME;
217                else if( g_strcasecmp( state, "Not At Desk" ) == 0 )
218                        yd->current_status = YAHOO_STATUS_NOTATDESK;
219                else if( g_strcasecmp( state, "Not In Office" ) == 0 )
220                        yd->current_status = YAHOO_STATUS_NOTINOFFICE;
221                else if( g_strcasecmp( state, "On Phone" ) == 0 )
222                        yd->current_status = YAHOO_STATUS_ONPHONE;
223                else if( g_strcasecmp( state, "On Vacation" ) == 0 )
224                        yd->current_status = YAHOO_STATUS_ONVACATION;
225                else if( g_strcasecmp( state, "Out To Lunch" ) == 0 )
226                        yd->current_status = YAHOO_STATUS_OUTTOLUNCH;
227                else if( g_strcasecmp( state, "Stepped Out" ) == 0 )
228                        yd->current_status = YAHOO_STATUS_STEPPEDOUT;
229                else if( g_strcasecmp( state, "Invisible" ) == 0 )
230                        yd->current_status = YAHOO_STATUS_INVISIBLE;
231                else
232                        yd->current_status = YAHOO_STATUS_CUSTOM;
233        }
234        else if( msg )
235                yd->current_status = YAHOO_STATUS_CUSTOM;
236        else
237                yd->current_status = YAHOO_STATUS_AVAILABLE;
238       
239        yahoo_set_away( yd->y2_id, yd->current_status, msg, state ? 2 : 0 );
240}
241
242static GList *byahoo_away_states( struct im_connection *ic )
243{
244        static GList *m = NULL;
245
246        if( m == NULL )
247        {
248                m = g_list_append( m, "Be Right Back" );
249                m = g_list_append( m, "Busy" );
250                m = g_list_append( m, "Not At Home" );
251                m = g_list_append( m, "Not At Desk" );
252                m = g_list_append( m, "Not In Office" );
253                m = g_list_append( m, "On Phone" );
254                m = g_list_append( m, "On Vacation" );
255                m = g_list_append( m, "Out To Lunch" );
256                m = g_list_append( m, "Stepped Out" );
257                m = g_list_append( m, "Invisible" );
258        }
259       
260        return m;
261}
262
263static void byahoo_keepalive( struct im_connection *ic )
264{
265        struct byahoo_data *yd = ic->proto_data;
266       
267        yahoo_keepalive( yd->y2_id );
268}
269
270static void byahoo_add_buddy( struct im_connection *ic, char *who, char *group )
271{
272        struct byahoo_data *yd = (struct byahoo_data *) ic->proto_data;
273        bee_user_t *bu;
274       
275        if( group && ( bu = bee_user_by_handle( ic->bee, ic, who ) ) && bu->group )
276        {
277                GSList *bgl;
278               
279                /* If the person is in our list already, this is a group change. */
280                yahoo_change_buddy_group( yd->y2_id, who, bu->group->name, group );
281               
282                /* No idea how often people have people in multiple groups and
283                   BitlBee doesn't currently support this anyway .. but keep
284                   this struct up-to-date for now. */
285                for( bgl = yd->buddygroups; bgl; bgl = bgl->next )
286                {
287                        struct byahoo_buddygroups *bg = bgl->data;
288                       
289                        if( g_strcasecmp( bg->buddy, who ) == 0 &&
290                            g_strcasecmp( bg->group, bu->group->name ) == 0 )
291                        {
292                                g_free( bg->group );
293                                bg->group = g_strdup( group );
294                        }
295                }
296        }
297        else
298                yahoo_add_buddy( yd->y2_id, who, group ? group : BYAHOO_DEFAULT_GROUP, NULL );
299}
300
301static void byahoo_remove_buddy( struct im_connection *ic, char *who, char *group )
302{
303        struct byahoo_data *yd = (struct byahoo_data *) ic->proto_data;
304        GSList *bgl;
305       
306        yahoo_remove_buddy( yd->y2_id, who, BYAHOO_DEFAULT_GROUP );
307       
308        for( bgl = yd->buddygroups; bgl; bgl = bgl->next )
309        {
310                struct byahoo_buddygroups *bg = bgl->data;
311               
312                if( g_strcasecmp( bg->buddy, who ) == 0 )
313                        yahoo_remove_buddy( yd->y2_id, who, bg->group );
314        }
315}
316
317static void byahoo_chat_msg( struct groupchat *c, char *message, int flags )
318{
319        struct byahoo_data *yd = (struct byahoo_data *) c->ic->proto_data;
320       
321        yahoo_conference_message( yd->y2_id, NULL, c->data, c->title, message, 1 );
322}
323
324static void byahoo_chat_invite( struct groupchat *c, char *who, char *msg )
325{
326        struct byahoo_data *yd = (struct byahoo_data *) c->ic->proto_data;
327       
328        yahoo_conference_invite( yd->y2_id, NULL, c->data, c->title, msg ? msg : "" );
329}
330
331static void byahoo_chat_leave( struct groupchat *c )
332{
333        struct byahoo_data *yd = (struct byahoo_data *) c->ic->proto_data;
334       
335        yahoo_conference_logoff( yd->y2_id, NULL, c->data, c->title );
336        imcb_chat_free( c );
337}
338
339static struct groupchat *byahoo_chat_with( struct im_connection *ic, char *who )
340{
341        struct byahoo_data *yd = (struct byahoo_data *) ic->proto_data;
342        struct groupchat *c;
343        char *roomname;
344        YList *members;
345       
346        roomname = g_strdup_printf( "%s-Bee-%d", ic->acc->user, byahoo_chat_id );
347       
348        c = imcb_chat_new( ic, roomname );
349        imcb_chat_add_buddy( c, ic->acc->user );
350       
351        /* FIXME: Free this thing when the chat's destroyed. We can't *always*
352                  do this because it's not always created here. */
353        c->data = members = g_new0( YList, 1 );
354        members->data = g_strdup( who );
355       
356        yahoo_conference_invite( yd->y2_id, NULL, members, roomname, "Please join my groupchat..." );
357       
358        g_free( roomname );
359       
360        return c;
361}
362
363static void byahoo_auth_allow( struct im_connection *ic, const char *who )
364{
365        struct byahoo_data *yd = (struct byahoo_data *) ic->proto_data;
366       
367        yahoo_confirm_buddy( yd->y2_id, who, 0, "" );
368}
369
370static void byahoo_auth_deny( struct im_connection *ic, const char *who )
371{
372        struct byahoo_data *yd = (struct byahoo_data *) ic->proto_data;
373       
374        yahoo_confirm_buddy( yd->y2_id, who, 1, "" );
375}
376
377void byahoo_initmodule( )
378{
379        struct prpl *ret = g_new0(struct prpl, 1);
380        ret->name = "yahoo";
381        ret->init = byahoo_init;
382       
383        ret->login = byahoo_login;
384        ret->keepalive = byahoo_keepalive;
385        ret->logout = byahoo_logout;
386       
387        ret->buddy_msg = byahoo_buddy_msg;
388        ret->get_info = byahoo_get_info;
389        ret->away_states = byahoo_away_states;
390        ret->set_away = byahoo_set_away;
391        ret->add_buddy = byahoo_add_buddy;
392        ret->remove_buddy = byahoo_remove_buddy;
393        ret->send_typing = byahoo_send_typing;
394       
395        ret->chat_msg = byahoo_chat_msg;
396        ret->chat_invite = byahoo_chat_invite;
397        ret->chat_leave = byahoo_chat_leave;
398        ret->chat_with = byahoo_chat_with;
399
400        ret->handle_cmp = g_strcasecmp;
401       
402        ret->auth_allow = byahoo_auth_allow;
403        ret->auth_deny = byahoo_auth_deny;
404       
405        register_protocol(ret);
406}
407
408static struct im_connection *byahoo_get_ic_by_id( int id )
409{
410        GSList *l;
411        struct im_connection *ic;
412        struct byahoo_data *yd;
413       
414        for( l = get_connections(); l; l = l->next )
415        {
416                ic = l->data;
417                yd = ic->proto_data;
418               
419                if( strcmp( ic->acc->prpl->name, "yahoo" ) == 0 && yd->y2_id == id )
420                        return( ic );
421        }
422       
423        return( NULL );
424}
425
426
427/* Now it's callback time! */
428
429struct byahoo_connect_callback_data
430{
431        int fd;
432        yahoo_connect_callback callback;
433        gpointer data;
434        int id;
435};
436
437void byahoo_connect_callback( gpointer data, gint source, b_input_condition cond )
438{
439        struct byahoo_connect_callback_data *d = data;
440       
441        if( !byahoo_get_ic_by_id( d->id ) )
442        {
443                g_free( d );
444                return;
445        }
446       
447        d->callback( NULL + d->fd, 0, d->data );
448        g_free( d );
449}
450
451struct byahoo_read_ready_data
452{
453        int id;
454        int fd;
455        int tag;
456        gpointer data;
457};
458
459gboolean byahoo_read_ready_callback( gpointer data, gint source, b_input_condition cond )
460{
461        struct byahoo_read_ready_data *d = data;
462       
463        if( !byahoo_get_ic_by_id( d->id ) )
464                /* WTF doesn't libyahoo clean this up? */
465                return FALSE;
466       
467        yahoo_read_ready( d->id, NULL + d->fd, d->data );
468       
469        return TRUE;
470}
471
472struct byahoo_write_ready_data
473{
474        int id;
475        int fd;
476        int tag;
477        gpointer data;
478};
479
480gboolean byahoo_write_ready_callback( gpointer data, gint source, b_input_condition cond )
481{
482        struct byahoo_write_ready_data *d = data;
483       
484        return yahoo_write_ready( d->id, NULL + d->fd, d->data );
485}
486
487void ext_yahoo_login_response( int id, int succ, const char *url )
488{
489        struct im_connection *ic = byahoo_get_ic_by_id( id );
490        struct byahoo_data *yd = NULL;
491       
492        if( ic == NULL )
493        {
494                /* libyahoo2 seems to call this one twice when something
495                   went wrong sometimes. Don't know why. Because we clean
496                   up the connection on the first failure, the second
497                   should be ignored. */
498               
499                return;
500        }
501       
502        yd = (struct byahoo_data *) ic->proto_data;
503       
504        if( succ == YAHOO_LOGIN_OK )
505        {
506                imcb_connected( ic );
507               
508                yd->logged_in = TRUE;
509        }
510        else
511        {
512                char *errstr;
513                int allow_reconnect = FALSE;
514               
515                yd->logged_in = FALSE;
516               
517                if( succ == YAHOO_LOGIN_UNAME )
518                        errstr = "Incorrect Yahoo! username";
519                else if( succ == YAHOO_LOGIN_PASSWD )
520                        errstr = "Incorrect Yahoo! password";
521                else if( succ == YAHOO_LOGIN_LOCK )
522                        errstr = "Yahoo! account locked";
523                else if( succ == 1236 )
524                        errstr = "Yahoo! account locked or machine temporarily banned";
525                else if( succ == YAHOO_LOGIN_DUPL )
526                        errstr = "Logged in on a different machine or device";
527                else if( succ == YAHOO_LOGIN_SOCK )
528                {
529                        errstr = "Socket problem";
530                        allow_reconnect = TRUE;
531                }
532                else
533                        errstr = "Unknown error";
534               
535                if( url && *url )
536                        imcb_error( ic, "Error %d (%s). See %s for more information.", succ, errstr, url );
537                else
538                        imcb_error( ic, "Error %d (%s)", succ, errstr );
539               
540                imc_logout( ic, allow_reconnect );
541        }
542}
543
544void ext_yahoo_got_buddies( int id, YList *buds )
545{
546        struct im_connection *ic = byahoo_get_ic_by_id( id );
547        struct byahoo_data *yd = ic->proto_data;
548        YList *bl = buds;
549       
550        while( bl )
551        {
552                struct yahoo_buddy *b = bl->data;
553                struct byahoo_buddygroups *bg;
554               
555                if( strcmp( b->group, BYAHOO_DEFAULT_GROUP ) != 0 )
556                {
557                        bg = g_new0( struct byahoo_buddygroups, 1 );
558                       
559                        bg->buddy = g_strdup( b->id );
560                        bg->group = g_strdup( b->group );
561                        yd->buddygroups = g_slist_append( yd->buddygroups, bg );
562                }
563               
564                imcb_add_buddy( ic, b->id, b->group );
565                imcb_rename_buddy( ic, b->id, b->real_name );
566               
567                bl = bl->next;
568        }
569}
570
571void ext_yahoo_got_ignore( int id, YList *igns )
572{
573}
574
575void ext_yahoo_got_identities( int id, YList *ids )
576{
577}
578
579void ext_yahoo_got_cookies( int id )
580{
581}
582
583void ext_yahoo_status_changed( int id, const char *who, int stat, const char *msg, int away, int idle, int mobile )
584{
585        struct im_connection *ic = byahoo_get_ic_by_id( id );
586        char *state_string = NULL;
587        int flags = OPT_LOGGED_IN;
588       
589        if( away )
590                flags |= OPT_AWAY;
591       
592        switch (stat)
593        {
594        case YAHOO_STATUS_BRB:
595                state_string = "Be Right Back";
596                break;
597        case YAHOO_STATUS_BUSY:
598                state_string = "Busy";
599                break;
600        case YAHOO_STATUS_NOTATHOME:
601                state_string = "Not At Home";
602                break;
603        case YAHOO_STATUS_NOTATDESK:
604                state_string = "Not At Desk";
605                break;
606        case YAHOO_STATUS_NOTINOFFICE:
607                state_string = "Not In Office";
608                break;
609        case YAHOO_STATUS_ONPHONE:
610                state_string = "On Phone";
611                break;
612        case YAHOO_STATUS_ONVACATION:
613                state_string = "On Vacation";
614                break;
615        case YAHOO_STATUS_OUTTOLUNCH:
616                state_string = "Out To Lunch";
617                break;
618        case YAHOO_STATUS_STEPPEDOUT:
619                state_string = "Stepped Out";
620                break;
621        case YAHOO_STATUS_INVISIBLE:
622                state_string = "Invisible";
623                break;
624        case YAHOO_STATUS_CUSTOM:
625                state_string = "Away";
626                break;
627        case YAHOO_STATUS_IDLE:
628                state_string = "Idle";
629                break;
630        case YAHOO_STATUS_OFFLINE:
631                state_string = "Offline";
632                flags = 0;
633                break;
634        }
635       
636        imcb_buddy_status( ic, who, flags, state_string, msg );
637       
638        if( stat == YAHOO_STATUS_IDLE )
639                imcb_buddy_times( ic, who, 0, idle );
640}
641
642void ext_yahoo_got_buzz( int id, const char *me, const char *who, long tm )
643{
644}
645
646void ext_yahoo_got_im( int id, const char *me, const char *who, const char *msg, long tm, int stat, int utf8 )
647{
648        struct im_connection *ic = byahoo_get_ic_by_id( id );
649        char *m;
650       
651        if( msg )
652        {
653                m = byahoo_strip( msg );
654                imcb_buddy_msg( ic, (char*) who, (char*) m, 0, 0 );
655                g_free( m );
656        }
657}
658
659void ext_yahoo_got_file( int id, const char *ignored, const char *who, const char *msg,
660                         const char *fname, unsigned long fesize, char *trid )
661{
662        struct im_connection *ic = byahoo_get_ic_by_id( id );
663       
664        imcb_log( ic, "Got a file transfer (file = %s) from %s. Ignoring for now due to lack of support.", fname, who );
665}
666
667void ext_yahoo_got_ft_data( int id, const unsigned char *in, int len, void *data )
668{
669}
670
671void ext_yahoo_file_transfer_done( int id, int result, void *data )
672{
673}
674
675void ext_yahoo_typing_notify( int id, const char *ignored, const char *who, int stat )
676{
677        struct im_connection *ic = byahoo_get_ic_by_id( id );
678       
679        if( stat == 1 )
680                imcb_buddy_typing( ic, (char*) who, OPT_TYPING );
681        else
682                imcb_buddy_typing( ic, (char*) who, 0 );
683}
684
685void ext_yahoo_system_message( int id, const char *me, const char *who, const char *msg )
686{
687        struct im_connection *ic = byahoo_get_ic_by_id( id );
688       
689        imcb_log( ic, "Yahoo! system message: %s", msg );
690}
691
692void ext_yahoo_webcam_invite( int id, const char *ignored, const char *from )
693{
694        struct im_connection *ic = byahoo_get_ic_by_id( id );
695       
696        imcb_log( ic, "Got a webcam invitation from %s. IRC+webcams is a no-no though...", from );
697}
698
699void ext_yahoo_error( int id, const char *err, int fatal, int num )
700{
701        struct im_connection *ic = byahoo_get_ic_by_id( id );
702       
703        imcb_error( ic, "%s", err );
704}
705
706/* TODO: Clear up the mess of inp and d structures */
707int ext_yahoo_add_handler( int id, void *fd_, yahoo_input_condition cond, void *data )
708{
709        struct byahoo_input_data *inp = g_new0( struct byahoo_input_data, 1 );
710        int fd = (long) fd_;
711       
712        if( cond == YAHOO_INPUT_READ )
713        {
714                struct byahoo_read_ready_data *d = g_new0( struct byahoo_read_ready_data, 1 );
715               
716                d->id = id;
717                d->fd = fd;
718                d->data = data;
719               
720                inp->d = d;
721                d->tag = inp->h = b_input_add( fd, B_EV_IO_READ, (b_event_handler) byahoo_read_ready_callback, (gpointer) d );
722        }
723        else if( cond == YAHOO_INPUT_WRITE )
724        {
725                struct byahoo_write_ready_data *d = g_new0( struct byahoo_write_ready_data, 1 );
726               
727                d->id = id;
728                d->fd = fd;
729                d->data = data;
730               
731                inp->d = d;
732                d->tag = inp->h = b_input_add( fd, B_EV_IO_WRITE, (b_event_handler) byahoo_write_ready_callback, (gpointer) d );
733        }
734        else
735        {
736                g_free( inp );
737                return -1;
738                /* Panic... */
739        }
740       
741        byahoo_inputs = g_slist_append( byahoo_inputs, inp );
742        return inp->h;
743}
744
745void ext_yahoo_remove_handler( int id, int tag )
746{
747        struct byahoo_input_data *inp;
748        GSList *l = byahoo_inputs;
749       
750        while( l )
751        {
752                inp = l->data;
753                if( inp->h == tag )
754                {
755                        g_free( inp->d );
756                        g_free( inp );
757                        byahoo_inputs = g_slist_remove( byahoo_inputs, inp );
758                        break;
759                }
760                l = l->next;
761        }
762       
763        b_event_remove( tag );
764}
765
766int ext_yahoo_connect_async( int id, const char *host, int port, yahoo_connect_callback callback, void *data, int use_ssl )
767{
768        struct byahoo_connect_callback_data *d;
769        int fd;
770       
771        d = g_new0( struct byahoo_connect_callback_data, 1 );
772        if( ( fd = proxy_connect( host, port, (b_event_handler) byahoo_connect_callback, (gpointer) d ) ) < 0 )
773        {
774                g_free( d );
775                return( fd );
776        }
777        d->fd = fd;
778        d->callback = callback;
779        d->data = data;
780        d->id = id;
781       
782        return fd;
783}
784
785char *ext_yahoo_get_ip_addr( const char *domain )
786{
787        return NULL;
788}
789
790int ext_yahoo_write( void *fd, char *buf, int len )
791{
792        return write( (long) fd, buf, len );
793}
794
795int ext_yahoo_read( void *fd, char *buf, int len )
796{
797        return read( (long) fd, buf, len );
798}
799
800void ext_yahoo_close( void *fd )
801{
802        close( (long) fd );
803}
804
805void ext_yahoo_got_buddy_change_group( int id, const char *me, const char *who,
806                                       const char *old_group, const char *new_group )
807{
808        struct im_connection *ic = byahoo_get_ic_by_id( id );
809       
810        imcb_add_buddy( ic, who, new_group );
811}
812
813/* Because we don't want asynchronous connects in BitlBee, and because
814   libyahoo doesn't seem to use this one anyway, this one is now defunct. */
815int ext_yahoo_connect(const char *host, int port)
816{
817        return -1;
818}
819
820static void byahoo_accept_conf( void *data )
821{
822        struct byahoo_conf_invitation *inv = data;
823        struct groupchat *b = NULL;
824        GSList *l;
825       
826        for( l = inv->ic->groupchats; l; l = l->next )
827        {
828                b = l->data;
829                if( b == inv->c )
830                        break;
831        }
832       
833        if( b != NULL )
834        {
835                yahoo_conference_logon( inv->yid, NULL, inv->members, inv->name );
836                imcb_chat_add_buddy( inv->c, inv->ic->acc->user );
837        }
838        else
839        {
840                imcb_log( inv->ic, "Duplicate/corrupted invitation to `%s'.", inv->name );
841        }
842       
843        g_free( inv->name );
844        g_free( inv );
845}
846
847static void byahoo_reject_conf( void *data )
848{
849        struct byahoo_conf_invitation *inv = data;
850       
851        yahoo_conference_decline( inv->yid, NULL, inv->members, inv->name, "User rejected groupchat" );
852        imcb_chat_free( inv->c );
853        g_free( inv->name );
854        g_free( inv );
855}
856
857void ext_yahoo_got_conf_invite( int id, const char *ignored,
858                                const char *who, const char *room, const char *msg, YList *members )
859{
860        struct im_connection *ic = byahoo_get_ic_by_id( id );
861        struct byahoo_conf_invitation *inv;
862        char txt[1024];
863        YList *m;
864       
865        if( g_strcasecmp( who, ic->acc->user ) == 0 )
866                /* WTF, Yahoo! seems to echo these now? */
867                return;
868       
869        inv = g_malloc( sizeof( struct byahoo_conf_invitation ) );
870        memset( inv, 0, sizeof( struct byahoo_conf_invitation ) );
871        inv->name = g_strdup( room );
872        inv->c = imcb_chat_new( ic, (char*) room );
873        inv->c->data = members;
874        inv->yid = id;
875        inv->members = members;
876        inv->ic = ic;
877       
878        for( m = members; m; m = m->next )
879                if( g_strcasecmp( m->data, ic->acc->user ) != 0 )
880                        imcb_chat_add_buddy( inv->c, m->data );
881       
882        g_snprintf( txt, 1024, "Got an invitation to chatroom %s from %s: %s", room, who, msg );
883       
884        imcb_ask( ic, txt, inv, byahoo_accept_conf, byahoo_reject_conf );
885}
886
887void ext_yahoo_conf_userdecline( int id, const char *ignored, const char *who, const char *room, const char *msg )
888{
889        struct im_connection *ic = byahoo_get_ic_by_id( id );
890       
891        imcb_log( ic, "Invite to chatroom %s rejected by %s: %s", room, who, msg );
892}
893
894void ext_yahoo_conf_userjoin( int id, const char *ignored, const char *who, const char *room )
895{
896        struct im_connection *ic = byahoo_get_ic_by_id( id );
897        struct groupchat *c = bee_chat_by_title( ic->bee, ic, room );
898       
899        if( c )
900                imcb_chat_add_buddy( c, (char*) who );
901}
902
903void ext_yahoo_conf_userleave( int id, const char *ignored, const char *who, const char *room )
904
905{
906        struct im_connection *ic = byahoo_get_ic_by_id( id );
907        struct groupchat *c = bee_chat_by_title( ic->bee, ic, room );
908       
909        if( c )
910                imcb_chat_remove_buddy( c, (char*) who, "" );
911}
912
913void ext_yahoo_conf_message( int id, const char *ignored, const char *who, const char *room, const char *msg, int utf8 )
914{
915        struct im_connection *ic = byahoo_get_ic_by_id( id );
916        char *m = byahoo_strip( msg );
917        struct groupchat *c = bee_chat_by_title( ic->bee, ic, room );
918       
919        if( c )
920                imcb_chat_msg( c, (char*) who, (char*) m, 0, 0 );
921        g_free( m );
922}
923
924void ext_yahoo_chat_cat_xml( int id, const char *xml )
925{
926}
927
928void ext_yahoo_chat_join( int id, const char *who, const char *room, const char *topic, YList *members, void *fd )
929{
930}
931
932void ext_yahoo_chat_userjoin( int id, const char *me, const char *room, struct yahoo_chat_member *who )
933{
934        free(who->id);
935        free(who->alias);
936        free(who->location);
937        free(who);
938}
939
940void ext_yahoo_chat_userleave( int id, const char *me, const char *room, const char *who )
941{
942}
943
944void ext_yahoo_chat_message( int id, const char *me, const char *who, const char *room, const char *msg, int msgtype, int utf8 )
945{
946}
947
948void ext_yahoo_chat_yahoologout( int id, const char *me )
949{
950}
951
952void ext_yahoo_chat_yahooerror( int id, const char *me )
953{
954}
955
956void ext_yahoo_contact_added( int id, const char *myid, const char *who, const char *msg )
957{
958        struct im_connection *ic = byahoo_get_ic_by_id( id );
959       
960        imcb_ask_auth( ic, who, msg );
961}
962
963void ext_yahoo_rejected( int id, const char *who, const char *msg )
964{
965}
966
967void ext_yahoo_game_notify( int id, const char *me, const char *who, int stat, const char *msg )
968{
969}
970
971void ext_yahoo_mail_notify( int id, const char *from, const char *subj, int cnt )
972{
973        struct im_connection *ic = byahoo_get_ic_by_id( id );
974       
975        if( !set_getbool( &ic->acc->set, "mail_notifications" ) )
976                ; /* The user doesn't care. */
977        else if( from && subj )
978                imcb_log( ic, "Received e-mail message from %s with subject `%s'", from, subj );
979        else if( cnt > 0 )
980                imcb_log( ic, "Received %d new e-mails", cnt );
981}
982
983void ext_yahoo_webcam_invite_reply( int id, const char *me, const char *from, int accept )
984{
985}
986
987void ext_yahoo_webcam_closed( int id, const char *who, int reason )
988{
989}
990
991void ext_yahoo_got_search_result( int id, int found, int start, int total, YList *contacts )
992{
993}
994
995void ext_yahoo_webcam_viewer( int id, const char *who, int connect )
996{
997}
998
999void ext_yahoo_webcam_data_request( int id, int send )
1000{
1001}
1002
1003int ext_yahoo_log( const char *fmt, ... )
1004{
1005        return( 0 );
1006}
1007
1008void ext_yahoo_got_webcam_image( int id, const char * who, const unsigned char *image, unsigned int image_size, unsigned int real_size, unsigned int timestamp )
1009{
1010}
1011
1012void ext_yahoo_got_ping( int id, const char *msg )
1013{
1014}
1015
1016void ext_yahoo_got_buddyicon (int id, const char *me, const char *who, const char *url, int checksum) {}
1017void ext_yahoo_got_buddyicon_checksum (int id, const char *me,const char *who, int checksum) {}
1018
1019void ext_yahoo_got_buddyicon_request(int id, const char *me, const char *who){}
1020void ext_yahoo_buddyicon_uploaded(int id, const char *url){}
Note: See TracBrowser for help on using the repository browser.