?  search:
summary | log | graphiclog1 | graphiclog2 | refs | edit | fork

b139ace20d833108e3162c43f48a3e2f324d8848
[siplcs.git] / src / core / sipe-conf.c
blobb139ace20d833108e3162c43f48a3e2f324d8848
1 /**
2 * @file sipe-conf.c
3 *
4 * pidgin-sipe
5 *
6 * Copyright (C) 2010-2013 SIPE Project <http://sipe.sourceforge.net/>
7 * Copyright (C) 2009 pier11 <pier11@operamail.com>
8 *
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 */
24
25 #ifdef HAVE_CONFIG_H
26 #include "config.h"
27 #endif
28
29 #include <stdlib.h>
30 #include <string.h>
31 #include <time.h>
32
33 #include <glib.h>
34
35 #include "sipe-common.h"
36 #include "sipmsg.h"
37 #include "sip-transport.h"
38 #include "sipe-backend.h"
39 #include "sipe-buddy.h"
40 #include "sipe-chat.h"
41 #include "sipe-conf.h"
42 #include "sipe-core.h"
43 #include "sipe-core-private.h"
44 #include "sipe-dialog.h"
45 #include "sipe-im.h"
46 #include "sipe-nls.h"
47 #include "sipe-session.h"
48 #include "sipe-subscriptions.h"
49 #include "sipe-user.h"
50 #include "sipe-utils.h"
51 #include "sipe-xml.h"
52
53 #ifdef HAVE_VV
54 #define ENTITY_VIEW_AUDIO_VIDEO "<msci:entity-view entity=\"audio-video\"/>"
55 #else
56 #define ENTITY_VIEW_AUDIO_VIDEO
57 #endif
58
59 /**
60 * Add Conference request to FocusFactory.
61 * @param focus_factory_uri (%s) Ex.: sip:bob7@boston.local;gruu;opaque=app:conf:focusfactory
62 * @param from (%s) Ex.: sip:bob7@boston.local
63 * @param request_id (%d) Ex.: 1094520
64 * @param conference_id (%s) Ex.: 8386E6AEAAA41E4AA6627BA76D43B6D1
65 * @param expiry_time (%s) Ex.: 2009-07-13T17:57:09Z , Default duration: 7 hours
66 */
67 #define SIPE_SEND_CONF_ADD \
68 "<?xml version=\"1.0\"?>"\
69 "<request xmlns=\"urn:ietf:params:xml:ns:cccp\" "\
70 "xmlns:mscp=\"http://schemas.microsoft.com/rtc/2005/08/cccpextensions\" "\
71 "C3PVersion=\"1\" "\
72 "to=\"%s\" "\
73 "from=\"%s\" "\
74 "requestId=\"%d\">"\
75 "<addConference>"\
76 "<ci:conference-info xmlns:ci=\"urn:ietf:params:xml:ns:conference-info\" entity=\"\" xmlns:msci=\"http://schemas.microsoft.com/rtc/2005/08/confinfoextensions\">"\
77 "<ci:conference-description>"\
78 "<ci:subject/>"\
79 "<msci:conference-id>%s</msci:conference-id>"\
80 "<msci:expiry-time>%s</msci:expiry-time>"\
81 "<msci:admission-policy>openAuthenticated</msci:admission-policy>"\
82 "</ci:conference-description>"\
83 "<msci:conference-view>"\
84 "<msci:entity-view entity=\"chat\"/>"\
85 ENTITY_VIEW_AUDIO_VIDEO \
86 "</msci:conference-view>"\
87 "</ci:conference-info>"\
88 "</addConference>"\
89 "</request>"
90
91 /**
92 * AddUser request to Focus.
93 * Params:
94 * focus_URI, from, request_id, focus_URI, from, endpoint_GUID
95 */
96 #define SIPE_SEND_CONF_ADD_USER \
97 "<?xml version=\"1.0\"?>"\
98 "<request xmlns=\"urn:ietf:params:xml:ns:cccp\" xmlns:mscp=\"http://schemas.microsoft.com/rtc/2005/08/cccpextensions\" "\
99 "C3PVersion=\"1\" "\
100 "to=\"%s\" "\
101 "from=\"%s\" "\
102 "requestId=\"%d\">"\
103 "<addUser>"\
104 "<conferenceKeys confEntity=\"%s\"/>"\
105 "<ci:user xmlns:ci=\"urn:ietf:params:xml:ns:conference-info\" entity=\"%s\">"\
106 "<ci:roles>"\
107 "<ci:entry>attendee</ci:entry>"\
108 "</ci:roles>"\
109 "<ci:endpoint entity=\"{%s}\" xmlns:msci=\"http://schemas.microsoft.com/rtc/2005/08/confinfoextensions\"/>"\
110 "</ci:user>"\
111 "</addUser>"\
112 "</request>"
113
114 /**
115 * ModifyUserRoles request to Focus. Makes user a leader.
116 * @param focus_uri (%s)
117 * @param from (%s)
118 * @param request_id (%d)
119 * @param focus_uri (%s)
120 * @param who (%s)
121 */
122 #define SIPE_SEND_CONF_MODIFY_USER_ROLES \
123 "<?xml version=\"1.0\"?>"\
124 "<request xmlns=\"urn:ietf:params:xml:ns:cccp\" xmlns:mscp=\"http://schemas.microsoft.com/rtc/2005/08/cccpextensions\" "\
125 "C3PVersion=\"1\" "\
126 "to=\"%s\" "\
127 "from=\"%s\" "\
128 "requestId=\"%d\">"\
129 "<modifyUserRoles>"\
130 "<userKeys confEntity=\"%s\" userEntity=\"%s\"/>"\
131 "<user-roles xmlns=\"urn:ietf:params:xml:ns:conference-info\">"\
132 "<entry>presenter</entry>"\
133 "</user-roles>"\
134 "</modifyUserRoles>"\
135 "</request>"
136
137 /**
138 * ModifyConferenceLock request to Focus. Locks/unlocks conference.
139 * @param focus_uri (%s)
140 * @param from (%s)
141 * @param request_id (%d)
142 * @param focus_uri (%s)
143 * @param locked (%s) "true" or "false" values applicable
144 */
145 #define SIPE_SEND_CONF_MODIFY_CONF_LOCK \
146 "<?xml version=\"1.0\"?>"\
147 "<request xmlns=\"urn:ietf:params:xml:ns:cccp\" xmlns:mscp=\"http://schemas.microsoft.com/rtc/2005/08/cccpextensions\" "\
148 "C3PVersion=\"1\" "\
149 "to=\"%s\" "\
150 "from=\"%s\" "\
151 "requestId=\"%d\">"\
152 "<modifyConferenceLock>"\
153 "<conferenceKeys confEntity=\"%s\"/>"\
154 "<locked>%s</locked>"\
155 "</modifyConferenceLock>"\
156 "</request>"
157
158 /**
159 * ModifyConferenceLock request to Focus. Locks/unlocks conference.
160 * @param focus_uri (%s)
161 * @param from (%s)
162 * @param request_id (%d)
163 * @param focus_uri (%s)
164 * @param who (%s)
165 */
166 #define SIPE_SEND_CONF_DELETE_USER \
167 "<?xml version=\"1.0\"?>"\
168 "<request xmlns=\"urn:ietf:params:xml:ns:cccp\" xmlns:mscp=\"http://schemas.microsoft.com/rtc/2005/08/cccpextensions\" "\
169 "C3PVersion=\"1\" "\
170 "to=\"%s\" "\
171 "from=\"%s\" "\
172 "requestId=\"%d\">"\
173 "<deleteUser>"\
174 "<userKeys confEntity=\"%s\" userEntity=\"%s\"/>"\
175 "</deleteUser>"\
176 "</request>"
177
178 /**
179 * Invite counterparty to join conference.
180 * @param focus_uri (%s)
181 * @param subject (%s) of conference
182 */
183 #define SIPE_SEND_CONF_INVITE \
184 "<Conferencing version=\"2.0\">"\
185 "<focus-uri>%s</focus-uri>"\
186 "<subject>%s</subject>"\
187 "<im available=\"true\">"\
188 "<first-im/>"\
189 "</im>"\
190 "</Conferencing>"
191
192 /**
193 * Generates random GUID.
194 * This method is borrowed from pidgin's msnutils.c
195 */
196 static char *
197 rand_guid()
198 {
199 return g_strdup_printf("%4X%4X-%4X-%4X-%4X-%4X%4X%4X",
200 rand() % 0xAAFF + 0x1111,
201 rand() % 0xAAFF + 0x1111,
202 rand() % 0xAAFF + 0x1111,
203 rand() % 0xAAFF + 0x1111,
204 rand() % 0xAAFF + 0x1111,
205 rand() % 0xAAFF + 0x1111,
206 rand() % 0xAAFF + 0x1111,
207 rand() % 0xAAFF + 0x1111);
208 }
209
210 /** Invite us to the focus callback */
211 static gboolean
212 process_invite_conf_focus_response(struct sipe_core_private *sipe_private,
213 struct sipmsg *msg,
214 SIPE_UNUSED_PARAMETER struct transaction *trans)
215 {
216 struct sip_session *session = NULL;
217 char *focus_uri = parse_from(sipmsg_find_header(msg, "To"));
218
219 session = sipe_session_find_conference(sipe_private, focus_uri);
220
221 if (!session) {
222 SIPE_DEBUG_INFO("process_invite_conf_focus_response: unable to find conf session with focus=%s", focus_uri);
223 g_free(focus_uri);
224 return FALSE;
225 }
226
227 if (!session->focus_dialog) {
228 SIPE_DEBUG_INFO_NOFORMAT("process_invite_conf_focus_response: session's focus_dialog is NULL");
229 g_free(focus_uri);
230 return FALSE;
231 }
232
233 sipe_dialog_parse(session->focus_dialog, msg, TRUE);
234
235 if (msg->response >= 200) {
236 /* send ACK to focus */
237 session->focus_dialog->cseq = 0;
238 sip_transport_ack(sipe_private, session->focus_dialog);
239 session->focus_dialog->outgoing_invite = NULL;
240 session->focus_dialog->is_established = TRUE;
241 }
242
243 if (msg->response >= 400) {
244 gchar *reason = sipmsg_get_ms_diagnostics_reason(msg);
245
246 SIPE_DEBUG_INFO_NOFORMAT("process_invite_conf_focus_response: INVITE response is not 200. Failed to join focus.");
247 sipe_backend_notify_error(SIPE_CORE_PUBLIC,
248 _("Failed to join the conference"),
249 reason ? reason : _("no reason given"));
250 g_free(reason);
251
252 sipe_session_remove(sipe_private, session);
253 g_free(focus_uri);
254 return FALSE;
255 } else if (msg->response == 200) {
256 sipe_xml *xn_response = sipe_xml_parse(msg->body, msg->bodylen);
257 const gchar *code = sipe_xml_attribute(xn_response, "code");
258 if (sipe_strequal(code, "success")) {
259 /* subscribe to focus */
260 sipe_subscribe_conference(sipe_private,
261 session->chat_session->id,
262 FALSE);
263 #ifdef HAVE_VV
264 if (session->is_call)
265 sipe_core_media_connect_conference(SIPE_CORE_PUBLIC,
266 session->chat_session);
267 #endif
268 }
269 sipe_xml_free(xn_response);
270 }
271
272 g_free(focus_uri);
273 return TRUE;
274 }
275
276 static gchar *
277 parse_ocs_focus_uri(const gchar *uri)
278 {
279 const gchar *confkey;
280 size_t uri_len;
281
282 if (!uri)
283 return NULL;
284
285 // URI can have this prefix if it was typed in by the user
286 if (g_str_has_prefix(uri, "meet:") || g_str_has_prefix(uri, "conf:")) {
287 uri += 5;
288 }
289
290 uri_len = strlen(uri);
291
292 if (!uri || !g_str_has_prefix(uri, "sip:") ||
293 uri_len == 4 || g_strstr_len(uri, -1, "%")) {
294 return NULL;
295 }
296
297 confkey = g_strstr_len(uri, -1, "?");
298 if (confkey) {
299 /* TODO: Investigate how conf-key field should be used,
300 * ignoring for now */
301 uri_len = confkey - uri;
302 }
303
304 return g_strndup(uri, uri_len);
305 }
306
307 static gchar *
308 parse_lync_join_url(const gchar *uri)
309 {
310 gchar *focus_uri = NULL;
311 gchar **parts;
312 int parts_count = 0;
313
314 if (!uri)
315 return NULL;
316
317 if (g_str_has_prefix(uri, "https://")) {
318 uri += 8;
319 } else if (g_str_has_prefix(uri, "http://")) {
320 uri += 7;
321 }
322
323 parts = g_strsplit(uri, "/", 0);
324
325 for (parts_count = 0; parts[parts_count]; ++parts_count);
326 if (parts_count >= 3) {
327 gchar *base_url = parts[0];
328 gchar *conference_id = parts[parts_count - 1];
329 gchar *organizer_alias = parts[parts_count - 2];
330
331 gchar **url_parts = g_strsplit(base_url, ".", 0);
332 int url_parts_count = 0;
333 for (url_parts_count = 0; url_parts[url_parts_count]; ++url_parts_count);
334
335 if (url_parts_count >= 3) {
336 focus_uri = g_strdup_printf("sip:%s@%s.%s;gruu;opaque=app:conf:focus:id:%s",
337 organizer_alias,
338 url_parts[url_parts_count - 2], url_parts[url_parts_count - 1],
339 conference_id);
340 }
341
342 g_strfreev(url_parts);
343 }
344
345 g_strfreev(parts);
346
347 return focus_uri;
348 }
349
350 struct sip_session *
351 sipe_core_conf_create(struct sipe_core_public *sipe_public,
352 const gchar *uri)
353 {
354 gchar *uri_ue = sipe_utils_uri_unescape(uri);
355 gchar *focus_uri;
356 struct sip_session *session = NULL;
357
358 focus_uri = parse_ocs_focus_uri(uri_ue);
359 if (!focus_uri) {
360 focus_uri = parse_lync_join_url(uri_ue);
361 }
362
363 if (focus_uri) {
364 session = sipe_conf_create(SIPE_CORE_PRIVATE, NULL, focus_uri);
365 g_free(focus_uri);
366 } else {
367 gchar *error = g_strdup_printf(_("\"%s\" is not a valid conference URI"),
368 uri ? uri : "");
369 sipe_backend_notify_error(sipe_public,
370 _("Failed to join the conference"),
371 error);
372 g_free(error);
373 }
374
375 g_free(uri_ue);
376
377 return session;
378 }
379
380 /** Create new session with Focus URI */
381 struct sip_session *
382 sipe_conf_create(struct sipe_core_private *sipe_private,
383 struct sipe_chat_session *chat_session,
384 const gchar *focus_uri)
385 {
386 gchar *hdr;
387 gchar *contact;
388 gchar *body;
389 gchar *self;
390 struct sip_session *session = sipe_session_add_chat(sipe_private,
391 chat_session,
392 FALSE,
393 focus_uri);
394
395 session->focus_dialog = g_new0(struct sip_dialog, 1);
396 session->focus_dialog->callid = gencallid();
397 session->focus_dialog->with = g_strdup(session->chat_session->id);
398 session->focus_dialog->endpoint_GUID = rand_guid();
399 session->focus_dialog->ourtag = gentag();
400
401 contact = get_contact(sipe_private);
402 hdr = g_strdup_printf(
403 "Supported: ms-sender\r\n"
404 "Contact: %s\r\n"
405 "Content-Type: application/cccp+xml\r\n",
406 contact);
407 g_free(contact);
408
409 /* @TODO put request_id to queue to further compare with incoming one */
410 /* focus_URI, from, request_id, focus_URI, from, endpoint_GUID */
411 self = sip_uri_self(sipe_private);
412 body = g_strdup_printf(
413 SIPE_SEND_CONF_ADD_USER,
414 session->focus_dialog->with,
415 self,
416 session->request_id++,
417 session->focus_dialog->with,
418 self,
419 session->focus_dialog->endpoint_GUID);
420
421 session->focus_dialog->outgoing_invite =
422 sip_transport_invite(sipe_private,
423 hdr,
424 body,
425 session->focus_dialog,
426 process_invite_conf_focus_response);
427 g_free(body);
428 g_free(hdr);
429
430 /* Rejoin existing session? */
431 if (chat_session) {
432 SIPE_DEBUG_INFO("sipe_conf_create: rejoin '%s' (%s)",
433 chat_session->title,
434 chat_session->id);
435 sipe_backend_chat_rejoin(SIPE_CORE_PUBLIC,
436 chat_session->backend,
437 self,
438 chat_session->title);
439 }
440 g_free(self);
441
442 return(session);
443 }
444
445 /** Modify User Role */
446 void
447 sipe_conf_modify_user_role(struct sipe_core_private *sipe_private,
448 struct sip_session *session,
449 const gchar* who)
450 {
451 gchar *hdr;
452 gchar *body;
453 gchar *self;
454
455 if (!session->focus_dialog || !session->focus_dialog->is_established) {
456 SIPE_DEBUG_INFO_NOFORMAT("sipe_conf_modify_user_role: no dialog with focus, exiting.");
457 return;
458 }
459
460 hdr = g_strdup(
461 "Content-Type: application/cccp+xml\r\n");
462
463 /* @TODO put request_id to queue to further compare with incoming one */
464 self = sip_uri_self(sipe_private);
465 body = g_strdup_printf(
466 SIPE_SEND_CONF_MODIFY_USER_ROLES,
467 session->focus_dialog->with,
468 self,
469 session->request_id++,
470 session->focus_dialog->with,
471 who);
472 g_free(self);
473
474 sip_transport_info(sipe_private,
475 hdr,
476 body,
477 session->focus_dialog,
478 NULL);
479 g_free(body);
480 g_free(hdr);
481 }
482
483 /**
484 * Check conference lock status
485 */
486 sipe_chat_lock_status sipe_core_chat_lock_status(struct sipe_core_public *sipe_public,
487 struct sipe_chat_session *chat_session)
488 {
489 struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
490 sipe_chat_lock_status status = SIPE_CHAT_LOCK_STATUS_NOT_ALLOWED;
491
492 if (chat_session &&
493 (chat_session->type == SIPE_CHAT_TYPE_CONFERENCE)) {
494 struct sip_session *session = sipe_session_find_chat(sipe_private,
495 chat_session);
496 if (session) {
497 gchar *self = sip_uri_self(sipe_private);
498
499 /* Only operators are allowed to change the lock status */
500 if (sipe_backend_chat_is_operator(chat_session->backend, self)) {
501 status = session->locked ?
502 SIPE_CHAT_LOCK_STATUS_LOCKED :
503 SIPE_CHAT_LOCK_STATUS_UNLOCKED;
504 }
505
506 g_free(self);
507 }
508 }
509
510 return(status);
511 }
512
513 /**
514 * Modify Conference Lock
515 * Sends request to Focus.
516 * INFO method is a carrier of application/cccp+xml
517 */
518 void
519 sipe_core_chat_modify_lock(struct sipe_core_public *sipe_public,
520 struct sipe_chat_session *chat_session,
521 const gboolean locked)
522 {
523 struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
524 gchar *hdr;
525 gchar *body;
526 gchar *self;
527
528 struct sip_session *session = sipe_session_find_chat(sipe_private,
529 chat_session);
530
531 if (!session) return;
532 if (!session->focus_dialog || !session->focus_dialog->is_established) {
533 SIPE_DEBUG_INFO_NOFORMAT("sipe_conf_modify_conference_lock: no dialog with focus, exiting.");
534 return;
535 }
536
537 hdr = g_strdup(
538 "Content-Type: application/cccp+xml\r\n");
539
540 /* @TODO put request_id to queue to further compare with incoming one */
541 self = sip_uri_self(sipe_private);
542 body = g_strdup_printf(
543 SIPE_SEND_CONF_MODIFY_CONF_LOCK,
544 session->focus_dialog->with,
545 self,
546 session->request_id++,
547 session->focus_dialog->with,
548 locked ? "true" : "false");
549 g_free(self);
550
551 sip_transport_info(sipe_private,
552 hdr,
553 body,
554 session->focus_dialog,
555 NULL);
556 g_free(body);
557 g_free(hdr);
558 }
559
560 /** Modify Delete User */
561 void
562 sipe_conf_delete_user(struct sipe_core_private *sipe_private,
563 struct sip_session *session,
564 const gchar* who)
565 {
566 gchar *hdr;
567 gchar *body;
568 gchar *self;
569
570 if (!session->focus_dialog || !session->focus_dialog->is_established) {
571 SIPE_DEBUG_INFO_NOFORMAT("sipe_conf_delete_user: no dialog with focus, exiting.");
572 return;
573 }
574
575 hdr = g_strdup(
576 "Content-Type: application/cccp+xml\r\n");
577
578 /* @TODO put request_id to queue to further compare with incoming one */
579 self = sip_uri_self(sipe_private);
580 body = g_strdup_printf(
581 SIPE_SEND_CONF_DELETE_USER,
582 session->focus_dialog->with,
583 self,
584 session->request_id++,
585 session->focus_dialog->with,
586 who);
587 g_free(self);
588
589 sip_transport_info(sipe_private,
590 hdr,
591 body,
592 session->focus_dialog,
593 NULL);
594 g_free(body);
595 g_free(hdr);
596 }
597
598 /** Invite counterparty to join conference callback */
599 static gboolean
600 process_invite_conf_response(struct sipe_core_private *sipe_private,
601 struct sipmsg *msg,
602 SIPE_UNUSED_PARAMETER struct transaction *trans)
603 {
604 struct sip_dialog *dialog = g_new0(struct sip_dialog, 1);
605
606 dialog->callid = g_strdup(sipmsg_find_header(msg, "Call-ID"));
607 dialog->cseq = sipmsg_parse_cseq(msg);
608 dialog->with = parse_from(sipmsg_find_header(msg, "To"));
609 sipe_dialog_parse(dialog, msg, TRUE);
610
611 if (msg->response >= 200) {
612 /* send ACK to counterparty */
613 dialog->cseq--;
614 sip_transport_ack(sipe_private, dialog);
615 dialog->outgoing_invite = NULL;
616 dialog->is_established = TRUE;
617 }
618
619 if (msg->response >= 400) {
620 SIPE_DEBUG_INFO("process_invite_conf_response: INVITE response is not 200. Failed to invite %s.", dialog->with);
621 /* @TODO notify user of failure to invite counterparty */
622 sipe_dialog_free(dialog);
623 return FALSE;
624 }
625
626 if (msg->response >= 200) {
627 struct sip_session *session = sipe_session_find_im(sipe_private, dialog->with);
628 struct sip_dialog *im_dialog = sipe_dialog_find(session, dialog->with);
629
630 /* close IM session to counterparty */
631 if (im_dialog) {
632 sip_transport_bye(sipe_private, im_dialog);
633 sipe_dialog_remove(session, dialog->with);
634 }
635 }
636
637 sipe_dialog_free(dialog);
638 return TRUE;
639 }
640
641 /**
642 * Invites counterparty to join conference.
643 */
644 void
645 sipe_invite_conf(struct sipe_core_private *sipe_private,
646 struct sip_session *session,
647 const gchar* who)
648 {
649 gchar *hdr;
650 gchar *contact;
651 gchar *body;
652 struct sip_dialog *dialog = NULL;
653
654 /* It will be short lived special dialog.
655 * Will not be stored in session.
656 */
657 dialog = g_new0(struct sip_dialog, 1);
658 dialog->callid = gencallid();
659 dialog->with = g_strdup(who);
660 dialog->ourtag = gentag();
661
662 contact = get_contact(sipe_private);
663 hdr = g_strdup_printf(
664 "Supported: ms-sender\r\n"
665 "Contact: %s\r\n"
666 "Content-Type: application/ms-conf-invite+xml\r\n",
667 contact);
668 g_free(contact);
669
670 body = g_strdup_printf(
671 SIPE_SEND_CONF_INVITE,
672 session->chat_session->id,
673 session->subject ? session->subject : ""
674 );
675
676 sip_transport_invite(sipe_private,
677 hdr,
678 body,
679 dialog,
680 process_invite_conf_response);
681
682 sipe_dialog_free(dialog);
683 g_free(body);
684 g_free(hdr);
685 }
686
687 /** Create conference callback */
688 static gboolean
689 process_conf_add_response(struct sipe_core_private *sipe_private,
690 struct sipmsg *msg,
691 struct transaction *trans)
692 {
693 if (msg->response >= 400) {
694 SIPE_DEBUG_INFO_NOFORMAT("process_conf_add_response: SERVICE response is not 200. Failed to create conference.");
695 /* @TODO notify user of failure to create conference */
696 return FALSE;
697 }
698 if (msg->response == 200) {
699 sipe_xml *xn_response = sipe_xml_parse(msg->body, msg->bodylen);
700 if (sipe_strequal("success", sipe_xml_attribute(xn_response, "code")))
701 {
702 gchar *who = trans->payload->data;
703 const sipe_xml *xn_conference_info = sipe_xml_child(xn_response, "addConference/conference-info");
704 struct sip_session *session = sipe_conf_create(sipe_private,
705 NULL,
706 sipe_xml_attribute(xn_conference_info,
707 "entity"));
708
709 SIPE_DEBUG_INFO("process_conf_add_response: session->focus_uri=%s",
710 session->chat_session->id);
711
712 session->pending_invite_queue = sipe_utils_slist_insert_unique_sorted(session->pending_invite_queue,
713 g_strdup(who),
714 (GCompareFunc)strcmp,
715 g_free);
716 }
717 sipe_xml_free(xn_response);
718 }
719
720 return TRUE;
721 }
722
723 /**
724 * Creates conference.
725 */
726 void
727 sipe_conf_add(struct sipe_core_private *sipe_private,
728 const gchar* who)
729 {
730 gchar *hdr;
731 gchar *conference_id;
732 gchar *contact;
733 gchar *body;
734 gchar *self;
735 struct transaction *trans;
736 struct sip_dialog *dialog = NULL;
737 time_t expiry = time(NULL) + 7*60*60; /* 7 hours */
738 char *expiry_time;
739 struct transaction_payload *payload;
740
741 contact = get_contact(sipe_private);
742 hdr = g_strdup_printf(
743 "Supported: ms-sender\r\n"
744 "Contact: %s\r\n"
745 "Content-Type: application/cccp+xml\r\n",
746 contact);
747 g_free(contact);
748
749 expiry_time = sipe_utils_time_to_str(expiry);
750 self = sip_uri_self(sipe_private);
751 conference_id = genconfid();
752 body = g_strdup_printf(
753 SIPE_SEND_CONF_ADD,
754 sipe_private->focus_factory_uri,
755 self,
756 rand(),
757 conference_id,
758 expiry_time);
759 g_free(self);
760 g_free(conference_id);
761 g_free(expiry_time);
762
763 trans = sip_transport_service(sipe_private,
764 sipe_private->focus_factory_uri,
765 hdr,
766 body,
767 process_conf_add_response);
768
769 payload = g_new0(struct transaction_payload, 1);
770 payload->destroy = g_free;
771 payload->data = g_strdup(who);
772 trans->payload = payload;
773
774 sipe_dialog_free(dialog);
775 g_free(body);
776 g_free(hdr);
777 }
778
779 static void
780 accept_incoming_invite_conf(struct sipe_core_private *sipe_private,
781 gchar *focus_uri,
782 gboolean audio,
783 struct sipmsg *msg)
784 {
785 struct sip_session *session;
786 gchar *newTag = gentag();
787 const gchar *oldHeader = sipmsg_find_header(msg, "To");
788 gchar *newHeader;
789
790 newHeader = g_strdup_printf("%s;tag=%s", oldHeader, newTag);
791 g_free(newTag);
792 sipmsg_remove_header_now(msg, "To");
793 sipmsg_add_header_now(msg, "To", newHeader);
794 g_free(newHeader);
795
796 /* acknowledge invite */
797 sip_transport_response(sipe_private, msg, 200, "OK", NULL);
798
799 /* add self to conf */
800 session = sipe_conf_create(sipe_private, NULL, focus_uri);
801 session->is_call = audio;
802 }
803
804 struct conf_accept_ctx {
805 gchar *focus_uri;
806 struct sipmsg *msg;
807 struct sipe_user_ask_ctx *ask_ctx;
808 };
809
810 static void
811 conf_accept_ctx_free(struct conf_accept_ctx *ctx)
812 {
813 g_return_if_fail(ctx != NULL);
814
815 sipmsg_free(ctx->msg);
816 g_free(ctx->focus_uri);
817 g_free(ctx);
818 }
819
820 static void
821 conf_accept_cb(struct sipe_core_private *sipe_private, struct conf_accept_ctx *ctx)
822 {
823 sipe_private->sessions_to_accept =
824 g_slist_remove(sipe_private->sessions_to_accept, ctx);
825
826 accept_incoming_invite_conf(sipe_private, ctx->focus_uri, TRUE, ctx->msg);
827 conf_accept_ctx_free(ctx);
828 }
829
830 static void
831 conf_decline_cb(struct sipe_core_private *sipe_private, struct conf_accept_ctx *ctx)
832 {
833 sipe_private->sessions_to_accept =
834 g_slist_remove(sipe_private->sessions_to_accept, ctx);
835
836 sip_transport_response(sipe_private,
837 ctx->msg,
838 603, "Decline", NULL);
839
840 conf_accept_ctx_free(ctx);
841 }
842
843 void
844 sipe_conf_cancel_unaccepted(struct sipe_core_private *sipe_private,
845 struct sipmsg *msg)
846 {
847 const gchar *callid1 = msg ? sipmsg_find_header(msg, "Call-ID") : NULL;
848 GSList *it = sipe_private->sessions_to_accept;
849 while (it) {
850 struct conf_accept_ctx *ctx = it->data;
851 const gchar *callid2 = NULL;
852
853 if (msg && ctx->msg)
854 callid2 = sipmsg_find_header(ctx->msg, "Call-ID");
855
856 if (sipe_strequal(callid1, callid2)) {
857 GSList *tmp;
858
859 if (ctx->msg)
860 sip_transport_response(sipe_private, ctx->msg,
861 487, "Request Terminated", NULL);
862
863 if (msg)
864 sip_transport_response(sipe_private, msg, 200, "OK", NULL);
865
866 sipe_user_close_ask(ctx->ask_ctx);
867 conf_accept_ctx_free(ctx);
868
869 tmp = it;
870 it = it->next;
871
872 sipe_private->sessions_to_accept =
873 g_slist_delete_link(sipe_private->sessions_to_accept, tmp);
874
875 if (callid1)
876 break;
877 } else
878 it = it->next;
879 }
880 }
881
882 static void
883 ask_accept_voice_conference(struct sipe_core_private *sipe_private,
884 const gchar *focus_uri,
885 struct sipmsg *msg,
886 SipeUserAskCb accept_cb,
887 SipeUserAskCb decline_cb)
888 {
889 gchar **parts;
890 gchar *alias;
891 gchar *ask_msg;
892 const gchar *novv_note;
893 struct conf_accept_ctx *ctx;
894
895 #ifdef HAVE_VV
896 novv_note = "";
897 #else
898 novv_note = _("\n\nAs this client was not compiled with voice call "
899 "support, if you accept, you will be able to contact "
900 "the other participants only via IM session.");
901 #endif
902
903 parts = g_strsplit(focus_uri, ";", 2);
904 alias = sipe_buddy_get_alias(sipe_private, parts[0]);
905
906 ask_msg = g_strdup_printf(_("%s wants to invite you "
907 "to the conference call%s"),
908 alias ? alias : parts[0], novv_note);
909
910 g_free(alias);
911 g_strfreev(parts);
912
913 ctx = g_new0(struct conf_accept_ctx, 1);
914 sipe_private->sessions_to_accept =
915 g_slist_append(sipe_private->sessions_to_accept, ctx);
916
917 ctx->focus_uri = g_strdup(focus_uri);
918 ctx->msg = msg ? sipmsg_copy(msg) : NULL;
919 ctx->ask_ctx = sipe_user_ask(sipe_private, ask_msg,
920 _("Accept"), accept_cb,
921 _("Decline"), decline_cb,
922 ctx);
923
924 g_free(ask_msg);
925 }
926
927 void
928 process_incoming_invite_conf(struct sipe_core_private *sipe_private,
929 struct sipmsg *msg)
930 {
931 sipe_xml *xn_conferencing = sipe_xml_parse(msg->body, msg->bodylen);
932 const sipe_xml *xn_focus_uri = sipe_xml_child(xn_conferencing, "focus-uri");
933 const sipe_xml *xn_audio = sipe_xml_child(xn_conferencing, "audio");
934 gchar *focus_uri = sipe_xml_data(xn_focus_uri);
935 gboolean audio = sipe_strequal(sipe_xml_attribute(xn_audio, "available"), "true");
936
937 sipe_xml_free(xn_conferencing);
938
939 SIPE_DEBUG_INFO("We have received invitation to Conference. Focus URI=%s", focus_uri);
940
941 if (audio) {
942 sip_transport_response(sipe_private, msg, 180, "Ringing", NULL);
943 ask_accept_voice_conference(sipe_private, focus_uri, msg,
944 (SipeUserAskCb) conf_accept_cb,
945 (SipeUserAskCb) conf_decline_cb);
946
947 } else {
948 accept_incoming_invite_conf(sipe_private, focus_uri, FALSE, msg);
949 }
950
951 g_free(focus_uri);
952 }
953
954 #ifdef HAVE_VV
955
956 static void
957 call_accept_cb(struct sipe_core_private *sipe_private, struct conf_accept_ctx *ctx)
958 {
959 struct sip_session *session;
960 session = sipe_session_find_conference(sipe_private, ctx->focus_uri);
961
962 sipe_private->sessions_to_accept =
963 g_slist_remove(sipe_private->sessions_to_accept, ctx);
964
965 if (session) {
966 sipe_core_media_connect_conference(SIPE_CORE_PUBLIC,
967 session->chat_session);
968 }
969
970 conf_accept_ctx_free(ctx);
971 }
972
973 static void
974 call_decline_cb(struct sipe_core_private *sipe_private, struct conf_accept_ctx *ctx)
975 {
976 sipe_private->sessions_to_accept =
977 g_slist_remove(sipe_private->sessions_to_accept, ctx);
978
979 conf_accept_ctx_free(ctx);
980 }
981
982 #endif // HAVE_VV
983
984 void
985 sipe_process_conference(struct sipe_core_private *sipe_private,
986 struct sipmsg *msg)
987 {
988 sipe_xml *xn_conference_info;
989 const sipe_xml *node;
990 const sipe_xml *xn_subject;
991 const gchar *focus_uri;
992 struct sip_session *session;
993 gboolean just_joined = FALSE;
994 #ifdef HAVE_VV
995 gboolean audio_was_added = FALSE;
996 #endif
997
998 if (msg->response != 0 && msg->response != 200) return;
999
1000 if (msg->bodylen == 0 || msg->body == NULL || !sipe_strequal(sipmsg_find_header(msg, "Event"), "conference")) return;
1001
1002 xn_conference_info = sipe_xml_parse(msg->body, msg->bodylen);
1003 if (!xn_conference_info) return;
1004
1005 focus_uri = sipe_xml_attribute(xn_conference_info, "entity");
1006 session = sipe_session_find_conference(sipe_private, focus_uri);
1007
1008 if (!session) {
1009 SIPE_DEBUG_INFO("sipe_process_conference: unable to find conf session with focus=%s", focus_uri);
1010 return;
1011 }
1012
1013 if (!session->chat_session->backend) {
1014 gchar *self = sip_uri_self(sipe_private);
1015
1016 /* create chat */
1017 session->chat_session->backend = sipe_backend_chat_create(SIPE_CORE_PUBLIC,
1018 session->chat_session,
1019 session->chat_session->title,
1020 self);
1021 just_joined = TRUE;
1022 /* @TODO ask for full state (re-subscribe) if it was a partial one -
1023 * this is to obtain full list of conference participants.
1024 */
1025 g_free(self);
1026 }
1027
1028 /* subject */
1029 if ((xn_subject = sipe_xml_child(xn_conference_info, "conference-description/subject"))) {
1030 g_free(session->subject);
1031 session->subject = sipe_xml_data(xn_subject);
1032 sipe_backend_chat_topic(session->chat_session->backend, session->subject);
1033 SIPE_DEBUG_INFO("sipe_process_conference: subject=%s", session->subject ? session->subject : "");
1034 }
1035
1036 /* IM MCU URI */
1037 if (!session->im_mcu_uri) {
1038 for (node = sipe_xml_child(xn_conference_info, "conference-description/conf-uris/entry");
1039 node;
1040 node = sipe_xml_twin(node))
1041 {
1042 gchar *purpose = sipe_xml_data(sipe_xml_child(node, "purpose"));
1043
1044 if (sipe_strequal("chat", purpose)) {
1045 g_free(purpose);
1046 session->im_mcu_uri = sipe_xml_data(sipe_xml_child(node, "uri"));
1047 SIPE_DEBUG_INFO("sipe_process_conference: im_mcu_uri=%s", session->im_mcu_uri);
1048 break;
1049 }
1050 g_free(purpose);
1051 }
1052 }
1053
1054 /* users */
1055 for (node = sipe_xml_child(xn_conference_info, "users/user"); node; node = sipe_xml_twin(node)) {
1056 const gchar *user_uri = sipe_xml_attribute(node, "entity");
1057 const gchar *state = sipe_xml_attribute(node, "state");
1058 gchar *role = sipe_xml_data(sipe_xml_child(node, "roles/entry"));
1059 gboolean is_operator = sipe_strequal(role, "presenter");
1060 gboolean is_in_im_mcu = FALSE;
1061 gchar *self = sip_uri_self(sipe_private);
1062
1063 if (sipe_strequal("deleted", state)) {
1064 if (sipe_backend_chat_find(session->chat_session->backend, user_uri)) {
1065 sipe_backend_chat_remove(session->chat_session->backend,
1066 user_uri);
1067 }
1068 } else {
1069 /* endpoints */
1070 const sipe_xml *endpoint;
1071 for (endpoint = sipe_xml_child(node, "endpoint"); endpoint; endpoint = sipe_xml_twin(endpoint)) {
1072 const gchar *session_type;
1073 gchar *status = sipe_xml_data(sipe_xml_child(endpoint, "status"));
1074 gboolean connected = sipe_strequal("connected", status);
1075 g_free(status);
1076
1077 if (!connected)
1078 continue;
1079
1080 session_type = sipe_xml_attribute(endpoint, "session-type");
1081
1082 if (sipe_strequal("chat", session_type)) {
1083 is_in_im_mcu = TRUE;
1084 if (!sipe_backend_chat_find(session->chat_session->backend, user_uri)) {
1085 sipe_backend_chat_add(session->chat_session->backend,
1086 user_uri,
1087 !just_joined && g_ascii_strcasecmp(user_uri, self));
1088 }
1089 if (is_operator) {
1090 sipe_backend_chat_operator(session->chat_session->backend,
1091 user_uri);
1092 }
1093 } else if (sipe_strequal("audio-video", session_type)) {
1094 #ifdef HAVE_VV
1095 if (!session->is_call)
1096 audio_was_added = TRUE;
1097 #endif
1098 }
1099 }
1100 if (!is_in_im_mcu) {
1101 if (sipe_backend_chat_find(session->chat_session->backend, user_uri)) {
1102 sipe_backend_chat_remove(session->chat_session->backend,
1103 user_uri);
1104 }
1105 }
1106 }
1107 g_free(role);
1108 g_free(self);
1109 }
1110
1111 #ifdef HAVE_VV
1112 if (audio_was_added) {
1113 session->is_call = TRUE;
1114 ask_accept_voice_conference(sipe_private, focus_uri, NULL,
1115 (SipeUserAskCb) call_accept_cb,
1116 (SipeUserAskCb) call_decline_cb);
1117 }
1118 #endif
1119
1120 /* entity-view, locked */
1121 for (node = sipe_xml_child(xn_conference_info, "conference-view/entity-view");
1122 node;
1123 node = sipe_xml_twin(node)) {
1124
1125 const sipe_xml *xn_type = sipe_xml_child(node, "entity-state/media/entry/type");
1126 gchar *tmp = NULL;
1127 if (xn_type && sipe_strequal("chat", (tmp = sipe_xml_data(xn_type)))) {
1128 const sipe_xml *xn_locked = sipe_xml_child(node, "entity-state/locked");
1129 if (xn_locked) {
1130 gchar *locked = sipe_xml_data(xn_locked);
1131 gboolean prev_locked = session->locked;
1132 session->locked = sipe_strequal(locked, "true");
1133 if (prev_locked && !session->locked) {
1134 sipe_user_present_info(sipe_private, session,
1135 _("This conference is no longer locked. Additional participants can now join."));
1136 }
1137 if (!prev_locked && session->locked) {
1138 sipe_user_present_info(sipe_private, session,
1139 _("This conference is locked. Nobody else can join the conference while it is locked."));
1140 }
1141
1142 SIPE_DEBUG_INFO("sipe_process_conference: session->locked=%s",
1143 session->locked ? "TRUE" : "FALSE");
1144 g_free(locked);
1145 }
1146 }
1147 g_free(tmp);
1148 }
1149 sipe_xml_free(xn_conference_info);
1150
1151 if (session->im_mcu_uri) {
1152 struct sip_dialog *dialog = sipe_dialog_find(session, session->im_mcu_uri);
1153 if (!dialog) {
1154 dialog = sipe_dialog_add(session);
1155
1156 dialog->callid = g_strdup(session->callid);
1157 dialog->with = g_strdup(session->im_mcu_uri);
1158
1159 /* send INVITE to IM MCU */
1160 sipe_im_invite(sipe_private, session, dialog->with, NULL, NULL, NULL, FALSE);
1161 }
1162 }
1163
1164 sipe_process_pending_invite_queue(sipe_private, session);
1165 }
1166
1167 void
1168 sipe_conf_immcu_closed(struct sipe_core_private *sipe_private,
1169 struct sip_session *session)
1170 {
1171 sipe_user_present_info(sipe_private, session,
1172 _("You have been disconnected from this conference."));
1173 sipe_backend_chat_close(session->chat_session->backend);
1174 }
1175
1176 void
1177 conf_session_close(struct sipe_core_private *sipe_private,
1178 struct sip_session *session)
1179 {
1180 if (session) {
1181 /* unsubscribe from focus */
1182 sipe_subscribe_conference(sipe_private,
1183 session->chat_session->id, TRUE);
1184
1185 if (session->focus_dialog) {
1186 /* send BYE to focus */
1187 sip_transport_bye(sipe_private, session->focus_dialog);
1188 }
1189 }
1190 }
1191
1192 void
1193 sipe_process_imdn(struct sipe_core_private *sipe_private,
1194 struct sipmsg *msg)
1195 {
1196 gchar *with = parse_from(sipmsg_find_header(msg, "From"));
1197 const gchar *callid = sipmsg_find_header(msg, "Call-ID");
1198 static struct sip_session *session;
1199 sipe_xml *xn_imdn;
1200 const sipe_xml *node;
1201 gchar *message_id;
1202 gchar *message;
1203
1204 session = sipe_session_find_chat_or_im(sipe_private, callid, with);
1205 if (!session) {
1206 SIPE_DEBUG_INFO("sipe_process_imdn: unable to find conf session with callid=%s", callid);
1207 g_free(with);
1208 return;
1209 }
1210
1211 xn_imdn = sipe_xml_parse(msg->body, msg->bodylen);
1212 message_id = sipe_xml_data(sipe_xml_child(xn_imdn, "message-id"));
1213
1214 message = g_hash_table_lookup(session->conf_unconfirmed_messages, message_id);
1215
1216 /* recipient */
1217 for (node = sipe_xml_child(xn_imdn, "recipient"); node; node = sipe_xml_twin(node)) {
1218 gchar *tmp = parse_from(sipe_xml_attribute(node, "uri"));
1219 gchar *uri = parse_from(tmp);
1220 sipe_user_present_message_undelivered(sipe_private, session, -1, -1, uri, message);
1221 g_free(tmp);
1222 g_free(uri);
1223 }
1224
1225 sipe_xml_free(xn_imdn);
1226
1227 g_hash_table_remove(session->conf_unconfirmed_messages, message_id);
1228 SIPE_DEBUG_INFO("sipe_process_imdn: removed message %s from conf_unconfirmed_messages(count=%d)",
1229 message_id, g_hash_table_size(session->conf_unconfirmed_messages));
1230 g_free(message_id);
1231 g_free(with);
1232 }
1233
1234 void sipe_core_conf_make_leader(struct sipe_core_public *sipe_public,
1235 gpointer parameter,
1236 const gchar *buddy_name)
1237 {
1238 struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
1239 struct sipe_chat_session *chat_session = parameter;
1240 struct sip_session *session;
1241
1242 SIPE_DEBUG_INFO("sipe_core_conf_make_leader: chat_title=%s",
1243 chat_session->title);
1244
1245 session = sipe_session_find_chat(sipe_private, chat_session);
1246 sipe_conf_modify_user_role(sipe_private, session, buddy_name);
1247 }
1248
1249 void sipe_core_conf_remove_from(struct sipe_core_public *sipe_public,
1250 gpointer parameter,
1251 const gchar *buddy_name)
1252 {
1253 struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
1254 struct sipe_chat_session *chat_session = parameter;
1255 struct sip_session *session;
1256
1257 SIPE_DEBUG_INFO("sipe_core_conf_remove_from: chat_title=%s",
1258 chat_session->title);
1259
1260 session = sipe_session_find_chat(sipe_private, chat_session);
1261 sipe_conf_delete_user(sipe_private, session, buddy_name);
1262 }
1263
1264 /*
1265 Local Variables:
1266 mode: c
1267 c-file-style: "bsd"
1268 indent-tabs-mode: t
1269 tab-width: 8
1270 End:
1271 */
A third-party Pidgin plugin for Microsoft LCS/OCS