source: protocols/yahoo/yahoo.c @ a6b2f13

Last change on this file since a6b2f13 was 5f8ab6a9, checked in by Sven Moritz Hallberg <pesco@…>, at 2010-06-03T10:41:03Z

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