source: protocols/yahoo/yahoo.c @ 84b045d

Last change on this file since 84b045d was 84b045d, checked in by Wilmer van der Gaast <wilmer@…>, at 2007-04-16T01:03:08Z

s/imc/imcb/ for callback functions. Moved things aroundin nogaim.h a
little bit, grouping things by category instead of original Gaim 0.58
filename.

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