source: protocols/msn/msn.c @ c6ca3ee

Last change on this file since c6ca3ee was c6ca3ee, checked in by Wilmer van der Gaast <wilmer@…>, at 2010-03-14T17:49:24Z

Some const/etc cleanups submitted by domen@… back in bug #431.

  • Property mode set to 100644
File size: 10.3 KB
RevLine 
[b7d3cc34]1  /********************************************************************\
2  * BitlBee -- An IRC to other IM-networks gateway                     *
3  *                                                                    *
4  * Copyright 2002-2004 Wilmer van der Gaast and others                *
5  \********************************************************************/
6
7/* MSN module - Main file; functions to be called from BitlBee          */
8
9/*
10  This program is free software; you can redistribute it and/or modify
11  it under the terms of the GNU General Public License as published by
12  the Free Software Foundation; either version 2 of the License, or
13  (at your option) any later version.
14
15  This program is distributed in the hope that it will be useful,
16  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  GNU General Public License for more details.
19
20  You should have received a copy of the GNU General Public License with
21  the Debian GNU/Linux distribution in /usr/share/common-licenses/GPL;
22  if not, write to the Free Software Foundation, Inc., 59 Temple Place,
23  Suite 330, Boston, MA  02111-1307  USA
24*/
25
26#include "nogaim.h"
27#include "msn.h"
28
[c6ca3ee]29int msn_chat_id;
30GSList *msn_connections;
31GSList *msn_switchboards;
32
[911f2eb]33static char *msn_set_display_name( set_t *set, char *value );
34
[0da65d5]35static void msn_init( account_t *acc )
[911f2eb]36{
37        set_t *s;
38       
39        s = set_add( &acc->set, "display_name", NULL, msn_set_display_name, acc );
40        s->flags |= ACC_SET_NOSAVE | ACC_SET_ONLINE_ONLY;
[1febf5c]41
42        s = set_add( &acc->set, "mail_notifications", "false", set_eval_bool, acc );
[911f2eb]43}
44
[0a3c243]45static void msn_login( account_t *acc )
[b7d3cc34]46{
[84b045d]47        struct im_connection *ic = imcb_new( acc );
[b7d3cc34]48        struct msn_data *md = g_new0( struct msn_data, 1 );
49       
[0da65d5]50        ic->proto_data = md;
[b7d3cc34]51        md->fd = -1;
52       
[0a3c243]53        if( strchr( acc->user, '@' ) == NULL )
[b7d3cc34]54        {
[84b045d]55                imcb_error( ic, "Invalid account name" );
[c2fb3809]56                imc_logout( ic, FALSE );
[b7d3cc34]57                return;
58        }
59       
[84b045d]60        imcb_log( ic, "Connecting" );
[2a29eac]61       
[0da65d5]62        md->fd = proxy_connect( "messenger.hotmail.com", 1863, msn_ns_connected, ic );
[b7d3cc34]63        if( md->fd < 0 )
64        {
[84b045d]65                imcb_error( ic, "Could not connect to server" );
[c2fb3809]66                imc_logout( ic, TRUE );
[2a29eac]67                return;
[b7d3cc34]68        }
[2a29eac]69       
[0da65d5]70        md->ic = ic;
[2a29eac]71        md->away_state = msn_away_state_list;
72       
[0da65d5]73        msn_connections = g_slist_append( msn_connections, ic );
[b7d3cc34]74}
75
[0da65d5]76static void msn_logout( struct im_connection *ic )
[b7d3cc34]77{
[0da65d5]78        struct msn_data *md = ic->proto_data;
[b7d3cc34]79        GSList *l;
80       
[5a5c926]81        if( md )
[b7d3cc34]82        {
[5a5c926]83                if( md->fd >= 0 )
84                        closesocket( md->fd );
[b7d3cc34]85               
[5a5c926]86                if( md->handler )
[b7d3cc34]87                {
[5a5c926]88                        if( md->handler->rxq ) g_free( md->handler->rxq );
89                        if( md->handler->cmd_text ) g_free( md->handler->cmd_text );
90                        g_free( md->handler );
91                }
92               
93                while( md->switchboards )
94                        msn_sb_destroy( md->switchboards->data );
[1053836]95               
[46dca11]96                msn_msgq_purge( ic, &md->msgq );
[5a5c926]97               
[bf25fa3]98                while( md->groupcount > 0 )
99                        g_free( md->grouplist[--md->groupcount] );
[59f5c42a]100                g_free( md->grouplist );
101               
[5a5c926]102                g_free( md );
[b7d3cc34]103        }
104       
[0da65d5]105        for( l = ic->permit; l; l = l->next )
[b7d3cc34]106                g_free( l->data );
[0da65d5]107        g_slist_free( ic->permit );
[b7d3cc34]108       
[0da65d5]109        for( l = ic->deny; l; l = l->next )
[b7d3cc34]110                g_free( l->data );
[0da65d5]111        g_slist_free( ic->deny );
[b7d3cc34]112       
[0da65d5]113        msn_connections = g_slist_remove( msn_connections, ic );
[b7d3cc34]114}
115
[f6c963b]116static int msn_buddy_msg( struct im_connection *ic, char *who, char *message, int away )
[b7d3cc34]117{
118        struct msn_switchboard *sb;
[0da65d5]119        struct msn_data *md = ic->proto_data;
[b7d3cc34]120       
[0da65d5]121        if( ( sb = msn_sb_by_handle( ic, who ) ) )
[b7d3cc34]122        {
123                return( msn_sb_sendmessage( sb, message ) );
124        }
125        else
126        {
127                struct msn_message *m;
128                char buf[1024];
129               
130                /* Create a message. We have to arrange a usable switchboard, and send the message later. */
131                m = g_new0( struct msn_message, 1 );
132                m->who = g_strdup( who );
133                m->text = g_strdup( message );
134               
135                /* FIXME: *CHECK* the reliability of using spare sb's! */
[0da65d5]136                if( ( sb = msn_sb_spare( ic ) ) )
[b7d3cc34]137                {
138                        debug( "Trying to use a spare switchboard to message %s", who );
139                       
140                        sb->who = g_strdup( who );
141                        g_snprintf( buf, sizeof( buf ), "CAL %d %s\r\n", ++sb->trId, who );
142                        if( msn_sb_write( sb, buf, strlen( buf ) ) )
143                        {
144                                /* He/She should join the switchboard soon, let's queue the message. */
145                                sb->msgq = g_slist_append( sb->msgq, m );
146                                return( 1 );
147                        }
148                }
149               
150                debug( "Creating a new switchboard to message %s", who );
151               
152                /* If we reach this line, there was no spare switchboard, so let's make one. */
153                g_snprintf( buf, sizeof( buf ), "XFR %d SB\r\n", ++md->trId );
[0da65d5]154                if( !msn_write( ic, buf, strlen( buf ) ) )
[b7d3cc34]155                {
156                        g_free( m->who );
157                        g_free( m->text );
158                        g_free( m );
159                       
160                        return( 0 );
161                }
162               
163                /* And queue the message to md. We'll pick it up when the switchboard comes up. */
164                md->msgq = g_slist_append( md->msgq, m );
165               
166                /* FIXME: If the switchboard creation fails, the message will not be sent. */
167               
168                return( 1 );
169        }
170       
171        return( 0 );
172}
173
[0da65d5]174static GList *msn_away_states( struct im_connection *ic )
[b7d3cc34]175{
[5e202b0]176        static GList *l = NULL;
[b7d3cc34]177        int i;
178       
[5e202b0]179        if( l == NULL )
180                for( i = 0; msn_away_state_list[i].number > -1; i ++ )
181                        l = g_list_append( l, (void*) msn_away_state_list[i].name );
[b7d3cc34]182       
[5e202b0]183        return l;
[b7d3cc34]184}
185
[0da65d5]186static void msn_set_away( struct im_connection *ic, char *state, char *message )
[b7d3cc34]187{
188        char buf[1024];
[0da65d5]189        struct msn_data *md = ic->proto_data;
[08995b0]190        const struct msn_away_state *st;
[b7d3cc34]191       
192        if( strcmp( state, GAIM_AWAY_CUSTOM ) == 0 )
193                st = msn_away_state_by_name( "Away" );
194        else
195                st = msn_away_state_by_name( state );
196       
197        if( !st ) st = msn_away_state_list;
198        md->away_state = st;
199       
200        g_snprintf( buf, sizeof( buf ), "CHG %d %s\r\n", ++md->trId, st->code );
[0da65d5]201        msn_write( ic, buf, strlen( buf ) );
[b7d3cc34]202}
203
[0da65d5]204static void msn_set_my_name( struct im_connection *ic, char *info )
[b7d3cc34]205{
[0da65d5]206        msn_set_display_name( set_find( &ic->acc->set, "display_name" ), info );
[b7d3cc34]207}
208
[0da65d5]209static void msn_get_info(struct im_connection *ic, char *who) 
[b7d3cc34]210{
211        /* Just make an URL and let the user fetch the info */
[84b045d]212        imcb_log( ic, "%s\n%s: %s%s", _("User Info"), _("For now, fetch yourself"), PROFILE_URL, who );
[b7d3cc34]213}
214
[0da65d5]215static void msn_add_buddy( struct im_connection *ic, char *who, char *group )
[b7d3cc34]216{
[0da65d5]217        msn_buddy_list_add( ic, "FL", who, who );
[b7d3cc34]218}
219
[0da65d5]220static void msn_remove_buddy( struct im_connection *ic, char *who, char *group )
[b7d3cc34]221{
[0da65d5]222        msn_buddy_list_remove( ic, "FL", who );
[b7d3cc34]223}
224
[f6c963b]225static void msn_chat_msg( struct groupchat *c, char *message, int flags )
[b7d3cc34]226{
[fa29d093]227        struct msn_switchboard *sb = msn_sb_by_chat( c );
[b7d3cc34]228       
229        if( sb )
[0da65d5]230                msn_sb_sendmessage( sb, message );
231        /* FIXME: Error handling (although this can't happen unless something's
232           already severely broken) disappeared here! */
[b7d3cc34]233}
234
[c058ff9]235static void msn_chat_invite( struct groupchat *c, char *who, char *message )
[b7d3cc34]236{
[fa29d093]237        struct msn_switchboard *sb = msn_sb_by_chat( c );
[b7d3cc34]238        char buf[1024];
239       
240        if( sb )
241        {
242                g_snprintf( buf, sizeof( buf ), "CAL %d %s\r\n", ++sb->trId, who );
243                msn_sb_write( sb, buf, strlen( buf ) );
244        }
245}
246
[0da65d5]247static void msn_chat_leave( struct groupchat *c )
[b7d3cc34]248{
[fa29d093]249        struct msn_switchboard *sb = msn_sb_by_chat( c );
[b7d3cc34]250       
251        if( sb )
252                msn_sb_write( sb, "OUT\r\n", 5 );
253}
254
[0da65d5]255static struct groupchat *msn_chat_with( struct im_connection *ic, char *who )
[b7d3cc34]256{
257        struct msn_switchboard *sb;
[0da65d5]258        struct msn_data *md = ic->proto_data;
[b7d3cc34]259        char buf[1024];
260       
[0da65d5]261        if( ( sb = msn_sb_by_handle( ic, who ) ) )
[b7d3cc34]262        {
263                debug( "Converting existing switchboard to %s to a groupchat", who );
[fa29d093]264                return msn_sb_to_chat( sb );
[b7d3cc34]265        }
266        else
267        {
268                struct msn_message *m;
269               
[0da65d5]270                if( ( sb = msn_sb_spare( ic ) ) )
[b7d3cc34]271                {
272                        debug( "Trying to reuse an existing switchboard as a groupchat with %s", who );
273                        g_snprintf( buf, sizeof( buf ), "CAL %d %s\r\n", ++sb->trId, who );
274                        if( msn_sb_write( sb, buf, strlen( buf ) ) )
[fa29d093]275                                return msn_sb_to_chat( sb );
[b7d3cc34]276                }
277               
278                /* If the stuff above failed for some reason: */
279                debug( "Creating a new switchboard to groupchat with %s", who );
280               
281                /* Request a new switchboard. */
282                g_snprintf( buf, sizeof( buf ), "XFR %d SB\r\n", ++md->trId );
[0da65d5]283                if( !msn_write( ic, buf, strlen( buf ) ) )
[b7d3cc34]284                        return( 0 );
285               
286                /* Create a magic message. This is quite hackish, but who cares? :-P */
287                m = g_new0( struct msn_message, 1 );
288                m->who = g_strdup( who );
289                m->text = g_strdup( GROUPCHAT_SWITCHBOARD_MESSAGE );
290               
291                /* Queue the magic message and cross your fingers. */
292                md->msgq = g_slist_append( md->msgq, m );
293               
[fa29d093]294                /* FIXME: Can I try to return something here already? */
295                return NULL;
[b7d3cc34]296        }
297       
[fa29d093]298        return NULL;
[b7d3cc34]299}
300
[0da65d5]301static void msn_keepalive( struct im_connection *ic )
[b7d3cc34]302{
[0da65d5]303        msn_write( ic, "PNG\r\n", strlen( "PNG\r\n" ) );
[b7d3cc34]304}
305
[0da65d5]306static void msn_add_permit( struct im_connection *ic, char *who )
[b7d3cc34]307{
[0da65d5]308        msn_buddy_list_add( ic, "AL", who, who );
[b7d3cc34]309}
310
[0da65d5]311static void msn_rem_permit( struct im_connection *ic, char *who )
[b7d3cc34]312{
[0da65d5]313        msn_buddy_list_remove( ic, "AL", who );
[b7d3cc34]314}
315
[0da65d5]316static void msn_add_deny( struct im_connection *ic, char *who )
[b7d3cc34]317{
318        struct msn_switchboard *sb;
319       
[0da65d5]320        msn_buddy_list_add( ic, "BL", who, who );
[b7d3cc34]321       
322        /* If there's still a conversation with this person, close it. */
[0da65d5]323        if( ( sb = msn_sb_by_handle( ic, who ) ) )
[b7d3cc34]324        {
325                msn_sb_destroy( sb );
326        }
327}
328
[0da65d5]329static void msn_rem_deny( struct im_connection *ic, char *who )
[b7d3cc34]330{
[0da65d5]331        msn_buddy_list_remove( ic, "BL", who );
[b7d3cc34]332}
333
[0da65d5]334static int msn_send_typing( struct im_connection *ic, char *who, int typing )
[b7d3cc34]335{
[df1fb67]336        if( typing & OPT_TYPING )
[f6c963b]337                return( msn_buddy_msg( ic, who, TYPING_NOTIFICATION_MESSAGE, 0 ) );
[b7d3cc34]338        else
339                return( 1 );
340}
341
[911f2eb]342static char *msn_set_display_name( set_t *set, char *value )
343{
344        account_t *acc = set->data;
[0da65d5]345        struct im_connection *ic = acc->ic;
[911f2eb]346        struct msn_data *md;
[e97827b]347        char buf[1024], *fn;
[911f2eb]348       
349        /* Double-check. */
[0da65d5]350        if( ic == NULL )
[911f2eb]351                return NULL;
352       
[0da65d5]353        md = ic->proto_data;
[911f2eb]354       
355        if( strlen( value ) > 129 )
356        {
[84b045d]357                imcb_log( ic, "Maximum name length exceeded" );
[911f2eb]358                return NULL;
359        }
360       
[e97827b]361        fn = msn_http_encode( value );
[911f2eb]362       
[c2fb3809]363        g_snprintf( buf, sizeof( buf ), "REA %d %s %s\r\n", ++md->trId, ic->acc->user, fn );
[0da65d5]364        msn_write( ic, buf, strlen( buf ) );
[911f2eb]365        g_free( fn );
366       
367        /* Returning NULL would be better, because the server still has to
368           confirm the name change. However, it looks a bit confusing to the
369           user. */
370        return value;
371}
372
[0da65d5]373void msn_initmodule()
[b7d3cc34]374{
[7b23afd]375        struct prpl *ret = g_new0(struct prpl, 1);
[911f2eb]376       
[7b23afd]377        ret->name = "msn";
[b7d3cc34]378        ret->login = msn_login;
[0da65d5]379        ret->init = msn_init;
380        ret->logout = msn_logout;
[f6c963b]381        ret->buddy_msg = msn_buddy_msg;
[b7d3cc34]382        ret->away_states = msn_away_states;
383        ret->set_away = msn_set_away;
384        ret->get_info = msn_get_info;
[0da65d5]385        ret->set_my_name = msn_set_my_name;
[b7d3cc34]386        ret->add_buddy = msn_add_buddy;
387        ret->remove_buddy = msn_remove_buddy;
[f6c963b]388        ret->chat_msg = msn_chat_msg;
[b7d3cc34]389        ret->chat_invite = msn_chat_invite;
390        ret->chat_leave = msn_chat_leave;
[0da65d5]391        ret->chat_with = msn_chat_with;
[b7d3cc34]392        ret->keepalive = msn_keepalive;
393        ret->add_permit = msn_add_permit;
394        ret->rem_permit = msn_rem_permit;
395        ret->add_deny = msn_add_deny;
396        ret->rem_deny = msn_rem_deny;
397        ret->send_typing = msn_send_typing;
[5b52a48]398        ret->handle_cmp = g_strcasecmp;
[b7d3cc34]399
[7b23afd]400        register_protocol(ret);
[b7d3cc34]401}
Note: See TracBrowser for help on using the repository browser.