source: protocols/yahoo/yahoo.c @ 64768d4

Last change on this file since 64768d4 was c00dd71, checked in by Wilmer van der Gaast <wilmer@…>, at 2010-08-21T22:39:22Z

Pick up away info from Yahoo! too.
  • 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        if( mobile )
592                flags |= OPT_MOBILE;
593       
594        switch (stat)
595        {
596        case YAHOO_STATUS_BRB:
597                state_string = "Be Right Back";
598                break;
599        case YAHOO_STATUS_BUSY:
600                state_string = "Busy";
601                break;
602        case YAHOO_STATUS_NOTATHOME:
603                state_string = "Not At Home";
604                break;
605        case YAHOO_STATUS_NOTATDESK:
606                state_string = "Not At Desk";
607                break;
608        case YAHOO_STATUS_NOTINOFFICE:
609                state_string = "Not In Office";
610                break;
611        case YAHOO_STATUS_ONPHONE:
612                state_string = "On Phone";
613                break;
614        case YAHOO_STATUS_ONVACATION:
615                state_string = "On Vacation";
616                break;
617        case YAHOO_STATUS_OUTTOLUNCH:
618                state_string = "Out To Lunch";
619                break;
620        case YAHOO_STATUS_STEPPEDOUT:
621                state_string = "Stepped Out";
622                break;
623        case YAHOO_STATUS_INVISIBLE:
624                state_string = "Invisible";
625                break;
626        case YAHOO_STATUS_CUSTOM:
627                state_string = "Away";
628                break;
629        case YAHOO_STATUS_IDLE:
630                state_string = "Idle";
631                break;
632        case YAHOO_STATUS_OFFLINE:
633                state_string = "Offline";
634                flags = 0;
635                break;
636        }
637       
638        imcb_buddy_status( ic, who, flags, state_string, msg );
639       
640        if( stat == YAHOO_STATUS_IDLE )
641                imcb_buddy_times( ic, who, 0, idle );
642}
643
644void ext_yahoo_got_buzz( int id, const char *me, const char *who, long tm )
645{
646}
647
648void ext_yahoo_got_im( int id, const char *me, const char *who, const char *msg, long tm, int stat, int utf8 )
649{
650        struct im_connection *ic = byahoo_get_ic_by_id( id );
651        char *m;
652       
653        if( msg )
654        {
655                m = byahoo_strip( msg );
656                imcb_buddy_msg( ic, (char*) who, (char*) m, 0, 0 );
657                g_free( m );
658        }
659}
660
661void ext_yahoo_got_file( int id, const char *ignored, const char *who, const char *msg,
662                         const char *fname, unsigned long fesize, char *trid )
663{
664        struct im_connection *ic = byahoo_get_ic_by_id( id );
665       
666        imcb_log( ic, "Got a file transfer (file = %s) from %s. Ignoring for now due to lack of support.", fname, who );
667}
668
669void ext_yahoo_got_ft_data( int id, const unsigned char *in, int len, void *data )
670{
671}
672
673void ext_yahoo_file_transfer_done( int id, int result, void *data )
674{
675}
676
677void ext_yahoo_typing_notify( int id, const char *ignored, const char *who, int stat )
678{
679        struct im_connection *ic = byahoo_get_ic_by_id( id );
680       
681        if( stat == 1 )
682                imcb_buddy_typing( ic, (char*) who, OPT_TYPING );
683        else
684                imcb_buddy_typing( ic, (char*) who, 0 );
685}
686
687void ext_yahoo_system_message( int id, const char *me, const char *who, const char *msg )
688{
689        struct im_connection *ic = byahoo_get_ic_by_id( id );
690       
691        imcb_log( ic, "Yahoo! system message: %s", msg );
692}
693
694void ext_yahoo_webcam_invite( int id, const char *ignored, const char *from )
695{
696        struct im_connection *ic = byahoo_get_ic_by_id( id );
697       
698        imcb_log( ic, "Got a webcam invitation from %s. IRC+webcams is a no-no though...", from );
699}
700
701void ext_yahoo_error( int id, const char *err, int fatal, int num )
702{
703        struct im_connection *ic = byahoo_get_ic_by_id( id );
704       
705        imcb_error( ic, "%s", err );
706}
707
708/* TODO: Clear up the mess of inp and d structures */
709int ext_yahoo_add_handler( int id, void *fd_, yahoo_input_condition cond, void *data )
710{
711        struct byahoo_input_data *inp = g_new0( struct byahoo_input_data, 1 );
712        int fd = (long) fd_;
713       
714        if( cond == YAHOO_INPUT_READ )
715        {
716                struct byahoo_read_ready_data *d = g_new0( struct byahoo_read_ready_data, 1 );
717               
718                d->id = id;
719                d->fd = fd;
720                d->data = data;
721               
722                inp->d = d;
723                d->tag = inp->h = b_input_add( fd, B_EV_IO_READ, (b_event_handler) byahoo_read_ready_callback, (gpointer) d );
724        }
725        else if( cond == YAHOO_INPUT_WRITE )
726        {
727                struct byahoo_write_ready_data *d = g_new0( struct byahoo_write_ready_data, 1 );
728               
729                d->id = id;
730                d->fd = fd;
731                d->data = data;
732               
733                inp->d = d;
734                d->tag = inp->h = b_input_add( fd, B_EV_IO_WRITE, (b_event_handler) byahoo_write_ready_callback, (gpointer) d );
735        }
736        else
737        {
738                g_free( inp );
739                return -1;
740                /* Panic... */
741        }
742       
743        byahoo_inputs = g_slist_append( byahoo_inputs, inp );
744        return inp->h;
745}
746
747void ext_yahoo_remove_handler( int id, int tag )
748{
749        struct byahoo_input_data *inp;
750        GSList *l = byahoo_inputs;
751       
752        while( l )
753        {
754                inp = l->data;
755                if( inp->h == tag )
756                {
757                        g_free( inp->d );
758                        g_free( inp );
759                        byahoo_inputs = g_slist_remove( byahoo_inputs, inp );
760                        break;
761                }
762                l = l->next;
763        }
764       
765        b_event_remove( tag );
766}
767
768int ext_yahoo_connect_async( int id, const char *host, int port, yahoo_connect_callback callback, void *data, int use_ssl )
769{
770        struct byahoo_connect_callback_data *d;
771        int fd;
772       
773        d = g_new0( struct byahoo_connect_callback_data, 1 );
774        if( ( fd = proxy_connect( host, port, (b_event_handler) byahoo_connect_callback, (gpointer) d ) ) < 0 )
775        {
776                g_free( d );
777                return( fd );
778        }
779        d->fd = fd;
780        d->callback = callback;
781        d->data = data;
782        d->id = id;
783       
784        return fd;
785}
786
787char *ext_yahoo_get_ip_addr( const char *domain )
788{
789        return NULL;
790}
791
792int ext_yahoo_write( void *fd, char *buf, int len )
793{
794        return write( (long) fd, buf, len );
795}
796
797int ext_yahoo_read( void *fd, char *buf, int len )
798{
799        return read( (long) fd, buf, len );
800}
801
802void ext_yahoo_close( void *fd )
803{
804        close( (long) fd );
805}
806
807void ext_yahoo_got_buddy_change_group( int id, const char *me, const char *who,
808                                       const char *old_group, const char *new_group )
809{
810        struct im_connection *ic = byahoo_get_ic_by_id( id );
811       
812        imcb_add_buddy( ic, who, new_group );
813}
814
815/* Because we don't want asynchronous connects in BitlBee, and because
816   libyahoo doesn't seem to use this one anyway, this one is now defunct. */
817int ext_yahoo_connect(const char *host, int port)
818{
819        return -1;
820}
821
822static void byahoo_accept_conf( void *data )
823{
824        struct byahoo_conf_invitation *inv = data;
825        struct groupchat *b = NULL;
826        GSList *l;
827       
828        for( l = inv->ic->groupchats; l; l = l->next )
829        {
830                b = l->data;
831                if( b == inv->c )
832                        break;
833        }
834       
835        if( b != NULL )
836        {
837                yahoo_conference_logon( inv->yid, NULL, inv->members, inv->name );
838                imcb_chat_add_buddy( inv->c, inv->ic->acc->user );
839        }
840        else
841        {
842                imcb_log( inv->ic, "Duplicate/corrupted invitation to `%s'.", inv->name );
843        }
844       
845        g_free( inv->name );
846        g_free( inv );
847}
848
849static void byahoo_reject_conf( void *data )
850{
851        struct byahoo_conf_invitation *inv = data;
852       
853        yahoo_conference_decline( inv->yid, NULL, inv->members, inv->name, "User rejected groupchat" );
854        imcb_chat_free( inv->c );
855        g_free( inv->name );
856        g_free( inv );
857}
858
859void ext_yahoo_got_conf_invite( int id, const char *ignored,
860                                const char *who, const char *room, const char *msg, YList *members )
861{
862        struct im_connection *ic = byahoo_get_ic_by_id( id );
863        struct byahoo_conf_invitation *inv;
864        char txt[1024];
865        YList *m;
866       
867        if( g_strcasecmp( who, ic->acc->user ) == 0 )
868                /* WTF, Yahoo! seems to echo these now? */
869                return;
870       
871        inv = g_malloc( sizeof( struct byahoo_conf_invitation ) );
872        memset( inv, 0, sizeof( struct byahoo_conf_invitation ) );
873        inv->name = g_strdup( room );
874        inv->c = imcb_chat_new( ic, (char*) room );
875        inv->c->data = members;
876        inv->yid = id;
877        inv->members = members;
878        inv->ic = ic;
879       
880        for( m = members; m; m = m->next )
881                if( g_strcasecmp( m->data, ic->acc->user ) != 0 )
882                        imcb_chat_add_buddy( inv->c, m->data );
883       
884        g_snprintf( txt, 1024, "Got an invitation to chatroom %s from %s: %s", room, who, msg );
885       
886        imcb_ask( ic, txt, inv, byahoo_accept_conf, byahoo_reject_conf );
887}
888
889void ext_yahoo_conf_userdecline( int id, const char *ignored, const char *who, const char *room, const char *msg )
890{
891        struct im_connection *ic = byahoo_get_ic_by_id( id );
892       
893        imcb_log( ic, "Invite to chatroom %s rejected by %s: %s", room, who, msg );
894}
895
896void ext_yahoo_conf_userjoin( int id, const char *ignored, const char *who, const char *room )
897{
898        struct im_connection *ic = byahoo_get_ic_by_id( id );
899        struct groupchat *c = bee_chat_by_title( ic->bee, ic, room );
900       
901        if( c )
902                imcb_chat_add_buddy( c, (char*) who );
903}
904
905void ext_yahoo_conf_userleave( int id, const char *ignored, const char *who, const char *room )
906
907{
908        struct im_connection *ic = byahoo_get_ic_by_id( id );
909        struct groupchat *c = bee_chat_by_title( ic->bee, ic, room );
910       
911        if( c )
912                imcb_chat_remove_buddy( c, (char*) who, "" );
913}
914
915void ext_yahoo_conf_message( int id, const char *ignored, const char *who, const char *room, const char *msg, int utf8 )
916{
917        struct im_connection *ic = byahoo_get_ic_by_id( id );
918        char *m = byahoo_strip( msg );
919        struct groupchat *c = bee_chat_by_title( ic->bee, ic, room );
920       
921        if( c )
922                imcb_chat_msg( c, (char*) who, (char*) m, 0, 0 );
923        g_free( m );
924}
925
926void ext_yahoo_chat_cat_xml( int id, const char *xml )
927{
928}
929
930void ext_yahoo_chat_join( int id, const char *who, const char *room, const char *topic, YList *members, void *fd )
931{
932}
933
934void ext_yahoo_chat_userjoin( int id, const char *me, const char *room, struct yahoo_chat_member *who )
935{
936        free(who->id);
937        free(who->alias);
938        free(who->location);
939        free(who);
940}
941
942void ext_yahoo_chat_userleave( int id, const char *me, const char *room, const char *who )
943{
944}
945
946void ext_yahoo_chat_message( int id, const char *me, const char *who, const char *room, const char *msg, int msgtype, int utf8 )
947{
948}
949
950void ext_yahoo_chat_yahoologout( int id, const char *me )
951{
952}
953
954void ext_yahoo_chat_yahooerror( int id, const char *me )
955{
956}
957
958void ext_yahoo_contact_added( int id, const char *myid, const char *who, const char *msg )
959{
960        struct im_connection *ic = byahoo_get_ic_by_id( id );
961       
962        imcb_ask_auth( ic, who, msg );
963}
964
965void ext_yahoo_rejected( int id, const char *who, const char *msg )
966{
967}
968
969void ext_yahoo_game_notify( int id, const char *me, const char *who, int stat, const char *msg )
970{
971}
972
973void ext_yahoo_mail_notify( int id, const char *from, const char *subj, int cnt )
974{
975        struct im_connection *ic = byahoo_get_ic_by_id( id );
976       
977        if( !set_getbool( &ic->acc->set, "mail_notifications" ) )
978                ; /* The user doesn't care. */
979        else if( from && subj )
980                imcb_log( ic, "Received e-mail message from %s with subject `%s'", from, subj );
981        else if( cnt > 0 )
982                imcb_log( ic, "Received %d new e-mails", cnt );
983}
984
985void ext_yahoo_webcam_invite_reply( int id, const char *me, const char *from, int accept )
986{
987}
988
989void ext_yahoo_webcam_closed( int id, const char *who, int reason )
990{
991}
992
993void ext_yahoo_got_search_result( int id, int found, int start, int total, YList *contacts )
994{
995}
996
997void ext_yahoo_webcam_viewer( int id, const char *who, int connect )
998{
999}
1000
1001void ext_yahoo_webcam_data_request( int id, int send )
1002{
1003}
1004
1005int ext_yahoo_log( const char *fmt, ... )
1006{
1007        return( 0 );
1008}
1009
1010void 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 )
1011{
1012}
1013
1014void ext_yahoo_got_ping( int id, const char *msg )
1015{
1016}
1017
1018void ext_yahoo_got_buddyicon (int id, const char *me, const char *who, const char *url, int checksum) {}
1019void ext_yahoo_got_buddyicon_checksum (int id, const char *me,const char *who, int checksum) {}
1020
1021void ext_yahoo_got_buddyicon_request(int id, const char *me, const char *who){}
1022void ext_yahoo_buddyicon_uploaded(int id, const char *url){}
Note: See TracBrowser for help on using the repository browser.