source: protocols/msn/soap.c @ 8d96b78

Last change on this file since 8d96b78 was 9f958f7, checked in by Wilmer van der Gaast <wilmer@…>, at 2011-12-19T18:09:11Z

Pass the SSL errors through another layer of indirection (Passport SOAP code).
  • Property mode set to 100644
File size: 32.2 KB
Line 
1  /********************************************************************\
2  * BitlBee -- An IRC to other IM-networks gateway                     *
3  *                                                                    *
4  * Copyright 2002-2010 Wilmer van der Gaast and others                *
5  \********************************************************************/
6
7/* MSN module - All the SOAPy XML stuff.
8   Some manager at Microsoft apparently thought MSNP wasn't XMLy enough so
9   someone stepped up and changed that. This is the result. Kilobytes and
10   more kilobytes of XML vomit to transfer tiny bits of informaiton. */
11
12/*
13  This program is free software; you can redistribute it and/or modify
14  it under the terms of the GNU General Public License as published by
15  the Free Software Foundation; either version 2 of the License, or
16  (at your option) any later version.
17
18  This program is distributed in the hope that it will be useful,
19  but WITHOUT ANY WARRANTY; without even the implied warranty of
20  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  GNU General Public License for more details.
22
23  You should have received a copy of the GNU General Public License with
24  the Debian GNU/Linux distribution in /usr/share/common-licenses/GPL;
25  if not, write to the Free Software Foundation, Inc., 59 Temple Place,
26  Suite 330, Boston, MA  02111-1307  USA
27*/
28
29#include "http_client.h"
30#include "soap.h"
31#include "msn.h"
32#include "bitlbee.h"
33#include "url.h"
34#include "misc.h"
35#include "sha1.h"
36#include "base64.h"
37#include "xmltree.h"
38#include <ctype.h>
39#include <errno.h>
40
41/* This file tries to make SOAP stuff pretty simple to do by letting you just
42   provide a function to build a request, a few functions to parse various
43   parts of the response, and a function to run when the full response was
44   received and parsed. See the various examples below. */
45
46typedef enum
47{
48        MSN_SOAP_OK,
49        MSN_SOAP_RETRY,
50        MSN_SOAP_REAUTH,
51        MSN_SOAP_ABORT,
52} msn_soap_result_t;
53
54struct msn_soap_req_data;
55typedef int (*msn_soap_func) ( struct msn_soap_req_data * );
56
57struct msn_soap_req_data
58{
59        void *data;
60        struct im_connection *ic;
61        int ttl;
62        char *error;
63       
64        char *url, *action, *payload;
65        struct http_request *http_req;
66       
67        const struct xt_handler_entry *xml_parser;
68        msn_soap_func build_request, handle_response, free_data;
69};
70
71static int msn_soap_send_request( struct msn_soap_req_data *req );
72static void msn_soap_free( struct msn_soap_req_data *soap_req );
73static void msn_soap_debug_print( const char *headers, const char *payload );
74
75static int msn_soap_start( struct im_connection *ic,
76                    void *data,
77                    msn_soap_func build_request,
78                    const struct xt_handler_entry *xml_parser,
79                    msn_soap_func handle_response,
80                    msn_soap_func free_data )
81{
82        struct msn_soap_req_data *req = g_new0( struct msn_soap_req_data, 1 );
83       
84        req->ic = ic;
85        req->data = data;
86        req->xml_parser = xml_parser;
87        req->build_request = build_request;
88        req->handle_response = handle_response;
89        req->free_data = free_data;
90        req->ttl = 3;
91       
92        return msn_soap_send_request( req );
93}
94
95static void msn_soap_handle_response( struct http_request *http_req );
96
97static int msn_soap_send_request( struct msn_soap_req_data *soap_req )
98{
99        char *http_req;
100        char *soap_action = NULL;
101        url_t url;
102       
103        soap_req->build_request( soap_req );
104       
105        if( soap_req->action )
106                soap_action = g_strdup_printf( "SOAPAction: \"%s\"\r\n", soap_req->action );
107       
108        url_set( &url, soap_req->url );
109        http_req = g_strdup_printf( SOAP_HTTP_REQUEST, url.file, url.host,
110                soap_action ? soap_action : "",
111                strlen( soap_req->payload ), soap_req->payload );
112       
113        msn_soap_debug_print( http_req, soap_req->payload );
114       
115        soap_req->http_req = http_dorequest( url.host, url.port, url.proto == PROTO_HTTPS,
116                http_req, msn_soap_handle_response, soap_req );
117       
118        g_free( http_req );
119        g_free( soap_action );
120       
121        return soap_req->http_req != NULL;
122}
123
124static void msn_soap_handle_response( struct http_request *http_req )
125{
126        struct msn_soap_req_data *soap_req = http_req->data;
127        int st;
128       
129        if( g_slist_find( msn_connections, soap_req->ic ) == NULL )
130        {
131                msn_soap_free( soap_req );
132                return;
133        }
134       
135        msn_soap_debug_print( http_req->reply_headers, http_req->reply_body );
136       
137        if( http_req->body_size > 0 )
138        {
139                struct xt_parser *parser;
140                struct xt_node *err;
141               
142                parser = xt_new( soap_req->xml_parser, soap_req );
143                xt_feed( parser, http_req->reply_body, http_req->body_size );
144                if( http_req->status_code == 500 &&
145                    ( err = xt_find_path( parser->root, "soap:Body/soap:Fault/detail/errorcode" ) ) &&
146                    err->text_len > 0 )
147                {
148                        if( strcmp( err->text, "PassportAuthFail" ) == 0 )
149                        {
150                                xt_free( parser );
151                                st = MSN_SOAP_REAUTH;
152                                goto fail;
153                        }
154                        /* TODO: Handle/report other errors. */
155                }
156               
157                xt_handle( parser, NULL, -1 );
158                xt_free( parser );
159        }
160       
161        if( http_req->status_code != 200 )
162                soap_req->error = g_strdup( http_req->status_string );
163       
164        st = soap_req->handle_response( soap_req );
165
166fail:   
167        g_free( soap_req->url );
168        g_free( soap_req->action );
169        g_free( soap_req->payload );
170        g_free( soap_req->error );
171        soap_req->url = soap_req->action = soap_req->payload = soap_req->error = NULL;
172       
173        if( st == MSN_SOAP_RETRY && --soap_req->ttl )
174        {
175                msn_soap_send_request( soap_req );
176        }
177        else if( st == MSN_SOAP_REAUTH )
178        {
179                struct msn_data *md = soap_req->ic->proto_data;
180               
181                if( !( md->flags & MSN_REAUTHING ) )
182                {
183                        /* Nonce shouldn't actually be touched for re-auths. */
184                        msn_soap_passport_sso_request( soap_req->ic, "blaataap" );
185                        md->flags |= MSN_REAUTHING; 
186                }
187                md->soapq = g_slist_append( md->soapq, soap_req );
188        }
189        else
190        {
191                soap_req->free_data( soap_req );
192                g_free( soap_req );
193        }
194}
195
196static char *msn_soap_abservice_build( const char *body_fmt, const char *scenario, const char *ticket, ... )
197{
198        va_list params;
199        char *ret, *format, *body;
200       
201        format = g_markup_printf_escaped( SOAP_ABSERVICE_PAYLOAD, scenario, ticket );
202       
203        va_start( params, ticket );
204        body = g_strdup_vprintf( body_fmt, params );
205        va_end( params );
206       
207        ret = g_strdup_printf( format, body );
208        g_free( body );
209        g_free( format );
210       
211        return ret;
212}
213
214static void msn_soap_debug_print( const char *headers, const char *payload )
215{
216        char *s;
217       
218        if( !getenv( "BITLBEE_DEBUG" ) )
219                return;
220       
221        if( headers )
222        {
223                if( ( s = strstr( headers, "\r\n\r\n" ) ) )
224                        write( 2, headers, s - headers + 4 );
225                else
226                        write( 2, headers, strlen( headers ) );
227        }
228       
229        if( payload )
230        {
231                struct xt_node *xt = xt_from_string( payload );
232                if( xt )
233                        xt_print( xt );
234                xt_free_node( xt );
235        }
236}
237
238int msn_soapq_flush( struct im_connection *ic, gboolean resend )
239{
240        struct msn_data *md = ic->proto_data;
241       
242        while( md->soapq )
243        {
244                if( resend )
245                        msn_soap_send_request( (struct msn_soap_req_data*) md->soapq->data );
246                else
247                        msn_soap_free( (struct msn_soap_req_data*) md->soapq->data );
248                md->soapq = g_slist_remove( md->soapq, md->soapq->data );
249        }
250       
251        return MSN_SOAP_OK;
252}
253
254static void msn_soap_free( struct msn_soap_req_data *soap_req )
255{
256        soap_req->free_data( soap_req );
257        g_free( soap_req->url );
258        g_free( soap_req->action );
259        g_free( soap_req->payload );
260        g_free( soap_req->error );
261        g_free( soap_req );
262}
263
264
265/* passport_sso: Authentication MSNP15+ */
266
267struct msn_soap_passport_sso_data
268{
269        char *nonce;
270        char *secret;
271        char *error;
272        char *redirect;
273};
274
275static int msn_soap_passport_sso_build_request( struct msn_soap_req_data *soap_req )
276{
277        struct msn_soap_passport_sso_data *sd = soap_req->data;
278        struct im_connection *ic = soap_req->ic;
279        struct msn_data *md = ic->proto_data;
280        char pass[MAX_PASSPORT_PWLEN+1];
281       
282        if( sd->redirect )
283        {
284                soap_req->url = sd->redirect;
285                sd->redirect = NULL;
286        }
287        /* MS changed this URL and broke the old MSN-specific one. The generic
288           one works, forwarding us to a msn.com URL that works. Takes an extra
289           second, but that's better than not being able to log in at all. :-/
290        else if( g_str_has_suffix( ic->acc->user, "@msn.com" ) )
291                soap_req->url = g_strdup( SOAP_PASSPORT_SSO_URL_MSN );
292        */
293        else
294                soap_req->url = g_strdup( SOAP_PASSPORT_SSO_URL );
295       
296        strncpy( pass, ic->acc->pass, MAX_PASSPORT_PWLEN );
297        pass[MAX_PASSPORT_PWLEN] = '\0';
298        soap_req->payload = g_markup_printf_escaped( SOAP_PASSPORT_SSO_PAYLOAD,
299                ic->acc->user, pass, md->pp_policy );
300       
301        return MSN_SOAP_OK;
302}
303
304static xt_status msn_soap_passport_sso_token( struct xt_node *node, gpointer data )
305{
306        struct msn_soap_req_data *soap_req = data;
307        struct msn_soap_passport_sso_data *sd = soap_req->data;
308        struct msn_data *md = soap_req->ic->proto_data;
309        struct xt_node *p;
310        char *id;
311       
312        if( ( id = xt_find_attr( node, "Id" ) ) == NULL )
313                return XT_HANDLED;
314        id += strlen( id ) - 1;
315        if( *id == '1' &&
316            ( p = xt_find_path( node, "../../wst:RequestedProofToken/wst:BinarySecret" ) ) &&
317            p->text )
318                sd->secret = g_strdup( p->text );
319       
320        *id -= '1';
321        if( *id >= 0 && *id < sizeof( md->tokens ) / sizeof( md->tokens[0] ) )
322        {
323                g_free( md->tokens[(int)*id] );
324                md->tokens[(int)*id] = g_strdup( node->text );
325        }
326       
327        return XT_HANDLED;
328}
329
330static xt_status msn_soap_passport_failure( struct xt_node *node, gpointer data )
331{
332        struct msn_soap_req_data *soap_req = data;
333        struct msn_soap_passport_sso_data *sd = soap_req->data;
334        struct xt_node *code = xt_find_node( node->children, "faultcode" );
335        struct xt_node *string = xt_find_node( node->children, "faultstring" );
336        struct xt_node *url;
337       
338        if( code == NULL || code->text_len == 0 )
339                sd->error = g_strdup( "Unknown error" );
340        else if( strcmp( code->text, "psf:Redirect" ) == 0 &&
341                 ( url = xt_find_node( node->children, "psf:redirectUrl" ) ) &&
342                 url->text_len > 0 )
343                sd->redirect = g_strdup( url->text );
344        else
345                sd->error = g_strdup_printf( "%s (%s)", code->text, string && string->text_len ?
346                                             string->text : "no description available" );
347       
348        return XT_HANDLED;
349}
350
351static const struct xt_handler_entry msn_soap_passport_sso_parser[] = {
352        { "wsse:BinarySecurityToken", "wst:RequestedSecurityToken", msn_soap_passport_sso_token },
353        { "S:Fault", "S:Envelope", msn_soap_passport_failure },
354        { NULL, NULL, NULL }
355};
356
357static char *msn_key_fuckery( char *key, int key_len, char *type )
358{
359        unsigned char hash1[20+strlen(type)+1];
360        unsigned char hash2[20];
361        char *ret;
362       
363        sha1_hmac( key, key_len, type, 0, hash1 );
364        strcpy( (char*) hash1 + 20, type );
365        sha1_hmac( key, key_len, (char*) hash1, sizeof( hash1 ) - 1, hash2 );
366       
367        /* This is okay as hash1 is read completely before it's overwritten. */
368        sha1_hmac( key, key_len, (char*) hash1, 20, hash1 );
369        sha1_hmac( key, key_len, (char*) hash1, sizeof( hash1 ) - 1, hash1 );
370       
371        ret = g_malloc( 24 );
372        memcpy( ret, hash2, 20 );
373        memcpy( ret + 20, hash1, 4 );
374        return ret;
375}
376
377static int msn_soap_passport_sso_handle_response( struct msn_soap_req_data *soap_req )
378{
379        struct msn_soap_passport_sso_data *sd = soap_req->data;
380        struct im_connection *ic = soap_req->ic;
381        struct msn_data *md = ic->proto_data;
382        char *key1, *key2, *key3, *blurb64;
383        int key1_len;
384        unsigned char *padnonce, *des3res;
385        struct
386        {
387                unsigned int uStructHeaderSize; // 28. Does not count data
388                unsigned int uCryptMode; // CRYPT_MODE_CBC (1)
389                unsigned int uCipherType; // TripleDES (0x6603)
390                unsigned int uHashType; // SHA1 (0x8004)
391                unsigned int uIVLen;    // 8
392                unsigned int uHashLen;  // 20
393                unsigned int uCipherLen; // 72
394                unsigned char iv[8];
395                unsigned char hash[20];
396                unsigned char cipherbytes[72];
397        } blurb = {
398                GUINT32_TO_LE( 28 ),
399                GUINT32_TO_LE( 1 ),
400                GUINT32_TO_LE( 0x6603 ),
401                GUINT32_TO_LE( 0x8004 ),
402                GUINT32_TO_LE( 8 ),
403                GUINT32_TO_LE( 20 ),
404                GUINT32_TO_LE( 72 ),
405        };
406       
407        if( sd->redirect )
408                return MSN_SOAP_RETRY;
409       
410        if( md->soapq )
411        {
412                md->flags &= ~MSN_REAUTHING; 
413                return msn_soapq_flush( ic, TRUE );
414        }
415       
416        if( sd->secret == NULL )
417        {
418                msn_auth_got_passport_token( ic, NULL, sd->error ? sd->error : soap_req->error );
419                return MSN_SOAP_OK;
420        }
421
422        key1_len = base64_decode( sd->secret, (unsigned char**) &key1 );
423       
424        key2 = msn_key_fuckery( key1, key1_len, "WS-SecureConversationSESSION KEY HASH" );
425        key3 = msn_key_fuckery( key1, key1_len, "WS-SecureConversationSESSION KEY ENCRYPTION" );
426       
427        sha1_hmac( key2, 24, sd->nonce, 0, blurb.hash );
428        padnonce = g_malloc( strlen( sd->nonce ) + 8 );
429        strcpy( (char*) padnonce, sd->nonce );
430        memset( padnonce + strlen( sd->nonce ), 8, 8 );
431       
432        random_bytes( blurb.iv, 8 );
433       
434        ssl_des3_encrypt( (unsigned char*) key3, 24, padnonce, strlen( sd->nonce ) + 8, blurb.iv, &des3res );
435        memcpy( blurb.cipherbytes, des3res, 72 );
436       
437        blurb64 = base64_encode( (unsigned char*) &blurb, sizeof( blurb ) );
438        msn_auth_got_passport_token( ic, blurb64, NULL );
439       
440        g_free( padnonce );
441        g_free( blurb64 );
442        g_free( des3res );
443        g_free( key1 );
444        g_free( key2 );
445        g_free( key3 );
446       
447        return MSN_SOAP_OK;
448}
449
450static int msn_soap_passport_sso_free_data( struct msn_soap_req_data *soap_req )
451{
452        struct msn_soap_passport_sso_data *sd = soap_req->data;
453       
454        g_free( sd->nonce );
455        g_free( sd->secret );
456        g_free( sd->error );
457        g_free( sd->redirect );
458        g_free( sd );
459       
460        return MSN_SOAP_OK;
461}
462
463int msn_soap_passport_sso_request( struct im_connection *ic, const char *nonce )
464{
465        struct msn_soap_passport_sso_data *sd = g_new0( struct msn_soap_passport_sso_data, 1 );
466       
467        sd->nonce = g_strdup( nonce );
468       
469        return msn_soap_start( ic, sd, msn_soap_passport_sso_build_request,
470                                       msn_soap_passport_sso_parser,
471                                       msn_soap_passport_sso_handle_response,
472                                       msn_soap_passport_sso_free_data );
473}
474
475
476/* oim_send: Sending offline messages */
477
478struct msn_soap_oim_send_data
479{
480        char *to;
481        char *msg;
482        int number;
483        msn_soap_result_t need_retry;
484};
485
486static int msn_soap_oim_build_request( struct msn_soap_req_data *soap_req )
487{
488        struct msn_soap_oim_send_data *oim = soap_req->data;
489        struct im_connection *ic = soap_req->ic;
490        struct msn_data *md = ic->proto_data;
491        char *display_name_b64;
492       
493        display_name_b64 = tobase64( set_getstr( &ic->acc->set, "display_name" ) );
494       
495        soap_req->url = g_strdup( SOAP_OIM_SEND_URL );
496        soap_req->action = g_strdup( SOAP_OIM_SEND_ACTION );
497        soap_req->payload = g_markup_printf_escaped( SOAP_OIM_SEND_PAYLOAD,
498                ic->acc->user, display_name_b64, MSNP_VER, MSNP_BUILD,
499                oim->to, md->tokens[2],
500                MSNP11_PROD_ID, md->lock_key ? md->lock_key : "",
501                oim->number, oim->number, oim->msg );
502       
503        g_free( display_name_b64 );
504        oim->need_retry = MSN_SOAP_OK;
505       
506        return MSN_SOAP_OK;
507}
508
509static xt_status msn_soap_oim_reauth( struct xt_node *node, gpointer data )
510{
511        struct msn_soap_req_data *soap_req = data;
512        struct msn_soap_oim_send_data *oim = soap_req->data;
513        struct im_connection *ic = soap_req->ic;
514        struct msn_data *md = ic->proto_data;
515        struct xt_node *c;
516       
517        if( ( c = xt_find_node( node->children, "LockKeyChallenge" ) ) && c->text_len > 0 )
518        {
519                g_free( md->lock_key );
520                md->lock_key = msn_p11_challenge( c->text );
521                oim->need_retry = MSN_SOAP_RETRY;
522        }
523        if( xt_find_node( node->children, "RequiredAuthPolicy" ) )
524        {
525                oim->need_retry = MSN_SOAP_REAUTH;
526        }
527       
528        return XT_HANDLED;
529}
530
531static const struct xt_handler_entry msn_soap_oim_send_parser[] = {
532        { "detail", "soap:Fault", msn_soap_oim_reauth },
533        { NULL,     NULL,         NULL                }
534};
535
536static int msn_soap_oim_handle_response( struct msn_soap_req_data *soap_req )
537{
538        struct msn_soap_oim_send_data *oim = soap_req->data;
539       
540        if( soap_req->http_req->status_code == 500 && oim->need_retry && soap_req->ttl > 0 )
541        {
542                return oim->need_retry;
543        }
544        else if( soap_req->http_req->status_code == 200 )
545        {
546                /* Noise..
547                imcb_log( soap_req->ic, "Offline message successfully delivered to %s", oim->to );
548                */
549                return MSN_SOAP_OK;
550        }
551        else
552        {
553                char *dec = frombase64( oim->msg );
554                imcb_log( soap_req->ic, "Failed to deliver offline message to %s:\n%s", oim->to, dec );
555                g_free( dec );
556                return MSN_SOAP_ABORT;
557        }
558}
559
560static int msn_soap_oim_free_data( struct msn_soap_req_data *soap_req )
561{
562        struct msn_soap_oim_send_data *oim = soap_req->data;
563       
564        g_free( oim->to );
565        g_free( oim->msg );
566        g_free( oim );
567       
568        return MSN_SOAP_OK;
569}
570
571int msn_soap_oim_send( struct im_connection *ic, const char *to, const char *msg )
572{
573        struct msn_soap_oim_send_data *data;
574       
575        /* Don't send any of the special messages since they creep people out. :-) */
576        if( strncmp( msg, "\r\r", 2 ) == 0 )
577                return 0;
578       
579        data = g_new0( struct msn_soap_oim_send_data, 1 );
580        data->to = g_strdup( to );
581        data->msg = tobase64( msg );
582        data->number = 1;
583       
584        return msn_soap_start( ic, data, msn_soap_oim_build_request,
585                                         msn_soap_oim_send_parser,
586                                         msn_soap_oim_handle_response,
587                                         msn_soap_oim_free_data );
588}
589
590int msn_soap_oim_send_queue( struct im_connection *ic, GSList **msgq )
591{
592        GSList *l;
593        char *n = NULL;
594       
595        for( l = *msgq; l; l = l->next )
596        {
597                struct msn_message *m = l->data;
598               
599                if( n == NULL )
600                        n = m->who;
601                if( strcmp( n, m->who ) == 0 )
602                        msn_soap_oim_send( ic, m->who, m->text );
603        }
604       
605        while( *msgq != NULL )
606        {
607                struct msn_message *m = (*msgq)->data;
608               
609                g_free( m->who );
610                g_free( m->text );
611                g_free( m );
612               
613                *msgq = g_slist_remove( *msgq, m );
614        }
615       
616        return 1;
617}
618
619
620/* memlist: Fetching the membership list (NOT address book) */
621
622static int msn_soap_memlist_build_request( struct msn_soap_req_data *soap_req )
623{
624        struct msn_data *md = soap_req->ic->proto_data;
625       
626        soap_req->url = g_strdup( SOAP_MEMLIST_URL );
627        soap_req->action = g_strdup( SOAP_MEMLIST_ACTION );
628        soap_req->payload = msn_soap_abservice_build( SOAP_MEMLIST_PAYLOAD, "Initial", md->tokens[1] );
629       
630        return 1;
631}
632
633static xt_status msn_soap_memlist_member( struct xt_node *node, gpointer data )
634{
635        bee_user_t *bu;
636        struct msn_buddy_data *bd;
637        struct xt_node *p;
638        char *role = NULL, *handle = NULL;
639        struct msn_soap_req_data *soap_req = data;
640        struct im_connection *ic = soap_req->ic;
641       
642        if( ( p = xt_find_path( node, "../../MemberRole" ) ) )
643                role = p->text;
644       
645        if( ( p = xt_find_node( node->children, "PassportName" ) ) )
646                handle = p->text;
647       
648        if( !role || !handle || 
649            !( ( bu = bee_user_by_handle( ic->bee, ic, handle ) ) ||
650               ( bu = bee_user_new( ic->bee, ic, handle, 0 ) ) ) )
651                return XT_HANDLED;
652       
653        bd = bu->data;
654        if( strcmp( role, "Allow" ) == 0 )
655        {
656                bd->flags |= MSN_BUDDY_AL;
657                ic->permit = g_slist_prepend( ic->permit, g_strdup( handle ) );
658        }
659        else if( strcmp( role, "Block" ) == 0 )
660        {
661                bd->flags |= MSN_BUDDY_BL;
662                ic->deny = g_slist_prepend( ic->deny, g_strdup( handle ) );
663        }
664        else if( strcmp( role, "Reverse" ) == 0 )
665                bd->flags |= MSN_BUDDY_RL;
666        else if( strcmp( role, "Pending" ) == 0 )
667                bd->flags |= MSN_BUDDY_PL;
668       
669        if( getenv( "BITLBEE_DEBUG" ) )
670                fprintf( stderr, "%p %s %d\n", bu, handle, bd->flags );
671       
672        return XT_HANDLED;
673}
674
675static const struct xt_handler_entry msn_soap_memlist_parser[] = {
676        { "Member", "Members", msn_soap_memlist_member },
677        { NULL,               NULL,     NULL                        }
678};
679
680static int msn_soap_memlist_handle_response( struct msn_soap_req_data *soap_req )
681{
682        msn_soap_addressbook_request( soap_req->ic );
683       
684        return MSN_SOAP_OK;
685}
686
687static int msn_soap_memlist_free_data( struct msn_soap_req_data *soap_req )
688{
689        return 0;
690}
691
692int msn_soap_memlist_request( struct im_connection *ic )
693{
694        return msn_soap_start( ic, NULL, msn_soap_memlist_build_request,
695                                         msn_soap_memlist_parser,
696                                         msn_soap_memlist_handle_response,
697                                         msn_soap_memlist_free_data );
698}
699
700/* Variant: Adding/Removing people */
701struct msn_soap_memlist_edit_data
702{
703        char *handle;
704        gboolean add;
705        msn_buddy_flags_t list;
706};
707
708static int msn_soap_memlist_edit_build_request( struct msn_soap_req_data *soap_req )
709{
710        struct msn_data *md = soap_req->ic->proto_data;
711        struct msn_soap_memlist_edit_data *med = soap_req->data;
712        char *add, *scenario, *list;
713       
714        soap_req->url = g_strdup( SOAP_MEMLIST_URL );
715        if( med->add )
716        {
717                soap_req->action = g_strdup( SOAP_MEMLIST_ADD_ACTION );
718                add = "Add";
719        }
720        else
721        {
722                soap_req->action = g_strdup( SOAP_MEMLIST_DEL_ACTION );
723                add = "Delete";
724        }
725        switch( med->list )
726        {
727        case MSN_BUDDY_AL:
728                scenario = "BlockUnblock";
729                list = "Allow";
730                break;
731        case MSN_BUDDY_BL:
732                scenario = "BlockUnblock";
733                list = "Block";
734                break;
735        case MSN_BUDDY_RL:
736                scenario = "Timer";
737                list = "Reverse";
738                break;
739        case MSN_BUDDY_PL:
740        default:
741                scenario = "Timer";
742                list = "Pending";
743                break;
744        }
745        soap_req->payload = msn_soap_abservice_build( SOAP_MEMLIST_EDIT_PAYLOAD,
746                scenario, md->tokens[1], add, list, med->handle, add );
747       
748        return 1;
749}
750
751static int msn_soap_memlist_edit_handle_response( struct msn_soap_req_data *soap_req )
752{
753        return MSN_SOAP_OK;
754}
755
756static int msn_soap_memlist_edit_free_data( struct msn_soap_req_data *soap_req )
757{
758        struct msn_soap_memlist_edit_data *med = soap_req->data;
759       
760        g_free( med->handle );
761        g_free( med );
762       
763        return 0;
764}
765
766int msn_soap_memlist_edit( struct im_connection *ic, const char *handle, gboolean add, int list )
767{
768        struct msn_soap_memlist_edit_data *med;
769       
770        med = g_new0( struct msn_soap_memlist_edit_data, 1 );
771        med->handle = g_strdup( handle );
772        med->add = add;
773        med->list = list;
774       
775        return msn_soap_start( ic, med, msn_soap_memlist_edit_build_request,
776                                        NULL,
777                                        msn_soap_memlist_edit_handle_response,
778                                        msn_soap_memlist_edit_free_data );
779}
780
781
782/* addressbook: Fetching the membership list (NOT address book) */
783
784static int msn_soap_addressbook_build_request( struct msn_soap_req_data *soap_req )
785{
786        struct msn_data *md = soap_req->ic->proto_data;
787       
788        soap_req->url = g_strdup( SOAP_ADDRESSBOOK_URL );
789        soap_req->action = g_strdup( SOAP_ADDRESSBOOK_ACTION );
790        soap_req->payload = msn_soap_abservice_build( SOAP_ADDRESSBOOK_PAYLOAD, "Initial", md->tokens[1] );
791       
792        return 1;
793}
794
795static xt_status msn_soap_addressbook_group( struct xt_node *node, gpointer data )
796{
797        struct xt_node *p;
798        char *id = NULL, *name = NULL;
799        struct msn_soap_req_data *soap_req = data;
800        struct msn_data *md = soap_req->ic->proto_data;
801       
802        if( ( p = xt_find_path( node, "../groupId" ) ) )
803                id = p->text;
804       
805        if( ( p = xt_find_node( node->children, "name" ) ) )
806                name = p->text;
807       
808        if( id && name )
809        {
810                struct msn_group *mg = g_new0( struct msn_group, 1 );
811                mg->id = g_strdup( id );
812                mg->name = g_strdup( name );
813                md->groups = g_slist_prepend( md->groups, mg );
814        }
815       
816        if( getenv( "BITLBEE_DEBUG" ) )
817                fprintf( stderr, "%s %s\n", id, name );
818       
819        return XT_HANDLED;
820}
821
822static xt_status msn_soap_addressbook_contact( struct xt_node *node, gpointer data )
823{
824        bee_user_t *bu;
825        struct msn_buddy_data *bd;
826        struct xt_node *p;
827        char *id = NULL, *type = NULL, *handle = NULL, *is_msgr = "false",
828             *display_name = NULL, *group_id = NULL;
829        struct msn_soap_req_data *soap_req = data;
830        struct im_connection *ic = soap_req->ic;
831        struct msn_group *group;
832       
833        if( ( p = xt_find_path( node, "../contactId" ) ) )
834                id = p->text;
835        if( ( p = xt_find_node( node->children, "contactType" ) ) )
836                type = p->text;
837        if( ( p = xt_find_node( node->children, "passportName" ) ) )
838                handle = p->text;
839        if( ( p = xt_find_node( node->children, "displayName" ) ) )
840                display_name = p->text;
841        if( ( p = xt_find_node( node->children, "isMessengerUser" ) ) )
842                is_msgr = p->text;
843        if( ( p = xt_find_path( node, "groupIds/guid" ) ) )
844                group_id = p->text;
845       
846        if( type && g_strcasecmp( type, "me" ) == 0 )
847        {
848                set_t *set = set_find( &ic->acc->set, "display_name" );
849                g_free( set->value );
850                set->value = g_strdup( display_name );
851               
852                /* Try to fetch the profile; if the user has one, that's where
853                   we can find the persistent display_name. */
854                if( ( p = xt_find_node( node->children, "CID" ) ) && p->text )
855                        msn_soap_profile_get( ic, p->text );
856               
857                return XT_HANDLED;
858        }
859       
860        if( !bool2int( is_msgr ) || handle == NULL )
861                return XT_HANDLED;
862       
863        if( !( bu = bee_user_by_handle( ic->bee, ic, handle ) ) &&
864            !( bu = bee_user_new( ic->bee, ic, handle, 0 ) ) )
865                return XT_HANDLED;
866       
867        bd = bu->data;
868        bd->flags |= MSN_BUDDY_FL;
869        g_free( bd->cid );
870        bd->cid = g_strdup( id );
871       
872        imcb_rename_buddy( ic, handle, display_name );
873       
874        if( group_id && ( group = msn_group_by_id( ic, group_id ) ) )
875                imcb_add_buddy( ic, handle, group->name );
876       
877        if( getenv( "BITLBEE_DEBUG" ) )
878                fprintf( stderr, "%s %s %s %s\n", id, type, handle, display_name );
879       
880        return XT_HANDLED;
881}
882
883static const struct xt_handler_entry msn_soap_addressbook_parser[] = {
884        { "contactInfo", "Contact", msn_soap_addressbook_contact },
885        { "groupInfo", "Group", msn_soap_addressbook_group },
886        { NULL,               NULL,     NULL                        }
887};
888
889static int msn_soap_addressbook_handle_response( struct msn_soap_req_data *soap_req )
890{
891        GSList *l;
892        int wtf = 0;
893       
894        for( l = soap_req->ic->bee->users; l; l = l->next )
895        {
896                struct bee_user *bu = l->data;
897                struct msn_buddy_data *bd = bu->data;
898               
899                if( bu->ic == soap_req->ic && bd )
900                {
901                        msn_buddy_ask( bu );
902                       
903                        if( ( bd->flags & ( MSN_BUDDY_AL | MSN_BUDDY_BL ) ) ==
904                                          ( MSN_BUDDY_AL | MSN_BUDDY_BL ) )
905                        {
906                                bd->flags &= ~MSN_BUDDY_BL;
907                                wtf++;
908                        }
909                }
910        }
911       
912        if( wtf )
913                imcb_log( soap_req->ic, "Warning: %d contacts were in both your "
914                          "block and your allow list. Assuming they're all "
915                          "allowed. Use the official WLM client once to fix "
916                          "this.", wtf );
917       
918        msn_auth_got_contact_list( soap_req->ic );
919       
920        return MSN_SOAP_OK;
921}
922
923static int msn_soap_addressbook_free_data( struct msn_soap_req_data *soap_req )
924{
925        return 0;
926}
927
928int msn_soap_addressbook_request( struct im_connection *ic )
929{
930        return msn_soap_start( ic, NULL, msn_soap_addressbook_build_request,
931                                         msn_soap_addressbook_parser,
932                                         msn_soap_addressbook_handle_response,
933                                         msn_soap_addressbook_free_data );
934}
935
936/* Variant: Change our display name. */
937static int msn_soap_ab_namechange_build_request( struct msn_soap_req_data *soap_req )
938{
939        struct msn_data *md = soap_req->ic->proto_data;
940       
941        soap_req->url = g_strdup( SOAP_ADDRESSBOOK_URL );
942        soap_req->action = g_strdup( SOAP_AB_NAMECHANGE_ACTION );
943        soap_req->payload = msn_soap_abservice_build( SOAP_AB_NAMECHANGE_PAYLOAD,
944                "Timer", md->tokens[1], (char *) soap_req->data );
945       
946        return 1;
947}
948
949static int msn_soap_ab_namechange_handle_response( struct msn_soap_req_data *soap_req )
950{
951        /* TODO: Ack the change? Not sure what the NAKs look like.. */
952        return MSN_SOAP_OK;
953}
954
955static int msn_soap_ab_namechange_free_data( struct msn_soap_req_data *soap_req )
956{
957        g_free( soap_req->data );
958        return 0;
959}
960
961int msn_soap_addressbook_set_display_name( struct im_connection *ic, const char *new )
962{
963        return msn_soap_start( ic, g_strdup( new ),
964                               msn_soap_ab_namechange_build_request,
965                               NULL,
966                               msn_soap_ab_namechange_handle_response,
967                               msn_soap_ab_namechange_free_data );
968}
969
970/* Add a contact. */
971static int msn_soap_ab_contact_add_build_request( struct msn_soap_req_data *soap_req )
972{
973        struct msn_data *md = soap_req->ic->proto_data;
974        bee_user_t *bu = soap_req->data;
975       
976        soap_req->url = g_strdup( SOAP_ADDRESSBOOK_URL );
977        soap_req->action = g_strdup( SOAP_AB_CONTACT_ADD_ACTION );
978        soap_req->payload = msn_soap_abservice_build( SOAP_AB_CONTACT_ADD_PAYLOAD,
979                "ContactSave", md->tokens[1], bu->handle, bu->fullname ? bu->fullname : bu->handle );
980       
981        return 1;
982}
983
984static xt_status msn_soap_ab_contact_add_cid( struct xt_node *node, gpointer data )
985{
986        struct msn_soap_req_data *soap_req = data;
987        bee_user_t *bu = soap_req->data;
988        struct msn_buddy_data *bd = bu->data;
989       
990        g_free( bd->cid );
991        bd->cid = g_strdup( node->text );
992       
993        return XT_HANDLED;
994}
995
996static const struct xt_handler_entry msn_soap_ab_contact_add_parser[] = {
997        { "guid", "ABContactAddResult", msn_soap_ab_contact_add_cid },
998        { NULL,               NULL,     NULL                        }
999};
1000
1001static int msn_soap_ab_contact_add_handle_response( struct msn_soap_req_data *soap_req )
1002{
1003        /* TODO: Ack the change? Not sure what the NAKs look like.. */
1004        return MSN_SOAP_OK;
1005}
1006
1007static int msn_soap_ab_contact_add_free_data( struct msn_soap_req_data *soap_req )
1008{
1009        return 0;
1010}
1011
1012int msn_soap_ab_contact_add( struct im_connection *ic, bee_user_t *bu )
1013{
1014        return msn_soap_start( ic, bu,
1015                               msn_soap_ab_contact_add_build_request,
1016                               msn_soap_ab_contact_add_parser,
1017                               msn_soap_ab_contact_add_handle_response,
1018                               msn_soap_ab_contact_add_free_data );
1019}
1020
1021/* Remove a contact. */
1022static int msn_soap_ab_contact_del_build_request( struct msn_soap_req_data *soap_req )
1023{
1024        struct msn_data *md = soap_req->ic->proto_data;
1025        const char *cid = soap_req->data;
1026       
1027        soap_req->url = g_strdup( SOAP_ADDRESSBOOK_URL );
1028        soap_req->action = g_strdup( SOAP_AB_CONTACT_DEL_ACTION );
1029        soap_req->payload = msn_soap_abservice_build( SOAP_AB_CONTACT_DEL_PAYLOAD,
1030                "Timer", md->tokens[1], cid );
1031       
1032        return 1;
1033}
1034
1035static int msn_soap_ab_contact_del_handle_response( struct msn_soap_req_data *soap_req )
1036{
1037        /* TODO: Ack the change? Not sure what the NAKs look like.. */
1038        return MSN_SOAP_OK;
1039}
1040
1041static int msn_soap_ab_contact_del_free_data( struct msn_soap_req_data *soap_req )
1042{
1043        g_free( soap_req->data );
1044        return 0;
1045}
1046
1047int msn_soap_ab_contact_del( struct im_connection *ic, bee_user_t *bu )
1048{
1049        struct msn_buddy_data *bd = bu->data;
1050       
1051        return msn_soap_start( ic, g_strdup( bd->cid ),
1052                               msn_soap_ab_contact_del_build_request,
1053                               NULL,
1054                               msn_soap_ab_contact_del_handle_response,
1055                               msn_soap_ab_contact_del_free_data );
1056}
1057
1058
1059
1060/* Storage stuff: Fetch profile. */
1061static int msn_soap_profile_get_build_request( struct msn_soap_req_data *soap_req )
1062{
1063        struct msn_data *md = soap_req->ic->proto_data;
1064       
1065        soap_req->url = g_strdup( SOAP_STORAGE_URL );
1066        soap_req->action = g_strdup( SOAP_PROFILE_GET_ACTION );
1067        soap_req->payload = g_markup_printf_escaped( SOAP_PROFILE_GET_PAYLOAD,
1068                md->tokens[3], (char*) soap_req->data );
1069       
1070        return 1;
1071}
1072
1073static xt_status msn_soap_profile_get_result( struct xt_node *node, gpointer data )
1074{
1075        struct msn_soap_req_data *soap_req = data;
1076        struct im_connection *ic = soap_req->ic;
1077        struct msn_data *md = soap_req->ic->proto_data;
1078        struct xt_node *dn;
1079       
1080        if( ( dn = xt_find_node( node->children, "DisplayName" ) ) && dn->text )
1081        {
1082                set_t *set = set_find( &ic->acc->set, "display_name" );
1083                g_free( set->value );
1084                set->value = g_strdup( dn->text );
1085               
1086                md->flags |= MSN_GOT_PROFILE_DN;
1087        }
1088       
1089        return XT_HANDLED;
1090}
1091
1092static xt_status msn_soap_profile_get_rid( struct xt_node *node, gpointer data )
1093{
1094        struct msn_soap_req_data *soap_req = data;
1095        struct msn_data *md = soap_req->ic->proto_data;
1096       
1097        g_free( md->profile_rid );
1098        md->profile_rid = g_strdup( node->text );
1099       
1100        return XT_HANDLED;
1101}
1102
1103static const struct xt_handler_entry msn_soap_profile_get_parser[] = {
1104        { "ExpressionProfile", "GetProfileResult", msn_soap_profile_get_result },
1105        { "ResourceID",        "GetProfileResult", msn_soap_profile_get_rid },
1106        { NULL,               NULL,     NULL                        }
1107};
1108
1109static int msn_soap_profile_get_handle_response( struct msn_soap_req_data *soap_req )
1110{
1111        struct msn_data *md = soap_req->ic->proto_data;
1112       
1113        md->flags |= MSN_GOT_PROFILE;
1114        msn_ns_finish_login( soap_req->ic );
1115       
1116        return MSN_SOAP_OK;
1117}
1118
1119static int msn_soap_profile_get_free_data( struct msn_soap_req_data *soap_req )
1120{
1121        g_free( soap_req->data );
1122        return 0;
1123}
1124
1125int msn_soap_profile_get( struct im_connection *ic, const char *cid )
1126{
1127        return msn_soap_start( ic, g_strdup( cid ),
1128                               msn_soap_profile_get_build_request,
1129                               msn_soap_profile_get_parser,
1130                               msn_soap_profile_get_handle_response,
1131                               msn_soap_profile_get_free_data );
1132}
1133
1134/* Update profile (display name). */
1135static int msn_soap_profile_set_dn_build_request( struct msn_soap_req_data *soap_req )
1136{
1137        struct msn_data *md = soap_req->ic->proto_data;
1138       
1139        soap_req->url = g_strdup( SOAP_STORAGE_URL );
1140        soap_req->action = g_strdup( SOAP_PROFILE_SET_DN_ACTION );
1141        soap_req->payload = g_markup_printf_escaped( SOAP_PROFILE_SET_DN_PAYLOAD,
1142                md->tokens[3], md->profile_rid, (char*) soap_req->data );
1143       
1144        return 1;
1145}
1146
1147static const struct xt_handler_entry msn_soap_profile_set_dn_parser[] = {
1148        { NULL,               NULL,     NULL                        }
1149};
1150
1151static int msn_soap_profile_set_dn_handle_response( struct msn_soap_req_data *soap_req )
1152{
1153        return MSN_SOAP_OK;
1154}
1155
1156static int msn_soap_profile_set_dn_free_data( struct msn_soap_req_data *soap_req )
1157{
1158        g_free( soap_req->data );
1159        return 0;
1160}
1161
1162int msn_soap_profile_set_dn( struct im_connection *ic, const char *dn )
1163{
1164        return msn_soap_start( ic, g_strdup( dn ),
1165                               msn_soap_profile_set_dn_build_request,
1166                               msn_soap_profile_set_dn_parser,
1167                               msn_soap_profile_set_dn_handle_response,
1168                               msn_soap_profile_set_dn_free_data );
1169}
Note: See TracBrowser for help on using the repository browser.