source: protocols/yahoo/yahoo.c @ 0da65d5

Last change on this file since 0da65d5 was 0da65d5, checked in by Wilmer van der Gaast <wilmer@…>, at 2007-03-31T05:40:45Z

s/gaim_connection/im_connection/ and some other minor API changes. The rest
will come tomorrow. It compiles, I'll leave the real testing up to someone
else. ;-)

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