source: protocols/yahoo/yahoo.c @ 7b23afd

Last change on this file since 7b23afd was 7b23afd, checked in by Jelmer Vernooij <jelmer@…>, at 2005-11-07T16:16:18Z

Migrate my pluginable branch to use Wilmers' branch as parent

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