source: protocols/yahoo/yahoo.c @ fa29d093

Last change on this file since fa29d093 was fa29d093, checked in by Wilmer van der Gaast <wilmer@…>, at 2007-03-28T05:53:11Z

Preparing for Jabber conference room support.

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