?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
appshare: process incoming invite
[siplcs.git] / src / core / sipe-lync-autodiscover.c
blob1f72f3496e838ba98a18b193b707f1b248ccc988
1 /**
2 * @file sipe-lync-autodiscover.c
3 *
4 * pidgin-sipe
5 *
6 * Copyright (C) 2016 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: 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: topology information of the user’s home server */
190 if ((node = sipe_xml_child(xml, "User")) != NULL) {
191 gpointer id = request->id;
192
193 /* Active request? */
194 if (id) {
195 GSList *servers;
196
197 /* List is reversed, i.e. internal will be tried first */
198 servers = g_slist_prepend(NULL, NULL);
199 servers = sipe_lync_autodiscover_add(servers,
200 node,
201 "SipClientExternalAccess");
202 servers = sipe_lync_autodiscover_add(servers,
203 node,
204 "SipClientInternalAccess");
205
206 /* Callback takes ownership of servers list */
207 (*request->cb)(sipe_private, servers, request->cb_data);
208
209 /* We're done with requests for this callback */
210 FOR_ALL_REQUESTS_WITH_SAME_ID( \
211 lar->cb = NULL; \
212 lar->id = NULL \
213 );
214
215 }
216
217 /* Request completed */
218 next = FALSE;
219 sipe_lync_autodiscover_request_free(sipe_private, request);
220 /* request is invalid */
221 }
222
223 sipe_xml_free(xml);
224
225 if (next)
226 sipe_lync_autodiscover_queue_request(sipe_private, request);
227 }
228
229 static void sipe_lync_autodiscover_webticket(struct sipe_core_private *sipe_private,
230 SIPE_UNUSED_PARAMETER const gchar *base_uri,
231 const gchar *auth_uri,
232 const gchar *wsse_security,
233 SIPE_UNUSED_PARAMETER const gchar *failure_msg,
234 gpointer callback_data)
235 {
236 struct lync_autodiscover_request *request = callback_data;
237 gchar *saml;
238
239 /* Extract SAML Assertion from WSSE Security XML text */
240 if (wsse_security &&
241 ((saml = sipe_xml_extract_raw(wsse_security,
242 "Assertion",
243 TRUE)) != NULL)) {
244 gchar *base64 = g_base64_encode((const guchar *) saml,
245 strlen(saml));
246 gchar *headers = g_strdup_printf(LYNC_AUTODISCOVER_ACCEPT_HEADER
247 "X-MS-WebTicket: opaque=%s\r\n",
248 base64);
249 g_free(base64);
250
251 SIPE_DEBUG_INFO("sipe_lync_autodiscover_webticket: got ticket for Auth URI %s",
252 auth_uri);
253 g_free(saml);
254
255 lync_request(sipe_private, request, auth_uri, headers);
256 g_free(headers);
257
258 } else
259 sipe_lync_autodiscover_queue_request(sipe_private, request);
260 }
261
262 static void sipe_lync_autodiscover_cb(struct sipe_core_private *sipe_private,
263 guint status,
264 GSList *headers,
265 const gchar *body,
266 gpointer callback_data)
267 {
268 struct lync_autodiscover_request *request = callback_data;
269 const gchar *type = sipe_utils_nameval_find(headers, "Content-Type");
270 gchar *uri = request->uri;
271
272 request->request = NULL;
273 request->uri = NULL;
274
275 switch (status) {
276 case SIPE_HTTP_STATUS_OK:
277 /* only accept Autodiscover XML responses */
278 if (body && g_str_has_prefix(type, "application/vnd.microsoft.rtc.autodiscover+xml"))
279 sipe_lync_autodiscover_parse(sipe_private, request, body);
280 else
281 sipe_lync_autodiscover_queue_request(sipe_private, request);
282 break;
283
284 case SIPE_HTTP_STATUS_FAILED:
285 {
286 if (uri) {
287 /* check for authentication failure */
288 const gchar *webticket_uri = sipe_utils_nameval_find(headers,
289 "X-MS-WebTicketURL");
290
291 if (!(webticket_uri &&
292 sipe_webticket_request_with_auth(sipe_private,
293 request->session,
294 webticket_uri,
295 uri, /* Auth URI */
296 sipe_lync_autodiscover_webticket,
297 request)))
298 sipe_lync_autodiscover_queue_request(sipe_private, request);
299 } else
300 sipe_lync_autodiscover_queue_request(sipe_private, request);
301 }
302 break;
303
304 case SIPE_HTTP_STATUS_ABORTED:
305 /* we are not allowed to generate new requests */
306 sipe_lync_autodiscover_request_free(sipe_private, request);
307 break;
308
309 default:
310 sipe_lync_autodiscover_queue_request(sipe_private, request);
311 break;
312 }
313
314 g_free(uri);
315 }
316
317 /* Proceed to next method for request */
318 static void sipe_lync_autodiscover_request(struct sipe_core_private *sipe_private,
319 struct lync_autodiscover_request *request)
320 {
321 gpointer id = request->id;
322
323 /* Active request? */
324 if (id) {
325 static const gchar *methods[] = {
326 "%s://LyncDiscoverInternal.%s/?sipuri=%s",
327 "%s://LyncDiscover.%s/?sipuri=%s",
328 NULL
329 };
330
331 request->is_pending = TRUE;
332
333 if (request->method)
334 request->method++;
335 else
336 request->method = methods;
337
338 if (*request->method) {
339 gchar *uri = g_strdup_printf(*request->method,
340 request->protocol,
341 SIPE_CORE_PUBLIC->sip_domain,
342 sipe_private->username);
343
344 SIPE_DEBUG_INFO("sipe_lync_autodiscover_request: trying '%s'", uri);
345
346 lync_request(sipe_private, request, uri, NULL);
347 g_free(uri);
348
349 } else {
350 guint count = 0;
351
352 /* Count entries with the same request ID */
353 FOR_ALL_REQUESTS_WITH_SAME_ID( \
354 count++; \
355 );
356
357 if (count == 1) {
358 /*
359 * This is the last pending request for this
360 * ID, i.e. autodiscover has failed. Create
361 * empty server list and return it.
362 */
363 GSList *servers = g_slist_prepend(NULL, NULL);
364
365 /* All methods tried, indicate failure to caller */
366 SIPE_DEBUG_INFO_NOFORMAT("sipe_lync_autodiscover_request: no more methods to try!");
367
368 /* Callback takes ownership of servers list */
369 (*request->cb)(sipe_private, servers, request->cb_data);
370 }
371
372 /* Request completed */
373 request->cb = NULL;
374 sipe_lync_autodiscover_request_free(sipe_private, request);
375 /* request is invalid */
376 }
377 } else {
378 /* Inactive request, callback already NULL */
379 sipe_lync_autodiscover_request_free(sipe_private, request);
380 /* request is invalid */
381 }
382 }
383
384 /* Proceed to next method for all requests */
385 static void sipe_lync_autodiscover_queue_request(struct sipe_core_private *sipe_private,
386 struct lync_autodiscover_request *request)
387 {
388 gpointer id = request->id;
389
390 /* This request is ready to proceed to next method */
391 request->is_pending = FALSE;
392
393 /* Is any request for the same ID still pending? */
394 FOR_ALL_REQUESTS_WITH_SAME_ID( \
395 if (lar->is_pending) \
396 return \
397 );
398
399 SIPE_DEBUG_INFO_NOFORMAT("sipe_lync_autodiscover_queue_request: proceed in lockstep");
400
401 /* No, proceed to next method for all requests */
402 FOR_ALL_REQUESTS_WITH_SAME_ID( \
403 sipe_lync_autodiscover_request(sipe_private, \
404 lar) \
405 );
406 }
407
408 static gpointer sipe_lync_autodiscover_create(struct sipe_core_private *sipe_private,
409 gpointer id,
410 const gchar *protocol,
411 sipe_lync_autodiscover_callback *callback,
412 gpointer callback_data)
413 {
414 struct sipe_lync_autodiscover *sla = sipe_private->lync_autodiscover;
415 struct lync_autodiscover_request *request = g_new0(struct lync_autodiscover_request, 1);
416
417 /* use address of first request structure as unique ID */
418 if (id == NULL)
419 id = request;
420
421 request->protocol = protocol;
422 request->cb = callback;
423 request->cb_data = callback_data;
424 request->id = id;
425 request->session = sipe_svc_session_start();
426
427 sla->pending_requests = g_slist_prepend(sla->pending_requests,
428 request);
429
430 sipe_lync_autodiscover_request(sipe_private, request);
431
432 return(id);
433 }
434
435 void sipe_lync_autodiscover_start(struct sipe_core_private *sipe_private,
436 sipe_lync_autodiscover_callback *callback,
437 gpointer callback_data)
438 {
439 gpointer id = NULL;
440
441 #define CREATE(protocol) \
442 id = sipe_lync_autodiscover_create(sipe_private, \
443 id, \
444 #protocol, \
445 callback, \
446 callback_data)
447 CREATE(http);
448 CREATE(https);
449 }
450
451 void sipe_lync_autodiscover_init(struct sipe_core_private *sipe_private)
452 {
453 struct sipe_lync_autodiscover *sla = g_new0(struct sipe_lync_autodiscover, 1);
454
455 sipe_private->lync_autodiscover = sla;
456 }
457
458 void sipe_lync_autodiscover_free(struct sipe_core_private *sipe_private)
459 {
460 struct sipe_lync_autodiscover *sla = sipe_private->lync_autodiscover;
461
462 while (sla->pending_requests)
463 sipe_lync_autodiscover_request_free(sipe_private,
464 sla->pending_requests->data);
465
466 g_free(sla);
467 sipe_private->lync_autodiscover = NULL;
468 }
469
470 /*
471 Local Variables:
472 mode: c
473 c-file-style: "bsd"
474 indent-tabs-mode: t
475 tab-width: 8
476 End:
477 */
A third-party Pidgin plugin for Microsoft LCS/OCS