source: protocols/yahoo/yahoo.c @ 3e1de87

Last change on this file since 3e1de87 was c572dd6, checked in by Wilmer van der Gaast <wilmer@…>, at 2005-11-18T12:41:58Z

HTML stripping is optional again (but still safer than before 0.93), but now enabled by default.
  • Property mode set to 100644
File size: 22.4 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        ret->cmp_buddynames = g_strcasecmp;
420       
421        my_protocol = ret;
422}
423
424static struct gaim_connection *byahoo_get_gc_by_id( int id )
425{
426        GSList *l;
427        struct gaim_connection *gc;
428        struct byahoo_data *yd;
429       
430        for( l = get_connections(); l; l = l->next )
431        {
432                gc = l->data;
433                yd = gc->proto_data;
434               
435                if( gc->protocol == PROTO_YAHOO && yd->y2_id == id )
436                        return( gc );
437        }
438       
439        return( NULL );
440}
441
442
443/* Now it's callback time! */
444
445struct byahoo_connect_callback_data
446{
447        int fd;
448        yahoo_connect_callback callback;
449        gpointer data;
450        int id;
451};
452
453void byahoo_connect_callback( gpointer data, gint source, GaimInputCondition cond )
454{
455        struct byahoo_connect_callback_data *d = data;
456       
457        if( !byahoo_get_gc_by_id( d->id ) )
458        {
459                g_free( d );
460                return;
461        }
462       
463        d->callback( d->fd, 0, d->data );
464        g_free( d );
465}
466
467struct byahoo_read_ready_data
468{
469        int id;
470        int fd;
471        int tag;
472        gpointer data;
473};
474
475void byahoo_read_ready_callback( gpointer data, gint source, GaimInputCondition cond )
476{
477        struct byahoo_read_ready_data *d = data;
478       
479        if( !byahoo_get_gc_by_id( d->id ) )
480        {
481                /* WTF doesn't libyahoo clean this up? */
482                ext_yahoo_remove_handler( d->id, d->tag );
483                return;
484        }
485       
486        yahoo_read_ready( d->id, d->fd, d->data );
487}
488
489struct byahoo_write_ready_data
490{
491        int id;
492        int fd;
493        int tag;
494        gpointer data;
495};
496
497void byahoo_write_ready_callback( gpointer data, gint source, GaimInputCondition cond )
498{
499        struct byahoo_write_ready_data *d = data;
500       
501        if( !byahoo_get_gc_by_id( d->id ) )
502        {
503                /* WTF doesn't libyahoo clean this up? */
504                ext_yahoo_remove_handler( d->id, d->tag );
505                return;
506        }
507       
508        yahoo_write_ready( d->id, d->fd, d->data );
509}
510
511void ext_yahoo_login_response( int id, int succ, char *url )
512{
513        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
514        struct byahoo_data *yd = NULL;
515       
516        if( gc == NULL )
517        {
518                /* libyahoo2 seems to call this one twice when something
519                   went wrong sometimes. Don't know why. Because we clean
520                   up the connection on the first failure, the second
521                   should be ignored. */
522               
523                return;
524        }
525       
526        yd = (struct byahoo_data *) gc->proto_data;
527       
528        if( succ == YAHOO_LOGIN_OK )
529        {
530                account_online( gc );
531               
532                yd->logged_in = TRUE;
533        }
534        else
535        {
536                char *errstr;
537                char *s;
538               
539                yd->logged_in = FALSE;
540               
541                if( succ == YAHOO_LOGIN_UNAME )
542                        errstr = "Incorrect Yahoo! username";
543                else if( succ == YAHOO_LOGIN_PASSWD )
544                        errstr = "Incorrect Yahoo! password";
545                else if( succ == YAHOO_LOGIN_LOCK )
546                        errstr = "Yahoo! account locked";
547                else if( succ == YAHOO_LOGIN_DUPL )
548                {
549                        errstr = "Logged in on a different machine or device";
550                        gc->wants_to_die = TRUE;
551                }
552                else if( succ == YAHOO_LOGIN_SOCK )
553                        errstr = "Socket problem";
554                else
555                        errstr = "Unknown error";
556               
557                if( url && *url )
558                {
559                        s = g_malloc( strlen( "Error %d (%s). See %s for more information." ) + strlen( url ) + strlen( errstr ) + 16 );
560                        sprintf( s, "Error %d (%s). See %s for more information.", succ, errstr, url );
561                }
562                else
563                {
564                        s = g_malloc( strlen( "Error %d (%s)" ) + strlen( errstr ) + 16 );
565                        sprintf( s, "Error %d (%s)", succ, errstr );
566                }
567               
568                if( yd->logged_in )
569                        hide_login_progress_error( gc, s );
570                else
571                        hide_login_progress( gc, s );
572               
573                g_free( s );
574               
575                signoff( gc );
576        }
577}
578
579void ext_yahoo_got_buddies( int id, YList *buds )
580{
581        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
582        struct byahoo_data *yd = gc->proto_data;
583        YList *bl = buds;
584       
585        while( bl )
586        {
587                struct yahoo_buddy *b = bl->data;
588                struct byahoo_buddygroups *bg;
589               
590                if( strcmp( b->group, BYAHOO_DEFAULT_GROUP ) != 0 )
591                {
592                        bg = g_new0( struct byahoo_buddygroups, 1 );
593                       
594                        bg->buddy = g_strdup( b->id );
595                        bg->group = g_strdup( b->group );
596                        yd->buddygroups = g_slist_append( yd->buddygroups, bg );
597                }
598               
599                add_buddy( gc, b->group, b->id, b->real_name );
600                bl = bl->next;
601        }
602}
603
604void ext_yahoo_got_ignore( int id, YList *igns )
605{
606}
607
608void ext_yahoo_got_identities( int id, YList *ids )
609{
610}
611
612void ext_yahoo_got_cookies( int id )
613{
614}
615
616void ext_yahoo_status_changed( int id, char *who, int stat, char *msg, int away )
617{
618        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
619       
620        serv_got_update( gc, who, stat != YAHOO_STATUS_OFFLINE, 0, 0, 0,
621                         ( stat != YAHOO_STATUS_AVAILABLE ) | ( stat << 1 ), 0 );
622}
623
624void ext_yahoo_got_im( int id, char *who, char *msg, long tm, int stat, int utf8 )
625{
626        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
627        char *m = byahoo_strip( msg );
628       
629        serv_got_im( gc, who, m, 0, 0, strlen( m ) );
630        g_free( m );
631}
632
633void ext_yahoo_got_file( int id, char *who, char *url, long expires, char *msg, char *fname, unsigned long fesize )
634{
635        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
636       
637        serv_got_crap( gc, "Got a file transfer (file = %s) from %s. Ignoring for now due to lack of support.", fname, who );
638}
639
640void ext_yahoo_typing_notify( int id, char *who, int stat )
641{
642        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
643       
644        serv_got_typing( gc, who, 1 );
645}
646
647void ext_yahoo_system_message( int id, char *msg )
648{
649        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
650       
651        serv_got_crap( gc, "Yahoo! system message: %s", msg );
652}
653
654void ext_yahoo_webcam_invite( int id, char *from )
655{
656        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
657       
658        serv_got_crap( gc, "Got a webcam invitation from %s. IRC+webcams is a no-no though...", from );
659}
660
661void ext_yahoo_error( int id, char *err, int fatal )
662{
663        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
664       
665        if( fatal )
666        {
667                hide_login_progress_error( gc, err );
668                signoff( gc );
669        }
670        else
671        {
672                do_error_dialog( gc, err, "Yahoo! error" );
673        }
674}
675
676/* TODO: Clear up the mess of inp and d structures */
677int ext_yahoo_add_handler( int id, int fd, yahoo_input_condition cond, void *data )
678{
679        struct byahoo_input_data *inp = g_new0( struct byahoo_input_data, 1 );
680       
681        if( cond == YAHOO_INPUT_READ )
682        {
683                struct byahoo_read_ready_data *d = g_new0( struct byahoo_read_ready_data, 1 );
684               
685                d->id = id;
686                d->fd = fd;
687                d->data = data;
688               
689                inp->d = d;
690                d->tag = inp->h = gaim_input_add( fd, GAIM_INPUT_READ, (GaimInputFunction) byahoo_read_ready_callback, (gpointer) d );
691        }
692        else if( cond == YAHOO_INPUT_WRITE )
693        {
694                struct byahoo_write_ready_data *d = g_new0( struct byahoo_write_ready_data, 1 );
695               
696                d->id = id;
697                d->fd = fd;
698                d->data = data;
699               
700                inp->d = d;
701                d->tag = inp->h = gaim_input_add( fd, GAIM_INPUT_WRITE, (GaimInputFunction) byahoo_write_ready_callback, (gpointer) d );
702        }
703        else
704        {
705                g_free( inp );
706                return( -1 );
707                /* Panic... */
708        }
709       
710        byahoo_inputs = g_slist_append( byahoo_inputs, inp );
711        return( inp->h );
712}
713
714void ext_yahoo_remove_handler( int id, int tag )
715{
716        struct byahoo_input_data *inp;
717        GSList *l = byahoo_inputs;
718       
719        while( l )
720        {
721                inp = l->data;
722                if( inp->h == tag )
723                {
724                        g_free( inp->d );
725                        g_free( inp );
726                        byahoo_inputs = g_slist_remove( byahoo_inputs, inp );
727                        break;
728                }
729                l = l->next;
730        }
731       
732        gaim_input_remove( tag );
733}
734
735int ext_yahoo_connect_async( int id, char *host, int port, yahoo_connect_callback callback, void *data )
736{
737        struct byahoo_connect_callback_data *d;
738        int fd;
739       
740        d = g_new0( struct byahoo_connect_callback_data, 1 );
741        if( ( fd = proxy_connect( host, port, (GaimInputFunction) byahoo_connect_callback, (gpointer) d ) ) < 0 )
742        {
743                g_free( d );
744                return( fd );
745        }
746        d->fd = fd;
747        d->callback = callback;
748        d->data = data;
749        d->id = id;
750       
751        return( fd );
752}
753
754/* Because we don't want asynchronous connects in BitlBee, and because
755   libyahoo doesn't seem to use this one anyway, this one is now defunct. */
756int ext_yahoo_connect(char *host, int port)
757{
758#if 0
759        struct sockaddr_in serv_addr;
760        static struct hostent *server;
761        static char last_host[256];
762        int servfd;
763        char **p;
764
765        if(last_host[0] || g_strcasecmp(last_host, host)!=0) {
766                if(!(server = gethostbyname(host))) {
767                        return -1;
768                }
769                strncpy(last_host, host, 255);
770        }
771
772        if((servfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
773                return -1;
774        }
775
776        for (p = server->h_addr_list; *p; p++)
777        {
778                memset(&serv_addr, 0, sizeof(serv_addr));
779                serv_addr.sin_family = AF_INET;
780                memcpy(&serv_addr.sin_addr.s_addr, *p, server->h_length);
781                serv_addr.sin_port = htons(port);
782
783                if(connect(servfd, (struct sockaddr *) &serv_addr,
784                                        sizeof(serv_addr)) == -1) {
785                        return -1;
786                } else {
787                        return servfd;
788                }
789        }
790
791        closesocket(servfd);
792#endif
793        return -1;
794}
795
796static void byahoo_accept_conf( gpointer w, struct byahoo_conf_invitation *inv )
797{
798        yahoo_conference_logon( inv->yid, NULL, inv->members, inv->name );
799        add_chat_buddy( inv->c, inv->gc->username );
800        g_free( inv->name );
801        g_free( inv );
802}
803
804static void byahoo_reject_conf( gpointer w, struct byahoo_conf_invitation *inv )
805{
806        yahoo_conference_decline( inv->yid, NULL, inv->members, inv->name, "User rejected groupchat" );
807        serv_got_chat_left( inv->gc, inv->c->id );
808        g_free( inv->name );
809        g_free( inv );
810}
811
812void ext_yahoo_got_conf_invite( int id, char *who, char *room, char *msg, YList *members )
813{
814        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
815        struct byahoo_conf_invitation *inv;
816        char txt[1024];
817        YList *m;
818       
819        inv = g_malloc( sizeof( struct byahoo_conf_invitation ) );
820        memset( inv, 0, sizeof( struct byahoo_conf_invitation ) );
821        inv->name = g_strdup( room );
822        inv->c = serv_got_joined_chat( gc, ++byahoo_chat_id, room );
823        inv->c->data = members;
824        inv->yid = id;
825        inv->members = members;
826        inv->gc = gc;
827       
828        for( m = members; m; m = m->next )
829                if( g_strcasecmp( m->data, gc->username ) != 0 )
830                        add_chat_buddy( inv->c, m->data );
831       
832        g_snprintf( txt, 1024, "Got an invitation to chatroom %s from %s: %s", room, who, msg );
833       
834        do_ask_dialog( gc, txt, inv, byahoo_accept_conf, byahoo_reject_conf );
835}
836
837void ext_yahoo_conf_userdecline( int id, char *who, char *room, char *msg )
838{
839        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
840       
841        serv_got_crap( gc, "Invite to chatroom %s rejected by %s: %s", room, who, msg );
842}
843
844void ext_yahoo_conf_userjoin( int id, char *who, char *room )
845{
846        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
847        struct conversation *c;
848       
849        for( c = gc->conversations; c && strcmp( c->title, room ) != 0; c = c->next );
850       
851        if( c )
852                add_chat_buddy( c, who );
853}
854
855void ext_yahoo_conf_userleave( int id, char *who, char *room )
856{
857        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
858        struct conversation *c;
859       
860        for( c = gc->conversations; c && strcmp( c->title, room ) != 0; c = c->next );
861       
862        if( c )
863                remove_chat_buddy( c, who, "" );
864}
865
866void ext_yahoo_conf_message( int id, char *who, char *room, char *msg, int utf8 )
867{
868        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
869        char *m = byahoo_strip( msg );
870        struct conversation *c;
871       
872        for( c = gc->conversations; c && strcmp( c->title, room ) != 0; c = c->next );
873       
874        serv_got_chat_in( gc, c ? c->id : 0, who, 0, m, 0 );
875        g_free( m );
876}
877
878void ext_yahoo_chat_cat_xml( int id, char *xml )
879{
880}
881
882void ext_yahoo_chat_join( int id, char *room, char *topic, YList *members, int fd )
883{
884}
885
886void ext_yahoo_chat_userjoin( int id, char *room, struct yahoo_chat_member *who )
887{
888}
889
890void ext_yahoo_chat_userleave( int id, char *room, char *who )
891{
892}
893
894void ext_yahoo_chat_message( int id, char *who, char *room, char *msg, int msgtype, int utf8 )
895{
896}
897
898void ext_yahoo_chat_yahoologout( int id )
899{
900}
901
902void ext_yahoo_chat_yahooerror( int id )
903{
904}
905
906void ext_yahoo_contact_added( int id, char *myid, char *who, char *msg )
907{
908}
909
910void ext_yahoo_rejected( int id, char *who, char *msg )
911{
912}
913
914void ext_yahoo_game_notify( int id, char *who, int stat )
915{
916}
917
918void ext_yahoo_mail_notify( int id, char *from, char *subj, int cnt )
919{
920        struct gaim_connection *gc = byahoo_get_gc_by_id( id );
921       
922        if( from && subj )
923                serv_got_crap( gc, "Received e-mail message from %s with subject `%s'", from, subj );
924        else if( cnt > 0 )
925                serv_got_crap( gc, "Received %d new e-mails", cnt );
926}
927
928void ext_yahoo_webcam_invite_reply( int id, char *from, int accept )
929{
930}
931
932void ext_yahoo_webcam_closed( int id, char *who, int reason )
933{
934}
935
936void ext_yahoo_got_search_result( int id, int found, int start, int total, YList *contacts )
937{
938}
939
940void ext_yahoo_webcam_viewer( int id, char *who, int connect )
941{
942}
943
944void ext_yahoo_webcam_data_request( int id, int send )
945{
946}
947
948int ext_yahoo_log( char *fmt, ... )
949{
950        return( 0 );
951}
952
953void 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 )
954{
955}
Note: See TracBrowser for help on using the repository browser.