source: protocols/yahoo/yahoo.c @ 5759edf

Last change on this file since 5759edf was b7d3cc34, checked in by Wilmer van der Gaast <wilmer@…>, at 2005-11-06T18:23:18Z

Initial repository (0.99 release tree)

  • Property mode set to 100644
File size: 22.6 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 char *yahoo_name()
67{
68        return "Yahoo";
69}
70
71static struct prpl *my_protocol = NULL;
72static GSList *byahoo_inputs = NULL;
73static int byahoo_chat_id = 0;
74
75static char *byahoo_strip( char *in )
76{
77        int len;
78       
79        /* This should get rid of HTML tags at the beginning of the string. */
80        while( *in )
81        {
82                if( g_strncasecmp( in, "<font", 5 ) == 0 ||
83                    g_strncasecmp( in, "<fade", 5 ) == 0 ||
84                    g_strncasecmp( in, "<alt", 4 ) == 0 )
85                {
86                        char *s = strchr( in, '>' );
87                        if( !s )
88                                break;
89                       
90                        in = s + 1;
91                }
92                else if( strncmp( in, "\e[", 2 ) == 0 )
93                {
94                        char *s;
95                       
96                        for( s = in + 2; *s && *s != 'm'; s ++ );
97                       
98                        if( *s != 'm' )
99                                break;
100                       
101                        in = s + 1;
102                }
103                else
104                {
105                        break;
106                }
107        }
108       
109        /* This is supposed to get rid of the closing HTML tags at the end of the line. */
110        len = strlen( in );
111        while( len > 0 && in[len-1] == '>' )
112        {
113                int blen = len;
114               
115                len --;
116                while( len > 0 && ( in[len] != '<' || in[len+1] != '/' ) )
117                        len --;
118               
119                if( len == 0 && ( in[len] != '<' || in[len+1] != '/' ) )
120                {
121                        len = blen;
122                        break;
123                }
124        }
125       
126        return( g_strndup( in, len ) );
127}
128
129static void byahoo_login( struct aim_user *user )
130{
131        struct gaim_connection *gc = new_gaim_conn( user );
132        struct byahoo_data *yd = gc->proto_data = g_new0( struct byahoo_data, 1 );
133       
134        yd->logged_in = FALSE;
135        yd->current_status = YAHOO_STATUS_AVAILABLE;
136       
137        set_login_progress( gc, 1, "Connecting" );
138        yd->y2_id = yahoo_init( user->username, user->password );
139        yahoo_login( yd->y2_id, yd->current_status );
140}
141
142static void byahoo_close( struct gaim_connection *gc )
143{
144        struct byahoo_data *yd = (struct byahoo_data *) gc->proto_data;
145        GSList *l;
146       
147        while( gc->conversations )
148                serv_got_chat_left( gc, gc->conversations->id );
149       
150        for( l = yd->buddygroups; l; l = l->next )
151        {
152                struct byahoo_buddygroups *bg = l->data;
153               
154                g_free( bg->buddy );
155                g_free( bg->group );
156                g_free( bg );
157        }
158        g_slist_free( yd->buddygroups );
159       
160        if( yd->logged_in )
161                yahoo_logoff( yd->y2_id );
162        else
163                yahoo_close( yd->y2_id );
164       
165        g_free( yd );
166}
167
168static void byahoo_get_info(struct gaim_connection *gc, char *who) 
169{
170        /* Just make an URL and let the user fetch the info */
171        serv_got_crap(gc, "%s\n%s: %s%s", _("User Info"), 
172                        _("For now, fetch yourself"), yahoo_get_profile_url(),
173                        who);
174}
175
176static int byahoo_send_im( struct gaim_connection *gc, char *who, char *what, int len, int flags )
177{
178        struct byahoo_data *yd = gc->proto_data;
179       
180        yahoo_send_im( yd->y2_id, NULL, who, what, 1 );
181       
182        return 1;
183}
184
185static int byahoo_send_typing( struct gaim_connection *gc, char *who, int typing )
186{
187        struct byahoo_data *yd = gc->proto_data;
188       
189        yahoo_send_typing( yd->y2_id, NULL, who, typing );
190       
191        return 1;
192}
193
194static void byahoo_set_away( struct gaim_connection *gc, char *state, char *msg )
195{
196        struct byahoo_data *yd = (struct byahoo_data *) gc->proto_data;
197
198        gc->away = NULL;
199
200        if (msg)
201        {
202                yd->current_status = YAHOO_STATUS_CUSTOM;
203                gc->away = "";
204        }
205        else if (state)
206        {
207                gc->away = "";
208                if( g_strcasecmp(state, "Available" ) == 0 )
209                {
210                        yd->current_status = YAHOO_STATUS_AVAILABLE;
211                        gc->away = NULL;
212                }
213                else if( g_strcasecmp( state, "Be Right Back" ) == 0 )
214                        yd->current_status = YAHOO_STATUS_BRB;
215                else if( g_strcasecmp( state, "Busy" ) == 0 )
216                        yd->current_status = YAHOO_STATUS_BUSY;
217                else if( g_strcasecmp( state, "Not At Home" ) == 0 )
218                        yd->current_status = YAHOO_STATUS_NOTATHOME;
219                else if( g_strcasecmp( state, "Not At Desk" ) == 0 )
220                        yd->current_status = YAHOO_STATUS_NOTATDESK;
221                else if( g_strcasecmp( state, "Not In Office" ) == 0 )
222                        yd->current_status = YAHOO_STATUS_NOTINOFFICE;
223                else if( g_strcasecmp( state, "On Phone" ) == 0 )
224                        yd->current_status = YAHOO_STATUS_ONPHONE;
225                else if( g_strcasecmp( state, "On Vacation" ) == 0 )
226                        yd->current_status = YAHOO_STATUS_ONVACATION;
227                else if( g_strcasecmp( state, "Out To Lunch" ) == 0 )
228                        yd->current_status = YAHOO_STATUS_OUTTOLUNCH;
229                else if( g_strcasecmp( state, "Stepped Out" ) == 0 )
230                        yd->current_status = YAHOO_STATUS_STEPPEDOUT;
231                else if( g_strcasecmp( state, "Invisible" ) == 0 )
232                        yd->current_status = YAHOO_STATUS_INVISIBLE;
233                else if( g_strcasecmp( state, GAIM_AWAY_CUSTOM ) == 0 )
234                {
235                        if (gc->is_idle)
236                                yd->current_status = YAHOO_STATUS_IDLE;
237                        else
238                                yd->current_status = YAHOO_STATUS_AVAILABLE;
239                       
240                        gc->away = NULL;
241                }
242        }
243        else if ( gc->is_idle )
244                yd->current_status = YAHOO_STATUS_IDLE;
245        else
246                yd->current_status = YAHOO_STATUS_AVAILABLE;
247       
248        yahoo_set_away( yd->y2_id, yd->current_status, msg, gc->away != NULL );
249}
250
251static GList *byahoo_away_states( struct gaim_connection *gc )
252{
253        GList *m = NULL;
254
255        m = g_list_append( m, "Available" );
256        m = g_list_append( m, "Be Right Back" );
257        m = g_list_append( m, "Busy" );
258        m = g_list_append( m, "Not At Home" );
259        m = g_list_append( m, "Not At Desk" );
260        m = g_list_append( m, "Not In Office" );
261        m = g_list_append( m, "On Phone" );
262        m = g_list_append( m, "On Vacation" );
263        m = g_list_append( m, "Out To Lunch" );
264        m = g_list_append( m, "Stepped Out" );
265        m = g_list_append( m, "Invisible" );
266        m = g_list_append( m, GAIM_AWAY_CUSTOM );
267       
268        return m;
269}
270
271static void byahoo_keepalive( struct gaim_connection *gc )
272{
273        struct byahoo_data *yd = gc->proto_data;
274       
275        yahoo_keepalive( yd->y2_id );
276}
277
278static void byahoo_add_buddy( struct gaim_connection *gc, char *who )
279{
280        struct byahoo_data *yd = (struct byahoo_data *) gc->proto_data;
281       
282        yahoo_add_buddy( yd->y2_id, who, BYAHOO_DEFAULT_GROUP );
283}
284
285static void byahoo_remove_buddy( struct gaim_connection *gc, char *who, char *group )
286{
287        struct byahoo_data *yd = (struct byahoo_data *) gc->proto_data;
288        GSList *bgl;
289       
290        yahoo_remove_buddy( yd->y2_id, who, BYAHOO_DEFAULT_GROUP );
291       
292        for( bgl = yd->buddygroups; bgl; bgl = bgl->next )
293        {
294                struct byahoo_buddygroups *bg = bgl->data;
295               
296                if( g_strcasecmp( bg->buddy, who ) == 0 )
297                        yahoo_remove_buddy( yd->y2_id, who, bg->group );
298        }
299}
300
301static char *byahoo_get_status_string( struct gaim_connection *gc, int stat )
302{
303        enum yahoo_status a = stat >> 1;
304       
305        switch (a)
306        {
307        case YAHOO_STATUS_BRB:
308                return "Be Right Back";
309        case YAHOO_STATUS_BUSY:
310                return "Busy";
311        case YAHOO_STATUS_NOTATHOME:
312                return "Not At Home";
313        case YAHOO_STATUS_NOTATDESK:
314                return "Not At Desk";
315        case YAHOO_STATUS_NOTINOFFICE:
316                return "Not In Office";
317        case YAHOO_STATUS_ONPHONE:
318                return "On Phone";
319        case YAHOO_STATUS_ONVACATION:
320                return "On Vacation";
321        case YAHOO_STATUS_OUTTOLUNCH:
322                return "Out To Lunch";
323        case YAHOO_STATUS_STEPPEDOUT:
324                return "Stepped Out";
325        case YAHOO_STATUS_INVISIBLE:
326                return "Invisible";
327        case YAHOO_STATUS_CUSTOM:
328                return "Away";
329        case YAHOO_STATUS_IDLE:
330                return "Idle";
331        case YAHOO_STATUS_OFFLINE:
332                return "Offline";
333        case YAHOO_STATUS_NOTIFY:
334                return "Notify";
335        default:
336                return "Away";
337        }
338}
339
340static int byahoo_chat_send( struct gaim_connection *gc, int id, char *message )
341{
342        struct byahoo_data *yd = (struct byahoo_data *) gc->proto_data;
343        struct conversation *c;
344       
345        for( c = gc->conversations; c && c->id != id; c = c->next );
346
347        yahoo_conference_message( yd->y2_id, NULL, c->data, c->title, message, 1 );
348       
349        return( 0 );
350}
351
352static void byahoo_chat_invite( struct gaim_connection *gc, int id, char *msg, char *who )
353{
354        struct byahoo_data *yd = (struct byahoo_data *) gc->proto_data;
355        struct conversation *c;
356       
357        for( c = gc->conversations; c && c->id != id; c = c->next );
358       
359        yahoo_conference_invite( yd->y2_id, NULL, c->data, c->title, msg );
360}
361
362static void byahoo_chat_leave( struct gaim_connection *gc, int id )
363{
364        struct byahoo_data *yd = (struct byahoo_data *) gc->proto_data;
365        struct conversation *c;
366       
367        for( c = gc->conversations; c && c->id != id; c = c->next );
368       
369        yahoo_conference_logoff( yd->y2_id, NULL, c->data, c->title );
370        serv_got_chat_left( gc, c->id );
371}
372
373static int byahoo_chat_open( struct gaim_connection *gc, char *who )
374{
375        struct byahoo_data *yd = (struct byahoo_data *) gc->proto_data;
376        struct conversation *c;
377        char *roomname;
378        YList *members;
379       
380        roomname = g_new0( char, strlen( gc->username ) + 16 );
381        g_snprintf( roomname, strlen( gc->username ) + 16, "%s-Bee-%d", gc->username, byahoo_chat_id );
382       
383        c = serv_got_joined_chat( gc, ++byahoo_chat_id, roomname );
384        add_chat_buddy( c, gc->username );
385       
386        /* FIXME: Free this thing when the chat's destroyed. We can't *always*
387                  do this because it's not always created here. */
388        c->data = members = g_new0( YList, 1 );
389        members->data = g_strdup( who );
390       
391        yahoo_conference_invite( yd->y2_id, NULL, members, roomname, "Please join my groupchat..." );
392       
393        g_free( roomname );
394       
395        return( 1 );
396}
397
398void byahoo_init( struct prpl *ret )
399{
400        ret->protocol = PROTO_YAHOO;
401        ret->name = yahoo_name;
402       
403        ret->login = byahoo_login;
404        ret->close = byahoo_close;
405        ret->send_im = byahoo_send_im;
406        ret->send_typing = byahoo_send_typing;
407        ret->get_info = byahoo_get_info;
408        ret->away_states = byahoo_away_states;
409        ret->set_away = byahoo_set_away;
410        ret->keepalive = byahoo_keepalive;
411        ret->add_buddy = byahoo_add_buddy;
412        ret->remove_buddy = byahoo_remove_buddy;
413        ret->get_status_string = byahoo_get_status_string;
414       
415        ret->chat_send = byahoo_chat_send;
416        ret->chat_invite = byahoo_chat_invite;
417        ret->chat_leave = byahoo_chat_leave;
418        ret->chat_open = byahoo_chat_open;
419       
420        my_protocol = ret;
421}
422
423static struct gaim_connection *byahoo_get_gc_by_id( int id )
424{
425        GSList *l;
426        struct gaim_connection *gc;
427        struct byahoo_data *yd;
428       
429        for( l = get_connections(); l; l = l->next )
430        {
431                gc = l->data;
432                yd = gc->proto_data;
433               
434                if( gc->protocol == PROTO_YAHOO && yd->y2_id == id )
435                        return( gc );
436        }
437       
438        return( NULL );
439}
440
441
442/* Now it's callback time! */
443
444struct byahoo_connect_callback_data
445{
446        int fd;
447        yahoo_connect_callback callback;
448        gpointer data;
449        int id;
450};
451
452void byahoo_connect_callback( gpointer data, gint source, GaimInputCondition cond )
453{
454        struct byahoo_connect_callback_data *d = data;
455       
456        if( !byahoo_get_gc_by_id( d->id ) )
457        {
458                g_free( d );
459                return;
460        }
461       
462        d->callback( d->fd, 0, d->data );
463        g_free( d );
464}
465
466struct byahoo_read_ready_data
467{
468        int id;
469        int fd;
470        int tag;
471        gpointer data;
472};
473
474void byahoo_read_ready_callback( gpointer data, gint source, GaimInputCondition cond )
475{
476        struct byahoo_read_ready_data *d = data;
477       
478        if( !byahoo_get_gc_by_id( d->id ) )
479        {
480                /* WTF doesn't libyahoo clean this up? */
481                ext_yahoo_remove_handler( d->id, d->tag );
482                return;
483        }
484       
485        yahoo_read_ready( d->id, d->fd, d->data );
486}
487
488struct byahoo_write_ready_data
489{
490        int id;
491        int fd;
492        int tag;
493        gpointer data;
494};
495
496void byahoo_write_ready_callback( gpointer data, gint source, GaimInputCondition cond )
497{
498        struct byahoo_write_ready_data *d = data;
499       
500        if( !byahoo_get_gc_by_id( d->id ) )
501        {
502                /* WTF doesn't libyahoo clean this up? */
503                ext_yahoo_remove_handler( d->id, d->tag );
504                return;
505        }
506       
507        yahoo_write_ready( d->id, d->fd, d->data );
508}
509
510void ext_yahoo_login_response( int id, int succ, char *url )
511{
512        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
513        struct byahoo_data *yd = NULL;
514       
515        if( gc == NULL )
516        {
517                /* libyahoo2 seems to call this one twice when something
518                   went wrong sometimes. Don't know why. Because we clean
519                   up the connection on the first failure, the second
520                   should be ignored. */
521               
522                return;
523        }
524       
525        yd = (struct byahoo_data *) gc->proto_data;
526       
527        if( succ == YAHOO_LOGIN_OK )
528        {
529                account_online( gc );
530               
531                yd->logged_in = TRUE;
532        }
533        else
534        {
535                char *errstr;
536                char *s;
537               
538                yd->logged_in = FALSE;
539               
540                if( succ == YAHOO_LOGIN_UNAME )
541                        errstr = "Incorrect Yahoo! username";
542                else if( succ == YAHOO_LOGIN_PASSWD )
543                        errstr = "Incorrect Yahoo! password";
544                else if( succ == YAHOO_LOGIN_LOCK )
545                        errstr = "Yahoo! account locked";
546                else if( succ == YAHOO_LOGIN_DUPL )
547                {
548                        errstr = "Logged in on a different machine or device";
549                        gc->wants_to_die = TRUE;
550                }
551                else if( succ == YAHOO_LOGIN_SOCK )
552                        errstr = "Socket problem";
553                else
554                        errstr = "Unknown error";
555               
556                if( url && *url )
557                {
558                        s = g_malloc( strlen( "Error %d (%s). See %s for more information." ) + strlen( url ) + strlen( errstr ) + 16 );
559                        sprintf( s, "Error %d (%s). See %s for more information.", succ, errstr, url );
560                }
561                else
562                {
563                        s = g_malloc( strlen( "Error %d (%s)" ) + strlen( errstr ) + 16 );
564                        sprintf( s, "Error %d (%s)", succ, errstr );
565                }
566               
567                if( yd->logged_in )
568                        hide_login_progress_error( gc, s );
569                else
570                        hide_login_progress( gc, s );
571               
572                g_free( s );
573               
574                signoff( gc );
575        }
576}
577
578void ext_yahoo_got_buddies( int id, YList *buds )
579{
580        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
581        struct byahoo_data *yd = gc->proto_data;
582        YList *bl = buds;
583       
584        while( bl )
585        {
586                struct yahoo_buddy *b = bl->data;
587                struct byahoo_buddygroups *bg;
588               
589                if( strcmp( b->group, BYAHOO_DEFAULT_GROUP ) != 0 )
590                {
591                        bg = g_new0( struct byahoo_buddygroups, 1 );
592                       
593                        bg->buddy = g_strdup( b->id );
594                        bg->group = g_strdup( b->group );
595                        yd->buddygroups = g_slist_append( yd->buddygroups, bg );
596                }
597               
598                add_buddy( gc, b->group, b->id, b->real_name );
599                bl = bl->next;
600        }
601}
602
603void ext_yahoo_got_ignore( int id, YList *igns )
604{
605}
606
607void ext_yahoo_got_identities( int id, YList *ids )
608{
609}
610
611void ext_yahoo_got_cookies( int id )
612{
613}
614
615void ext_yahoo_status_changed( int id, char *who, int stat, char *msg, int away )
616{
617        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
618       
619        serv_got_update( gc, who, stat != YAHOO_STATUS_OFFLINE, 0, 0, 0,
620                         ( stat != YAHOO_STATUS_AVAILABLE ) | ( stat << 1 ), 0 );
621}
622
623void ext_yahoo_got_im( int id, char *who, char *msg, long tm, int stat, int utf8 )
624{
625        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
626        char *m = byahoo_strip( msg );
627       
628        serv_got_im( gc, who, m, 0, 0, strlen( m ) );
629        g_free( m );
630}
631
632void ext_yahoo_got_file( int id, char *who, char *url, long expires, char *msg, char *fname, unsigned long fesize )
633{
634        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
635       
636        serv_got_crap( gc, "Got a file transfer (file = %s) from %s. Ignoring for now due to lack of support.", fname, who );
637}
638
639void ext_yahoo_typing_notify( int id, char *who, int stat )
640{
641        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
642       
643        serv_got_typing( gc, who, 1 );
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 = gaim_input_add( fd, GAIM_INPUT_READ, (GaimInputFunction) 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 = gaim_input_add( fd, GAIM_INPUT_WRITE, (GaimInputFunction) 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        gaim_input_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, (GaimInputFunction) 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        else if( set_getint( gc->irc, "debug" ) )
853                serv_got_crap( gc, "Got ext_yahoo_conf_userjoin() from %s for unknown conference %s", who, room );
854}
855
856void ext_yahoo_conf_userleave( int id, char *who, char *room )
857{
858        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
859        struct conversation *c;
860       
861        for( c = gc->conversations; c && strcmp( c->title, room ) != 0; c = c->next );
862       
863        if( c )
864                remove_chat_buddy( c, who, "" );
865        else if( set_getint( gc->irc, "debug" ) )
866                serv_got_crap( gc, "Got ext_yahoo_conf_userleave() from %s for unknown conference %s", who, room );
867}
868
869void ext_yahoo_conf_message( int id, char *who, char *room, char *msg, int utf8 )
870{
871        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
872        char *m = byahoo_strip( msg );
873        struct conversation *c;
874       
875        for( c = gc->conversations; c && strcmp( c->title, room ) != 0; c = c->next );
876       
877        serv_got_chat_in( gc, c ? c->id : 0, who, 0, m, 0 );
878        g_free( m );
879}
880
881void ext_yahoo_chat_cat_xml( int id, char *xml )
882{
883}
884
885void ext_yahoo_chat_join( int id, char *room, char *topic, YList *members, int fd )
886{
887}
888
889void ext_yahoo_chat_userjoin( int id, char *room, struct yahoo_chat_member *who )
890{
891}
892
893void ext_yahoo_chat_userleave( int id, char *room, char *who )
894{
895}
896
897void ext_yahoo_chat_message( int id, char *who, char *room, char *msg, int msgtype, int utf8 )
898{
899}
900
901void ext_yahoo_chat_yahoologout( int id )
902{
903}
904
905void ext_yahoo_chat_yahooerror( int id )
906{
907}
908
909void ext_yahoo_contact_added( int id, char *myid, char *who, char *msg )
910{
911}
912
913void ext_yahoo_rejected( int id, char *who, char *msg )
914{
915}
916
917void ext_yahoo_game_notify( int id, char *who, int stat )
918{
919}
920
921void ext_yahoo_mail_notify( int id, char *from, char *subj, int cnt )
922{
923        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
924       
925        if( from && subj )
926                serv_got_crap( gc, "Received e-mail message from %s with subject `%s'", from, subj );
927        else if( cnt > 0 )
928                serv_got_crap( gc, "Received %d new e-mails", cnt );
929}
930
931void ext_yahoo_webcam_invite_reply( int id, char *from, int accept )
932{
933}
934
935void ext_yahoo_webcam_closed( int id, char *who, int reason )
936{
937}
938
939void ext_yahoo_got_search_result( int id, int found, int start, int total, YList *contacts )
940{
941}
942
943void ext_yahoo_webcam_viewer( int id, char *who, int connect )
944{
945}
946
947void ext_yahoo_webcam_data_request( int id, int send )
948{
949}
950
951int ext_yahoo_log( char *fmt, ... )
952{
953        return( 0 );
954}
955
956void 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 )
957{
958}
Note: See TracBrowser for help on using the repository browser.