?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix #336: Lync autodiscover does not follow user redirect
[siplcs.git] / src / core / sipe-lync-autodiscover.c
blobc083f2e9b61b13cab4df08075790025b677daf40
1 /**
2 * @file sipe-lync-autodiscover.c
3 *
4 * pidgin-sipe
5 *
6 * Copyright (C) 2016-2017 SIPE Project <http://sipe.sourceforge.net/>
7 *
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 *
23 * Specification references:
24 *
25 * - [MS-OCDISCWS]: https://msdn.microsoft.com/en-us/library/hh623245.aspx
26 * - Understanding Autodiscover in Lync Server 2013
27 * https://technet.microsoft.com/en-us/library/jj945654.aspx
28 */
29
30 #include <string.h>
31
32 #include <glib.h>
33
34 #include "sipe-common.h"
35 #include "sipe-backend.h"
36 #include "sipe-core.h"
37 #include "sipe-core-private.h"
38 #include "sipe-http.h"
39 #include "sipe-lync-autodiscover.h"
40 #include "sipe-utils.h"
41 #include "sipe-svc.h"
42 #include "sipe-webticket.h"
43 #include "sipe-xml.h"
44
45 #define LYNC_AUTODISCOVER_ACCEPT_HEADER \
46 "Accept: application/vnd.microsoft.rtc.autodiscover+xml;v=1\r\n"
47
48 struct lync_autodiscover_request {
49 sipe_lync_autodiscover_callback *cb;
50 gpointer cb_data;
51 gpointer id; /* != NULL for active request */
52 struct sipe_http_request *request;
53 struct sipe_svc_session *session;
54 const gchar *protocol;
55 const gchar **method;
56 gchar *uri;
57 gboolean is_pending;
58 };
59
60 struct sipe_lync_autodiscover {
61 GSList *pending_requests;
62 };
63
64 /* Use "lar" inside the code fragment */
65 #define FOR_ALL_REQUESTS_WITH_SAME_ID(code) \
66 { \
67 GSList *entry = sipe_private->lync_autodiscover->pending_requests; \
68 while (entry) { \
69 struct lync_autodiscover_request *lar = entry->data; \
70 entry = entry->next; \
71 if (lar->id == id) { \
72 code; \
73 } \
74 } \
75 }
76
77 static void sipe_lync_autodiscover_request_free(struct sipe_core_private *sipe_private,
78 struct lync_autodiscover_request *request)
79 {
80 struct sipe_lync_autodiscover *sla = sipe_private->lync_autodiscover;
81
82 sla->pending_requests = g_slist_remove(sla->pending_requests, request);
83
84 if (request->request)
85 sipe_http_request_cancel(request->request);
86 if (request->cb)
87 /* Callback: aborted */
88 (*request->cb)(sipe_private, NULL, request->cb_data);
89 sipe_svc_session_close(request->session);
90 g_free(request->uri);
91 g_free(request);
92 }
93
94 static void sipe_lync_autodiscover_cb(struct sipe_core_private *sipe_private,
95 guint status,
96 GSList *headers,
97 const gchar *body,
98 gpointer callback_data);
99 static void lync_request(struct sipe_core_private *sipe_private,
100 struct lync_autodiscover_request *request,
101 const gchar *uri,
102 const gchar *headers)
103 {
104 request->request = sipe_http_request_get(sipe_private,
105 uri,
106 headers ? headers : LYNC_AUTODISCOVER_ACCEPT_HEADER,
107 sipe_lync_autodiscover_cb,
108 request);
109 }
110
111 static GSList *sipe_lync_autodiscover_add(GSList *servers,
112 const sipe_xml *node,
113 const gchar *name)
114 {
115 const sipe_xml *child = sipe_xml_child(node, name);
116 const gchar *fqdn = sipe_xml_attribute(child, "fqdn");
117 guint port = sipe_xml_int_attribute(child, "port", 0);
118
119 /* Add new entry to head of list */
120 if (fqdn && (port != 0)) {
121 struct sipe_lync_autodiscover_data *lync_data = g_new0(struct sipe_lync_autodiscover_data, 1);
122 lync_data->server = g_strdup(fqdn);
123 lync_data->port = port;
124 servers = g_slist_prepend(servers, lync_data);
125 }
126
127 return(servers);
128 }
129
130 GSList *sipe_lync_autodiscover_pop(GSList *servers)
131 {
132 if (servers) {
133 struct sipe_lync_autodiscover_data *lync_data = servers->data;
134 servers = g_slist_remove(servers, lync_data);
135
136 if (lync_data) {
137 g_free((gchar *) lync_data->server);
138 g_free(lync_data);
139 }
140 }
141
142 return(servers);
143 }
144
145 static void sipe_lync_autodiscover_queue_request(struct sipe_core_private *sipe_private,
146 struct lync_autodiscover_request *request);
147 static void sipe_lync_autodiscover_parse(struct sipe_core_private *sipe_private,
148 struct lync_autodiscover_request *request,
149 const gchar *body)
150 {
151 sipe_xml *xml = sipe_xml_parse(body, strlen(body));
152 const sipe_xml *node;
153 gboolean next = TRUE;
154
155 /* Root/Link: resources exposed by this server */
156 for (node = sipe_xml_child(xml, "Root/Link");
157 node;
158 node = sipe_xml_twin(node)) {
159 const gchar *token = sipe_xml_attribute(node, "token");
160 const gchar *uri = sipe_xml_attribute(node, "href");
161
162 if (token && uri) {
163 /* Redirect? */
164 if (sipe_strcase_equal(token, "Redirect")) {
165 SIPE_DEBUG_INFO("sipe_lync_autodiscover_parse: redirect to %s",
166 uri);
167 lync_request(sipe_private, request, uri, NULL);
168 next = FALSE;
169 break;
170
171 /* User? */
172 } else if (sipe_strcase_equal(token, "User")) {
173 SIPE_DEBUG_INFO("sipe_lync_autodiscover_parse: user %s",
174 uri);
175
176 /* remember URI for authentication failure */
177 request->uri = g_strdup(uri);
178
179 lync_request(sipe_private, request, uri, NULL);
180 next = FALSE;
181 break;
182
183 } else
184 SIPE_DEBUG_INFO("sipe_lync_autodiscover_parse: unknown token %s",
185 token);
186 }
187 }
188
189 /* User/Link: topology information of the user’s home server */
190 for (node = sipe_xml_child(xml, "User/Link");
191 node;
192 node = sipe_xml_twin(node)) {
193 const gchar *token = sipe_xml_attribute(node, "token");
194 const gchar *uri = sipe_xml_attribute(node, "href");
195
196 if (token && uri) {
197 /* Redirect? */
198 if (sipe_strcase_equal(token, "Redirect")) {
199 SIPE_DEBUG_INFO("sipe_lync_autodiscover_parse: redirect to %s",
200 uri);
201 lync_request(sipe_private, request, uri, NULL);
202 next = FALSE;
203 break;
204 } else
205 SIPE_DEBUG_INFO("sipe_lync_autodiscover_parse: unknown token %s",
206 token);
207 }
208 }
209
210 /* if nothing else matched */
211 if (next) {
212 const gchar *access_location = sipe_xml_attribute(xml, "AccessLocation");
213
214 /* User: topology information of the user’s home server */
215 if ((node = sipe_xml_child(xml, "User")) != NULL) {
216 gpointer id = request->id;
217
218 /* Active request? */
219 if (id) {
220 GSList *servers;
221
222 /* List is reversed, i.e. internal will be tried first */
223 servers = g_slist_prepend(NULL, NULL);
224
225 if (!access_location ||
226 sipe_strcase_equal(access_location, "external")) {
227 servers = sipe_lync_autodiscover_add(servers,
228 node,
229 "SipClientExternalAccess");
230 }
231
232 if (!access_location ||
233 sipe_strcase_equal(access_location, "internal")) {
234 servers = sipe_lync_autodiscover_add(servers,
235 node,
236 "SipClientInternalAccess");
237 }
238
239 /* Callback takes ownership of servers list */
240 (*request->cb)(sipe_private, servers, request->cb_data);
241
242 /* We're done with requests for this callback */
243 FOR_ALL_REQUESTS_WITH_SAME_ID( \
244 lar->cb = NULL; \
245 lar->id = NULL \
246 );
247
248 }
249
250 /* Request completed */
251 next = FALSE;
252 sipe_lync_autodiscover_request_free(sipe_private, request);
253 /* request is invalid */
254 }
255 }
256
257 sipe_xml_free(xml);
258
259 if (next)
260 sipe_lync_autodiscover_queue_request(sipe_private, request);
261 }
262
263 static void sipe_lync_autodiscover_webticket(struct sipe_core_private *sipe_private,
264 SIPE_UNUSED_PARAMETER const gchar *base_uri,
265 const gchar *auth_uri,
266 const gchar *wsse_security,
267 SIPE_UNUSED_PARAMETER const gchar *failure_msg,
268 gpointer callback_data)
269 {
270 struct lync_autodiscover_request *request = callback_data;
271 gchar *saml;
272
273 /* Extract SAML Assertion from WSSE Security XML text */
274 if (wsse_security &&
275 ((saml = sipe_xml_extract_raw(wsse_security,
276 "Assertion",
277 TRUE)) != NULL)) {
278 gchar *base64 = g_base64_encode((const guchar *) saml,
279 strlen(saml));
280 gchar *headers = g_strdup_printf(LYNC_AUTODISCOVER_ACCEPT_HEADER
281 "X-MS-WebTicket: opaque=%s\r\n",
282 base64);
283 g_free(base64);
284
285 SIPE_DEBUG_INFO("sipe_lync_autodiscover_webticket: got ticket for Auth URI %s",
286 auth_uri);
287 g_free(saml);
288
289 lync_request(sipe_private, request, auth_uri, headers);
290 g_free(headers);
291
292 } else
293 sipe_lync_autodiscover_queue_request(sipe_private, request);
294 }
295
296 static void sipe_lync_autodiscover_cb(struct sipe_core_private *sipe_private,
297 guint status,
298 GSList *headers,
299 const gchar *body,
300 gpointer callback_data)
301 {
302 struct lync_autodiscover_request *request = callback_data;
303 const gchar *type = sipe_utils_nameval_find(headers, "Content-Type");
304 gchar *uri = request->uri;
305
306 request->request = NULL;
307 request->uri = NULL;
308
309 switch (status) {
310 case SIPE_HTTP_STATUS_OK:
311 /* only accept Autodiscover XML responses */
312 if (body && g_str_has_prefix(type, "application/vnd.microsoft.rtc.autodiscover+xml"))
313 sipe_lync_autodiscover_parse(sipe_private, request, body);
314 else
315 sipe_lync_autodiscover_queue_request(sipe_private, request);
316 break;
317
318 case SIPE_HTTP_STATUS_FAILED:
319 {
320 if (uri) {
321 /* check for authentication failure */
322 const gchar *webticket_uri = sipe_utils_nameval_find(headers,
323 "X-MS-WebTicketURL");
324
325 if (!(webticket_uri &&
326 sipe_webticket_request_with_auth(sipe_private,
327 request->session,
328 webticket_uri,
329 uri, /* Auth URI */
330 sipe_lync_autodiscover_webticket,
331 request)))
332 sipe_lync_autodiscover_queue_request(sipe_private, request);
333 } else
334 sipe_lync_autodiscover_queue_request(sipe_private, request);
335 }
336 break;
337
338 case SIPE_HTTP_STATUS_ABORTED:
339 /* we are not allowed to generate new requests */
340 sipe_lync_autodiscover_request_free(sipe_private, request);
341 break;
342
343 default:
344 sipe_lync_autodiscover_queue_request(sipe_private, request);
345 break;
346 }
347
348 g_free(uri);
349 }
350
351 /* Proceed to next method for request */
352 static void sipe_lync_autodiscover_request(struct sipe_core_private *sipe_private,
353 struct lync_autodiscover_request *request)
354 {
355 gpointer id = request->id;
356
357 /* Active request? */
358 if (id) {
359 static const gchar *methods[] = {
360 "%s://LyncDiscoverInternal.%s/?sipuri=%s",
361 "%s://LyncDiscover.%s/?sipuri=%s",
362 NULL
363 };
364
365 request->is_pending = TRUE;
366
367 if (request->method)
368 request->method++;
369 else
370 request->method = methods;
371
372 if (*request->method) {
373 gchar *uri = g_strdup_printf(*request->method,
374 request->protocol,
375 SIPE_CORE_PUBLIC->sip_domain,
376 sipe_private->username);
377
378 SIPE_DEBUG_INFO("sipe_lync_autodiscover_request: trying '%s'", uri);
379
380 lync_request(sipe_private, request, uri, NULL);
381 g_free(uri);
382
383 } else {
384 guint count = 0;
385
386 /* Count entries with the same request ID */
387 FOR_ALL_REQUESTS_WITH_SAME_ID( \
388 count++; \
389 );
390
391 if (count == 1) {
392 /*
393 * This is the last pending request for this
394 * ID, i.e. autodiscover has failed. Create
395 * empty server list and return it.
396 */
397 GSList *servers = g_slist_prepend(NULL, NULL);
398
399 /* All methods tried, indicate failure to caller */
400 SIPE_DEBUG_INFO_NOFORMAT("sipe_lync_autodiscover_request: no more methods to try!");
401
402 /* Callback takes ownership of servers list */
403 (*request->cb)(sipe_private, servers, request->cb_data);
404 }
405
406 /* Request completed */
407 request->cb = NULL;
408 sipe_lync_autodiscover_request_free(sipe_private, request);
409 /* request is invalid */
410 }
411 } else {
412 /* Inactive request, callback already NULL */
413 sipe_lync_autodiscover_request_free(sipe_private, request);
414 /* request is invalid */
415 }
416 }
417
418 /* Proceed to next method for all requests */
419 static void sipe_lync_autodiscover_queue_request(struct sipe_core_private *sipe_private,
420 struct lync_autodiscover_request *request)
421 {
422 gpointer id = request->id;
423
424 /* This request is ready to proceed to next method */
425 request->is_pending = FALSE;
426
427 /* Is any request for the same ID still pending? */
428 FOR_ALL_REQUESTS_WITH_SAME_ID( \
429 if (lar->is_pending) \
430 return \
431 );
432
433 SIPE_DEBUG_INFO_NOFORMAT("sipe_lync_autodiscover_queue_request: proceed in lockstep");
434
435 /* No, proceed to next method for all requests */
436 FOR_ALL_REQUESTS_WITH_SAME_ID( \
437 sipe_lync_autodiscover_request(sipe_private, \
438 lar) \
439 );
440 }
441
442 static gpointer sipe_lync_autodiscover_create(struct sipe_core_private *sipe_private,
443 gpointer id,
444 const gchar *protocol,
445 sipe_lync_autodiscover_callback *callback,
446 gpointer callback_data)
447 {
448 struct sipe_lync_autodiscover *sla = sipe_private->lync_autodiscover;
449 struct lync_autodiscover_request *request = g_new0(struct lync_autodiscover_request, 1);
450
451 /* use address of first request structure as unique ID */
452 if (id == NULL)
453 id = request;
454
455 request->protocol = protocol;
456 request->cb = callback;
457 request->cb_data = callback_data;
458 request->id = id;
459 request->session = sipe_svc_session_start();
460
461 sla->pending_requests = g_slist_prepend(sla->pending_requests,
462 request);
463
464 sipe_lync_autodiscover_request(sipe_private, request);
465
466 return(id);
467 }
468
469 void sipe_lync_autodiscover_start(struct sipe_core_private *sipe_private,
470 sipe_lync_autodiscover_callback *callback,
471 gpointer callback_data)
472 {
473 gpointer id = NULL;
474
475 #define CREATE(protocol) \
476 id = sipe_lync_autodiscover_create(sipe_private, \
477 id, \
478 #protocol, \
479 callback, \
480 callback_data)
481 CREATE(http);
482 CREATE(https);
483 }
484
485 void sipe_lync_autodiscover_init(struct sipe_core_private *sipe_private)
486 {
487 struct sipe_lync_autodiscover *sla = g_new0(struct sipe_lync_autodiscover, 1);
488
489 sipe_private->lync_autodiscover = sla;
490 }
491
492 void sipe_lync_autodiscover_free(struct sipe_core_private *sipe_private)
493 {
494 struct sipe_lync_autodiscover *sla = sipe_private->lync_autodiscover;
495
496 while (sla->pending_requests)
497 sipe_lync_autodiscover_request_free(sipe_private,
498 sla->pending_requests->data);
499
500 g_free(sla);
501 sipe_private->lync_autodiscover = NULL;
502 }
503
504 /*
505 Local Variables:
506 mode: c
507 c-file-style: "bsd"
508 indent-tabs-mode: t
509 tab-width: 8
510 End:
511 */
A third-party Pidgin plugin for Microsoft LCS/OCS