source: protocols/yahoo/yahoo.c @ 54794b8

Last change on this file since 54794b8 was a36b030, checked in by Wilmer van der Gaast <wilmer@…>, at 2006-07-27T19:18:33Z

The Yahoo! module now properly sets away states instead of away messages.
(So other BitlBees can read your Yahoo! away states better and others can
see the proper icons again.)

  • Property mode set to 100644
File size: 22.5 KB
Line 
1/*
2 * libyahoo2 wrapper to BitlBee
3 *
4 * Mostly Copyright 2004 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 conversation *c;
61        int yid;
62        YList *members;
63        struct gaim_connection *gc;
64};
65
66static GSList *byahoo_inputs = NULL;
67static int byahoo_chat_id = 0;
68
69static char *byahoo_strip( char *in )
70{
71        int len;
72       
73        /* This should get rid of HTML tags 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                        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 closing HTML tags at the end of the line. */
104        len = strlen( in );
105        while( len > 0 && in[len-1] == '>' )
106        {
107                int blen = len;
108               
109                len --;
110                while( len > 0 && ( in[len] != '<' || in[len+1] != '/' ) )
111                        len --;
112               
113                if( len == 0 && ( in[len] != '<' || in[len+1] != '/' ) )
114                {
115                        len = blen;
116                        break;
117                }
118        }
119       
120        return( g_strndup( in, len ) );
121}
122
123static void byahoo_login( struct aim_user *user )
124{
125        struct gaim_connection *gc = new_gaim_conn( user );
126        struct byahoo_data *yd = gc->proto_data = g_new0( struct byahoo_data, 1 );
127       
128        yd->logged_in = FALSE;
129        yd->current_status = YAHOO_STATUS_AVAILABLE;
130       
131        set_login_progress( gc, 1, "Connecting" );
132        yd->y2_id = yahoo_init( user->username, user->password );
133        yahoo_login( yd->y2_id, yd->current_status );
134}
135
136static void byahoo_close( struct gaim_connection *gc )
137{
138        struct byahoo_data *yd = (struct byahoo_data *) gc->proto_data;
139        GSList *l;
140       
141        while( gc->conversations )
142                serv_got_chat_left( gc, gc->conversations->id );
143       
144        for( l = yd->buddygroups; l; l = l->next )
145        {
146                struct byahoo_buddygroups *bg = l->data;
147               
148                g_free( bg->buddy );
149                g_free( bg->group );
150                g_free( bg );
151        }
152        g_slist_free( yd->buddygroups );
153       
154        if( yd->logged_in )
155                yahoo_logoff( yd->y2_id );
156        else
157                yahoo_close( yd->y2_id );
158       
159        g_free( yd );
160}
161
162static void byahoo_get_info(struct gaim_connection *gc, char *who) 
163{
164        /* Just make an URL and let the user fetch the info */
165        serv_got_crap(gc, "%s\n%s: %s%s", _("User Info"), 
166                        _("For now, fetch yourself"), yahoo_get_profile_url(),
167                        who);
168}
169
170static int byahoo_send_im( struct gaim_connection *gc, char *who, char *what, int len, int flags )
171{
172        struct byahoo_data *yd = gc->proto_data;
173       
174        yahoo_send_im( yd->y2_id, NULL, who, what, 1 );
175       
176        return 1;
177}
178
179static int byahoo_send_typing( struct gaim_connection *gc, char *who, int typing )
180{
181        struct byahoo_data *yd = gc->proto_data;
182       
183        yahoo_send_typing( yd->y2_id, NULL, who, typing );
184       
185        return 1;
186}
187
188static void byahoo_set_away( struct gaim_connection *gc, char *state, char *msg )
189{
190        struct byahoo_data *yd = (struct byahoo_data *) gc->proto_data;
191       
192        gc->away = NULL;
193       
194        if( state && msg && g_strcasecmp( state, msg ) != 0 )
195        {
196                yd->current_status = YAHOO_STATUS_CUSTOM;
197                gc->away = "";
198        }
199        else if( state )
200        {
201                /* Set msg to NULL since (if it isn't NULL already) it's equal
202                   to state. msg must be empty if we want to use an existing
203                   away state. */
204                msg = NULL;
205               
206                gc->away = "";
207                if( g_strcasecmp( state, "Available" ) == 0 )
208                {
209                        yd->current_status = YAHOO_STATUS_AVAILABLE;
210                        gc->away = NULL;
211                }
212                else if( g_strcasecmp( state, "Be Right Back" ) == 0 )
213                        yd->current_status = YAHOO_STATUS_BRB;
214                else if( g_strcasecmp( state, "Busy" ) == 0 )
215                        yd->current_status = YAHOO_STATUS_BUSY;
216                else if( g_strcasecmp( state, "Not At Home" ) == 0 )
217                        yd->current_status = YAHOO_STATUS_NOTATHOME;
218                else if( g_strcasecmp( state, "Not At Desk" ) == 0 )
219                        yd->current_status = YAHOO_STATUS_NOTATDESK;
220                else if( g_strcasecmp( state, "Not In Office" ) == 0 )
221                        yd->current_status = YAHOO_STATUS_NOTINOFFICE;
222                else if( g_strcasecmp( state, "On Phone" ) == 0 )
223                        yd->current_status = YAHOO_STATUS_ONPHONE;
224                else if( g_strcasecmp( state, "On Vacation" ) == 0 )
225                        yd->current_status = YAHOO_STATUS_ONVACATION;
226                else if( g_strcasecmp( state, "Out To Lunch" ) == 0 )
227                        yd->current_status = YAHOO_STATUS_OUTTOLUNCH;
228                else if( g_strcasecmp( state, "Stepped Out" ) == 0 )
229                        yd->current_status = YAHOO_STATUS_STEPPEDOUT;
230                else if( g_strcasecmp( state, "Invisible" ) == 0 )
231                        yd->current_status = YAHOO_STATUS_INVISIBLE;
232                else if( g_strcasecmp( state, GAIM_AWAY_CUSTOM ) == 0 )
233                {
234                        yd->current_status = YAHOO_STATUS_AVAILABLE;
235                       
236                        gc->away = NULL;
237                }
238        }
239        else
240                yd->current_status = YAHOO_STATUS_AVAILABLE;
241       
242        yahoo_set_away( yd->y2_id, yd->current_status, msg, gc->away != NULL );
243}
244
245static GList *byahoo_away_states( struct gaim_connection *gc )
246{
247        GList *m = NULL;
248
249        m = g_list_append( m, "Available" );
250        m = g_list_append( m, "Be Right Back" );
251        m = g_list_append( m, "Busy" );
252        m = g_list_append( m, "Not At Home" );
253        m = g_list_append( m, "Not At Desk" );
254        m = g_list_append( m, "Not In Office" );
255        m = g_list_append( m, "On Phone" );
256        m = g_list_append( m, "On Vacation" );
257        m = g_list_append( m, "Out To Lunch" );
258        m = g_list_append( m, "Stepped Out" );
259        m = g_list_append( m, "Invisible" );
260        m = g_list_append( m, GAIM_AWAY_CUSTOM );
261       
262        return m;
263}
264
265static void byahoo_keepalive( struct gaim_connection *gc )
266{
267        struct byahoo_data *yd = gc->proto_data;
268       
269        yahoo_keepalive( yd->y2_id );
270}
271
272static void byahoo_add_buddy( struct gaim_connection *gc, char *who )
273{
274        struct byahoo_data *yd = (struct byahoo_data *) gc->proto_data;
275       
276        yahoo_add_buddy( yd->y2_id, who, BYAHOO_DEFAULT_GROUP );
277}
278
279static void byahoo_remove_buddy( struct gaim_connection *gc, char *who, char *group )
280{
281        struct byahoo_data *yd = (struct byahoo_data *) gc->proto_data;
282        GSList *bgl;
283       
284        yahoo_remove_buddy( yd->y2_id, who, BYAHOO_DEFAULT_GROUP );
285       
286        for( bgl = yd->buddygroups; bgl; bgl = bgl->next )
287        {
288                struct byahoo_buddygroups *bg = bgl->data;
289               
290                if( g_strcasecmp( bg->buddy, who ) == 0 )
291                        yahoo_remove_buddy( yd->y2_id, who, bg->group );
292        }
293}
294
295static char *byahoo_get_status_string( struct gaim_connection *gc, int stat )
296{
297        enum yahoo_status a = stat >> 1;
298       
299        switch (a)
300        {
301        case YAHOO_STATUS_BRB:
302                return "Be Right Back";
303        case YAHOO_STATUS_BUSY:
304                return "Busy";
305        case YAHOO_STATUS_NOTATHOME:
306                return "Not At Home";
307        case YAHOO_STATUS_NOTATDESK:
308                return "Not At Desk";
309        case YAHOO_STATUS_NOTINOFFICE:
310                return "Not In Office";
311        case YAHOO_STATUS_ONPHONE:
312                return "On Phone";
313        case YAHOO_STATUS_ONVACATION:
314                return "On Vacation";
315        case YAHOO_STATUS_OUTTOLUNCH:
316                return "Out To Lunch";
317        case YAHOO_STATUS_STEPPEDOUT:
318                return "Stepped Out";
319        case YAHOO_STATUS_INVISIBLE:
320                return "Invisible";
321        case YAHOO_STATUS_CUSTOM:
322                return "Away";
323        case YAHOO_STATUS_IDLE:
324                return "Idle";
325        case YAHOO_STATUS_OFFLINE:
326                return "Offline";
327        case YAHOO_STATUS_NOTIFY:
328                return "Notify";
329        default:
330                return "Away";
331        }
332}
333
334static int byahoo_chat_send( struct gaim_connection *gc, int id, char *message )
335{
336        struct byahoo_data *yd = (struct byahoo_data *) gc->proto_data;
337        struct conversation *c;
338       
339        for( c = gc->conversations; c && c->id != id; c = c->next );
340
341        yahoo_conference_message( yd->y2_id, NULL, c->data, c->title, message, 1 );
342       
343        return( 0 );
344}
345
346static void byahoo_chat_invite( struct gaim_connection *gc, int id, char *msg, char *who )
347{
348        struct byahoo_data *yd = (struct byahoo_data *) gc->proto_data;
349        struct conversation *c;
350       
351        for( c = gc->conversations; c && c->id != id; c = c->next );
352       
353        yahoo_conference_invite( yd->y2_id, NULL, c->data, c->title, msg );
354}
355
356static void byahoo_chat_leave( struct gaim_connection *gc, int id )
357{
358        struct byahoo_data *yd = (struct byahoo_data *) gc->proto_data;
359        struct conversation *c;
360       
361        for( c = gc->conversations; c && c->id != id; c = c->next );
362       
363        yahoo_conference_logoff( yd->y2_id, NULL, c->data, c->title );
364        serv_got_chat_left( gc, c->id );
365}
366
367static int byahoo_chat_open( struct gaim_connection *gc, char *who )
368{
369        struct byahoo_data *yd = (struct byahoo_data *) gc->proto_data;
370        struct conversation *c;
371        char *roomname;
372        YList *members;
373       
374        roomname = g_new0( char, strlen( gc->username ) + 16 );
375        g_snprintf( roomname, strlen( gc->username ) + 16, "%s-Bee-%d", gc->username, byahoo_chat_id );
376       
377        c = serv_got_joined_chat( gc, ++byahoo_chat_id, roomname );
378        add_chat_buddy( c, gc->username );
379       
380        /* FIXME: Free this thing when the chat's destroyed. We can't *always*
381                  do this because it's not always created here. */
382        c->data = members = g_new0( YList, 1 );
383        members->data = g_strdup( who );
384       
385        yahoo_conference_invite( yd->y2_id, NULL, members, roomname, "Please join my groupchat..." );
386       
387        g_free( roomname );
388       
389        return( 1 );
390}
391
392void byahoo_init( )
393{
394        struct prpl *ret = g_new0(struct prpl, 1);
395        ret->name = "yahoo";
396       
397        ret->login = byahoo_login;
398        ret->close = byahoo_close;
399        ret->send_im = byahoo_send_im;
400        ret->get_info = byahoo_get_info;
401        ret->away_states = byahoo_away_states;
402        ret->set_away = byahoo_set_away;
403        ret->keepalive = byahoo_keepalive;
404        ret->add_buddy = byahoo_add_buddy;
405        ret->remove_buddy = byahoo_remove_buddy;
406        ret->get_status_string = byahoo_get_status_string;
407        ret->send_typing = byahoo_send_typing;
408       
409        ret->chat_send = byahoo_chat_send;
410        ret->chat_invite = byahoo_chat_invite;
411        ret->chat_leave = byahoo_chat_leave;
412        ret->chat_open = byahoo_chat_open;
413        ret->cmp_buddynames = g_strcasecmp;
414       
415        register_protocol(ret);
416}
417
418static struct gaim_connection *byahoo_get_gc_by_id( int id )
419{
420        GSList *l;
421        struct gaim_connection *gc;
422        struct byahoo_data *yd;
423       
424        for( l = get_connections(); l; l = l->next )
425        {
426                gc = l->data;
427                yd = gc->proto_data;
428               
429                if( !strcmp(gc->prpl->name, "yahoo") && yd->y2_id == id )
430                        return( gc );
431        }
432       
433        return( NULL );
434}
435
436
437/* Now it's callback time! */
438
439struct byahoo_connect_callback_data
440{
441        int fd;
442        yahoo_connect_callback callback;
443        gpointer data;
444        int id;
445};
446
447void byahoo_connect_callback( gpointer data, gint source, b_input_condition cond )
448{
449        struct byahoo_connect_callback_data *d = data;
450       
451        if( !byahoo_get_gc_by_id( d->id ) )
452        {
453                g_free( d );
454                return;
455        }
456       
457        d->callback( d->fd, 0, d->data );
458        g_free( d );
459}
460
461struct byahoo_read_ready_data
462{
463        int id;
464        int fd;
465        int tag;
466        gpointer data;
467};
468
469gboolean byahoo_read_ready_callback( gpointer data, gint source, b_input_condition cond )
470{
471        struct byahoo_read_ready_data *d = data;
472       
473        if( !byahoo_get_gc_by_id( d->id ) )
474                /* WTF doesn't libyahoo clean this up? */
475                return FALSE;
476       
477        yahoo_read_ready( d->id, d->fd, d->data );
478       
479        return TRUE;
480}
481
482struct byahoo_write_ready_data
483{
484        int id;
485        int fd;
486        int tag;
487        gpointer data;
488};
489
490gboolean byahoo_write_ready_callback( gpointer data, gint source, b_input_condition cond )
491{
492        struct byahoo_write_ready_data *d = data;
493       
494        if( !byahoo_get_gc_by_id( d->id ) )
495                /* WTF doesn't libyahoo clean this up? */
496                return FALSE;
497       
498        yahoo_write_ready( d->id, d->fd, d->data );
499       
500        return FALSE;
501}
502
503void ext_yahoo_login_response( int id, int succ, char *url )
504{
505        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
506        struct byahoo_data *yd = NULL;
507       
508        if( gc == NULL )
509        {
510                /* libyahoo2 seems to call this one twice when something
511                   went wrong sometimes. Don't know why. Because we clean
512                   up the connection on the first failure, the second
513                   should be ignored. */
514               
515                return;
516        }
517       
518        yd = (struct byahoo_data *) gc->proto_data;
519       
520        if( succ == YAHOO_LOGIN_OK )
521        {
522                account_online( gc );
523               
524                yd->logged_in = TRUE;
525        }
526        else
527        {
528                char *errstr;
529                char *s;
530               
531                yd->logged_in = FALSE;
532               
533                if( succ == YAHOO_LOGIN_UNAME )
534                        errstr = "Incorrect Yahoo! username";
535                else if( succ == YAHOO_LOGIN_PASSWD )
536                        errstr = "Incorrect Yahoo! password";
537                else if( succ == YAHOO_LOGIN_LOCK )
538                        errstr = "Yahoo! account locked";
539                else if( succ == YAHOO_LOGIN_DUPL )
540                {
541                        errstr = "Logged in on a different machine or device";
542                        gc->wants_to_die = TRUE;
543                }
544                else if( succ == YAHOO_LOGIN_SOCK )
545                        errstr = "Socket problem";
546                else
547                        errstr = "Unknown error";
548               
549                if( url && *url )
550                {
551                        s = g_malloc( strlen( "Error %d (%s). See %s for more information." ) + strlen( url ) + strlen( errstr ) + 16 );
552                        sprintf( s, "Error %d (%s). See %s for more information.", succ, errstr, url );
553                }
554                else
555                {
556                        s = g_malloc( strlen( "Error %d (%s)" ) + strlen( errstr ) + 16 );
557                        sprintf( s, "Error %d (%s)", succ, errstr );
558                }
559               
560                if( yd->logged_in )
561                        hide_login_progress_error( gc, s );
562                else
563                        hide_login_progress( gc, s );
564               
565                g_free( s );
566               
567                signoff( gc );
568        }
569}
570
571void ext_yahoo_got_buddies( int id, YList *buds )
572{
573        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
574        struct byahoo_data *yd = gc->proto_data;
575        YList *bl = buds;
576       
577        while( bl )
578        {
579                struct yahoo_buddy *b = bl->data;
580                struct byahoo_buddygroups *bg;
581               
582                if( strcmp( b->group, BYAHOO_DEFAULT_GROUP ) != 0 )
583                {
584                        bg = g_new0( struct byahoo_buddygroups, 1 );
585                       
586                        bg->buddy = g_strdup( b->id );
587                        bg->group = g_strdup( b->group );
588                        yd->buddygroups = g_slist_append( yd->buddygroups, bg );
589                }
590               
591                add_buddy( gc, b->group, b->id, b->real_name );
592                bl = bl->next;
593        }
594}
595
596void ext_yahoo_got_ignore( int id, YList *igns )
597{
598}
599
600void ext_yahoo_got_identities( int id, YList *ids )
601{
602}
603
604void ext_yahoo_got_cookies( int id )
605{
606}
607
608void ext_yahoo_status_changed( int id, char *who, int stat, char *msg, int away )
609{
610        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
611       
612        serv_got_update( gc, who, stat != YAHOO_STATUS_OFFLINE, 0, 0,
613                         ( stat == YAHOO_STATUS_IDLE ) ? away : 0,
614                         ( stat != YAHOO_STATUS_AVAILABLE ) | ( stat << 1 ), 0 );
615}
616
617void ext_yahoo_got_im( int id, char *who, char *msg, long tm, int stat, int utf8 )
618{
619        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
620        char *m = byahoo_strip( msg );
621       
622        serv_got_im( gc, who, m, 0, 0, strlen( m ) );
623        g_free( m );
624}
625
626void ext_yahoo_got_file( int id, char *who, char *url, long expires, char *msg, char *fname, unsigned long fesize )
627{
628        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
629       
630        serv_got_crap( gc, "Got a file transfer (file = %s) from %s. Ignoring for now due to lack of support.", fname, who );
631}
632
633void ext_yahoo_typing_notify( int id, char *who, int stat )
634{
635        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
636        if (stat == 1) {
637                /* User is typing */
638                serv_got_typing( gc, who, 1, 1 );
639        }
640        else {
641                /* User stopped typing */
642                serv_got_typing( gc, who, 1, 0 );
643        }
644}
645
646void ext_yahoo_system_message( int id, char *msg )
647{
648        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
649       
650        serv_got_crap( gc, "Yahoo! system message: %s", msg );
651}
652
653void ext_yahoo_webcam_invite( int id, char *from )
654{
655        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
656       
657        serv_got_crap( gc, "Got a webcam invitation from %s. IRC+webcams is a no-no though...", from );
658}
659
660void ext_yahoo_error( int id, char *err, int fatal )
661{
662        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
663       
664        if( fatal )
665        {
666                hide_login_progress_error( gc, err );
667                signoff( gc );
668        }
669        else
670        {
671                do_error_dialog( gc, err, "Yahoo! error" );
672        }
673}
674
675/* TODO: Clear up the mess of inp and d structures */
676int ext_yahoo_add_handler( int id, int fd, yahoo_input_condition cond, void *data )
677{
678        struct byahoo_input_data *inp = g_new0( struct byahoo_input_data, 1 );
679       
680        if( cond == YAHOO_INPUT_READ )
681        {
682                struct byahoo_read_ready_data *d = g_new0( struct byahoo_read_ready_data, 1 );
683               
684                d->id = id;
685                d->fd = fd;
686                d->data = data;
687               
688                inp->d = d;
689                d->tag = inp->h = b_input_add( fd, GAIM_INPUT_READ, (b_event_handler) byahoo_read_ready_callback, (gpointer) d );
690        }
691        else if( cond == YAHOO_INPUT_WRITE )
692        {
693                struct byahoo_write_ready_data *d = g_new0( struct byahoo_write_ready_data, 1 );
694               
695                d->id = id;
696                d->fd = fd;
697                d->data = data;
698               
699                inp->d = d;
700                d->tag = inp->h = b_input_add( fd, GAIM_INPUT_WRITE, (b_event_handler) byahoo_write_ready_callback, (gpointer) d );
701        }
702        else
703        {
704                g_free( inp );
705                return( -1 );
706                /* Panic... */
707        }
708       
709        byahoo_inputs = g_slist_append( byahoo_inputs, inp );
710        return( inp->h );
711}
712
713void ext_yahoo_remove_handler( int id, int tag )
714{
715        struct byahoo_input_data *inp;
716        GSList *l = byahoo_inputs;
717       
718        while( l )
719        {
720                inp = l->data;
721                if( inp->h == tag )
722                {
723                        g_free( inp->d );
724                        g_free( inp );
725                        byahoo_inputs = g_slist_remove( byahoo_inputs, inp );
726                        break;
727                }
728                l = l->next;
729        }
730       
731        b_event_remove( tag );
732}
733
734int ext_yahoo_connect_async( int id, char *host, int port, yahoo_connect_callback callback, void *data )
735{
736        struct byahoo_connect_callback_data *d;
737        int fd;
738       
739        d = g_new0( struct byahoo_connect_callback_data, 1 );
740        if( ( fd = proxy_connect( host, port, (b_event_handler) byahoo_connect_callback, (gpointer) d ) ) < 0 )
741        {
742                g_free( d );
743                return( fd );
744        }
745        d->fd = fd;
746        d->callback = callback;
747        d->data = data;
748        d->id = id;
749       
750        return( fd );
751}
752
753/* Because we don't want asynchronous connects in BitlBee, and because
754   libyahoo doesn't seem to use this one anyway, this one is now defunct. */
755int ext_yahoo_connect(char *host, int port)
756{
757#if 0
758        struct sockaddr_in serv_addr;
759        static struct hostent *server;
760        static char last_host[256];
761        int servfd;
762        char **p;
763
764        if(last_host[0] || g_strcasecmp(last_host, host)!=0) {
765                if(!(server = gethostbyname(host))) {
766                        return -1;
767                }
768                strncpy(last_host, host, 255);
769        }
770
771        if((servfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
772                return -1;
773        }
774
775        for (p = server->h_addr_list; *p; p++)
776        {
777                memset(&serv_addr, 0, sizeof(serv_addr));
778                serv_addr.sin_family = AF_INET;
779                memcpy(&serv_addr.sin_addr.s_addr, *p, server->h_length);
780                serv_addr.sin_port = htons(port);
781
782                if(connect(servfd, (struct sockaddr *) &serv_addr,
783                                        sizeof(serv_addr)) == -1) {
784                        return -1;
785                } else {
786                        return servfd;
787                }
788        }
789
790        closesocket(servfd);
791#endif
792        return -1;
793}
794
795static void byahoo_accept_conf( gpointer w, struct byahoo_conf_invitation *inv )
796{
797        yahoo_conference_logon( inv->yid, NULL, inv->members, inv->name );
798        add_chat_buddy( inv->c, inv->gc->username );
799        g_free( inv->name );
800        g_free( inv );
801}
802
803static void byahoo_reject_conf( gpointer w, struct byahoo_conf_invitation *inv )
804{
805        yahoo_conference_decline( inv->yid, NULL, inv->members, inv->name, "User rejected groupchat" );
806        serv_got_chat_left( inv->gc, inv->c->id );
807        g_free( inv->name );
808        g_free( inv );
809}
810
811void ext_yahoo_got_conf_invite( int id, char *who, char *room, char *msg, YList *members )
812{
813        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
814        struct byahoo_conf_invitation *inv;
815        char txt[1024];
816        YList *m;
817       
818        inv = g_malloc( sizeof( struct byahoo_conf_invitation ) );
819        memset( inv, 0, sizeof( struct byahoo_conf_invitation ) );
820        inv->name = g_strdup( room );
821        inv->c = serv_got_joined_chat( gc, ++byahoo_chat_id, room );
822        inv->c->data = members;
823        inv->yid = id;
824        inv->members = members;
825        inv->gc = gc;
826       
827        for( m = members; m; m = m->next )
828                if( g_strcasecmp( m->data, gc->username ) != 0 )
829                        add_chat_buddy( inv->c, m->data );
830       
831        g_snprintf( txt, 1024, "Got an invitation to chatroom %s from %s: %s", room, who, msg );
832       
833        do_ask_dialog( gc, txt, inv, byahoo_accept_conf, byahoo_reject_conf );
834}
835
836void ext_yahoo_conf_userdecline( int id, char *who, char *room, char *msg )
837{
838        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
839       
840        serv_got_crap( gc, "Invite to chatroom %s rejected by %s: %s", room, who, msg );
841}
842
843void ext_yahoo_conf_userjoin( int id, char *who, char *room )
844{
845        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
846        struct conversation *c;
847       
848        for( c = gc->conversations; c && strcmp( c->title, room ) != 0; c = c->next );
849       
850        if( c )
851                add_chat_buddy( c, who );
852}
853
854void ext_yahoo_conf_userleave( int id, char *who, char *room )
855{
856        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
857        struct conversation *c;
858       
859        for( c = gc->conversations; c && strcmp( c->title, room ) != 0; c = c->next );
860       
861        if( c )
862                remove_chat_buddy( c, who, "" );
863}
864
865void ext_yahoo_conf_message( int id, char *who, char *room, char *msg, int utf8 )
866{
867        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
868        char *m = byahoo_strip( msg );
869        struct conversation *c;
870       
871        for( c = gc->conversations; c && strcmp( c->title, room ) != 0; c = c->next );
872       
873        serv_got_chat_in( gc, c ? c->id : 0, who, 0, m, 0 );
874        g_free( m );
875}
876
877void ext_yahoo_chat_cat_xml( int id, char *xml )
878{
879}
880
881void ext_yahoo_chat_join( int id, char *room, char *topic, YList *members, int fd )
882{
883}
884
885void ext_yahoo_chat_userjoin( int id, char *room, struct yahoo_chat_member *who )
886{
887}
888
889void ext_yahoo_chat_userleave( int id, char *room, char *who )
890{
891}
892
893void ext_yahoo_chat_message( int id, char *who, char *room, char *msg, int msgtype, int utf8 )
894{
895}
896
897void ext_yahoo_chat_yahoologout( int id )
898{
899}
900
901void ext_yahoo_chat_yahooerror( int id )
902{
903}
904
905void ext_yahoo_contact_added( int id, char *myid, char *who, char *msg )
906{
907}
908
909void ext_yahoo_rejected( int id, char *who, char *msg )
910{
911}
912
913void ext_yahoo_game_notify( int id, char *who, int stat )
914{
915}
916
917void ext_yahoo_mail_notify( int id, char *from, char *subj, int cnt )
918{
919        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
920       
921        if( from && subj )
922                serv_got_crap( gc, "Received e-mail message from %s with subject `%s'", from, subj );
923        else if( cnt > 0 )
924                serv_got_crap( gc, "Received %d new e-mails", cnt );
925}
926
927void ext_yahoo_webcam_invite_reply( int id, char *from, int accept )
928{
929}
930
931void ext_yahoo_webcam_closed( int id, char *who, int reason )
932{
933}
934
935void ext_yahoo_got_search_result( int id, int found, int start, int total, YList *contacts )
936{
937}
938
939void ext_yahoo_webcam_viewer( int id, char *who, int connect )
940{
941}
942
943void ext_yahoo_webcam_data_request( int id, int send )
944{
945}
946
947int ext_yahoo_log( char *fmt, ... )
948{
949        return( 0 );
950}
951
952void 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 )
953{
954}
Note: See TracBrowser for help on using the repository browser.