?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ucs: add AddImGroup operation
[siplcs.git] / src / core / sipe-ucs.c
blobac97fb167b34bf40db0dbf2daab8f90521fc9ab6
1 /**
2 * @file sipe-ucs.c
3 *
4 * pidgin-sipe
5 *
6 * Copyright (C) 2013 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 *
24 * Implementation for Unified Contact Store [MS-OXWSCOS]
25 * <http://msdn.microsoft.com/en-us/library/jj194130.aspx>
26 */
27
28 #include <string.h>
29
30 #include <glib.h>
31
32 #include "sipe-backend.h"
33 #include "sipe-buddy.h"
34 #include "sipe-common.h"
35 #include "sipe-core.h"
36 #include "sipe-core-private.h"
37 #include "sipe-digest.h"
38 #include "sipe-ews-autodiscover.h"
39 #include "sipe-group.h"
40 #include "sipe-http.h"
41 #include "sipe-subscriptions.h"
42 #include "sipe-ucs.h"
43 #include "sipe-utils.h"
44 #include "sipe-xml.h"
45
46 typedef void (ucs_callback)(struct sipe_core_private *sipe_private,
47 const sipe_xml *body,
48 gpointer callback_data);
49
50 struct ucs_deferred {
51 ucs_callback *cb;
52 gpointer cb_data;
53 gchar *body;
54 };
55
56 struct ucs_request {
57 ucs_callback *cb;
58 gpointer cb_data;
59 struct sipe_http_request *request;
60 };
61
62 struct sipe_ucs {
63 gchar *ews_url;
64 GSList *deferred_requests;
65 GSList *pending_requests;
66 guint group_id;
67 gboolean migrated;
68 gboolean shutting_down;
69 };
70
71 static void sipe_ucs_deferred_free(struct sipe_core_private *sipe_private,
72 struct ucs_deferred *data)
73 {
74 if (data->cb)
75 /* Callback: aborted */
76 (*data->cb)(sipe_private, NULL, data->cb_data);
77 g_free(data->body);
78 g_free(data);
79 }
80
81 static void sipe_ucs_request_free(struct sipe_core_private *sipe_private,
82 struct ucs_request *data)
83 {
84 if (data->request)
85 sipe_http_request_cancel(data->request);
86 if (data->cb)
87 /* Callback: aborted */
88 (*data->cb)(sipe_private, NULL, data->cb_data);
89 g_free(data);
90 }
91
92 static void sipe_ucs_http_response(struct sipe_core_private *sipe_private,
93 guint status,
94 SIPE_UNUSED_PARAMETER GSList *headers,
95 const gchar *body,
96 gpointer callback_data)
97 {
98 struct ucs_request *data = callback_data;
99 struct sipe_ucs *ucs = sipe_private->ucs;
100
101 SIPE_DEBUG_INFO("sipe_ucs_http_response: code %d", status);
102 data->request = NULL;
103
104 if ((status == SIPE_HTTP_STATUS_OK) && body) {
105 sipe_xml *xml = sipe_xml_parse(body, strlen(body));
106 const sipe_xml *soap_body = sipe_xml_child(xml, "Body");
107 /* Callback: success */
108 (*data->cb)(sipe_private, soap_body, data->cb_data);
109 sipe_xml_free(xml);
110 } else {
111 /* Callback: failed */
112 (*data->cb)(sipe_private, NULL, data->cb_data);
113 }
114
115 /* already been called */
116 data->cb = NULL;
117
118 ucs->pending_requests = g_slist_remove(ucs->pending_requests,
119 data);
120 sipe_ucs_request_free(sipe_private, data);
121 }
122
123 static gboolean sipe_ucs_http_request(struct sipe_core_private *sipe_private,
124 const gchar *body,
125 ucs_callback *callback,
126 gpointer callback_data)
127 {
128 struct sipe_ucs *ucs = sipe_private->ucs;
129 gboolean success = FALSE;
130
131 if (ucs->shutting_down) {
132 SIPE_DEBUG_ERROR("sipe_ucs_http_request: new UCS request during shutdown: THIS SHOULD NOT HAPPEN! Debugging information:\n"
133 "Body: %s\n",
134 body ? body : "<EMPTY>");
135
136 } else if (ucs->ews_url) {
137 struct ucs_request *data = g_new0(struct ucs_request, 1);
138 gchar *soap = g_strdup_printf("<?xml version=\"1.0\"?>\r\n"
139 "<soap:Envelope"
140 " xmlns:m=\"http://schemas.microsoft.com/exchange/services/2006/messages\""
141 " xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\""
142 " xmlns:t=\"http://schemas.microsoft.com/exchange/services/2006/types\""
143 " >"
144 " <soap:Header>"
145 " <t:RequestServerVersion Version=\"Exchange2013\" />"
146 " </soap:Header>"
147 " <soap:Body>"
148 " %s"
149 " </soap:Body>"
150 "</soap:Envelope>",
151 body);
152 struct sipe_http_request *request = sipe_http_request_post(sipe_private,
153 ucs->ews_url,
154 NULL,
155 soap,
156 "text/xml; charset=UTF-8",
157 sipe_ucs_http_response,
158 data);
159 g_free(soap);
160
161 if (request) {
162 data->cb = callback;
163 data->cb_data = callback_data;
164 data->request = request;
165
166 ucs->pending_requests = g_slist_prepend(ucs->pending_requests,
167 data);
168
169 sipe_core_email_authentication(sipe_private,
170 request);
171 sipe_http_request_allow_redirect(request);
172 sipe_http_request_ready(request);
173
174 success = TRUE;
175 } else {
176 SIPE_DEBUG_ERROR_NOFORMAT("sipe_ucs_http_request: failed to create HTTP connection");
177 g_free(data);
178 }
179
180 } else {
181 struct ucs_deferred *data = g_new0(struct ucs_deferred, 1);
182 data->cb = callback;
183 data->cb_data = callback_data;
184 data->body = g_strdup(body);
185
186 ucs->deferred_requests = g_slist_prepend(ucs->deferred_requests,
187 data);
188 success = TRUE;
189 }
190
191 return(success);
192 }
193
194 static void sipe_ucs_get_user_photo_response(struct sipe_core_private *sipe_private,
195 const sipe_xml *body,
196 gpointer callback_data)
197 {
198 gchar *uri = callback_data;
199 const sipe_xml *node = sipe_xml_child(body,
200 "GetUserPhotoResponse/PictureData");
201
202 if (node) {
203 gchar *base64;
204 gsize photo_size;
205 guchar *photo;
206 guchar digest[SIPE_DIGEST_SHA1_LENGTH];
207 gchar *digest_string;
208
209 /* decode photo data */
210 base64 = sipe_xml_data(node);
211 photo = g_base64_decode(base64, &photo_size);
212 g_free(base64);
213
214 /* EWS doesn't provide a hash -> calculate SHA-1 digest */
215 sipe_digest_sha1(photo, photo_size, digest);
216 digest_string = buff_to_hex_str(digest,
217 SIPE_DIGEST_SHA1_LENGTH);
218
219 /* backend frees "photo" */
220 sipe_backend_buddy_set_photo(SIPE_CORE_PUBLIC,
221 uri,
222 photo,
223 photo_size,
224 digest_string);
225 g_free(digest_string);
226 }
227
228 g_free(uri);
229 }
230
231 void sipe_ucs_get_photo(struct sipe_core_private *sipe_private,
232 const gchar *uri)
233 {
234 gchar *payload = g_strdup(uri);
235 gchar *body = g_strdup_printf("<m:GetUserPhoto>"
236 " <m:Email>%s</m:Email>"
237 " <m:SizeRequested>HR48x48</m:SizeRequested>"
238 "</m:GetUserPhoto>",
239 sipe_get_no_sip_uri(uri));
240
241 if (!sipe_ucs_http_request(sipe_private,
242 body,
243 sipe_ucs_get_user_photo_response,
244 payload))
245 g_free(payload);
246
247 g_free(body);
248 }
249
250 static void sipe_ucs_ignore_response(SIPE_UNUSED_PARAMETER struct sipe_core_private *sipe_private,
251 SIPE_UNUSED_PARAMETER const sipe_xml *body,
252 SIPE_UNUSED_PARAMETER gpointer callback_data)
253 {
254 SIPE_DEBUG_INFO_NOFORMAT("sipe_ucs_ignore_response: done");
255 }
256
257 static struct sipe_group *ucs_create_group(struct sipe_core_private *sipe_private,
258 const sipe_xml *group_node)
259 {
260 const sipe_xml *id_node = sipe_xml_child(group_node,
261 "ExchangeStoreId");
262 const gchar *key = sipe_xml_attribute(id_node, "Id");
263 const gchar *change = sipe_xml_attribute(id_node, "ChangeKey");
264 struct sipe_group *group = NULL;
265
266 if (!(is_empty(key) || is_empty(change))) {
267 gchar *name = sipe_xml_data(sipe_xml_child(group_node,
268 "DisplayName"));
269 group = sipe_group_add(sipe_private,
270 name,
271 key,
272 change,
273 /* sipe_group must have unique ID */
274 ++sipe_private->ucs->group_id);
275 g_free(name);
276 }
277
278 return(group);
279 }
280
281 static void sipe_ucs_add_im_group_response(struct sipe_core_private *sipe_private,
282 const sipe_xml *body,
283 gpointer callback_data)
284 {
285 gchar *who = callback_data;
286 const sipe_xml *group_node = sipe_xml_child(body,
287 "AddImGroupResponse/ImGroup");
288 struct sipe_group *group = ucs_create_group(sipe_private, group_node);
289
290 if (group)
291 sipe_group_add_buddy(sipe_private, group, who);
292
293 g_free(who);
294 }
295
296 void sipe_ucs_group_create(struct sipe_core_private *sipe_private,
297 const gchar *name,
298 const gchar *who)
299 {
300 /* new_name can contain restricted characters */
301 gchar *body = g_markup_printf_escaped("<m:AddImGroup>"
302 " <m:DisplayName>%s</m:DisplayName>"
303 "</m:AddImGroup>",
304 name);
305 sipe_ucs_http_request(sipe_private,
306 body,
307 sipe_ucs_add_im_group_response,
308 g_strdup(who));
309 g_free(body);
310 }
311
312 void sipe_ucs_group_rename(struct sipe_core_private *sipe_private,
313 struct sipe_group *group,
314 const gchar *new_name)
315 {
316 /* new_name can contain restricted characters */
317 gchar *body = g_markup_printf_escaped("<m:SetImGroup>"
318 " <m:GroupId Id=\"%s\" ChangeKey=\"%s\"/>"
319 " <m:NewDisplayName>%s</m:NewDisplayName>"
320 "</m:SetImGroup>",
321 group->exchange_key,
322 group->change_key,
323 new_name);
324
325 sipe_ucs_http_request(sipe_private,
326 body,
327 sipe_ucs_ignore_response,
328 NULL);
329 g_free(body);
330 }
331
332 void sipe_ucs_group_remove(struct sipe_core_private *sipe_private,
333 struct sipe_group *group)
334 {
335 gchar *body = g_strdup_printf("<m:RemoveImGroup>"
336 " <m:GroupId Id=\"%s\" ChangeKey=\"%s\"/>"
337 "</m:RemoveImGroup>",
338 group->exchange_key,
339 group->change_key);
340
341 sipe_ucs_http_request(sipe_private,
342 body,
343 sipe_ucs_ignore_response,
344 NULL);
345 g_free(body);
346 }
347
348 static void sipe_ucs_get_im_item_list_response(struct sipe_core_private *sipe_private,
349 const sipe_xml *body,
350 SIPE_UNUSED_PARAMETER gpointer callback_data)
351 {
352 const sipe_xml *node = sipe_xml_child(body,
353 "GetImItemListResponse/ImItemList");
354
355 if (node) {
356 const sipe_xml *persona_node;
357 const sipe_xml *group_node;
358
359 /* Start processing contact list */
360 sipe_backend_buddy_list_processing_start(SIPE_CORE_PUBLIC);
361
362 for (persona_node = sipe_xml_child(node, "Personas/Persona");
363 persona_node;
364 persona_node = sipe_xml_twin(persona_node)) {
365 gchar *address = sipe_xml_data(sipe_xml_child(persona_node,
366 "ImAddress"));
367 const gchar *key = NULL;
368 const gchar *change = NULL;
369 const sipe_xml *attr_node;
370
371 /* extract Exchange key - not sure if this is correct */
372 for (attr_node = sipe_xml_child(persona_node,
373 "Attributions/Attribution");
374 attr_node;
375 attr_node = sipe_xml_twin(attr_node)) {
376 const sipe_xml *id_node = sipe_xml_child(attr_node,
377 "SourceId");
378 gchar *type = sipe_xml_data(sipe_xml_child(attr_node,
379 "DisplayName"));
380 if (id_node &&
381 sipe_strequal(type, "Lync Contacts")) {
382 key = sipe_xml_attribute(id_node, "Id");
383 change = sipe_xml_attribute(id_node, "ChangeKey");
384 g_free(type);
385 break;
386 }
387 g_free(type);
388 }
389
390 if (!(is_empty(address) || is_empty(key) || is_empty(change))) {
391 gchar *uri = sip_uri_from_name(address);
392 struct sipe_buddy *buddy = sipe_buddy_add(sipe_private,
393 uri,
394 key,
395 change);
396 g_free(uri);
397
398 SIPE_DEBUG_INFO("sipe_ucs_get_im_item_list_response: persona URI '%s' key '%s' change '%s'",
399 buddy->name, key, change);
400 }
401 g_free(address);
402 }
403
404 for (group_node = sipe_xml_child(node, "Groups/ImGroup");
405 group_node;
406 group_node = sipe_xml_twin(group_node)) {
407 struct sipe_group *group = ucs_create_group(sipe_private,
408 group_node);
409
410 if (group) {
411 const sipe_xml *member_node;
412
413 for (member_node = sipe_xml_child(group_node,
414 "MemberCorrelationKey/ItemId");
415 member_node;
416 member_node = sipe_xml_twin(member_node)) {
417 struct sipe_buddy *buddy = sipe_buddy_find_by_exchange_key(sipe_private,
418 sipe_xml_attribute(member_node,
419 "Id"));
420 if (buddy)
421 sipe_buddy_add_to_group(sipe_private,
422 buddy,
423 group,
424 /* alias will be set via buddy presence update */
425 NULL);
426 }
427 }
428 }
429
430 /* Finished processing contact list */
431 sipe_buddy_cleanup_local_list(sipe_private);
432 sipe_backend_buddy_list_processing_finish(SIPE_CORE_PUBLIC);
433 sipe_subscribe_presence_initial(sipe_private);
434 }
435 }
436
437 static void ucs_ews_autodiscover_cb(struct sipe_core_private *sipe_private,
438 const struct sipe_ews_autodiscover_data *ews_data,
439 SIPE_UNUSED_PARAMETER gpointer callback_data)
440 {
441 struct sipe_ucs *ucs = sipe_private->ucs;
442 const gchar *ews_url;
443
444 if (!ucs || !ews_data)
445 return;
446
447 ews_url = ews_data->ews_url;
448 if (is_empty(ews_url)) {
449 SIPE_DEBUG_ERROR_NOFORMAT("ucs_ews_autodiscover_cb: can't detect EWS URL, contact list operations will not work!");
450 return;
451 }
452
453 SIPE_DEBUG_INFO("ucs_ews_autodiscover_cb: EWS URL '%s'", ews_url);
454 ucs->ews_url = g_strdup(ews_url);
455
456 /* Request migrated contact list */
457 if (ucs->migrated)
458 sipe_ucs_http_request(sipe_private,
459 "<m:GetImItemList/>",
460 sipe_ucs_get_im_item_list_response,
461 NULL);
462
463 /* EWS URL is valid, send all deferred requests now */
464 if (ucs->deferred_requests) {
465 GSList *entry = ucs->deferred_requests;
466 while (entry) {
467 struct ucs_deferred *data = entry->data;
468
469 sipe_ucs_http_request(sipe_private,
470 data->body,
471 data->cb,
472 data->cb_data);
473
474 /* callback & data has been forwarded */
475 data->cb = NULL;
476 sipe_ucs_deferred_free(sipe_private, data);
477
478 entry = entry->next;
479 }
480 g_slist_free(ucs->deferred_requests);
481 ucs->deferred_requests = NULL;
482 }
483 }
484
485 gboolean sipe_ucs_is_migrated(struct sipe_core_private *sipe_private)
486 {
487 return(sipe_private->ucs ? sipe_private->ucs->migrated : FALSE);
488 }
489
490 void sipe_ucs_init(struct sipe_core_private *sipe_private,
491 gboolean migrated)
492 {
493 struct sipe_ucs *ucs;
494
495 if (sipe_private->ucs)
496 return;
497
498 sipe_private->ucs = ucs = g_new0(struct sipe_ucs, 1);
499 ucs->migrated = migrated;
500
501 sipe_ews_autodiscover_start(sipe_private,
502 ucs_ews_autodiscover_cb,
503 NULL);
504 }
505
506 void sipe_ucs_free(struct sipe_core_private *sipe_private)
507 {
508 struct sipe_ucs *ucs = sipe_private->ucs;
509
510 if (!ucs)
511 return;
512
513 /* UCS stack is shutting down: reject all new requests */
514 ucs->shutting_down = TRUE;
515
516 if (ucs->deferred_requests) {
517 GSList *entry = ucs->deferred_requests;
518 while (entry) {
519 sipe_ucs_deferred_free(sipe_private, entry->data);
520 entry = entry->next;
521 }
522 g_slist_free(ucs->deferred_requests);
523 }
524
525 if (ucs->pending_requests) {
526 GSList *entry = ucs->pending_requests;
527 while (entry) {
528 sipe_ucs_request_free(sipe_private, entry->data);
529 entry = entry->next;
530 }
531 g_slist_free(ucs->pending_requests);
532 }
533
534 g_free(ucs->ews_url);
535 g_free(ucs);
536 sipe_private->ucs = NULL;
537 }
538
539 /*
540 Local Variables:
541 mode: c
542 c-file-style: "bsd"
543 indent-tabs-mode: t
544 tab-width: 8
545 End:
546 */
A third-party Pidgin plugin for Microsoft LCS/OCS