source: protocols/yahoo/yahoo.c @ b20b32f

Last change on this file since b20b32f was 2cdd8ce, checked in by Jelmer Vernooij <jelmer@…>, at 2005-11-19T15:17:03Z

Merge Wilmer

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