source: protocols/yahoo/yahoo.c @ 13c4cd3

Last change on this file since 13c4cd3 was 703f0f7, checked in by Jelmer Vernooij <jelmer@…>, at 2005-12-14T01:17:25Z

Merge my pluginable branch

  • 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 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        if (stat == 1) {
638                /* User is typing */
639                serv_got_typing( gc, who, 1, 1 );
640        }
641        else {
642                /* User stopped typing */
643                serv_got_typing( gc, who, 1, 0 );
644        }
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.