Context Navigation

source: protocols/msn/soap.c @ e59eec0

Last change on this file since e59eec0 was 693aca0, checked in by dequis <dx@…>, at 2015-04-10T17:10:40Z
msn: colorful debug
Property mode set to `100644`
File size: 28.6 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
46	typedef enum {
47	MSN_SOAP_OK,
48	MSN_SOAP_RETRY,
49	MSN_SOAP_REAUTH,
50	MSN_SOAP_ABORT,
51	} msn_soap_result_t;
52
53	struct msn_soap_req_data;
54	typedef int (msn_soap_func) (struct msn_soap_req_data );
55
56	struct 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
69	static int msn_soap_send_request(struct msn_soap_req_data *req);
70	static void msn_soap_free(struct msn_soap_req_data *soap_req);
71	static void msn_soap_debug_print(const char headers, const char payload);
72
73	static 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
93	static void msn_soap_handle_response(struct http_request *http_req);
94
95	static 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
123	static 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
162	fail:
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, "blaataap");
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
186	static 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
204	static 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
231	int 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
247	static 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
260	struct msn_soap_passport_sso_data {
261	char *nonce;
262	char *secret;
263	char *error;
264	char *redirect;
265	};
266
267	static int msn_soap_passport_sso_build_request(struct msn_soap_req_data *soap_req)
268	{
269	struct msn_soap_passport_sso_data *sd = soap_req->data;
270	struct im_connection *ic = soap_req->ic;
271	struct msn_data *md = ic->proto_data;
272	char pass[MAX_PASSPORT_PWLEN + 1];
273
274	if (sd->redirect) {
275	soap_req->url = sd->redirect;
276	sd->redirect = NULL;
277	}
278	/* MS changed this URL and broke the old MSN-specific one. The generic
279	one works, forwarding us to a msn.com URL that works. Takes an extra
280	second, but that's better than not being able to log in at all. :-/
281	else if( g_str_has_suffix( ic->acc->user, "@msn.com" ) )
282	soap_req->url = g_strdup( SOAP_PASSPORT_SSO_URL_MSN );
283	*/
284	else {
285	soap_req->url = g_strdup(SOAP_PASSPORT_SSO_URL);
286	}
287
288	strncpy(pass, ic->acc->pass, MAX_PASSPORT_PWLEN);
289	pass[MAX_PASSPORT_PWLEN] = '\0';
290	soap_req->payload = g_markup_printf_escaped(SOAP_PASSPORT_SSO_PAYLOAD,
291	ic->acc->user, pass, md->pp_policy);
292
293	return MSN_SOAP_OK;
294	}
295
296	static xt_status msn_soap_passport_sso_token(struct xt_node *node, gpointer data)
297	{
298	struct msn_soap_req_data *soap_req = data;
299	struct msn_soap_passport_sso_data *sd = soap_req->data;
300	struct msn_data *md = soap_req->ic->proto_data;
301	struct xt_node *p;
302	char *id;
303
304	if ((id = xt_find_attr(node, "Id")) == NULL) {
305	return XT_HANDLED;
306	}
307	id += strlen(id) - 1;
308	if (*id == '1' &&
309	(p = xt_find_path(node, "../../wst:RequestedProofToken/wst:BinarySecret")) &&
310	p->text) {
311	sd->secret = g_strdup(p->text);
312	}
313
314	*id -= '1';
315	if (id >= 0 && id < sizeof(md->tokens) / sizeof(md->tokens[0])) {
316	g_free(md->tokens[(int) *id]);
317	md->tokens[(int) *id] = g_strdup(node->text);
318	}
319
320	return XT_HANDLED;
321	}
322
323	static xt_status msn_soap_passport_failure(struct xt_node *node, gpointer data)
324	{
325	struct msn_soap_req_data *soap_req = data;
326	struct msn_soap_passport_sso_data *sd = soap_req->data;
327	struct xt_node *code = xt_find_node(node->children, "faultcode");
328	struct xt_node *string = xt_find_node(node->children, "faultstring");
329	struct xt_node *url;
330
331	if (code == NULL \|\| code->text_len == 0) {
332	sd->error = g_strdup("Unknown error");
333	} else if (strcmp(code->text, "psf:Redirect") == 0 &&
334	(url = xt_find_node(node->children, "psf:redirectUrl")) &&
335	url->text_len > 0) {
336	sd->redirect = g_strdup(url->text);
337	} else {
338	sd->error = g_strdup_printf("%s (%s)", code->text, string && string->text_len ?
339	string->text : "no description available");
340	}
341
342	return XT_HANDLED;
343	}
344
345	static const struct xt_handler_entry msn_soap_passport_sso_parser[] = {
346	{ "wsse:BinarySecurityToken", "wst:RequestedSecurityToken", msn_soap_passport_sso_token },
347	{ "S:Fault", "S:Envelope", msn_soap_passport_failure },
348	{ NULL, NULL, NULL }
349	};
350
351	static char msn_key_fuckery(char key, int key_len, char *type)
352	{
353	unsigned char hash1[20 + strlen(type) + 1];
354	unsigned char hash2[20];
355	char *ret;
356
357	sha1_hmac(key, key_len, type, 0, hash1);
358	strcpy((char *) hash1 + 20, type);
359	sha1_hmac(key, key_len, (char *) hash1, sizeof(hash1) - 1, hash2);
360
361	/* This is okay as hash1 is read completely before it's overwritten. */
362	sha1_hmac(key, key_len, (char *) hash1, 20, hash1);
363	sha1_hmac(key, key_len, (char *) hash1, sizeof(hash1) - 1, hash1);
364
365	ret = g_malloc(24);
366	memcpy(ret, hash2, 20);
367	memcpy(ret + 20, hash1, 4);
368	return ret;
369	}
370
371	static int msn_soap_passport_sso_handle_response(struct msn_soap_req_data *soap_req)
372	{
373	struct msn_soap_passport_sso_data *sd = soap_req->data;
374	struct im_connection *ic = soap_req->ic;
375	struct msn_data *md = ic->proto_data;
376	char key1, key2, key3, blurb64;
377	int key1_len;
378	unsigned char padnonce, des3res;
379
380	struct {
381	unsigned int uStructHeaderSize; // 28. Does not count data
382	unsigned int uCryptMode; // CRYPT_MODE_CBC (1)
383	unsigned int uCipherType; // TripleDES (0x6603)
384	unsigned int uHashType; // SHA1 (0x8004)
385	unsigned int uIVLen; // 8
386	unsigned int uHashLen; // 20
387	unsigned int uCipherLen; // 72
388	unsigned char iv[8];
389	unsigned char hash[20];
390	unsigned char cipherbytes[72];
391	} blurb = {
392	GUINT32_TO_LE(28),
393	GUINT32_TO_LE(1),
394	GUINT32_TO_LE(0x6603),
395	GUINT32_TO_LE(0x8004),
396	GUINT32_TO_LE(8),
397	GUINT32_TO_LE(20),
398	GUINT32_TO_LE(72),
399	};
400
401	if (sd->redirect) {
402	return MSN_SOAP_RETRY;
403	}
404
405	if (md->soapq) {
406	md->flags &= ~MSN_REAUTHING;
407	return msn_soapq_flush(ic, TRUE);
408	}
409
410	if (sd->secret == NULL) {
411	msn_auth_got_passport_token(ic, NULL, sd->error ? sd->error : soap_req->error);
412	return MSN_SOAP_OK;
413	}
414
415	key1_len = base64_decode(sd->secret, (unsigned char **) &key1);
416
417	key2 = msn_key_fuckery(key1, key1_len, "WS-SecureConversationSESSION KEY HASH");
418	key3 = msn_key_fuckery(key1, key1_len, "WS-SecureConversationSESSION KEY ENCRYPTION");
419
420	sha1_hmac(key2, 24, sd->nonce, 0, blurb.hash);
421	padnonce = g_malloc(strlen(sd->nonce) + 8);
422	strcpy((char *) padnonce, sd->nonce);
423	memset(padnonce + strlen(sd->nonce), 8, 8);
424
425	random_bytes(blurb.iv, 8);
426
427	ssl_des3_encrypt((unsigned char *) key3, 24, padnonce, strlen(sd->nonce) + 8, blurb.iv, &des3res);
428	memcpy(blurb.cipherbytes, des3res, 72);
429
430	blurb64 = base64_encode((unsigned char *) &blurb, sizeof(blurb));
431	msn_auth_got_passport_token(ic, blurb64, NULL);
432
433	g_free(padnonce);
434	g_free(blurb64);
435	g_free(des3res);
436	g_free(key1);
437	g_free(key2);
438	g_free(key3);
439
440	return MSN_SOAP_OK;
441	}
442
443	static int msn_soap_passport_sso_free_data(struct msn_soap_req_data *soap_req)
444	{
445	struct msn_soap_passport_sso_data *sd = soap_req->data;
446
447	g_free(sd->nonce);
448	g_free(sd->secret);
449	g_free(sd->error);
450	g_free(sd->redirect);
451	g_free(sd);
452
453	return MSN_SOAP_OK;
454	}
455
456	int msn_soap_passport_sso_request(struct im_connection ic, const char nonce)
457	{
458	struct msn_soap_passport_sso_data *sd = g_new0(struct msn_soap_passport_sso_data, 1);
459
460	sd->nonce = g_strdup(nonce);
461
462	return msn_soap_start(ic, sd, msn_soap_passport_sso_build_request,
463	msn_soap_passport_sso_parser,
464	msn_soap_passport_sso_handle_response,
465	msn_soap_passport_sso_free_data);
466	}
467
468
469	/* memlist: Fetching the membership list (NOT address book) */
470
471	static int msn_soap_memlist_build_request(struct msn_soap_req_data *soap_req)
472	{
473	struct msn_data *md = soap_req->ic->proto_data;
474
475	soap_req->url = g_strdup(SOAP_MEMLIST_URL);
476	soap_req->action = g_strdup(SOAP_MEMLIST_ACTION);
477	soap_req->payload = msn_soap_abservice_build(SOAP_MEMLIST_PAYLOAD, "Initial", md->tokens[1]);
478
479	return 1;
480	}
481
482	static xt_status msn_soap_memlist_member(struct xt_node *node, gpointer data)
483	{
484	bee_user_t *bu;
485	struct msn_buddy_data *bd;
486	struct xt_node *p;
487	char role = NULL, handle = NULL;
488	struct msn_soap_req_data *soap_req = data;
489	struct im_connection *ic = soap_req->ic;
490
491	if ((p = xt_find_path(node, "../../MemberRole"))) {
492	role = p->text;
493	}
494
495	if ((p = xt_find_node(node->children, "PassportName"))) {
496	handle = p->text;
497	}
498
499	if (!role \|\| !handle \|\|
500	!((bu = bee_user_by_handle(ic->bee, ic, handle)) \|\|
501	(bu = bee_user_new(ic->bee, ic, handle, 0)))) {
502	return XT_HANDLED;
503	}
504
505	bd = bu->data;
506	if (strcmp(role, "Allow") == 0) {
507	bd->flags \|= MSN_BUDDY_AL;
508	ic->permit = g_slist_prepend(ic->permit, g_strdup(handle));
509	} else if (strcmp(role, "Block") == 0) {
510	bd->flags \|= MSN_BUDDY_BL;
511	ic->deny = g_slist_prepend(ic->deny, g_strdup(handle));
512	} else if (strcmp(role, "Reverse") == 0) {
513	bd->flags \|= MSN_BUDDY_RL;
514	} else if (strcmp(role, "Pending") == 0) {
515	bd->flags \|= MSN_BUDDY_PL;
516	}
517
518	if (getenv("BITLBEE_DEBUG")) {
519	fprintf(stderr, "%p %s %d\n", bu, handle, bd->flags);
520	}
521
522	return XT_HANDLED;
523	}
524
525	static const struct xt_handler_entry msn_soap_memlist_parser[] = {
526	{ "Member", "Members", msn_soap_memlist_member },
527	{ NULL, NULL, NULL }
528	};
529
530	static int msn_soap_memlist_handle_response(struct msn_soap_req_data *soap_req)
531	{
532	msn_soap_addressbook_request(soap_req->ic);
533
534	return MSN_SOAP_OK;
535	}
536
537	static int msn_soap_memlist_free_data(struct msn_soap_req_data *soap_req)
538	{
539	return 0;
540	}
541
542	int msn_soap_memlist_request(struct im_connection *ic)
543	{
544	return msn_soap_start(ic, NULL, msn_soap_memlist_build_request,
545	msn_soap_memlist_parser,
546	msn_soap_memlist_handle_response,
547	msn_soap_memlist_free_data);
548	}
549
550	/* Variant: Adding/Removing people */
551	struct msn_soap_memlist_edit_data {
552	char *handle;
553	gboolean add;
554	msn_buddy_flags_t list;
555	};
556
557	static int msn_soap_memlist_edit_build_request(struct msn_soap_req_data *soap_req)
558	{
559	struct msn_data *md = soap_req->ic->proto_data;
560	struct msn_soap_memlist_edit_data *med = soap_req->data;
561	char add, scenario, *list;
562
563	soap_req->url = g_strdup(SOAP_MEMLIST_URL);
564	if (med->add) {
565	soap_req->action = g_strdup(SOAP_MEMLIST_ADD_ACTION);
566	add = "Add";
567	} else {
568	soap_req->action = g_strdup(SOAP_MEMLIST_DEL_ACTION);
569	add = "Delete";
570	}
571	switch (med->list) {
572	case MSN_BUDDY_AL:
573	scenario = "BlockUnblock";
574	list = "Allow";
575	break;
576	case MSN_BUDDY_BL:
577	scenario = "BlockUnblock";
578	list = "Block";
579	break;
580	case MSN_BUDDY_RL:
581	scenario = "Timer";
582	list = "Reverse";
583	break;
584	case MSN_BUDDY_PL:
585	default:
586	scenario = "Timer";
587	list = "Pending";
588	break;
589	}
590	soap_req->payload = msn_soap_abservice_build(SOAP_MEMLIST_EDIT_PAYLOAD,
591	scenario, md->tokens[1], add, list, med->handle, add);
592
593	return 1;
594	}
595
596	static int msn_soap_memlist_edit_handle_response(struct msn_soap_req_data *soap_req)
597	{
598	return MSN_SOAP_OK;
599	}
600
601	static int msn_soap_memlist_edit_free_data(struct msn_soap_req_data *soap_req)
602	{
603	struct msn_soap_memlist_edit_data *med = soap_req->data;
604
605	g_free(med->handle);
606	g_free(med);
607
608	return 0;
609	}
610
611	int msn_soap_memlist_edit(struct im_connection ic, const char handle, gboolean add, int list)
612	{
613	struct msn_soap_memlist_edit_data *med;
614
615	med = g_new0(struct msn_soap_memlist_edit_data, 1);
616	med->handle = g_strdup(handle);
617	med->add = add;
618	med->list = list;
619
620	return msn_soap_start(ic, med, msn_soap_memlist_edit_build_request,
621	NULL,
622	msn_soap_memlist_edit_handle_response,
623	msn_soap_memlist_edit_free_data);
624	}
625
626
627	/* addressbook: Fetching the membership list (NOT address book) */
628
629	static int msn_soap_addressbook_build_request(struct msn_soap_req_data *soap_req)
630	{
631	struct msn_data *md = soap_req->ic->proto_data;
632
633	soap_req->url = g_strdup(SOAP_ADDRESSBOOK_URL);
634	soap_req->action = g_strdup(SOAP_ADDRESSBOOK_ACTION);
635	soap_req->payload = msn_soap_abservice_build(SOAP_ADDRESSBOOK_PAYLOAD, "Initial", md->tokens[1]);
636
637	return 1;
638	}
639
640	static xt_status msn_soap_addressbook_group(struct xt_node *node, gpointer data)
641	{
642	struct xt_node *p;
643	char id = NULL, name = NULL;
644	struct msn_soap_req_data *soap_req = data;
645	struct msn_data *md = soap_req->ic->proto_data;
646
647	if ((p = xt_find_path(node, "../groupId"))) {
648	id = p->text;
649	}
650
651	if ((p = xt_find_node(node->children, "name"))) {
652	name = p->text;
653	}
654
655	if (id && name) {
656	struct msn_group *mg = g_new0(struct msn_group, 1);
657	mg->id = g_strdup(id);
658	mg->name = g_strdup(name);
659	md->groups = g_slist_prepend(md->groups, mg);
660	}
661
662	if (getenv("BITLBEE_DEBUG")) {
663	fprintf(stderr, "%s %s\n", id, name);
664	}
665
666	return XT_HANDLED;
667	}
668
669	static xt_status msn_soap_addressbook_contact(struct xt_node *node, gpointer data)
670	{
671	bee_user_t *bu;
672	struct msn_buddy_data *bd;
673	struct xt_node *p;
674	char id = NULL, type = NULL, handle = NULL, is_msgr = "false",
675	display_name = NULL, group_id = NULL;
676	struct msn_soap_req_data *soap_req = data;
677	struct im_connection *ic = soap_req->ic;
678	struct msn_group *group;
679
680	if ((p = xt_find_path(node, "../contactId"))) {
681	id = p->text;
682	}
683	if ((p = xt_find_node(node->children, "contactType"))) {
684	type = p->text;
685	}
686	if ((p = xt_find_node(node->children, "passportName"))) {
687	handle = p->text;
688	}
689	if ((p = xt_find_node(node->children, "displayName"))) {
690	display_name = p->text;
691	}
692	if ((p = xt_find_node(node->children, "isMessengerUser"))) {
693	is_msgr = p->text;
694	}
695	if ((p = xt_find_path(node, "groupIds/guid"))) {
696	group_id = p->text;
697	}
698
699	if (type && g_strcasecmp(type, "me") == 0) {
700	set_t *set = set_find(&ic->acc->set, "display_name");
701	g_free(set->value);
702	set->value = g_strdup(display_name);
703
704	/* Try to fetch the profile; if the user has one, that's where
705	we can find the persistent display_name. */
706	if ((p = xt_find_node(node->children, "CID")) && p->text) {
707	msn_soap_profile_get(ic, p->text);
708	}
709
710	return XT_HANDLED;
711	}
712
713	if (!bool2int(is_msgr) \|\| handle == NULL) {
714	return XT_HANDLED;
715	}
716
717	if (!(bu = bee_user_by_handle(ic->bee, ic, handle)) &&
718	!(bu = bee_user_new(ic->bee, ic, handle, 0))) {
719	return XT_HANDLED;
720	}
721
722	bd = bu->data;
723	bd->flags \|= MSN_BUDDY_FL;
724	g_free(bd->cid);
725	bd->cid = g_strdup(id);
726
727	imcb_rename_buddy(ic, handle, display_name);
728
729	if (group_id && (group = msn_group_by_id(ic, group_id))) {
730	imcb_add_buddy(ic, handle, group->name);
731	}
732
733	if (getenv("BITLBEE_DEBUG")) {
734	fprintf(stderr, "%s %s %s %s\n", id, type, handle, display_name);
735	}
736
737	return XT_HANDLED;
738	}
739
740	static const struct xt_handler_entry msn_soap_addressbook_parser[] = {
741	{ "contactInfo", "Contact", msn_soap_addressbook_contact },
742	{ "groupInfo", "Group", msn_soap_addressbook_group },
743	{ NULL, NULL, NULL }
744	};
745
746	static int msn_soap_addressbook_handle_response(struct msn_soap_req_data *soap_req)
747	{
748	GSList *l;
749	int wtf = 0;
750
751	for (l = soap_req->ic->bee->users; l; l = l->next) {
752	struct bee_user *bu = l->data;
753	struct msn_buddy_data *bd = bu->data;
754
755	if (bu->ic == soap_req->ic && bd) {
756	msn_buddy_ask(bu);
757
758	if ((bd->flags & (MSN_BUDDY_AL \| MSN_BUDDY_BL)) ==
759	(MSN_BUDDY_AL \| MSN_BUDDY_BL)) {
760	/* both allow and block, delete block, add wtf */
761	bd->flags &= ~MSN_BUDDY_BL;
762	wtf++;
763	}
764
765
766	if ((bd->flags & (MSN_BUDDY_AL \| MSN_BUDDY_BL)) == 0) {
767	/* neither allow or block, add allow */
768	bd->flags \|= MSN_BUDDY_AL;
769	}
770	}
771	}
772
773	if (wtf) {
774	imcb_log(soap_req->ic, "Warning: %d contacts were in both your "
775	"block and your allow list. Assuming they're all "
776	"allowed. Use the official WLM client once to fix "
777	"this.", wtf);
778	}
779
780	msn_auth_got_contact_list(soap_req->ic);
781
782	return MSN_SOAP_OK;
783	}
784
785	static int msn_soap_addressbook_free_data(struct msn_soap_req_data *soap_req)
786	{
787	return 0;
788	}
789
790	int msn_soap_addressbook_request(struct im_connection *ic)
791	{
792	return msn_soap_start(ic, NULL, msn_soap_addressbook_build_request,
793	msn_soap_addressbook_parser,
794	msn_soap_addressbook_handle_response,
795	msn_soap_addressbook_free_data);
796	}
797
798	/* Variant: Change our display name. */
799	static int msn_soap_ab_namechange_build_request(struct msn_soap_req_data *soap_req)
800	{
801	struct msn_data *md = soap_req->ic->proto_data;
802
803	soap_req->url = g_strdup(SOAP_ADDRESSBOOK_URL);
804	soap_req->action = g_strdup(SOAP_AB_NAMECHANGE_ACTION);
805	soap_req->payload = msn_soap_abservice_build(SOAP_AB_NAMECHANGE_PAYLOAD,
806	"Timer", md->tokens[1], (char *) soap_req->data);
807
808	return 1;
809	}
810
811	static int msn_soap_ab_namechange_handle_response(struct msn_soap_req_data *soap_req)
812	{
813	/* TODO: Ack the change? Not sure what the NAKs look like.. */
814	return MSN_SOAP_OK;
815	}
816
817	static int msn_soap_ab_namechange_free_data(struct msn_soap_req_data *soap_req)
818	{
819	g_free(soap_req->data);
820	return 0;
821	}
822
823	int msn_soap_addressbook_set_display_name(struct im_connection ic, const char new)
824	{
825	return msn_soap_start(ic, g_strdup(new),
826	msn_soap_ab_namechange_build_request,
827	NULL,
828	msn_soap_ab_namechange_handle_response,
829	msn_soap_ab_namechange_free_data);
830	}
831
832	/* Add a contact. */
833	static int msn_soap_ab_contact_add_build_request(struct msn_soap_req_data *soap_req)
834	{
835	struct msn_data *md = soap_req->ic->proto_data;
836	bee_user_t *bu = soap_req->data;
837
838	soap_req->url = g_strdup(SOAP_ADDRESSBOOK_URL);
839	soap_req->action = g_strdup(SOAP_AB_CONTACT_ADD_ACTION);
840	soap_req->payload = msn_soap_abservice_build(SOAP_AB_CONTACT_ADD_PAYLOAD,
841	"ContactSave", md->tokens[1], bu->handle,
842	bu->fullname ? bu->fullname : bu->handle);
843
844	return 1;
845	}
846
847	static xt_status msn_soap_ab_contact_add_cid(struct xt_node *node, gpointer data)
848	{
849	struct msn_soap_req_data *soap_req = data;
850	bee_user_t *bu = soap_req->data;
851	struct msn_buddy_data *bd = bu->data;
852
853	g_free(bd->cid);
854	bd->cid = g_strdup(node->text);
855
856	return XT_HANDLED;
857	}
858
859	static const struct xt_handler_entry msn_soap_ab_contact_add_parser[] = {
860	{ "guid", "ABContactAddResult", msn_soap_ab_contact_add_cid },
861	{ NULL, NULL, NULL }
862	};
863
864	static int msn_soap_ab_contact_add_handle_response(struct msn_soap_req_data *soap_req)
865	{
866	/* TODO: Ack the change? Not sure what the NAKs look like.. */
867	return MSN_SOAP_OK;
868	}
869
870	static int msn_soap_ab_contact_add_free_data(struct msn_soap_req_data *soap_req)
871	{
872	return 0;
873	}
874
875	int msn_soap_ab_contact_add(struct im_connection ic, bee_user_t bu)
876	{
877	return msn_soap_start(ic, bu,
878	msn_soap_ab_contact_add_build_request,
879	msn_soap_ab_contact_add_parser,
880	msn_soap_ab_contact_add_handle_response,
881	msn_soap_ab_contact_add_free_data);
882	}
883
884	/* Remove a contact. */
885	static int msn_soap_ab_contact_del_build_request(struct msn_soap_req_data *soap_req)
886	{
887	struct msn_data *md = soap_req->ic->proto_data;
888	const char *cid = soap_req->data;
889
890	soap_req->url = g_strdup(SOAP_ADDRESSBOOK_URL);
891	soap_req->action = g_strdup(SOAP_AB_CONTACT_DEL_ACTION);
892	soap_req->payload = msn_soap_abservice_build(SOAP_AB_CONTACT_DEL_PAYLOAD,
893	"Timer", md->tokens[1], cid);
894
895	return 1;
896	}
897
898	static int msn_soap_ab_contact_del_handle_response(struct msn_soap_req_data *soap_req)
899	{
900	/* TODO: Ack the change? Not sure what the NAKs look like.. */
901	return MSN_SOAP_OK;
902	}
903
904	static int msn_soap_ab_contact_del_free_data(struct msn_soap_req_data *soap_req)
905	{
906	g_free(soap_req->data);
907	return 0;
908	}
909
910	int msn_soap_ab_contact_del(struct im_connection ic, bee_user_t bu)
911	{
912	struct msn_buddy_data *bd = bu->data;
913
914	return msn_soap_start(ic, g_strdup(bd->cid),
915	msn_soap_ab_contact_del_build_request,
916	NULL,
917	msn_soap_ab_contact_del_handle_response,
918	msn_soap_ab_contact_del_free_data);
919	}
920
921
922
923	/* Storage stuff: Fetch profile. */
924	static int msn_soap_profile_get_build_request(struct msn_soap_req_data *soap_req)
925	{
926	struct msn_data *md = soap_req->ic->proto_data;
927
928	soap_req->url = g_strdup(SOAP_STORAGE_URL);
929	soap_req->action = g_strdup(SOAP_PROFILE_GET_ACTION);
930	soap_req->payload = g_markup_printf_escaped(SOAP_PROFILE_GET_PAYLOAD,
931	md->tokens[3], (char *) soap_req->data);
932
933	return 1;
934	}
935
936	static xt_status msn_soap_profile_get_result(struct xt_node *node, gpointer data)
937	{
938	struct msn_soap_req_data *soap_req = data;
939	struct im_connection *ic = soap_req->ic;
940	struct msn_data *md = soap_req->ic->proto_data;
941	struct xt_node *dn;
942
943	if ((dn = xt_find_node(node->children, "DisplayName")) && dn->text) {
944	set_t *set = set_find(&ic->acc->set, "display_name");
945	g_free(set->value);
946	set->value = g_strdup(dn->text);
947
948	md->flags \|= MSN_GOT_PROFILE_DN;
949	}
950
951	return XT_HANDLED;
952	}
953
954	static xt_status msn_soap_profile_get_rid(struct xt_node *node, gpointer data)
955	{
956	struct msn_soap_req_data *soap_req = data;
957	struct msn_data *md = soap_req->ic->proto_data;
958
959	g_free(md->profile_rid);
960	md->profile_rid = g_strdup(node->text);
961
962	return XT_HANDLED;
963	}
964
965	static const struct xt_handler_entry msn_soap_profile_get_parser[] = {
966	{ "ExpressionProfile", "GetProfileResult", msn_soap_profile_get_result },
967	{ "ResourceID", "GetProfileResult", msn_soap_profile_get_rid },
968	{ NULL, NULL, NULL }
969	};
970
971	static int msn_soap_profile_get_handle_response(struct msn_soap_req_data *soap_req)
972	{
973	struct msn_data *md = soap_req->ic->proto_data;
974
975	md->flags \|= MSN_GOT_PROFILE;
976	msn_ns_finish_login(soap_req->ic);
977
978	return MSN_SOAP_OK;
979	}
980
981	static int msn_soap_profile_get_free_data(struct msn_soap_req_data *soap_req)
982	{
983	g_free(soap_req->data);
984	return 0;
985	}
986
987	int msn_soap_profile_get(struct im_connection ic, const char cid)
988	{
989	return msn_soap_start(ic, g_strdup(cid),
990	msn_soap_profile_get_build_request,
991	msn_soap_profile_get_parser,
992	msn_soap_profile_get_handle_response,
993	msn_soap_profile_get_free_data);
994	}
995
996	/* Update profile (display name). */
997	static int msn_soap_profile_set_dn_build_request(struct msn_soap_req_data *soap_req)
998	{
999	struct msn_data *md = soap_req->ic->proto_data;
1000
1001	soap_req->url = g_strdup(SOAP_STORAGE_URL);
1002	soap_req->action = g_strdup(SOAP_PROFILE_SET_DN_ACTION);
1003	soap_req->payload = g_markup_printf_escaped(SOAP_PROFILE_SET_DN_PAYLOAD,
1004	md->tokens[3], md->profile_rid, (char *) soap_req->data);
1005
1006	return 1;
1007	}
1008
1009	static const struct xt_handler_entry msn_soap_profile_set_dn_parser[] = {
1010	{ NULL, NULL, NULL }
1011	};
1012
1013	static int msn_soap_profile_set_dn_handle_response(struct msn_soap_req_data *soap_req)
1014	{
1015	return MSN_SOAP_OK;
1016	}
1017
1018	static int msn_soap_profile_set_dn_free_data(struct msn_soap_req_data *soap_req)
1019	{
1020	g_free(soap_req->data);
1021	return 0;
1022	}
1023
1024	int msn_soap_profile_set_dn(struct im_connection ic, const char dn)
1025	{
1026	return msn_soap_start(ic, g_strdup(dn),
1027	msn_soap_profile_set_dn_build_request,
1028	msn_soap_profile_set_dn_parser,
1029	msn_soap_profile_set_dn_handle_response,
1030	msn_soap_profile_set_dn_free_data);
1031	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: