source: protocols/yahoo/yahoo.c @ 3f81999

Last change on this file since 3f81999 was 3f81999, checked in by Sven Moritz Hallberg <pesco@…>, at 2010-06-03T10:31:46Z

merge in bitlbee 1.2.4

  • Property mode set to 100644
File size: 24.2 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( const char *in )
70{
71        int len;
72       
73        /* This should get rid of the markup noise 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                        const 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 noise at the end of the line. */
104        len = strlen( in );
105        while( len > 0 && ( in[len-1] == '>' || in[len-1] == 'm' ) )
106        {
107                int blen = len;
108                const char *search;
109               
110                if( in[len-1] == '>' )
111                        search = "</";
112                else
113                        search = "\e[";
114               
115                len -= 3;
116                while( len > 0 && strncmp( in + len, search, 2 ) != 0 )
117                        len --;
118               
119                if( len <= 0 && strncmp( in, search, 2 ) != 0 )
120                {
121                        len = blen;
122                        break;
123                }
124        }
125       
126        return( g_strndup( in, len ) );
127}
128
129static void byahoo_init( account_t *acc )
130{
131        set_add( &acc->set, "mail_notifications", "false", set_eval_bool, acc );
132}
133
134static void byahoo_login( account_t *acc )
135{
136        struct im_connection *ic = imcb_new( acc );
137        struct byahoo_data *yd = ic->proto_data = g_new0( struct byahoo_data, 1 );
138       
139        yd->logged_in = FALSE;
140        yd->current_status = YAHOO_STATUS_AVAILABLE;
141       
142        imcb_log( ic, "Connecting" );
143        yd->y2_id = yahoo_init( acc->user, acc->pass );
144        yahoo_login( yd->y2_id, yd->current_status );
145}
146
147static void byahoo_logout( struct im_connection *ic )
148{
149        struct byahoo_data *yd = (struct byahoo_data *) ic->proto_data;
150        GSList *l;
151       
152        while( ic->groupchats )
153                imcb_chat_free( ic->groupchats );
154       
155        for( l = yd->buddygroups; l; l = l->next )
156        {
157                struct byahoo_buddygroups *bg = l->data;
158               
159                g_free( bg->buddy );
160                g_free( bg->group );
161                g_free( bg );
162        }
163        g_slist_free( yd->buddygroups );
164       
165        yahoo_logoff( yd->y2_id );
166       
167        g_free( yd );
168}
169
170static void byahoo_get_info(struct im_connection *ic, char *who) 
171{
172        /* Just make an URL and let the user fetch the info */
173        imcb_log(ic, "%s\n%s: %s%s", _("User Info"), 
174                        _("For now, fetch yourself"), yahoo_get_profile_url(),
175                        who);
176}
177
178static int byahoo_buddy_msg( struct im_connection *ic, char *who, char *what, int flags )
179{
180        struct byahoo_data *yd = ic->proto_data;
181       
182        yahoo_send_im( yd->y2_id, NULL, who, what, 1, 0 );
183       
184        return 1;
185}
186
187static int byahoo_send_typing( struct im_connection *ic, char *who, int typing )
188{
189        struct byahoo_data *yd = ic->proto_data;
190       
191        yahoo_send_typing( yd->y2_id, NULL, who, ( typing & OPT_TYPING ) != 0 );
192       
193        return 1;
194}
195
196static void byahoo_set_away( struct im_connection *ic, char *state, char *msg )
197{
198        struct byahoo_data *yd = (struct byahoo_data *) ic->proto_data;
199        char *away;
200       
201        away = NULL;
202       
203        if( state && msg && g_strcasecmp( state, msg ) != 0 )
204        {
205                yd->current_status = YAHOO_STATUS_CUSTOM;
206                away = "";
207        }
208        else if( state )
209        {
210                /* Set msg to NULL since (if it isn't NULL already) it's equal
211                   to state. msg must be empty if we want to use an existing
212                   away state. */
213                msg = NULL;
214               
215                away = "";
216                if( g_strcasecmp( state, "Available" ) == 0 )
217                {
218                        yd->current_status = YAHOO_STATUS_AVAILABLE;
219                        away = NULL;
220                }
221                else if( g_strcasecmp( state, "Be Right Back" ) == 0 )
222                        yd->current_status = YAHOO_STATUS_BRB;
223                else if( g_strcasecmp( state, "Busy" ) == 0 )
224                        yd->current_status = YAHOO_STATUS_BUSY;
225                else if( g_strcasecmp( state, "Not At Home" ) == 0 )
226                        yd->current_status = YAHOO_STATUS_NOTATHOME;
227                else if( g_strcasecmp( state, "Not At Desk" ) == 0 )
228                        yd->current_status = YAHOO_STATUS_NOTATDESK;
229                else if( g_strcasecmp( state, "Not In Office" ) == 0 )
230                        yd->current_status = YAHOO_STATUS_NOTINOFFICE;
231                else if( g_strcasecmp( state, "On Phone" ) == 0 )
232                        yd->current_status = YAHOO_STATUS_ONPHONE;
233                else if( g_strcasecmp( state, "On Vacation" ) == 0 )
234                        yd->current_status = YAHOO_STATUS_ONVACATION;
235                else if( g_strcasecmp( state, "Out To Lunch" ) == 0 )
236                        yd->current_status = YAHOO_STATUS_OUTTOLUNCH;
237                else if( g_strcasecmp( state, "Stepped Out" ) == 0 )
238                        yd->current_status = YAHOO_STATUS_STEPPEDOUT;
239                else if( g_strcasecmp( state, "Invisible" ) == 0 )
240                        yd->current_status = YAHOO_STATUS_INVISIBLE;
241                else if( g_strcasecmp( state, GAIM_AWAY_CUSTOM ) == 0 )
242                {
243                        yd->current_status = YAHOO_STATUS_AVAILABLE;
244                       
245                        away = NULL;
246                }
247        }
248        else
249                yd->current_status = YAHOO_STATUS_AVAILABLE;
250       
251        yahoo_set_away( yd->y2_id, yd->current_status, msg, away != NULL ? 2 : 0 );
252}
253
254static GList *byahoo_away_states( struct im_connection *ic )
255{
256        static GList *m = NULL;
257
258        if( m == NULL )
259        {
260                m = g_list_append( m, "Available" );
261                m = g_list_append( m, "Be Right Back" );
262                m = g_list_append( m, "Busy" );
263                m = g_list_append( m, "Not At Home" );
264                m = g_list_append( m, "Not At Desk" );
265                m = g_list_append( m, "Not In Office" );
266                m = g_list_append( m, "On Phone" );
267                m = g_list_append( m, "On Vacation" );
268                m = g_list_append( m, "Out To Lunch" );
269                m = g_list_append( m, "Stepped Out" );
270                m = g_list_append( m, "Invisible" );
271                m = g_list_append( m, GAIM_AWAY_CUSTOM );
272        }
273       
274        return m;
275}
276
277static void byahoo_keepalive( struct im_connection *ic )
278{
279        struct byahoo_data *yd = ic->proto_data;
280       
281        yahoo_keepalive( yd->y2_id );
282}
283
284static void byahoo_add_buddy( struct im_connection *ic, char *who, char *group )
285{
286        struct byahoo_data *yd = (struct byahoo_data *) ic->proto_data;
287       
288        yahoo_add_buddy( yd->y2_id, who, group ? group : BYAHOO_DEFAULT_GROUP, NULL );
289}
290
291static void byahoo_remove_buddy( struct im_connection *ic, char *who, char *group )
292{
293        struct byahoo_data *yd = (struct byahoo_data *) ic->proto_data;
294        GSList *bgl;
295       
296        yahoo_remove_buddy( yd->y2_id, who, BYAHOO_DEFAULT_GROUP );
297       
298        for( bgl = yd->buddygroups; bgl; bgl = bgl->next )
299        {
300                struct byahoo_buddygroups *bg = bgl->data;
301               
302                if( g_strcasecmp( bg->buddy, who ) == 0 )
303                        yahoo_remove_buddy( yd->y2_id, who, bg->group );
304        }
305}
306
307static void byahoo_chat_msg( struct groupchat *c, char *message, int flags )
308{
309        struct byahoo_data *yd = (struct byahoo_data *) c->ic->proto_data;
310       
311        yahoo_conference_message( yd->y2_id, NULL, c->data, c->title, message, 1 );
312}
313
314static void byahoo_chat_invite( struct groupchat *c, char *who, char *msg )
315{
316        struct byahoo_data *yd = (struct byahoo_data *) c->ic->proto_data;
317       
318        yahoo_conference_invite( yd->y2_id, NULL, c->data, c->title, msg ? msg : "" );
319}
320
321static void byahoo_chat_leave( struct groupchat *c )
322{
323        struct byahoo_data *yd = (struct byahoo_data *) c->ic->proto_data;
324       
325        yahoo_conference_logoff( yd->y2_id, NULL, c->data, c->title );
326        imcb_chat_free( c );
327}
328
329static struct groupchat *byahoo_chat_with( struct im_connection *ic, char *who )
330{
331        struct byahoo_data *yd = (struct byahoo_data *) ic->proto_data;
332        struct groupchat *c;
333        char *roomname;
334        YList *members;
335       
336        roomname = g_strdup_printf( "%s-Bee-%d", ic->acc->user, byahoo_chat_id );
337       
338        c = imcb_chat_new( ic, roomname );
339        imcb_chat_add_buddy( c, ic->acc->user );
340       
341        /* FIXME: Free this thing when the chat's destroyed. We can't *always*
342                  do this because it's not always created here. */
343        c->data = members = g_new0( YList, 1 );
344        members->data = g_strdup( who );
345       
346        yahoo_conference_invite( yd->y2_id, NULL, members, roomname, "Please join my groupchat..." );
347       
348        g_free( roomname );
349       
350        return c;
351}
352
353static void byahoo_auth_allow( struct im_connection *ic, const char *who )
354{
355        struct byahoo_data *yd = (struct byahoo_data *) ic->proto_data;
356       
357        yahoo_accept_buddy_ymsg13( yd->y2_id, NULL, who );
358}
359
360static void byahoo_auth_deny( struct im_connection *ic, const char *who )
361{
362        struct byahoo_data *yd = (struct byahoo_data *) ic->proto_data;
363       
364        yahoo_reject_buddy_ymsg13( yd->y2_id, NULL, who, NULL );
365}
366
367void byahoo_initmodule( )
368{
369        struct prpl *ret = g_new0(struct prpl, 1);
370        ret->name = "yahoo";
371    ret->mms = 832;           /* this guess taken from libotr UPGRADING file */
372        ret->init = byahoo_init;
373       
374        ret->login = byahoo_login;
375        ret->keepalive = byahoo_keepalive;
376        ret->logout = byahoo_logout;
377       
378        ret->buddy_msg = byahoo_buddy_msg;
379        ret->get_info = byahoo_get_info;
380        ret->away_states = byahoo_away_states;
381        ret->set_away = byahoo_set_away;
382        ret->add_buddy = byahoo_add_buddy;
383        ret->remove_buddy = byahoo_remove_buddy;
384        ret->send_typing = byahoo_send_typing;
385       
386        ret->chat_msg = byahoo_chat_msg;
387        ret->chat_invite = byahoo_chat_invite;
388        ret->chat_leave = byahoo_chat_leave;
389        ret->chat_with = byahoo_chat_with;
390
391        ret->handle_cmp = g_strcasecmp;
392       
393        ret->auth_allow = byahoo_auth_allow;
394        ret->auth_deny = byahoo_auth_deny;
395       
396        register_protocol(ret);
397}
398
399static struct im_connection *byahoo_get_ic_by_id( int id )
400{
401        GSList *l;
402        struct im_connection *ic;
403        struct byahoo_data *yd;
404       
405        for( l = get_connections(); l; l = l->next )
406        {
407                ic = l->data;
408                yd = ic->proto_data;
409               
410                if( strcmp( ic->acc->prpl->name, "yahoo" ) == 0 && yd->y2_id == id )
411                        return( ic );
412        }
413       
414        return( NULL );
415}
416
417
418/* Now it's callback time! */
419
420struct byahoo_connect_callback_data
421{
422        int fd;
423        yahoo_connect_callback callback;
424        gpointer data;
425        int id;
426};
427
428void byahoo_connect_callback( gpointer data, gint source, b_input_condition cond )
429{
430        struct byahoo_connect_callback_data *d = data;
431       
432        if( !byahoo_get_ic_by_id( d->id ) )
433        {
434                g_free( d );
435                return;
436        }
437       
438        d->callback( d->fd, 0, d->data );
439        g_free( d );
440}
441
442struct byahoo_read_ready_data
443{
444        int id;
445        int fd;
446        int tag;
447        gpointer data;
448};
449
450gboolean byahoo_read_ready_callback( gpointer data, gint source, b_input_condition cond )
451{
452        struct byahoo_read_ready_data *d = data;
453       
454        if( !byahoo_get_ic_by_id( d->id ) )
455                /* WTF doesn't libyahoo clean this up? */
456                return FALSE;
457       
458        yahoo_read_ready( d->id, d->fd, d->data );
459       
460        return TRUE;
461}
462
463struct byahoo_write_ready_data
464{
465        int id;
466        int fd;
467        int tag;
468        gpointer data;
469};
470
471gboolean byahoo_write_ready_callback( gpointer data, gint source, b_input_condition cond )
472{
473        struct byahoo_write_ready_data *d = data;
474       
475        return yahoo_write_ready( d->id, d->fd, d->data );
476}
477
478void ext_yahoo_login_response( int id, int succ, const char *url )
479{
480        struct im_connection *ic = byahoo_get_ic_by_id( id );
481        struct byahoo_data *yd = NULL;
482       
483        if( ic == NULL )
484        {
485                /* libyahoo2 seems to call this one twice when something
486                   went wrong sometimes. Don't know why. Because we clean
487                   up the connection on the first failure, the second
488                   should be ignored. */
489               
490                return;
491        }
492       
493        yd = (struct byahoo_data *) ic->proto_data;
494       
495        if( succ == YAHOO_LOGIN_OK )
496        {
497                imcb_connected( ic );
498               
499                yd->logged_in = TRUE;
500        }
501        else
502        {
503                char *errstr;
504                int allow_reconnect = TRUE;
505               
506                yd->logged_in = FALSE;
507               
508                if( succ == YAHOO_LOGIN_UNAME )
509                        errstr = "Incorrect Yahoo! username";
510                else if( succ == YAHOO_LOGIN_PASSWD )
511                        errstr = "Incorrect Yahoo! password";
512                else if( succ == YAHOO_LOGIN_LOCK )
513                        errstr = "Yahoo! account locked";
514                else if( succ == YAHOO_LOGIN_DUPL )
515                {
516                        errstr = "Logged in on a different machine or device";
517                        allow_reconnect = FALSE;
518                }
519                else if( succ == YAHOO_LOGIN_SOCK )
520                        errstr = "Socket problem";
521                else
522                        errstr = "Unknown error";
523               
524                if( url && *url )
525                        imcb_error( ic, "Error %d (%s). See %s for more information.", succ, errstr, url );
526                else
527                        imcb_error( ic, "Error %d (%s)", succ, errstr );
528               
529                imc_logout( ic, allow_reconnect );
530        }
531}
532
533void ext_yahoo_got_buddies( int id, YList *buds )
534{
535        struct im_connection *ic = byahoo_get_ic_by_id( id );
536        struct byahoo_data *yd = ic->proto_data;
537        YList *bl = buds;
538       
539        while( bl )
540        {
541                struct yahoo_buddy *b = bl->data;
542                struct byahoo_buddygroups *bg;
543               
544                if( strcmp( b->group, BYAHOO_DEFAULT_GROUP ) != 0 )
545                {
546                        bg = g_new0( struct byahoo_buddygroups, 1 );
547                       
548                        bg->buddy = g_strdup( b->id );
549                        bg->group = g_strdup( b->group );
550                        yd->buddygroups = g_slist_append( yd->buddygroups, bg );
551                }
552               
553                imcb_add_buddy( ic, b->id, b->group );
554                imcb_rename_buddy( ic, b->id, b->real_name );
555               
556                bl = bl->next;
557        }
558}
559
560void ext_yahoo_got_ignore( int id, YList *igns )
561{
562}
563
564void ext_yahoo_got_identities( int id, YList *ids )
565{
566}
567
568void ext_yahoo_got_cookies( int id )
569{
570}
571
572void ext_yahoo_status_changed( int id, const char *who, int stat, const char *msg, int away, int idle, int mobile )
573{
574        struct im_connection *ic = byahoo_get_ic_by_id( id );
575        char *state_string = NULL;
576        int flags = OPT_LOGGED_IN;
577       
578        if( away )
579                flags |= OPT_AWAY;
580       
581        switch (stat)
582        {
583        case YAHOO_STATUS_BRB:
584                state_string = "Be Right Back";
585                break;
586        case YAHOO_STATUS_BUSY:
587                state_string = "Busy";
588                break;
589        case YAHOO_STATUS_NOTATHOME:
590                state_string = "Not At Home";
591                break;
592        case YAHOO_STATUS_NOTATDESK:
593                state_string = "Not At Desk";
594                break;
595        case YAHOO_STATUS_NOTINOFFICE:
596                state_string = "Not In Office";
597                break;
598        case YAHOO_STATUS_ONPHONE:
599                state_string = "On Phone";
600                break;
601        case YAHOO_STATUS_ONVACATION:
602                state_string = "On Vacation";
603                break;
604        case YAHOO_STATUS_OUTTOLUNCH:
605                state_string = "Out To Lunch";
606                break;
607        case YAHOO_STATUS_STEPPEDOUT:
608                state_string = "Stepped Out";
609                break;
610        case YAHOO_STATUS_INVISIBLE:
611                state_string = "Invisible";
612                break;
613        case YAHOO_STATUS_CUSTOM:
614                state_string = "Away";
615                break;
616        case YAHOO_STATUS_IDLE:
617                state_string = "Idle";
618                break;
619        case YAHOO_STATUS_OFFLINE:
620                state_string = "Offline";
621                flags = 0;
622                break;
623        case YAHOO_STATUS_NOTIFY:
624                state_string = "Notify";
625                break;
626        }
627       
628        imcb_buddy_status( ic, who, flags, state_string, msg );
629       
630        /* Not implemented yet...
631        if( stat == YAHOO_STATUS_IDLE )
632                imcb_buddy_times( ic, who, 0, away );
633        */
634}
635
636void ext_yahoo_got_im( int id, const char *me, const char *who, const char *msg, long tm, int stat, int utf8 )
637{
638        struct im_connection *ic = byahoo_get_ic_by_id( id );
639        char *m;
640       
641        if( msg )
642        {
643                m = byahoo_strip( msg );
644                imcb_buddy_msg( ic, (char*) who, (char*) m, 0, 0 );
645                g_free( m );
646        }
647}
648
649void ext_yahoo_got_file( int id,
650                         const char *ignored,
651                         const char *who, const char *url, long expires, const char *msg, const char *fname, unsigned long fesize )
652{
653        struct im_connection *ic = byahoo_get_ic_by_id( id );
654       
655        imcb_log( ic, "Got a file transfer (file = %s) from %s. Ignoring for now due to lack of support.", fname, who );
656}
657
658void ext_yahoo_typing_notify( int id, const char *ignored, const char *who, int stat )
659{
660        struct im_connection *ic = byahoo_get_ic_by_id( id );
661       
662        if( stat == 1 )
663                imcb_buddy_typing( ic, (char*) who, OPT_TYPING );
664        else
665                imcb_buddy_typing( ic, (char*) who, 0 );
666}
667
668void ext_yahoo_system_message( int id, const char *msg )
669{
670        struct im_connection *ic = byahoo_get_ic_by_id( id );
671       
672        imcb_log( ic, "Yahoo! system message: %s", msg );
673}
674
675void ext_yahoo_webcam_invite( int id, const char *ignored, const char *from )
676{
677        struct im_connection *ic = byahoo_get_ic_by_id( id );
678       
679        imcb_log( ic, "Got a webcam invitation from %s. IRC+webcams is a no-no though...", from );
680}
681
682void ext_yahoo_error( int id, const char *err, int fatal, int num )
683{
684        struct im_connection *ic = byahoo_get_ic_by_id( id );
685       
686        imcb_error( ic, "%s", err );
687}
688
689/* TODO: Clear up the mess of inp and d structures */
690int ext_yahoo_add_handler( int id, int fd, yahoo_input_condition cond, void *data )
691{
692        struct byahoo_input_data *inp = g_new0( struct byahoo_input_data, 1 );
693       
694        if( cond == YAHOO_INPUT_READ )
695        {
696                struct byahoo_read_ready_data *d = g_new0( struct byahoo_read_ready_data, 1 );
697               
698                d->id = id;
699                d->fd = fd;
700                d->data = data;
701               
702                inp->d = d;
703                d->tag = inp->h = b_input_add( fd, GAIM_INPUT_READ, (b_event_handler) byahoo_read_ready_callback, (gpointer) d );
704        }
705        else if( cond == YAHOO_INPUT_WRITE )
706        {
707                struct byahoo_write_ready_data *d = g_new0( struct byahoo_write_ready_data, 1 );
708               
709                d->id = id;
710                d->fd = fd;
711                d->data = data;
712               
713                inp->d = d;
714                d->tag = inp->h = b_input_add( fd, GAIM_INPUT_WRITE, (b_event_handler) byahoo_write_ready_callback, (gpointer) d );
715        }
716        else
717        {
718                g_free( inp );
719                return( -1 );
720                /* Panic... */
721        }
722       
723        byahoo_inputs = g_slist_append( byahoo_inputs, inp );
724        return( inp->h );
725}
726
727void ext_yahoo_remove_handler( int id, int tag )
728{
729        struct byahoo_input_data *inp;
730        GSList *l = byahoo_inputs;
731       
732        while( l )
733        {
734                inp = l->data;
735                if( inp->h == tag )
736                {
737                        g_free( inp->d );
738                        g_free( inp );
739                        byahoo_inputs = g_slist_remove( byahoo_inputs, inp );
740                        break;
741                }
742                l = l->next;
743        }
744       
745        b_event_remove( tag );
746}
747
748int ext_yahoo_connect_async( int id, const char *host, int port, yahoo_connect_callback callback, void *data )
749{
750        struct byahoo_connect_callback_data *d;
751        int fd;
752       
753        d = g_new0( struct byahoo_connect_callback_data, 1 );
754        if( ( fd = proxy_connect( host, port, (b_event_handler) byahoo_connect_callback, (gpointer) d ) ) < 0 )
755        {
756                g_free( d );
757                return( fd );
758        }
759        d->fd = fd;
760        d->callback = callback;
761        d->data = data;
762        d->id = id;
763       
764        return( fd );
765}
766
767/* Because we don't want asynchronous connects in BitlBee, and because
768   libyahoo doesn't seem to use this one anyway, this one is now defunct. */
769int ext_yahoo_connect(const char *host, int port)
770{
771#if 0
772        struct sockaddr_in serv_addr;
773        static struct hostent *server;
774        static char last_host[256];
775        int servfd;
776        char **p;
777
778        if(last_host[0] || g_strcasecmp(last_host, host)!=0) {
779                if(!(server = gethostbyname(host))) {
780                        return -1;
781                }
782                strncpy(last_host, host, 255);
783        }
784
785        if((servfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
786                return -1;
787        }
788
789        for (p = server->h_addr_list; *p; p++)
790        {
791                memset(&serv_addr, 0, sizeof(serv_addr));
792                serv_addr.sin_family = AF_INET;
793                memcpy(&serv_addr.sin_addr.s_addr, *p, server->h_length);
794                serv_addr.sin_port = htons(port);
795
796                if(connect(servfd, (struct sockaddr *) &serv_addr,
797                                        sizeof(serv_addr)) == -1) {
798                        return -1;
799                } else {
800                        return servfd;
801                }
802        }
803
804        closesocket(servfd);
805#endif
806        return -1;
807}
808
809static void byahoo_accept_conf( void *data )
810{
811        struct byahoo_conf_invitation *inv = data;
812        struct groupchat *b;
813       
814        for( b = inv->ic->groupchats; b; b = b->next )
815                if( b == inv->c )
816                        break;
817       
818        if( b != NULL )
819        {
820                yahoo_conference_logon( inv->yid, NULL, inv->members, inv->name );
821                imcb_chat_add_buddy( inv->c, inv->ic->acc->user );
822        }
823        else
824        {
825                imcb_log( inv->ic, "Duplicate/corrupted invitation to `%s'.", inv->name );
826        }
827       
828        g_free( inv->name );
829        g_free( inv );
830}
831
832static void byahoo_reject_conf( void *data )
833{
834        struct byahoo_conf_invitation *inv = data;
835       
836        yahoo_conference_decline( inv->yid, NULL, inv->members, inv->name, "User rejected groupchat" );
837        imcb_chat_free( inv->c );
838        g_free( inv->name );
839        g_free( inv );
840}
841
842void ext_yahoo_got_conf_invite( int id, const char *ignored,
843                                const char *who, const char *room, const char *msg, YList *members )
844{
845        struct im_connection *ic = byahoo_get_ic_by_id( id );
846        struct byahoo_conf_invitation *inv;
847        char txt[1024];
848        YList *m;
849       
850        inv = g_malloc( sizeof( struct byahoo_conf_invitation ) );
851        memset( inv, 0, sizeof( struct byahoo_conf_invitation ) );
852        inv->name = g_strdup( room );
853        inv->c = imcb_chat_new( ic, (char*) room );
854        inv->c->data = members;
855        inv->yid = id;
856        inv->members = members;
857        inv->ic = ic;
858       
859        for( m = members; m; m = m->next )
860                if( g_strcasecmp( m->data, ic->acc->user ) != 0 )
861                        imcb_chat_add_buddy( inv->c, m->data );
862       
863        g_snprintf( txt, 1024, "Got an invitation to chatroom %s from %s: %s", room, who, msg );
864       
865        imcb_ask( ic, txt, inv, byahoo_accept_conf, byahoo_reject_conf );
866}
867
868void ext_yahoo_conf_userdecline( int id, const char *ignored, const char *who, const char *room, const char *msg )
869{
870        struct im_connection *ic = byahoo_get_ic_by_id( id );
871       
872        imcb_log( ic, "Invite to chatroom %s rejected by %s: %s", room, who, msg );
873}
874
875void ext_yahoo_conf_userjoin( int id, const char *ignored, const char *who, const char *room )
876{
877        struct im_connection *ic = byahoo_get_ic_by_id( id );
878        struct groupchat *c;
879       
880        for( c = ic->groupchats; c && strcmp( c->title, room ) != 0; c = c->next );
881       
882        if( c )
883                imcb_chat_add_buddy( c, (char*) who );
884}
885
886void ext_yahoo_conf_userleave( int id, const char *ignored, const char *who, const char *room )
887
888{
889        struct im_connection *ic = byahoo_get_ic_by_id( id );
890        struct groupchat *c;
891       
892        for( c = ic->groupchats; c && strcmp( c->title, room ) != 0; c = c->next );
893       
894        if( c )
895                imcb_chat_remove_buddy( c, (char*) who, "" );
896}
897
898void ext_yahoo_conf_message( int id, const char *ignored, const char *who, const char *room, const char *msg, int utf8 )
899{
900        struct im_connection *ic = byahoo_get_ic_by_id( id );
901        char *m = byahoo_strip( msg );
902        struct groupchat *c;
903       
904        for( c = ic->groupchats; c && strcmp( c->title, room ) != 0; c = c->next );
905       
906        if( c )
907                imcb_chat_msg( c, (char*) who, (char*) m, 0, 0 );
908        g_free( m );
909}
910
911void ext_yahoo_chat_cat_xml( int id, const char *xml )
912{
913}
914
915void ext_yahoo_chat_join( int id, const char *who, const char *room, const char *topic, YList *members, int fd )
916{
917}
918
919void ext_yahoo_chat_userjoin( int id, const char *me, const char *room, struct yahoo_chat_member *who )
920{
921        free(who->id);
922        free(who->alias);
923        free(who->location);
924        free(who);
925}
926
927void ext_yahoo_chat_userleave( int id, const char *me, const char *room, const char *who )
928{
929}
930
931void ext_yahoo_chat_message( int id, const char *me, const char *who, const char *room, const char *msg, int msgtype, int utf8 )
932{
933}
934
935void ext_yahoo_chat_yahoologout( int id, const char *me )
936{
937}
938
939void ext_yahoo_chat_yahooerror( int id, const char *me )
940{
941}
942
943void ext_yahoo_contact_auth_request( int id, const char *myid, const char *who, const char *msg )
944{
945        struct im_connection *ic = byahoo_get_ic_by_id( id );
946       
947        imcb_ask_auth( ic, who, NULL );
948}
949
950void ext_yahoo_contact_added( int id, const char *myid, const char *who, const char *msg )
951{
952        struct im_connection *ic = byahoo_get_ic_by_id( id );
953       
954        imcb_add_buddy( ic, (char*) who, NULL );
955}
956
957void ext_yahoo_rejected( int id, const char *who, const char *msg )
958{
959}
960
961void ext_yahoo_game_notify( int id, const char *me, const char *who, int stat )
962{
963}
964
965void ext_yahoo_mail_notify( int id, const char *from, const char *subj, int cnt )
966{
967        struct im_connection *ic = byahoo_get_ic_by_id( id );
968       
969        if( !set_getbool( &ic->acc->set, "mail_notifications" ) )
970                ; /* The user doesn't care. */
971        else if( from && subj )
972                imcb_log( ic, "Received e-mail message from %s with subject `%s'", from, subj );
973        else if( cnt > 0 )
974                imcb_log( ic, "Received %d new e-mails", cnt );
975}
976
977void ext_yahoo_webcam_invite_reply( int id, const char *me, const char *from, int accept )
978{
979}
980
981void ext_yahoo_webcam_closed( int id, const char *who, int reason )
982{
983}
984
985void ext_yahoo_got_search_result( int id, int found, int start, int total, YList *contacts )
986{
987}
988
989void ext_yahoo_webcam_viewer( int id, const char *who, int connect )
990{
991}
992
993void ext_yahoo_webcam_data_request( int id, int send )
994{
995}
996
997int ext_yahoo_log( const char *fmt, ... )
998{
999        return( 0 );
1000}
1001
1002void 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 )
1003{
1004}
1005
1006void ext_yahoo_got_ping( int id, const char *msg)
1007{
1008}
1009
1010void ext_yahoo_got_buddyicon (int id, const char *me, const char *who, const char *url, int checksum) {}
1011void ext_yahoo_got_buddyicon_checksum (int id, const char *me,const char *who, int checksum) {}
1012
1013void ext_yahoo_got_buddyicon_request(int id, const char *me, const char *who){}
1014void ext_yahoo_buddyicon_uploaded(int id, const char *url){}
Note: See TracBrowser for help on using the repository browser.