source: protocols/msn/soap.c @ ef9ee0e

Last change on this file since ef9ee0e was 6a89740, checked in by dequis <dx@…>, at 2015-05-31T02:40:04Z

msn/soap: remove MSNP15 SSO crypto code
  • Property mode set to 100644
File size: 26.0 KB
Line 
1/********************************************************************\
2  * BitlBee -- An IRC to other IM-networks gateway                     *
3  *                                                                    *
4  * Copyright 2002-2012 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., 51 Franklin St.,
26  Fifth Floor, Boston, MA  02110-1301  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        MSN_SOAP_OK,
48        MSN_SOAP_RETRY,
49        MSN_SOAP_REAUTH,
50        MSN_SOAP_ABORT,
51} msn_soap_result_t;
52
53struct msn_soap_req_data;
54typedef int (*msn_soap_func) (struct msn_soap_req_data *);
55
56struct msn_soap_req_data {
57        void *data;
58        struct im_connection *ic;
59        int ttl;
60        char *error;
61
62        char *url, *action, *payload;
63        struct http_request *http_req;
64
65        const struct xt_handler_entry *xml_parser;
66        msn_soap_func build_request, handle_response, free_data;
67};
68
69static int msn_soap_send_request(struct msn_soap_req_data *req);
70static void msn_soap_free(struct msn_soap_req_data *soap_req);
71static void msn_soap_debug_print(const char *headers, const char *payload);
72
73static int msn_soap_start(struct im_connection *ic,
74                          void *data,
75                          msn_soap_func build_request,
76                          const struct xt_handler_entry *xml_parser,
77                          msn_soap_func handle_response,
78                          msn_soap_func free_data)
79{
80        struct msn_soap_req_data *req = g_new0(struct msn_soap_req_data, 1);
81
82        req->ic = ic;
83        req->data = data;
84        req->xml_parser = xml_parser;
85        req->build_request = build_request;
86        req->handle_response = handle_response;
87        req->free_data = free_data;
88        req->ttl = 3;
89
90        return msn_soap_send_request(req);
91}
92
93static void msn_soap_handle_response(struct http_request *http_req);
94
95static int msn_soap_send_request(struct msn_soap_req_data *soap_req)
96{
97        char *http_req;
98        char *soap_action = NULL;
99        url_t url;
100
101        soap_req->build_request(soap_req);
102
103        if (soap_req->action) {
104                soap_action = g_strdup_printf("SOAPAction: \"%s\"\r\n", soap_req->action);
105        }
106
107        url_set(&url, soap_req->url);
108        http_req = g_strdup_printf(SOAP_HTTP_REQUEST, url.file, url.host,
109                                   soap_action ? soap_action : "",
110                                   strlen(soap_req->payload), soap_req->payload);
111
112        msn_soap_debug_print(http_req, soap_req->payload);
113
114        soap_req->http_req = http_dorequest(url.host, url.port, url.proto == PROTO_HTTPS,
115                                            http_req, msn_soap_handle_response, soap_req);
116
117        g_free(http_req);
118        g_free(soap_action);
119
120        return soap_req->http_req != NULL;
121}
122
123static void msn_soap_handle_response(struct http_request *http_req)
124{
125        struct msn_soap_req_data *soap_req = http_req->data;
126        int st;
127
128        if (g_slist_find(msn_connections, soap_req->ic) == NULL) {
129                msn_soap_free(soap_req);
130                return;
131        }
132
133        msn_soap_debug_print(http_req->reply_headers, http_req->reply_body);
134
135        if (http_req->body_size > 0) {
136                struct xt_parser *parser;
137                struct xt_node *err;
138
139                parser = xt_new(soap_req->xml_parser, soap_req);
140                xt_feed(parser, http_req->reply_body, http_req->body_size);
141                if (http_req->status_code == 500 &&
142                    (err = xt_find_path(parser->root, "soap:Body/soap:Fault/detail/errorcode")) &&
143                    err->text_len > 0) {
144                        if (strcmp(err->text, "PassportAuthFail") == 0) {
145                                xt_free(parser);
146                                st = MSN_SOAP_REAUTH;
147                                goto fail;
148                        }
149                        /* TODO: Handle/report other errors. */
150                }
151
152                xt_handle(parser, NULL, -1);
153                xt_free(parser);
154        }
155
156        if (http_req->status_code != 200) {
157                soap_req->error = g_strdup(http_req->status_string);
158        }
159
160        st = soap_req->handle_response(soap_req);
161
162fail:
163        g_free(soap_req->url);
164        g_free(soap_req->action);
165        g_free(soap_req->payload);
166        g_free(soap_req->error);
167        soap_req->url = soap_req->action = soap_req->payload = soap_req->error = NULL;
168
169        if (st == MSN_SOAP_RETRY && --soap_req->ttl) {
170                msn_soap_send_request(soap_req);
171        } else if (st == MSN_SOAP_REAUTH) {
172                struct msn_data *md = soap_req->ic->proto_data;
173
174                if (!(md->flags & MSN_REAUTHING)) {
175                        /* Nonce shouldn't actually be touched for re-auths. */
176                        msn_soap_passport_sso_request(soap_req->ic);
177                        md->flags |= MSN_REAUTHING;
178                }
179                md->soapq = g_slist_append(md->soapq, soap_req);
180        } else {
181                soap_req->free_data(soap_req);
182                g_free(soap_req);
183        }
184}
185
186static char *msn_soap_abservice_build(const char *body_fmt, const char *scenario, const char *ticket, ...)
187{
188        va_list params;
189        char *ret, *format, *body;
190
191        format = g_markup_printf_escaped(SOAP_ABSERVICE_PAYLOAD, scenario, ticket);
192
193        va_start(params, ticket);
194        body = g_strdup_vprintf(body_fmt, params);
195        va_end(params);
196
197        ret = g_strdup_printf(format, body);
198        g_free(body);
199        g_free(format);
200
201        return ret;
202}
203
204static void msn_soap_debug_print(const char *headers, const char *payload)
205{
206        char *s;
207
208        if (!getenv("BITLBEE_DEBUG")) {
209                return;
210        }
211        fprintf(stderr, "\n\x1b[90mSOAP:\n");
212
213        if (headers) {
214                if ((s = strstr(headers, "\r\n\r\n"))) {
215                        write(2, headers, s - headers + 4);
216                } else {
217                        write(2, headers, strlen(headers));
218                }
219        }
220
221        if (payload) {
222                struct xt_node *xt = xt_from_string(payload, 0);
223                if (xt) {
224                        xt_print(xt);
225                }
226                xt_free_node(xt);
227        }
228        fprintf(stderr, "\n\x1b[97m\n");
229}
230
231int msn_soapq_flush(struct im_connection *ic, gboolean resend)
232{
233        struct msn_data *md = ic->proto_data;
234
235        while (md->soapq) {
236                if (resend) {
237                        msn_soap_send_request((struct msn_soap_req_data*) md->soapq->data);
238                } else {
239                        msn_soap_free((struct msn_soap_req_data*) md->soapq->data);
240                }
241                md->soapq = g_slist_remove(md->soapq, md->soapq->data);
242        }
243
244        return MSN_SOAP_OK;
245}
246
247static void msn_soap_free(struct msn_soap_req_data *soap_req)
248{
249        soap_req->free_data(soap_req);
250        g_free(soap_req->url);
251        g_free(soap_req->action);
252        g_free(soap_req->payload);
253        g_free(soap_req->error);
254        g_free(soap_req);
255}
256
257
258/* passport_sso: Authentication MSNP15+ */
259
260struct msn_soap_passport_sso_data {
261        char *error;
262        char *redirect;
263};
264
265static int msn_soap_passport_sso_build_request(struct msn_soap_req_data *soap_req)
266{
267        struct msn_soap_passport_sso_data *sd = soap_req->data;
268        struct im_connection *ic = soap_req->ic;
269        char pass[MAX_PASSPORT_PWLEN + 1];
270
271        if (sd->redirect) {
272                soap_req->url = sd->redirect;
273                sd->redirect = NULL;
274        } else {
275                soap_req->url = g_strdup(SOAP_PASSPORT_SSO_URL);
276        }
277
278        strncpy(pass, ic->acc->pass, MAX_PASSPORT_PWLEN);
279        pass[MAX_PASSPORT_PWLEN] = '\0';
280        soap_req->payload = g_markup_printf_escaped(SOAP_PASSPORT_SSO_PAYLOAD,
281                                                    ic->acc->user, pass);
282
283        return MSN_SOAP_OK;
284}
285
286static xt_status msn_soap_passport_sso_token(struct xt_node *node, gpointer data)
287{
288        struct msn_soap_req_data *soap_req = data;
289        struct msn_data *md = soap_req->ic->proto_data;
290        char *id;
291
292        if ((id = xt_find_attr(node, "Id")) == NULL) {
293                return XT_HANDLED;
294        }
295        id += strlen(id) - 1;
296
297        *id -= '1';
298        if (*id >= 0 && *id < sizeof(md->tokens) / sizeof(md->tokens[0])) {
299                g_free(md->tokens[(int) *id]);
300                md->tokens[(int) *id] = g_strdup(node->text);
301        }
302
303        return XT_HANDLED;
304}
305
306static xt_status msn_soap_passport_failure(struct xt_node *node, gpointer data)
307{
308        struct msn_soap_req_data *soap_req = data;
309        struct msn_soap_passport_sso_data *sd = soap_req->data;
310        struct xt_node *code = xt_find_node(node->children, "faultcode");
311        struct xt_node *string = xt_find_node(node->children, "faultstring");
312        struct xt_node *url;
313
314        if (code == NULL || code->text_len == 0) {
315                sd->error = g_strdup("Unknown error");
316        } else if (strcmp(code->text, "psf:Redirect") == 0 &&
317                   (url = xt_find_node(node->children, "psf:redirectUrl")) &&
318                   url->text_len > 0) {
319                sd->redirect = g_strdup(url->text);
320        } else {
321                sd->error = g_strdup_printf("%s (%s)", code->text, string && string->text_len ?
322                                            string->text : "no description available");
323        }
324
325        return XT_HANDLED;
326}
327
328static const struct xt_handler_entry msn_soap_passport_sso_parser[] = {
329        { "wsse:BinarySecurityToken", "wst:RequestedSecurityToken", msn_soap_passport_sso_token },
330        { "S:Fault", "S:Envelope", msn_soap_passport_failure },
331        { NULL, NULL, NULL }
332};
333
334static int msn_soap_passport_sso_handle_response(struct msn_soap_req_data *soap_req)
335{
336        struct msn_soap_passport_sso_data *sd = soap_req->data;
337        struct im_connection *ic = soap_req->ic;
338        struct msn_data *md = ic->proto_data;
339
340        if (sd->redirect) {
341                return MSN_SOAP_RETRY;
342        }
343
344        if (md->soapq) {
345                md->flags &= ~MSN_REAUTHING;
346                return msn_soapq_flush(ic, TRUE);
347        }
348
349        if (md->tokens[0] == NULL) {
350                msn_auth_got_passport_token(ic, NULL, sd->error ? sd->error : soap_req->error);
351                return MSN_SOAP_OK;
352        }
353
354        msn_auth_got_passport_token(ic, md->tokens[0], NULL);
355
356        return MSN_SOAP_OK;
357}
358
359static int msn_soap_passport_sso_free_data(struct msn_soap_req_data *soap_req)
360{
361        struct msn_soap_passport_sso_data *sd = soap_req->data;
362
363        g_free(sd->error);
364        g_free(sd->redirect);
365        g_free(sd);
366
367        return MSN_SOAP_OK;
368}
369
370int msn_soap_passport_sso_request(struct im_connection *ic)
371{
372        struct msn_soap_passport_sso_data *sd = g_new0(struct msn_soap_passport_sso_data, 1);
373
374        return msn_soap_start(ic, sd, msn_soap_passport_sso_build_request,
375                              msn_soap_passport_sso_parser,
376                              msn_soap_passport_sso_handle_response,
377                              msn_soap_passport_sso_free_data);
378}
379
380
381/* memlist: Fetching the membership list (NOT address book) */
382
383static int msn_soap_memlist_build_request(struct msn_soap_req_data *soap_req)
384{
385        struct msn_data *md = soap_req->ic->proto_data;
386
387        soap_req->url = g_strdup(SOAP_MEMLIST_URL);
388        soap_req->action = g_strdup(SOAP_MEMLIST_ACTION);
389        soap_req->payload = msn_soap_abservice_build(SOAP_MEMLIST_PAYLOAD, "Initial", md->tokens[1]);
390
391        return 1;
392}
393
394static xt_status msn_soap_memlist_member(struct xt_node *node, gpointer data)
395{
396        bee_user_t *bu;
397        struct msn_buddy_data *bd;
398        struct xt_node *p;
399        char *role = NULL, *handle = NULL;
400        struct msn_soap_req_data *soap_req = data;
401        struct im_connection *ic = soap_req->ic;
402
403        if ((p = xt_find_path(node, "../../MemberRole"))) {
404                role = p->text;
405        }
406
407        if ((p = xt_find_node(node->children, "PassportName"))) {
408                handle = p->text;
409        }
410
411        if (!role || !handle ||
412            !((bu = bee_user_by_handle(ic->bee, ic, handle)) ||
413              (bu = bee_user_new(ic->bee, ic, handle, 0)))) {
414                return XT_HANDLED;
415        }
416
417        bd = bu->data;
418        if (strcmp(role, "Allow") == 0) {
419                bd->flags |= MSN_BUDDY_AL;
420                ic->permit = g_slist_prepend(ic->permit, g_strdup(handle));
421        } else if (strcmp(role, "Block") == 0) {
422                bd->flags |= MSN_BUDDY_BL;
423                ic->deny = g_slist_prepend(ic->deny, g_strdup(handle));
424        } else if (strcmp(role, "Reverse") == 0) {
425                bd->flags |= MSN_BUDDY_RL;
426        } else if (strcmp(role, "Pending") == 0) {
427                bd->flags |= MSN_BUDDY_PL;
428        }
429
430        if (getenv("BITLBEE_DEBUG")) {
431                fprintf(stderr, "%p %s %d\n", bu, handle, bd->flags);
432        }
433
434        return XT_HANDLED;
435}
436
437static const struct xt_handler_entry msn_soap_memlist_parser[] = {
438        { "Member", "Members", msn_soap_memlist_member },
439        { NULL,               NULL,     NULL                        }
440};
441
442static int msn_soap_memlist_handle_response(struct msn_soap_req_data *soap_req)
443{
444        msn_soap_addressbook_request(soap_req->ic);
445
446        return MSN_SOAP_OK;
447}
448
449static int msn_soap_memlist_free_data(struct msn_soap_req_data *soap_req)
450{
451        return 0;
452}
453
454int msn_soap_memlist_request(struct im_connection *ic)
455{
456        return msn_soap_start(ic, NULL, msn_soap_memlist_build_request,
457                              msn_soap_memlist_parser,
458                              msn_soap_memlist_handle_response,
459                              msn_soap_memlist_free_data);
460}
461
462/* Variant: Adding/Removing people */
463struct msn_soap_memlist_edit_data {
464        char *handle;
465        gboolean add;
466        msn_buddy_flags_t list;
467};
468
469static int msn_soap_memlist_edit_build_request(struct msn_soap_req_data *soap_req)
470{
471        struct msn_data *md = soap_req->ic->proto_data;
472        struct msn_soap_memlist_edit_data *med = soap_req->data;
473        char *add, *scenario, *list;
474
475        soap_req->url = g_strdup(SOAP_MEMLIST_URL);
476        if (med->add) {
477                soap_req->action = g_strdup(SOAP_MEMLIST_ADD_ACTION);
478                add = "Add";
479        } else {
480                soap_req->action = g_strdup(SOAP_MEMLIST_DEL_ACTION);
481                add = "Delete";
482        }
483        switch (med->list) {
484        case MSN_BUDDY_AL:
485                scenario = "BlockUnblock";
486                list = "Allow";
487                break;
488        case MSN_BUDDY_BL:
489                scenario = "BlockUnblock";
490                list = "Block";
491                break;
492        case MSN_BUDDY_RL:
493                scenario = "Timer";
494                list = "Reverse";
495                break;
496        case MSN_BUDDY_PL:
497        default:
498                scenario = "Timer";
499                list = "Pending";
500                break;
501        }
502        soap_req->payload = msn_soap_abservice_build(SOAP_MEMLIST_EDIT_PAYLOAD,
503                                                     scenario, md->tokens[1], add, list, med->handle, add);
504
505        return 1;
506}
507
508static int msn_soap_memlist_edit_handle_response(struct msn_soap_req_data *soap_req)
509{
510        return MSN_SOAP_OK;
511}
512
513static int msn_soap_memlist_edit_free_data(struct msn_soap_req_data *soap_req)
514{
515        struct msn_soap_memlist_edit_data *med = soap_req->data;
516
517        g_free(med->handle);
518        g_free(med);
519
520        return 0;
521}
522
523int msn_soap_memlist_edit(struct im_connection *ic, const char *handle, gboolean add, int list)
524{
525        struct msn_soap_memlist_edit_data *med;
526
527        med = g_new0(struct msn_soap_memlist_edit_data, 1);
528        med->handle = g_strdup(handle);
529        med->add = add;
530        med->list = list;
531
532        return msn_soap_start(ic, med, msn_soap_memlist_edit_build_request,
533                              NULL,
534                              msn_soap_memlist_edit_handle_response,
535                              msn_soap_memlist_edit_free_data);
536}
537
538
539/* addressbook: Fetching the membership list (NOT address book) */
540
541static int msn_soap_addressbook_build_request(struct msn_soap_req_data *soap_req)
542{
543        struct msn_data *md = soap_req->ic->proto_data;
544
545        soap_req->url = g_strdup(SOAP_ADDRESSBOOK_URL);
546        soap_req->action = g_strdup(SOAP_ADDRESSBOOK_ACTION);
547        soap_req->payload = msn_soap_abservice_build(SOAP_ADDRESSBOOK_PAYLOAD, "Initial", md->tokens[1]);
548
549        return 1;
550}
551
552static xt_status msn_soap_addressbook_group(struct xt_node *node, gpointer data)
553{
554        struct xt_node *p;
555        char *id = NULL, *name = NULL;
556        struct msn_soap_req_data *soap_req = data;
557        struct msn_data *md = soap_req->ic->proto_data;
558
559        if ((p = xt_find_path(node, "../groupId"))) {
560                id = p->text;
561        }
562
563        if ((p = xt_find_node(node->children, "name"))) {
564                name = p->text;
565        }
566
567        if (id && name) {
568                struct msn_group *mg = g_new0(struct msn_group, 1);
569                mg->id = g_strdup(id);
570                mg->name = g_strdup(name);
571                md->groups = g_slist_prepend(md->groups, mg);
572        }
573
574        if (getenv("BITLBEE_DEBUG")) {
575                fprintf(stderr, "%s %s\n", id, name);
576        }
577
578        return XT_HANDLED;
579}
580
581static xt_status msn_soap_addressbook_contact(struct xt_node *node, gpointer data)
582{
583        bee_user_t *bu;
584        struct msn_buddy_data *bd;
585        struct xt_node *p;
586        char *id = NULL, *type = NULL, *handle = NULL, *is_msgr = "false",
587        *display_name = NULL, *group_id = NULL;
588        struct msn_soap_req_data *soap_req = data;
589        struct im_connection *ic = soap_req->ic;
590        struct msn_group *group;
591
592        if ((p = xt_find_path(node, "../contactId"))) {
593                id = p->text;
594        }
595        if ((p = xt_find_node(node->children, "contactType"))) {
596                type = p->text;
597        }
598        if ((p = xt_find_node(node->children, "passportName"))) {
599                handle = p->text;
600        }
601        if ((p = xt_find_node(node->children, "displayName"))) {
602                display_name = p->text;
603        }
604        if ((p = xt_find_node(node->children, "isMessengerUser"))) {
605                is_msgr = p->text;
606        }
607        if ((p = xt_find_path(node, "groupIds/guid"))) {
608                group_id = p->text;
609        }
610
611        if (type && g_strcasecmp(type, "me") == 0) {
612                set_t *set = set_find(&ic->acc->set, "display_name");
613                g_free(set->value);
614                set->value = g_strdup(display_name);
615
616                /* Try to fetch the profile; if the user has one, that's where
617                   we can find the persistent display_name. */
618                if ((p = xt_find_node(node->children, "CID")) && p->text) {
619                        msn_soap_profile_get(ic, p->text);
620                }
621
622                return XT_HANDLED;
623        }
624
625        if (!bool2int(is_msgr) || handle == NULL) {
626                return XT_HANDLED;
627        }
628
629        if (!(bu = bee_user_by_handle(ic->bee, ic, handle)) &&
630            !(bu = bee_user_new(ic->bee, ic, handle, 0))) {
631                return XT_HANDLED;
632        }
633
634        bd = bu->data;
635        bd->flags |= MSN_BUDDY_FL;
636        g_free(bd->cid);
637        bd->cid = g_strdup(id);
638
639        imcb_rename_buddy(ic, handle, display_name);
640
641        if (group_id && (group = msn_group_by_id(ic, group_id))) {
642                imcb_add_buddy(ic, handle, group->name);
643        }
644
645        if (getenv("BITLBEE_DEBUG")) {
646                fprintf(stderr, "%s %s %s %s\n", id, type, handle, display_name);
647        }
648
649        return XT_HANDLED;
650}
651
652static const struct xt_handler_entry msn_soap_addressbook_parser[] = {
653        { "contactInfo", "Contact", msn_soap_addressbook_contact },
654        { "groupInfo", "Group", msn_soap_addressbook_group },
655        { NULL,               NULL,     NULL                        }
656};
657
658static int msn_soap_addressbook_handle_response(struct msn_soap_req_data *soap_req)
659{
660        GSList *l;
661        int wtf = 0;
662
663        for (l = soap_req->ic->bee->users; l; l = l->next) {
664                struct bee_user *bu = l->data;
665                struct msn_buddy_data *bd = bu->data;
666
667                if (bu->ic == soap_req->ic && bd) {
668                        msn_buddy_ask(bu);
669
670                        if ((bd->flags & (MSN_BUDDY_AL | MSN_BUDDY_BL)) ==
671                            (MSN_BUDDY_AL | MSN_BUDDY_BL)) {
672                                /* both allow and block, delete block, add wtf */
673                                bd->flags &= ~MSN_BUDDY_BL;
674                                wtf++;
675                        }
676
677
678                        if ((bd->flags & (MSN_BUDDY_AL | MSN_BUDDY_BL)) == 0) {
679                                /* neither allow or block, add allow */
680                                bd->flags |= MSN_BUDDY_AL;
681                        }
682                }
683        }
684
685        if (wtf) {
686                imcb_log(soap_req->ic, "Warning: %d contacts were in both your "
687                         "block and your allow list. Assuming they're all "
688                         "allowed. Use the official WLM client once to fix "
689                         "this.", wtf);
690        }
691
692        msn_auth_got_contact_list(soap_req->ic);
693
694        return MSN_SOAP_OK;
695}
696
697static int msn_soap_addressbook_free_data(struct msn_soap_req_data *soap_req)
698{
699        return 0;
700}
701
702int msn_soap_addressbook_request(struct im_connection *ic)
703{
704        return msn_soap_start(ic, NULL, msn_soap_addressbook_build_request,
705                              msn_soap_addressbook_parser,
706                              msn_soap_addressbook_handle_response,
707                              msn_soap_addressbook_free_data);
708}
709
710/* Variant: Change our display name. */
711static int msn_soap_ab_namechange_build_request(struct msn_soap_req_data *soap_req)
712{
713        struct msn_data *md = soap_req->ic->proto_data;
714
715        soap_req->url = g_strdup(SOAP_ADDRESSBOOK_URL);
716        soap_req->action = g_strdup(SOAP_AB_NAMECHANGE_ACTION);
717        soap_req->payload = msn_soap_abservice_build(SOAP_AB_NAMECHANGE_PAYLOAD,
718                                                     "Timer", md->tokens[1], (char *) soap_req->data);
719
720        return 1;
721}
722
723static int msn_soap_ab_namechange_handle_response(struct msn_soap_req_data *soap_req)
724{
725        /* TODO: Ack the change? Not sure what the NAKs look like.. */
726        return MSN_SOAP_OK;
727}
728
729static int msn_soap_ab_namechange_free_data(struct msn_soap_req_data *soap_req)
730{
731        g_free(soap_req->data);
732        return 0;
733}
734
735int msn_soap_addressbook_set_display_name(struct im_connection *ic, const char *new)
736{
737        return msn_soap_start(ic, g_strdup(new),
738                              msn_soap_ab_namechange_build_request,
739                              NULL,
740                              msn_soap_ab_namechange_handle_response,
741                              msn_soap_ab_namechange_free_data);
742}
743
744/* Add a contact. */
745static int msn_soap_ab_contact_add_build_request(struct msn_soap_req_data *soap_req)
746{
747        struct msn_data *md = soap_req->ic->proto_data;
748        bee_user_t *bu = soap_req->data;
749
750        soap_req->url = g_strdup(SOAP_ADDRESSBOOK_URL);
751        soap_req->action = g_strdup(SOAP_AB_CONTACT_ADD_ACTION);
752        soap_req->payload = msn_soap_abservice_build(SOAP_AB_CONTACT_ADD_PAYLOAD,
753                                                     "ContactSave", md->tokens[1], bu->handle,
754                                                     bu->fullname ? bu->fullname : bu->handle);
755
756        return 1;
757}
758
759static xt_status msn_soap_ab_contact_add_cid(struct xt_node *node, gpointer data)
760{
761        struct msn_soap_req_data *soap_req = data;
762        bee_user_t *bu = soap_req->data;
763        struct msn_buddy_data *bd = bu->data;
764
765        g_free(bd->cid);
766        bd->cid = g_strdup(node->text);
767
768        return XT_HANDLED;
769}
770
771static const struct xt_handler_entry msn_soap_ab_contact_add_parser[] = {
772        { "guid", "ABContactAddResult", msn_soap_ab_contact_add_cid },
773        { NULL,               NULL,     NULL                        }
774};
775
776static int msn_soap_ab_contact_add_handle_response(struct msn_soap_req_data *soap_req)
777{
778        /* TODO: Ack the change? Not sure what the NAKs look like.. */
779        return MSN_SOAP_OK;
780}
781
782static int msn_soap_ab_contact_add_free_data(struct msn_soap_req_data *soap_req)
783{
784        return 0;
785}
786
787int msn_soap_ab_contact_add(struct im_connection *ic, bee_user_t *bu)
788{
789        return msn_soap_start(ic, bu,
790                              msn_soap_ab_contact_add_build_request,
791                              msn_soap_ab_contact_add_parser,
792                              msn_soap_ab_contact_add_handle_response,
793                              msn_soap_ab_contact_add_free_data);
794}
795
796/* Remove a contact. */
797static int msn_soap_ab_contact_del_build_request(struct msn_soap_req_data *soap_req)
798{
799        struct msn_data *md = soap_req->ic->proto_data;
800        const char *cid = soap_req->data;
801
802        soap_req->url = g_strdup(SOAP_ADDRESSBOOK_URL);
803        soap_req->action = g_strdup(SOAP_AB_CONTACT_DEL_ACTION);
804        soap_req->payload = msn_soap_abservice_build(SOAP_AB_CONTACT_DEL_PAYLOAD,
805                                                     "Timer", md->tokens[1], cid);
806
807        return 1;
808}
809
810static int msn_soap_ab_contact_del_handle_response(struct msn_soap_req_data *soap_req)
811{
812        /* TODO: Ack the change? Not sure what the NAKs look like.. */
813        return MSN_SOAP_OK;
814}
815
816static int msn_soap_ab_contact_del_free_data(struct msn_soap_req_data *soap_req)
817{
818        g_free(soap_req->data);
819        return 0;
820}
821
822int msn_soap_ab_contact_del(struct im_connection *ic, bee_user_t *bu)
823{
824        struct msn_buddy_data *bd = bu->data;
825
826        return msn_soap_start(ic, g_strdup(bd->cid),
827                              msn_soap_ab_contact_del_build_request,
828                              NULL,
829                              msn_soap_ab_contact_del_handle_response,
830                              msn_soap_ab_contact_del_free_data);
831}
832
833
834
835/* Storage stuff: Fetch profile. */
836static int msn_soap_profile_get_build_request(struct msn_soap_req_data *soap_req)
837{
838        struct msn_data *md = soap_req->ic->proto_data;
839
840        soap_req->url = g_strdup(SOAP_STORAGE_URL);
841        soap_req->action = g_strdup(SOAP_PROFILE_GET_ACTION);
842        soap_req->payload = g_markup_printf_escaped(SOAP_PROFILE_GET_PAYLOAD,
843                                                    md->tokens[3], (char *) soap_req->data);
844
845        return 1;
846}
847
848static xt_status msn_soap_profile_get_result(struct xt_node *node, gpointer data)
849{
850        struct msn_soap_req_data *soap_req = data;
851        struct im_connection *ic = soap_req->ic;
852        struct msn_data *md = soap_req->ic->proto_data;
853        struct xt_node *dn;
854
855        if ((dn = xt_find_node(node->children, "DisplayName")) && dn->text) {
856                set_t *set = set_find(&ic->acc->set, "display_name");
857                g_free(set->value);
858                set->value = g_strdup(dn->text);
859
860                md->flags |= MSN_GOT_PROFILE_DN;
861        }
862
863        return XT_HANDLED;
864}
865
866static xt_status msn_soap_profile_get_rid(struct xt_node *node, gpointer data)
867{
868        struct msn_soap_req_data *soap_req = data;
869        struct msn_data *md = soap_req->ic->proto_data;
870
871        g_free(md->profile_rid);
872        md->profile_rid = g_strdup(node->text);
873
874        return XT_HANDLED;
875}
876
877static const struct xt_handler_entry msn_soap_profile_get_parser[] = {
878        { "ExpressionProfile", "GetProfileResult", msn_soap_profile_get_result },
879        { "ResourceID",        "GetProfileResult", msn_soap_profile_get_rid },
880        { NULL,               NULL,     NULL                        }
881};
882
883static int msn_soap_profile_get_handle_response(struct msn_soap_req_data *soap_req)
884{
885        struct msn_data *md = soap_req->ic->proto_data;
886
887        md->flags |= MSN_GOT_PROFILE;
888        msn_ns_finish_login(soap_req->ic);
889
890        return MSN_SOAP_OK;
891}
892
893static int msn_soap_profile_get_free_data(struct msn_soap_req_data *soap_req)
894{
895        g_free(soap_req->data);
896        return 0;
897}
898
899int msn_soap_profile_get(struct im_connection *ic, const char *cid)
900{
901        return msn_soap_start(ic, g_strdup(cid),
902                              msn_soap_profile_get_build_request,
903                              msn_soap_profile_get_parser,
904                              msn_soap_profile_get_handle_response,
905                              msn_soap_profile_get_free_data);
906}
907
908/* Update profile (display name). */
909static int msn_soap_profile_set_dn_build_request(struct msn_soap_req_data *soap_req)
910{
911        struct msn_data *md = soap_req->ic->proto_data;
912
913        soap_req->url = g_strdup(SOAP_STORAGE_URL);
914        soap_req->action = g_strdup(SOAP_PROFILE_SET_DN_ACTION);
915        soap_req->payload = g_markup_printf_escaped(SOAP_PROFILE_SET_DN_PAYLOAD,
916                                                    md->tokens[3], md->profile_rid, (char *) soap_req->data);
917
918        return 1;
919}
920
921static const struct xt_handler_entry msn_soap_profile_set_dn_parser[] = {
922        { NULL,               NULL,     NULL                        }
923};
924
925static int msn_soap_profile_set_dn_handle_response(struct msn_soap_req_data *soap_req)
926{
927        return MSN_SOAP_OK;
928}
929
930static int msn_soap_profile_set_dn_free_data(struct msn_soap_req_data *soap_req)
931{
932        g_free(soap_req->data);
933        return 0;
934}
935
936int msn_soap_profile_set_dn(struct im_connection *ic, const char *dn)
937{
938        return msn_soap_start(ic, g_strdup(dn),
939                              msn_soap_profile_set_dn_build_request,
940                              msn_soap_profile_set_dn_parser,
941                              msn_soap_profile_set_dn_handle_response,
942                              msn_soap_profile_set_dn_free_data);
943}
Note: See TracBrowser for help on using the repository browser.