src/core/sipe-conf.c

   1 /**
   2  * @file sipe-conf.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2010-2016 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 /**
  26  * Documentation references:
  27  *
  28  * Microsoft DevNet: [MS-CONFIM]: Centralized Conference Control Protocol:
  29  *                                Instant Messaging Extensions
  30  *  <http://msdn.microsoft.com/en-us/library/cc431500%28v=office.12%29.aspx>
  31  *
  32  */
  33
  34 #ifdef HAVE_CONFIG_H
  35 #include "config.h"
  36 #endif
  37
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <time.h>
  41
  42 #include <glib.h>
  43
  44 #ifdef HAVE_GIO
  45 #include <gio/gio.h>
  46 #include "sipe-appshare.h"
  47 #endif
  48
  49 #include "sipe-common.h"
  50 #include "sipmsg.h"
  51 #include "sip-transport.h"
  52 #include "sipe-backend.h"
  53 #include "sipe-buddy.h"
  54 #include "sipe-chat.h"
  55 #include "sipe-conf.h"
  56 #include "sipe-core.h"
  57 #include "sipe-core-private.h"
  58 #include "sipe-dialog.h"
  59 #include "sipe-http.h"
  60 #include "sipe-im.h"
  61 #include "sipe-nls.h"
  62 #include "sipe-session.h"
  63 #include "sipe-subscriptions.h"
  64 #include "sipe-user.h"
  65 #include "sipe-utils.h"
  66 #include "sipe-xml.h"
  67
  68 /**
  69  * Invite counterparty to join conference.
  70  * @param focus_uri (%s)
  71  * @param subject (%s) of conference
  72  */
  73 #define SIPE_SEND_CONF_INVITE \
  74 "<Conferencing version=\"2.0\">"\
  75         "<focus-uri>%s</focus-uri>"\
  76         "<subject>%s</subject>"\
  77         "<im available=\"true\">"\
  78                 "<first-im/>"\
  79         "</im>"\
  80 "</Conferencing>"
  81
  82 static gboolean
  83 sipe_conf_check_for_lync_url(struct sipe_core_private *sipe_private,
  84                              gchar *uri);
  85
  86 static struct transaction *
  87 cccp_request(struct sipe_core_private *sipe_private, const gchar *method,
  88              const gchar *with, struct sip_dialog *dialog,
  89              TransCallback callback, const gchar *body, ...)
  90 {
  91         gchar *headers;
  92         gchar *request;
  93         gchar *request_body;
  94
  95         gchar *self = sip_uri_self(sipe_private);
  96
  97         va_list args;
  98
  99         struct transaction *trans;
 100
 101         headers = g_strdup_printf(
 102                 "Supported: ms-sender\r\n"
 103                 "Contact: %s\r\n"
 104                 "Content-Type: application/cccp+xml\r\n",
 105                 sipe_private->contact);
 106
 107         /* TODO: put request_id to queue to further compare with incoming one */
 108         request = g_strdup_printf(
 109                 "<?xml version=\"1.0\"?>"
 110                 "<request xmlns=\"urn:ietf:params:xml:ns:cccp\" "
 111                 "xmlns:mscp=\"http://schemas.microsoft.com/rtc/2005/08/cccpextensions\" "
 112                         "C3PVersion=\"1\" "
 113                         "to=\"%s\" "
 114                         "from=\"%s\" "
 115                         "requestId=\"%d\">"
 116                         "%s"
 117                 "</request>",
 118                 with,
 119                 self,
 120                 sipe_private->cccp_request_id++,
 121                 body);
 122         g_free(self);
 123
 124         va_start(args, body);
 125         request_body = g_strdup_vprintf(request, args);
 126         va_end(args);
 127
 128         g_free(request);
 129
 130         trans = sip_transport_request(sipe_private,
 131                                       method,
 132                                       with,
 133                                       with,
 134                                       headers,
 135                                       request_body,
 136                                       dialog,
 137                                       callback);
 138
 139         g_free(headers);
 140         g_free(request_body);
 141
 142         return trans;
 143 }
 144
 145 static gboolean
 146 process_conf_get_capabilities(SIPE_UNUSED_PARAMETER struct sipe_core_private *sipe_private,
 147                               struct sipmsg *msg,
 148                               SIPE_UNUSED_PARAMETER struct transaction *trans)
 149 {
 150         if (msg->response >= 400) {
 151                 SIPE_DEBUG_INFO_NOFORMAT("process_conf_get_capabilities: "
 152                                 "getConferencingCapabilities failed.");
 153                 return FALSE;
 154         }
 155         if (msg->response == 200) {
 156                 sipe_xml *xn_response = sipe_xml_parse(msg->body, msg->bodylen);
 157                 const sipe_xml *node;
 158                 gchar *default_region;
 159
 160                 if (!sipe_strequal("success", sipe_xml_attribute(xn_response, "code"))) {
 161                         return TRUE;
 162                 }
 163
 164                 node = sipe_xml_child(xn_response, "getConferencingCapabilities/mcu-types/mcuType");
 165                 for (;node; node = sipe_xml_twin(node)) {
 166                         sipe_private->conf_mcu_types =
 167                                         g_slist_append(sipe_private->conf_mcu_types,
 168                                                        sipe_xml_data(node));
 169                 }
 170
 171                 g_hash_table_remove_all(sipe_private->access_numbers);
 172                 node = sipe_xml_child(xn_response, "getConferencingCapabilities/pstn-bridging/access-numbers/region");
 173                 for (;node; node = sipe_xml_twin(node)) {
 174                         gchar *name = g_strdup(sipe_xml_attribute(node, "name"));
 175                         gchar *number = sipe_xml_data(sipe_xml_child(node, "access-number/number"));
 176                         if (name && number) {
 177                                 g_hash_table_insert(sipe_private->access_numbers, name, number);
 178                         }
 179                 }
 180
 181                 node = sipe_xml_child(xn_response, "getConferencingCapabilities/pstn-bridging/access-numbers/default-region");
 182                 default_region = sipe_xml_data(node);
 183                 if (default_region) {
 184                         sipe_private->default_access_number =
 185                                         g_hash_table_lookup(sipe_private->access_numbers, default_region);
 186                 }
 187                 g_free(default_region);
 188
 189                 sipe_xml_free(xn_response);
 190         }
 191
 192         return TRUE;
 193 }
 194
 195 void
 196 sipe_conf_get_capabilities(struct sipe_core_private *sipe_private)
 197 {
 198         cccp_request(sipe_private, "SERVICE",
 199                      sipe_private->focus_factory_uri,
 200                      NULL,
 201                      process_conf_get_capabilities,
 202                      "<getConferencingCapabilities />");
 203 }
 204
 205 gboolean
 206 sipe_conf_supports_mcu_type(struct sipe_core_private *sipe_private,
 207                             const gchar *type)
 208 {
 209         return g_slist_find_custom(sipe_private->conf_mcu_types, type,
 210                                    sipe_strcompare) != NULL;
 211 }
 212
 213 /**
 214  * Generates random GUID.
 215  * This method is borrowed from pidgin's msnutils.c
 216  */
 217 static char *
 218 rand_guid()
 219 {
 220         return g_strdup_printf("%4X%4X-%4X-%4X-%4X-%4X%4X%4X",
 221                         rand() % 0xAAFF + 0x1111,
 222                         rand() % 0xAAFF + 0x1111,
 223                         rand() % 0xAAFF + 0x1111,
 224                         rand() % 0xAAFF + 0x1111,
 225                         rand() % 0xAAFF + 0x1111,
 226                         rand() % 0xAAFF + 0x1111,
 227                         rand() % 0xAAFF + 0x1111,
 228                         rand() % 0xAAFF + 0x1111);
 229 }
 230
 231 /** Invite us to the focus callback */
 232 static gboolean
 233 process_invite_conf_focus_response(struct sipe_core_private *sipe_private,
 234                                    struct sipmsg *msg,
 235                                    SIPE_UNUSED_PARAMETER struct transaction *trans)
 236 {
 237         struct sip_session *session = NULL;
 238         char *focus_uri = parse_from(sipmsg_find_header(msg, "To"));
 239
 240         session = sipe_session_find_conference(sipe_private, focus_uri);
 241
 242         if (!session) {
 243                 SIPE_DEBUG_INFO("process_invite_conf_focus_response: unable to find conf session with focus=%s", focus_uri);
 244                 g_free(focus_uri);
 245                 return FALSE;
 246         }
 247
 248         if (!session->focus_dialog) {
 249                 SIPE_DEBUG_INFO_NOFORMAT("process_invite_conf_focus_response: session's focus_dialog is NULL");
 250                 g_free(focus_uri);
 251                 return FALSE;
 252         }
 253
 254         sipe_dialog_parse(session->focus_dialog, msg, TRUE);
 255
 256         if (msg->response >= 200) {
 257                 /* send ACK to focus */
 258                 session->focus_dialog->cseq = 0;
 259                 sip_transport_ack(sipe_private, session->focus_dialog);
 260                 session->focus_dialog->outgoing_invite = NULL;
 261                 session->focus_dialog->is_established = TRUE;
 262         }
 263
 264         if (msg->response >= 400) {
 265                 gchar *reason = sipmsg_get_ms_diagnostics_reason(msg);
 266
 267                 SIPE_DEBUG_INFO_NOFORMAT("process_invite_conf_focus_response: INVITE response is not 200. Failed to join focus.");
 268                 sipe_backend_notify_error(SIPE_CORE_PUBLIC,
 269                                           _("Failed to join the conference"),
 270                                           reason ? reason : _("no reason given"));
 271                 g_free(reason);
 272
 273                 sipe_session_remove(sipe_private, session);
 274                 g_free(focus_uri);
 275                 return FALSE;
 276         } else if (msg->response == 200) {
 277                 sipe_xml *xn_response = sipe_xml_parse(msg->body, msg->bodylen);
 278                 const gchar *code = sipe_xml_attribute(xn_response, "code");
 279                 if (sipe_strequal(code, "success")) {
 280                         /* subscribe to focus */
 281                         sipe_subscribe_conference(sipe_private,
 282                                                   session->chat_session->id,
 283                                                   FALSE);
 284 #ifdef HAVE_VV
 285                         if (session->is_call)
 286                                 sipe_core_media_connect_conference(SIPE_CORE_PUBLIC,
 287                                                                    session->chat_session);
 288 #endif
 289                 }
 290                 sipe_xml_free(xn_response);
 291         }
 292
 293         g_free(focus_uri);
 294         return TRUE;
 295 }
 296
 297 static gchar *
 298 parse_ocs_focus_uri(const gchar *uri)
 299 {
 300         const gchar *confkey;
 301         size_t uri_len;
 302
 303         if (!uri)
 304                 return NULL;
 305
 306         // URI can have this prefix if it was typed in by the user
 307         if (g_str_has_prefix(uri, "meet:") || g_str_has_prefix(uri, "conf:")) {
 308                 uri += 5;
 309         }
 310
 311         uri_len = strlen(uri);
 312
 313         if (!uri || !g_str_has_prefix(uri, "sip:") ||
 314                 uri_len == 4 || g_strstr_len(uri, -1, "%")) {
 315                 return NULL;
 316         }
 317
 318         confkey = g_strstr_len(uri, -1, "?");
 319         if (confkey) {
 320                 /* TODO: Investigate how conf-key field should be used,
 321                  * ignoring for now */
 322                 uri_len = confkey - uri;
 323         }
 324
 325         return g_strndup(uri, uri_len);
 326 }
 327
 328 static gchar *
 329 extract_uri_from_html(const gchar *body,
 330                       const gchar *prefix,
 331                       guint prefix_skip_chars)
 332 {
 333         gchar *uri = NULL;
 334         const gchar *start = g_strstr_len(body, -1, prefix);
 335
 336         if (start) {
 337                 const gchar *end;
 338
 339                 start += prefix_skip_chars;
 340                 end = strchr(start, '"');
 341
 342                 if (end) {
 343                         gchar *html = g_strndup(start, end - start);
 344
 345                         /* decode HTML entities */
 346                         gchar *html_unescaped = sipe_backend_markup_strip_html(html);
 347                         g_free(html);
 348
 349                         if (!is_empty(html_unescaped)) {
 350                                 uri = sipe_utils_uri_unescape(html_unescaped);
 351                         }
 352
 353                         g_free(html_unescaped);
 354                 }
 355         }
 356
 357         return uri;
 358 }
 359
 360 static void sipe_conf_lync_url_cb(struct sipe_core_private *sipe_private,
 361                                   guint status,
 362                                   SIPE_UNUSED_PARAMETER GSList *headers,
 363                                   const gchar *body,
 364                                   gpointer callback_data)
 365 {
 366         gchar *uri = callback_data;
 367
 368         if (status != (guint) SIPE_HTTP_STATUS_ABORTED) {
 369                 gchar *focus_uri = NULL;
 370
 371                 if (body) {
 372                         /*
 373                          * Extract focus URI from HTML, e.g.
 374                          *
 375                          *  <a ... href="conf&#58;sip&#58;...ABCDEF&#37;3Frequired..." ... >
 376                          */
 377                         gchar *uri = extract_uri_from_html(body, "href=\"conf", 6);
 378                         focus_uri = parse_ocs_focus_uri(uri);
 379                         g_free(uri);
 380                 }
 381
 382                 if (focus_uri) {
 383                         SIPE_DEBUG_INFO("sipe_conf_lync_url_cb: found focus URI"
 384                                         " '%s'", focus_uri);
 385
 386                         sipe_conf_create(sipe_private, NULL, focus_uri);
 387                         g_free(focus_uri);
 388                 } else {
 389                         /*
 390                          * If present, domainOwnerJoinLauncherUrl redirects to
 391                          * a page from where we still may extract the focus URI.
 392                          */
 393                         gchar *launcher_url;
 394                         static const gchar launcher_url_prefix[] =
 395                                         "var domainOwnerJoinLauncherUrl = \"";
 396
 397                         SIPE_DEBUG_INFO("sipe_conf_lync_url_cb: no focus URI "
 398                                         "found from URL '%s'", uri);
 399
 400                         launcher_url = extract_uri_from_html(body,
 401                                                              launcher_url_prefix,
 402                                                              sizeof (launcher_url_prefix) - 1);
 403
 404                         if (launcher_url &&
 405                             sipe_conf_check_for_lync_url(sipe_private, launcher_url)) {
 406                                 SIPE_DEBUG_INFO("sipe_conf_lync_url_cb: retrying with URL '%s'",
 407                                                 launcher_url);
 408                                 /* Ownership taken by sipe_conf_check_for_lync_url() */
 409                                 launcher_url = NULL;
 410                         } else {
 411                                 gchar *error;
 412
 413                                 error = g_strdup_printf(_("Can't find a conference URI on this page:\n\n%s"),
 414                                                         uri);
 415
 416                                 sipe_backend_notify_error(SIPE_CORE_PUBLIC,
 417                                                           _("Failed to join the conference"),
 418                                                           error);
 419                                 g_free(error);
 420                         }
 421
 422                         g_free(launcher_url);
 423                 }
 424         }
 425
 426         g_free(uri);
 427 }
 428
 429 static gboolean sipe_conf_check_for_lync_url(struct sipe_core_private *sipe_private,
 430                                              gchar *uri)
 431 {
 432         if (!(g_str_has_prefix(uri, "https://") ||
 433               g_str_has_prefix(uri, "http://")))
 434                 return(FALSE);
 435
 436         /* URL points to a HTML page with the conference focus URI */
 437         return(sipe_http_request_get(sipe_private,
 438                                      uri,
 439                                      NULL,
 440                                      sipe_conf_lync_url_cb,
 441                                      uri)
 442                != NULL);
 443 }
 444
 445 static void sipe_conf_uri_error(struct sipe_core_private *sipe_private,
 446                                 const gchar *uri)
 447 {
 448         gchar *error = g_strdup_printf(_("\"%s\" is not a valid conference URI"),
 449                                        uri ? uri : "");
 450         sipe_backend_notify_error(SIPE_CORE_PUBLIC,
 451                                   _("Failed to join the conference"),
 452                                   error);
 453         g_free(error);
 454 }
 455
 456 void sipe_core_conf_create(struct sipe_core_public *sipe_public,
 457                            const gchar *uri,
 458                            const gchar *organizer,
 459                            const gchar *meeting_id)
 460 {
 461         struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
 462
 463         /* SIP URI or HTTP URL */
 464         if (uri) {
 465                 gchar *uri_ue = sipe_utils_uri_unescape(uri);
 466
 467                 SIPE_DEBUG_INFO("sipe_core_conf_create: URI '%s' unescaped '%s'",
 468                                 uri,
 469                                 uri_ue ? uri_ue : "<UNDEFINED>");
 470
 471                 /* takes ownership of "uri_ue" if successful */
 472                 if (!sipe_conf_check_for_lync_url(sipe_private, uri_ue)) {
 473                         gchar *focus_uri = parse_ocs_focus_uri(uri_ue);
 474
 475                         if (focus_uri) {
 476                                 sipe_conf_create(sipe_private, NULL, focus_uri);
 477                                 g_free(focus_uri);
 478                         } else
 479                                 sipe_conf_uri_error(sipe_private, uri);
 480
 481                         g_free(uri_ue);
 482                 }
 483
 484         /* Organizer email and meeting ID */
 485         } else if (organizer && meeting_id) {
 486                 gchar *tmp = g_strdup_printf("sip:%s;gruu;opaque=app:conf:focus:id:%s",
 487                                              organizer, meeting_id);
 488                 gchar *focus_uri = parse_ocs_focus_uri(tmp);
 489
 490                 SIPE_DEBUG_INFO("sipe_core_conf_create: organizer '%s' meeting ID '%s'",
 491                                 organizer,
 492                                 meeting_id);
 493
 494                 if (focus_uri) {
 495                         sipe_conf_create(sipe_private, NULL, focus_uri);
 496                         g_free(focus_uri);
 497                 } else
 498                         sipe_conf_uri_error(sipe_private, tmp);
 499                 g_free(tmp);
 500
 501         } else {
 502                 sipe_backend_notify_error(SIPE_CORE_PUBLIC,
 503                                           _("Failed to join the conference"),
 504                                           _("Incomplete conference information provided"));
 505         }
 506 }
 507
 508 /** Create new session with Focus URI */
 509 struct sip_session *
 510 sipe_conf_create(struct sipe_core_private *sipe_private,
 511                  struct sipe_chat_session *chat_session,
 512                  const gchar *focus_uri)
 513 {
 514         /* addUser request to the focus.
 515          *
 516          * focus_URI, from, endpoint_GUID
 517          */
 518         static const gchar CCCP_ADD_USER[] =
 519                 "<addUser>"
 520                         "<conferenceKeys confEntity=\"%s\"/>"
 521                         "<ci:user xmlns:ci=\"urn:ietf:params:xml:ns:conference-info\" entity=\"%s\">"
 522                                 "<ci:roles>"
 523                                         "<ci:entry>attendee</ci:entry>"
 524                                 "</ci:roles>"
 525                                 "<ci:endpoint entity=\"{%s}\" "
 526                                               "xmlns:msci=\"http://schemas.microsoft.com/rtc/2005/08/confinfoextensions\"/>"
 527                         "</ci:user>"
 528                 "</addUser>";
 529
 530         gchar *self;
 531         struct sip_session *session = sipe_session_add_chat(sipe_private,
 532                                                             chat_session,
 533                                                             FALSE,
 534                                                             focus_uri);
 535
 536         session->focus_dialog = g_new0(struct sip_dialog, 1);
 537         session->focus_dialog->callid = gencallid();
 538         session->focus_dialog->with = g_strdup(session->chat_session->id);
 539         session->focus_dialog->endpoint_GUID = rand_guid();
 540         session->focus_dialog->ourtag = gentag();
 541
 542         self = sip_uri_self(sipe_private);
 543         session->focus_dialog->outgoing_invite =
 544                 cccp_request(sipe_private, "INVITE",
 545                              session->focus_dialog->with, session->focus_dialog,
 546                              process_invite_conf_focus_response,
 547                              CCCP_ADD_USER,
 548                              session->focus_dialog->with, self,
 549                              session->focus_dialog->endpoint_GUID);
 550
 551         /* Rejoin existing session? */
 552         if (chat_session) {
 553                 SIPE_DEBUG_INFO("sipe_conf_create: rejoin '%s' (%s)",
 554                                 chat_session->title,
 555                                 chat_session->id);
 556                 sipe_backend_chat_rejoin(SIPE_CORE_PUBLIC,
 557                                          chat_session->backend,
 558                                          self,
 559                                          chat_session->title);
 560         }
 561         g_free(self);
 562
 563         return(session);
 564 }
 565
 566 /** Modify User Role */
 567 void
 568 sipe_conf_modify_user_role(struct sipe_core_private *sipe_private,
 569                            struct sip_session *session,
 570                            const gchar* who)
 571 {
 572         /* modifyUserRoles request to the focus. Makes user a leader.
 573          *
 574          * focus_uri (%s)
 575          * who (%s)
 576          */
 577         static const gchar CCCP_MODIFY_USER_ROLES[] =
 578                 "<modifyUserRoles>"
 579                         "<userKeys confEntity=\"%s\" userEntity=\"%s\"/>"
 580                         "<user-roles xmlns=\"urn:ietf:params:xml:ns:conference-info\">"
 581                                 "<entry>presenter</entry>"
 582                         "</user-roles>"
 583                 "</modifyUserRoles>";
 584
 585         if (!session->focus_dialog || !session->focus_dialog->is_established) {
 586                 SIPE_DEBUG_INFO_NOFORMAT("sipe_conf_modify_user_role: no dialog with focus, exiting.");
 587                 return;
 588         }
 589
 590         cccp_request(sipe_private, "INFO", session->focus_dialog->with,
 591                      session->focus_dialog, NULL,
 592                      CCCP_MODIFY_USER_ROLES,
 593                      session->focus_dialog->with, who);
 594 }
 595
 596 /**
 597  * Check conference lock status
 598  */
 599 sipe_chat_lock_status sipe_core_chat_lock_status(struct sipe_core_public *sipe_public,
 600                                                  struct sipe_chat_session *chat_session)
 601 {
 602         struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
 603         sipe_chat_lock_status status = SIPE_CHAT_LOCK_STATUS_NOT_ALLOWED;
 604
 605         if (chat_session &&
 606             (chat_session->type == SIPE_CHAT_TYPE_CONFERENCE)) {
 607                 struct sip_session *session = sipe_session_find_chat(sipe_private,
 608                                                                      chat_session);
 609                 if (session) {
 610                         gchar *self = sip_uri_self(sipe_private);
 611
 612                         /* Only operators are allowed to change the lock status */
 613                         if (sipe_backend_chat_is_operator(chat_session->backend, self)) {
 614                                 status = session->locked ?
 615                                         SIPE_CHAT_LOCK_STATUS_LOCKED :
 616                                         SIPE_CHAT_LOCK_STATUS_UNLOCKED;
 617                         }
 618
 619                         g_free(self);
 620                 }
 621         }
 622
 623         return(status);
 624 }
 625
 626 /**
 627  * Modify Conference Lock
 628  * Sends request to Focus.
 629  * INFO method is a carrier of application/cccp+xml
 630  */
 631 void
 632 sipe_core_chat_modify_lock(struct sipe_core_public *sipe_public,
 633                            struct sipe_chat_session *chat_session,
 634                            const gboolean locked)
 635 {
 636         /* modifyConferenceLock request to the focus. Locks/unlocks conference.
 637          *
 638          * focus_uri (%s)
 639          * locked (%s) "true" or "false" values applicable
 640          */
 641         static const gchar CCCP_MODIFY_CONFERENCE_LOCK[] =
 642                 "<modifyConferenceLock>"
 643                         "<conferenceKeys confEntity=\"%s\"/>"
 644                         "<locked>%s</locked>"
 645                 "</modifyConferenceLock>";
 646
 647         struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
 648
 649         struct sip_session *session = sipe_session_find_chat(sipe_private,
 650                                                              chat_session);
 651
 652         if (!session) return;
 653         if (!session->focus_dialog || !session->focus_dialog->is_established) {
 654                 SIPE_DEBUG_INFO_NOFORMAT("sipe_conf_modify_conference_lock: no dialog with focus, exiting.");
 655                 return;
 656         }
 657
 658         cccp_request(sipe_private, "INFO", session->focus_dialog->with,
 659                      session->focus_dialog, NULL,
 660                      CCCP_MODIFY_CONFERENCE_LOCK,
 661                      session->focus_dialog->with,
 662                      locked ? "true" : "false");
 663 }
 664
 665 /** Modify Delete User */
 666 void
 667 sipe_conf_delete_user(struct sipe_core_private *sipe_private,
 668                       struct sip_session *session,
 669                       const gchar* who)
 670 {
 671         /* deleteUser request to the focus. Removes a user from the conference.
 672          *
 673          * focus_uri (%s)
 674          * who (%s)
 675          */
 676         static const gchar CCCP_DELETE_USER[] =
 677                 "<deleteUser>"
 678                         "<userKeys confEntity=\"%s\" userEntity=\"%s\"/>"
 679                 "</deleteUser>";
 680
 681         if (!session->focus_dialog || !session->focus_dialog->is_established) {
 682                 SIPE_DEBUG_INFO_NOFORMAT("sipe_conf_delete_user: no dialog with focus, exiting.");
 683                 return;
 684         }
 685
 686         cccp_request(sipe_private, "INFO", session->focus_dialog->with,
 687                      session->focus_dialog, NULL,
 688                      CCCP_DELETE_USER,
 689                      session->focus_dialog->with, who);
 690 }
 691
 692 void
 693 sipe_conf_announce_audio_mute_state(struct sipe_core_private *sipe_private,
 694                                     struct sip_session *session,
 695                                     gboolean is_muted)
 696 {
 697         // See [MS-CONFAV] 3.2.5.4 and 4.3
 698         static const gchar CCCP_MODIFY_ENDPOINT_MEDIA[] =
 699                 "<modifyEndpointMedia mscp:mcuUri=\"%s\""
 700                 " xmlns:mscp=\"http://schemas.microsoft.com/rtc/2005/08/cccpextensions\">"
 701                         "<mediaKeys confEntity=\"%s\" userEntity=\"%s\""
 702                         " endpointEntity=\"%s\" mediaId=\"%d\"/>"
 703                         "<ci:media"
 704                         " xmlns:ci=\"urn:ietf:params:xml:ns:conference-info\" id=\"%d\">"
 705                                 "<ci:type>audio</ci:type>"
 706                                 "<ci:status>%s</ci:status>"
 707                                 "<media-ingress-filter"
 708                                 " xmlns=\"http://schemas.microsoft.com/rtc/2005/08/confinfoextensions\">"
 709                                         "%s"
 710                                 "</media-ingress-filter>"
 711                         "</ci:media>"
 712                 "</modifyEndpointMedia>";
 713
 714         gchar *mcu_uri = sipe_conf_build_uri(session->focus_dialog->with,
 715                                              "audio-video");
 716         gchar *self = sip_uri_self(sipe_private);
 717
 718         cccp_request(sipe_private, "INFO", session->focus_dialog->with,
 719                      session->focus_dialog, NULL,
 720                      CCCP_MODIFY_ENDPOINT_MEDIA,
 721                      mcu_uri, session->focus_dialog->with, self,
 722                      session->audio_video_entity,
 723                      session->audio_media_id, session->audio_media_id,
 724                      is_muted ? "recvonly" : "sendrecv",
 725                      is_muted ? "block" : "unblock");
 726
 727         g_free(mcu_uri);
 728         g_free(self);
 729 }
 730
 731 /** Invite counterparty to join conference callback */
 732 static gboolean
 733 process_invite_conf_response(struct sipe_core_private *sipe_private,
 734                              struct sipmsg *msg,
 735                              SIPE_UNUSED_PARAMETER struct transaction *trans)
 736 {
 737         struct sip_dialog *dialog = g_new0(struct sip_dialog, 1);
 738
 739         dialog->callid = g_strdup(sipmsg_find_header(msg, "Call-ID"));
 740         dialog->cseq = sipmsg_parse_cseq(msg);
 741         dialog->with = parse_from(sipmsg_find_header(msg, "To"));
 742         sipe_dialog_parse(dialog, msg, TRUE);
 743
 744         if (msg->response >= 200) {
 745                 /* send ACK to counterparty */
 746                 dialog->cseq--;
 747                 sip_transport_ack(sipe_private, dialog);
 748                 dialog->outgoing_invite = NULL;
 749                 dialog->is_established = TRUE;
 750         }
 751
 752         if (msg->response >= 400) {
 753                 SIPE_DEBUG_INFO("process_invite_conf_response: INVITE response is not 200. Failed to invite %s.", dialog->with);
 754                 /* @TODO notify user of failure to invite counterparty */
 755                 sipe_dialog_free(dialog);
 756                 return FALSE;
 757         }
 758
 759         if (msg->response >= 200) {
 760                 struct sip_session *session = sipe_session_find_im(sipe_private, dialog->with);
 761                 struct sip_dialog *im_dialog = sipe_dialog_find(session, dialog->with);
 762
 763                 /* close IM session to counterparty */
 764                 if (im_dialog) {
 765                         sip_transport_bye(sipe_private, im_dialog);
 766                         sipe_dialog_remove(session, dialog->with);
 767                 }
 768         }
 769
 770         sipe_dialog_free(dialog);
 771         return TRUE;
 772 }
 773
 774 /**
 775  * Invites counterparty to join conference.
 776  */
 777 void
 778 sipe_invite_conf(struct sipe_core_private *sipe_private,
 779                  struct sip_session *session,
 780                  const gchar* who)
 781 {
 782         gchar *hdr;
 783         gchar *contact;
 784         gchar *body;
 785         struct sip_dialog *dialog = NULL;
 786
 787         /* It will be short lived special dialog.
 788          * Will not be stored in session.
 789          */
 790         dialog = g_new0(struct sip_dialog, 1);
 791         dialog->callid = gencallid();
 792         dialog->with = g_strdup(who);
 793         dialog->ourtag = gentag();
 794
 795         contact = get_contact(sipe_private);
 796         hdr = g_strdup_printf(
 797                 "Supported: ms-sender\r\n"
 798                 "Contact: %s\r\n"
 799                 "Content-Type: application/ms-conf-invite+xml\r\n",
 800                 contact);
 801         g_free(contact);
 802
 803         body = g_strdup_printf(
 804                 SIPE_SEND_CONF_INVITE,
 805                 session->chat_session->id,
 806                 session->subject ? session->subject : ""
 807                 );
 808
 809         sip_transport_invite(sipe_private,
 810                              hdr,
 811                              body,
 812                              dialog,
 813                              process_invite_conf_response);
 814
 815         sipe_dialog_free(dialog);
 816         g_free(body);
 817         g_free(hdr);
 818 }
 819
 820 /** Create conference callback */
 821 static gboolean
 822 process_conf_add_response(struct sipe_core_private *sipe_private,
 823                           struct sipmsg *msg,
 824                           struct transaction *trans)
 825 {
 826         if (msg->response >= 400) {
 827                 SIPE_DEBUG_INFO_NOFORMAT("process_conf_add_response: SERVICE response is not 200. Failed to create conference.");
 828                 /* @TODO notify user of failure to create conference */
 829                 return FALSE;
 830         }
 831         if (msg->response == 200) {
 832                 sipe_xml *xn_response = sipe_xml_parse(msg->body, msg->bodylen);
 833                 if (sipe_strequal("success", sipe_xml_attribute(xn_response, "code")))
 834                 {
 835                         gchar *who = trans->payload->data;
 836                         const sipe_xml *xn_conference_info = sipe_xml_child(xn_response, "addConference/conference-info");
 837                         struct sip_session *session = sipe_conf_create(sipe_private,
 838                                                                        NULL,
 839                                                                        sipe_xml_attribute(xn_conference_info,
 840                                                                                           "entity"));
 841
 842                         SIPE_DEBUG_INFO("process_conf_add_response: session->focus_uri=%s",
 843                                         session->chat_session->id);
 844
 845                         session->pending_invite_queue = sipe_utils_slist_insert_unique_sorted(session->pending_invite_queue,
 846                                                                                               g_strdup(who),
 847                                                                                               (GCompareFunc)strcmp,
 848                                                                                               g_free);
 849                 }
 850                 sipe_xml_free(xn_response);
 851         }
 852
 853         return TRUE;
 854 }
 855
 856 /**
 857  * Creates conference.
 858  */
 859 void
 860 sipe_conf_add(struct sipe_core_private *sipe_private,
 861               const gchar* who)
 862 {
 863         gchar *conference_id;
 864         struct transaction *trans;
 865         time_t expiry = time(NULL) + 7*60*60; /* 7 hours */
 866         char *expiry_time;
 867
 868         /* addConference request to the focus factory.
 869          *
 870          * conference_id        (%s) Ex.: 8386E6AEAAA41E4AA6627BA76D43B6D1
 871          * expiry_time          (%s) Ex.: 2009-07-13T17:57:09Z
 872          * conference_view      (%s) Ex.: <msci:entity-view entity="chat"/>
 873          */
 874         static const gchar CCCP_ADD_CONFERENCE[] =
 875                 "<addConference>"
 876                         "<ci:conference-info xmlns:ci=\"urn:ietf:params:xml:ns:conference-info\" "
 877                                              "entity=\"\" "
 878                                              "xmlns:msci=\"http://schemas.microsoft.com/rtc/2005/08/confinfoextensions\">"
 879                                 "<ci:conference-description>"
 880                                         "<ci:subject/>"
 881                                         "<msci:conference-id>%s</msci:conference-id>"
 882                                         "<msci:expiry-time>%s</msci:expiry-time>"
 883                                         "<msci:admission-policy>openAuthenticated</msci:admission-policy>"
 884                                 "</ci:conference-description>"
 885                                 "<msci:conference-view>%s</msci:conference-view>"
 886                         "</ci:conference-info>"
 887                 "</addConference>";
 888
 889         static const gchar *DESIRED_MCU_TYPES[] = {
 890                 "chat",
 891 #ifdef HAVE_VV
 892                 "audio-video",
 893 #endif
 894                 NULL
 895         };
 896
 897         GString *conference_view = g_string_new("");
 898         const gchar **type;
 899
 900         for (type = DESIRED_MCU_TYPES; *type; ++type ) {
 901                 if (sipe_conf_supports_mcu_type(sipe_private, *type)) {
 902                         g_string_append(conference_view, "<msci:entity-view entity=\"");
 903                         g_string_append(conference_view, *type);
 904                         g_string_append(conference_view, "\"/>");
 905                 }
 906         }
 907
 908         expiry_time = sipe_utils_time_to_str(expiry);
 909         conference_id = genconfid();
 910         trans = cccp_request(sipe_private, "SERVICE", sipe_private->focus_factory_uri,
 911                              NULL, process_conf_add_response,
 912                              CCCP_ADD_CONFERENCE,
 913                              conference_id, expiry_time, conference_view->str);
 914         g_free(conference_id);
 915         g_free(expiry_time);
 916         g_string_free(conference_view, TRUE);
 917
 918         if (trans) {
 919                 struct transaction_payload *payload = g_new0(struct transaction_payload, 1);
 920
 921                 payload->destroy = g_free;
 922                 payload->data = g_strdup(who);
 923                 trans->payload = payload;
 924         }
 925 }
 926
 927 static void
 928 accept_incoming_invite_conf(struct sipe_core_private *sipe_private,
 929                             gchar *focus_uri,
 930                             gboolean audio,
 931                             struct sipmsg *msg)
 932 {
 933         struct sip_session *session;
 934         gchar *newTag = gentag();
 935         const gchar *oldHeader = sipmsg_find_header(msg, "To");
 936         gchar *newHeader;
 937
 938         newHeader = g_strdup_printf("%s;tag=%s", oldHeader, newTag);
 939         g_free(newTag);
 940         sipmsg_remove_header_now(msg, "To");
 941         sipmsg_add_header_now(msg, "To", newHeader);
 942         g_free(newHeader);
 943
 944         /* acknowledge invite */
 945         sip_transport_response(sipe_private, msg, 200, "OK", NULL);
 946
 947         /* add self to conf */
 948         session = sipe_conf_create(sipe_private, NULL, focus_uri);
 949         session->is_call = audio;
 950 }
 951
 952 struct conf_accept_ctx {
 953         gchar *focus_uri;
 954         struct sipmsg *msg;
 955         struct sipe_user_ask_ctx *ask_ctx;
 956
 957         SipeUserAskCb accept_cb;
 958         SipeUserAskCb decline_cb;
 959
 960         gpointer user_data;
 961 };
 962
 963 static void
 964 conf_accept_ctx_free(struct conf_accept_ctx *ctx)
 965 {
 966         g_return_if_fail(ctx != NULL);
 967
 968         sipmsg_free(ctx->msg);
 969         g_free(ctx->focus_uri);
 970         g_free(ctx);
 971 }
 972
 973 static void
 974 conf_accept_cb(struct sipe_core_private *sipe_private, struct conf_accept_ctx *ctx)
 975 {
 976         accept_incoming_invite_conf(sipe_private, ctx->focus_uri, TRUE, ctx->msg);
 977 }
 978
 979 static void
 980 conf_decline_cb(struct sipe_core_private *sipe_private, struct conf_accept_ctx *ctx)
 981 {
 982         sip_transport_response(sipe_private,
 983                                ctx->msg,
 984                                603, "Decline", NULL);
 985 }
 986
 987 void
 988 sipe_conf_cancel_unaccepted(struct sipe_core_private *sipe_private,
 989                             struct sipmsg *msg)
 990 {
 991         const gchar *callid1 = msg ? sipmsg_find_header(msg, "Call-ID") : NULL;
 992         GSList *it = sipe_private->sessions_to_accept;
 993         while (it) {
 994                 struct conf_accept_ctx *ctx = it->data;
 995                 const gchar *callid2 = NULL;
 996
 997                 if (msg && ctx->msg)
 998                         callid2 = sipmsg_find_header(ctx->msg, "Call-ID");
 999
1000                 if (sipe_strequal(callid1, callid2)) {
1001                         GSList *tmp;
1002
1003                         if (ctx->msg)
1004                                 sip_transport_response(sipe_private, ctx->msg,
1005                                                        487, "Request Terminated", NULL);
1006
1007                         if (msg)
1008                                 sip_transport_response(sipe_private, msg, 200, "OK", NULL);
1009
1010                         sipe_user_close_ask(ctx->ask_ctx);
1011                         conf_accept_ctx_free(ctx);
1012
1013                         tmp = it;
1014                         it = it->next;
1015
1016                         sipe_private->sessions_to_accept =
1017                                 g_slist_delete_link(sipe_private->sessions_to_accept, tmp);
1018
1019                         if (callid1)
1020                                 break;
1021                 } else
1022                         it = it->next;
1023         }
1024 }
1025
1026 static void
1027 accept_invitation_cb(struct sipe_core_private *sipe_private, gpointer data)
1028 {
1029         struct conf_accept_ctx *ctx = data;
1030
1031         sipe_private->sessions_to_accept =
1032                         g_slist_remove(sipe_private->sessions_to_accept, ctx);
1033
1034         if (ctx->accept_cb) {
1035                 ctx->accept_cb(sipe_private, ctx);
1036         }
1037
1038         conf_accept_ctx_free(ctx);
1039 }
1040
1041 static void
1042 decline_invitation_cb(struct sipe_core_private *sipe_private, gpointer data)
1043 {
1044         struct conf_accept_ctx *ctx = data;
1045
1046         sipe_private->sessions_to_accept =
1047                         g_slist_remove(sipe_private->sessions_to_accept, ctx);
1048
1049         if (ctx->decline_cb) {
1050                 ctx->decline_cb(sipe_private, ctx);
1051         }
1052
1053         conf_accept_ctx_free(ctx);
1054 }
1055
1056 static void
1057 ask_accept_invitation(struct sipe_core_private *sipe_private,
1058                       const gchar *focus_uri,
1059                       const gchar *question,
1060                       struct sipmsg *msg,
1061                       SipeUserAskCb accept_cb,
1062                       SipeUserAskCb decline_cb,
1063                       gpointer user_data)
1064 {
1065         gchar **parts;
1066         gchar *alias;
1067         gchar *question_str;
1068         struct conf_accept_ctx *ctx;
1069
1070         parts = g_strsplit(focus_uri, ";", 2);
1071         alias = sipe_buddy_get_alias(sipe_private, parts[0]);
1072
1073         question_str = g_strdup_printf("%s %s", alias ? alias : parts[0], question);
1074
1075         g_free(alias);
1076         g_strfreev(parts);
1077
1078         ctx = g_new0(struct conf_accept_ctx, 1);
1079         sipe_private->sessions_to_accept =
1080                         g_slist_append(sipe_private->sessions_to_accept, ctx);
1081
1082         ctx->focus_uri = g_strdup(focus_uri);
1083         ctx->msg = msg ? sipmsg_copy(msg) : NULL;
1084         ctx->accept_cb = accept_cb;
1085         ctx->decline_cb = decline_cb;
1086         ctx->user_data = user_data;
1087         ctx->ask_ctx = sipe_user_ask(sipe_private, question_str,
1088                                      _("Accept"), accept_invitation_cb,
1089                                      _("Decline"), decline_invitation_cb,
1090                                      ctx);
1091
1092         g_free(question_str);
1093 }
1094
1095 static void
1096 ask_accept_voice_conference(struct sipe_core_private *sipe_private,
1097                             const gchar *focus_uri,
1098                             struct sipmsg *msg,
1099                             SipeUserAskCb accept_cb,
1100                             SipeUserAskCb decline_cb)
1101 {
1102         gchar *question;
1103         const gchar *novv_note;
1104
1105 #ifdef HAVE_VV
1106         novv_note = "";
1107 #else
1108         novv_note = _("\n\nAs this client was not compiled with voice call "
1109                       "support, if you accept, you will be able to contact "
1110                       "the other participants only via IM session.");
1111 #endif
1112
1113         question = g_strdup_printf(_("wants to invite you "
1114                                      "to a conference call%s"), novv_note);
1115
1116         ask_accept_invitation(sipe_private, focus_uri, question, msg,
1117                               accept_cb, decline_cb, NULL);
1118
1119         g_free(question);
1120 }
1121
1122 void
1123 process_incoming_invite_conf(struct sipe_core_private *sipe_private,
1124                              struct sipmsg *msg)
1125 {
1126         sipe_xml *xn_conferencing = sipe_xml_parse(msg->body, msg->bodylen);
1127         const sipe_xml *xn_focus_uri = sipe_xml_child(xn_conferencing, "focus-uri");
1128         const sipe_xml *xn_audio = sipe_xml_child(xn_conferencing, "audio");
1129         gchar *focus_uri = sipe_xml_data(xn_focus_uri);
1130         gboolean audio = sipe_strequal(sipe_xml_attribute(xn_audio, "available"), "true");
1131
1132         sipe_xml_free(xn_conferencing);
1133
1134         SIPE_DEBUG_INFO("We have received invitation to Conference. Focus URI=%s", focus_uri);
1135
1136         if (audio) {
1137                 sip_transport_response(sipe_private, msg, 180, "Ringing", NULL);
1138                 ask_accept_voice_conference(sipe_private, focus_uri, msg,
1139                                             (SipeUserAskCb) conf_accept_cb,
1140                                             (SipeUserAskCb) conf_decline_cb);
1141
1142         } else {
1143                 accept_incoming_invite_conf(sipe_private, focus_uri, FALSE, msg);
1144         }
1145
1146         g_free(focus_uri);
1147 }
1148
1149 #ifdef HAVE_VV
1150
1151 static void
1152 process_conference_av_endpoint(const sipe_xml *endpoint,
1153                                const gchar *user_uri,
1154                                const gchar *self_uri,
1155                                struct sip_session *session)
1156 {
1157         const sipe_xml *media;
1158         const gchar *new_entity;
1159
1160         if (!sipe_strequal(user_uri, self_uri)) {
1161                 /* We are interested only in our own endpoint data. */
1162                 return;
1163         }
1164
1165         new_entity = sipe_xml_attribute(endpoint, "entity");
1166         if (!sipe_strequal(session->audio_video_entity, new_entity)) {
1167                 g_free(session->audio_video_entity);
1168                 session->audio_video_entity = g_strdup(new_entity);
1169         }
1170
1171         session->audio_media_id = 0;
1172
1173         media = sipe_xml_child(endpoint, "media");
1174         for (; media; media = sipe_xml_twin(media)) {
1175                 gchar *type = sipe_xml_data(sipe_xml_child(media, "type"));
1176
1177                 if (sipe_strequal(type, "audio")) {
1178                         session->audio_media_id =
1179                                         sipe_xml_int_attribute(media, "id", 0);
1180                 }
1181
1182                 g_free(type);
1183
1184                 if (session->audio_media_id != 0) {
1185                         break;
1186                 }
1187         }
1188 }
1189
1190 static void
1191 call_accept_cb(struct sipe_core_private *sipe_private, struct conf_accept_ctx *ctx)
1192 {
1193         struct sip_session *session;
1194         session = sipe_session_find_conference(sipe_private, ctx->focus_uri);
1195
1196         if (session) {
1197                 sipe_core_media_connect_conference(SIPE_CORE_PUBLIC,
1198                                                    session->chat_session);
1199         }
1200 }
1201
1202 #if defined(HAVE_XDATA) && defined(HAVE_GIO)
1203 gboolean
1204 sipe_core_conf_is_viewing_appshare(struct sipe_core_public *sipe_public,
1205                                    struct sipe_chat_session *chat_session)
1206 {
1207         gchar *mcu_uri;
1208         GList *calls;
1209
1210         mcu_uri = sipe_conf_build_uri(chat_session->id, "applicationsharing");
1211         calls = g_hash_table_get_values(SIPE_CORE_PRIVATE->media_calls);
1212
1213         for (; calls; calls = g_list_delete_link(calls, calls)) {
1214                 struct sipe_media_call *call = calls->data;
1215                 if (sipe_strequal(call->with, mcu_uri)) {
1216                         break;
1217                 }
1218         }
1219
1220         g_free(mcu_uri);
1221
1222         if (calls != NULL) {
1223                 g_list_free(calls);
1224                 return TRUE;
1225         }
1226
1227         return FALSE;
1228 }
1229 #endif // defined(HAVE_XDATA) && defined(HAVE_GIO)
1230 #endif // HAVE_VV
1231
1232 void
1233 sipe_process_conference(struct sipe_core_private *sipe_private,
1234                         struct sipmsg *msg)
1235 {
1236         sipe_xml *xn_conference_info;
1237         const sipe_xml *node;
1238         const sipe_xml *xn_subject;
1239         const gchar *focus_uri;
1240         struct sip_session *session;
1241         gboolean just_joined = FALSE;
1242 #ifdef HAVE_VV
1243         gboolean audio_was_added = FALSE;
1244 #if defined(HAVE_XDATA) && defined(HAVE_GIO)
1245         gboolean presentation_was_added = FALSE;
1246 #endif // defined(HAVE_XDATA) && defined(HAVE_GIO)
1247 #endif // HAVE_VV
1248
1249         if (msg->response != 0 && msg->response != 200) return;
1250
1251         if (msg->bodylen == 0 || msg->body == NULL || !sipe_strequal(sipmsg_find_header(msg, "Event"), "conference")) return;
1252
1253         xn_conference_info = sipe_xml_parse(msg->body, msg->bodylen);
1254         if (!xn_conference_info) return;
1255
1256         focus_uri = sipe_xml_attribute(xn_conference_info, "entity");
1257         session = sipe_session_find_conference(sipe_private, focus_uri);
1258
1259         if (!session) {
1260                 SIPE_DEBUG_INFO("sipe_process_conference: unable to find conf session with focus=%s", focus_uri);
1261                 return;
1262         }
1263
1264         if (!session->chat_session->backend) {
1265                 gchar *self = sip_uri_self(sipe_private);
1266
1267                 /* create chat */
1268                 session->chat_session->backend = sipe_backend_chat_create(SIPE_CORE_PUBLIC,
1269                                                                           session->chat_session,
1270                                                                           session->chat_session->title,
1271                                                                           self);
1272                 just_joined = TRUE;
1273                 /* @TODO ask for full state (re-subscribe) if it was a partial one -
1274                  * this is to obtain full list of conference participants.
1275                  */
1276                  g_free(self);
1277         }
1278
1279         /* subject */
1280         if ((xn_subject = sipe_xml_child(xn_conference_info, "conference-description/subject"))) {
1281                 g_free(session->subject);
1282                 session->subject = sipe_xml_data(xn_subject);
1283                 sipe_backend_chat_topic(session->chat_session->backend, session->subject);
1284                 SIPE_DEBUG_INFO("sipe_process_conference: subject=%s", session->subject ? session->subject : "");
1285         }
1286
1287         /* IM MCU URI */
1288         if (!session->im_mcu_uri) {
1289                 for (node = sipe_xml_child(xn_conference_info, "conference-description/conf-uris/entry");
1290                      node;
1291                      node = sipe_xml_twin(node))
1292                 {
1293                         gchar *purpose = sipe_xml_data(sipe_xml_child(node, "purpose"));
1294
1295                         if (sipe_strequal("chat", purpose)) {
1296                                 g_free(purpose);
1297                                 session->im_mcu_uri = sipe_xml_data(sipe_xml_child(node, "uri"));
1298                                 SIPE_DEBUG_INFO("sipe_process_conference: im_mcu_uri=%s", session->im_mcu_uri);
1299                                 break;
1300                         }
1301                         g_free(purpose);
1302                 }
1303         }
1304
1305         /* organizer */
1306         if (!session->chat_session->organizer) {
1307                 node = sipe_xml_child(xn_conference_info, "conference-description/organizer/display-name");
1308                 if (node) {
1309                         session->chat_session->organizer = sipe_xml_data(node);
1310                 }
1311         }
1312
1313         /* join URL */
1314         if (!session->chat_session->join_url) {
1315                 node = sipe_xml_child(xn_conference_info, "conference-description/join-url");
1316                 if (node) {
1317                         session->chat_session->join_url = sipe_xml_data(node);
1318                 }
1319         }
1320
1321         /* dial-in conference id */
1322         if (!session->chat_session->dial_in_conf_id) {
1323                 node = sipe_xml_child(xn_conference_info, "conference-description/pstn-access/id");
1324                 if (node) {
1325                         session->chat_session->dial_in_conf_id = sipe_xml_data(node);
1326                 }
1327         }
1328
1329         /* users */
1330         for (node = sipe_xml_child(xn_conference_info, "users/user"); node; node = sipe_xml_twin(node)) {
1331                 const gchar *user_uri = sipe_xml_attribute(node, "entity");
1332                 const gchar *state = sipe_xml_attribute(node, "state");
1333                 gchar *role = sipe_xml_data(sipe_xml_child(node, "roles/entry"));
1334                 gboolean is_operator = sipe_strequal(role, "presenter");
1335                 gboolean is_in_im_mcu = FALSE;
1336                 gchar *self = sip_uri_self(sipe_private);
1337
1338                 if (sipe_strequal("deleted", state)) {
1339                         if (sipe_backend_chat_find(session->chat_session->backend, user_uri)) {
1340                                 sipe_backend_chat_remove(session->chat_session->backend,
1341                                                          user_uri);
1342                         }
1343                 } else {
1344                         /* endpoints */
1345                         const sipe_xml *endpoint;
1346                         for (endpoint = sipe_xml_child(node, "endpoint"); endpoint; endpoint = sipe_xml_twin(endpoint)) {
1347                                 const gchar *session_type;
1348                                 gchar *status = sipe_xml_data(sipe_xml_child(endpoint, "status"));
1349                                 gboolean connected = sipe_strequal("connected", status);
1350                                 g_free(status);
1351
1352                                 if (!connected)
1353                                         continue;
1354
1355                                 session_type = sipe_xml_attribute(endpoint, "session-type");
1356
1357                                 if (sipe_strequal("chat", session_type)) {
1358                                         is_in_im_mcu = TRUE;
1359                                         if (!sipe_backend_chat_find(session->chat_session->backend, user_uri)) {
1360                                                 sipe_backend_chat_add(session->chat_session->backend,
1361                                                                       user_uri,
1362                                                                       !just_joined && g_ascii_strcasecmp(user_uri, self));
1363                                         }
1364                                         if (is_operator) {
1365                                                 sipe_backend_chat_operator(session->chat_session->backend,
1366                                                                            user_uri);
1367                                         }
1368                                 } else if (sipe_strequal("audio-video", session_type)) {
1369 #ifdef HAVE_VV
1370                                         if (!session->is_call)
1371                                                 audio_was_added = TRUE;
1372                                         process_conference_av_endpoint(endpoint,
1373                                                                        user_uri,
1374                                                                        self,
1375                                                                        session);
1376 #endif
1377                                 } else if (sipe_strequal("applicationsharing", session_type)) {
1378 #if defined(HAVE_XDATA) && defined(HAVE_GIO)
1379                                         if (!sipe_core_conf_is_viewing_appshare(SIPE_CORE_PUBLIC,
1380                                                                                 session->chat_session)) {
1381                                                 gchar *media_state;
1382                                                 gchar *status;
1383
1384                                                 media_state = sipe_xml_data(sipe_xml_child(endpoint, "media/media-state"));
1385                                                 status = sipe_xml_data(sipe_xml_child(endpoint, "media/status"));
1386
1387                                                 if (sipe_strequal(media_state, "connected") &&
1388                                                     sipe_strequal(status, "sendonly")) {
1389                                                         presentation_was_added = TRUE;
1390                                                 }
1391                                                 g_free(media_state);
1392                                                 g_free(status);
1393                                         }
1394 #endif // defined(HAVE_XDATA) && defined(HAVE_GIO)
1395                                 }
1396                         }
1397                         if (!is_in_im_mcu) {
1398                                 if (sipe_backend_chat_find(session->chat_session->backend, user_uri)) {
1399                                         sipe_backend_chat_remove(session->chat_session->backend,
1400                                                                  user_uri);
1401                                 }
1402                         }
1403                 }
1404                 g_free(role);
1405                 g_free(self);
1406         }
1407
1408 #ifdef HAVE_VV
1409         if (audio_was_added) {
1410                 session->is_call = TRUE;
1411                 ask_accept_voice_conference(sipe_private, focus_uri, NULL,
1412                                             (SipeUserAskCb) call_accept_cb,
1413                                             NULL);
1414         }
1415 #if defined(HAVE_XDATA) && defined(HAVE_GIO)
1416         if (presentation_was_added) {
1417                 sipe_appshare_connect_conference(sipe_private, session->chat_session,
1418                                                  TRUE);
1419         }
1420 #endif // defined(HAVE_XDATA) && defined(HAVE_GIO)
1421 #endif // HAVE_VV
1422
1423         /* entity-view, locked */
1424         for (node = sipe_xml_child(xn_conference_info, "conference-view/entity-view");
1425              node;
1426              node = sipe_xml_twin(node)) {
1427
1428                 const sipe_xml *xn_type = sipe_xml_child(node, "entity-state/media/entry/type");
1429                 gchar *tmp = NULL;
1430                 if (xn_type && sipe_strequal("chat", (tmp = sipe_xml_data(xn_type)))) {
1431                         const sipe_xml *xn_locked = sipe_xml_child(node, "entity-state/locked");
1432                         if (xn_locked) {
1433                                 gchar *locked = sipe_xml_data(xn_locked);
1434                                 gboolean prev_locked = session->locked;
1435                                 session->locked = sipe_strequal(locked, "true");
1436                                 if (prev_locked && !session->locked) {
1437                                         sipe_user_present_info(sipe_private, session,
1438                                                                _("This conference is no longer locked. Additional participants can now join."));
1439                                 }
1440                                 if (!prev_locked && session->locked) {
1441                                         sipe_user_present_info(sipe_private, session,
1442                                                                _("This conference is locked. Nobody else can join the conference while it is locked."));
1443                                 }
1444
1445                                 SIPE_DEBUG_INFO("sipe_process_conference: session->locked=%s",
1446                                                 session->locked ? "TRUE" : "FALSE");
1447                                 g_free(locked);
1448                         }
1449                 }
1450                 g_free(tmp);
1451         }
1452         sipe_xml_free(xn_conference_info);
1453
1454         if (session->im_mcu_uri) {
1455                 struct sip_dialog *dialog = sipe_dialog_find(session, session->im_mcu_uri);
1456                 if (!dialog) {
1457                         dialog = sipe_dialog_add(session);
1458
1459                         dialog->callid = g_strdup(session->callid);
1460                         dialog->with = g_strdup(session->im_mcu_uri);
1461
1462                         /* send INVITE to IM MCU */
1463                         sipe_im_invite(sipe_private, session, dialog->with, NULL, NULL, NULL, FALSE);
1464                 }
1465         }
1466
1467         sipe_process_pending_invite_queue(sipe_private, session);
1468 }
1469
1470 void
1471 sipe_conf_immcu_closed(struct sipe_core_private *sipe_private,
1472                        struct sip_session *session)
1473 {
1474         sipe_user_present_info(sipe_private, session,
1475                                _("You have been disconnected from this conference."));
1476         sipe_backend_chat_close(session->chat_session->backend);
1477 }
1478
1479 void
1480 conf_session_close(struct sipe_core_private *sipe_private,
1481                    struct sip_session *session)
1482 {
1483         if (session) {
1484                 /* unsubscribe from focus */
1485                 sipe_subscribe_conference(sipe_private,
1486                                           session->chat_session->id, TRUE);
1487
1488                 if (session->focus_dialog) {
1489                         /* send BYE to focus */
1490                         sip_transport_bye(sipe_private, session->focus_dialog);
1491                 }
1492         }
1493 }
1494
1495 void
1496 sipe_process_imdn(struct sipe_core_private *sipe_private,
1497                   struct sipmsg *msg)
1498 {
1499         gchar *with = parse_from(sipmsg_find_header(msg, "From"));
1500         const gchar *callid = sipmsg_find_header(msg, "Call-ID");
1501         static struct sip_session *session;
1502         sipe_xml *xn_imdn;
1503         const sipe_xml *node;
1504         gchar *message_id;
1505         gchar *message;
1506
1507         session = sipe_session_find_chat_or_im(sipe_private, callid, with);
1508         if (!session) {
1509                 SIPE_DEBUG_INFO("sipe_process_imdn: unable to find conf session with callid=%s", callid);
1510                 g_free(with);
1511                 return;
1512         }
1513
1514         xn_imdn = sipe_xml_parse(msg->body, msg->bodylen);
1515         message_id = sipe_xml_data(sipe_xml_child(xn_imdn, "message-id"));
1516
1517         message = g_hash_table_lookup(session->conf_unconfirmed_messages, message_id);
1518
1519         /* recipient */
1520         for (node = sipe_xml_child(xn_imdn, "recipient"); node; node = sipe_xml_twin(node)) {
1521                 gchar *tmp = parse_from(sipe_xml_attribute(node, "uri"));
1522                 gchar *uri = parse_from(tmp);
1523                 gchar *status = sipe_xml_data(sipe_xml_child(node, "status"));
1524                 guint error = status ? g_ascii_strtoull(status, NULL, 10) : 0;
1525                 /* default to error if missing or conversion failed */
1526                 if ((error == 0) || (error >= 300))
1527                         sipe_user_present_message_undelivered(sipe_private,
1528                                                               session,
1529                                                               error,
1530                                                               -1,
1531                                                               uri,
1532                                                               message);
1533                 g_free(status);
1534                 g_free(tmp);
1535                 g_free(uri);
1536         }
1537
1538         sipe_xml_free(xn_imdn);
1539
1540         g_hash_table_remove(session->conf_unconfirmed_messages, message_id);
1541         SIPE_DEBUG_INFO("sipe_process_imdn: removed message %s from conf_unconfirmed_messages(count=%d)",
1542                         message_id, g_hash_table_size(session->conf_unconfirmed_messages));
1543         g_free(message_id);
1544         g_free(with);
1545 }
1546
1547 void sipe_core_conf_make_leader(struct sipe_core_public *sipe_public,
1548                                 gpointer parameter,
1549                                 const gchar *buddy_name)
1550 {
1551         struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
1552         struct sipe_chat_session *chat_session = parameter;
1553         struct sip_session *session;
1554
1555         SIPE_DEBUG_INFO("sipe_core_conf_make_leader: chat_title=%s",
1556                         chat_session->title);
1557
1558         session = sipe_session_find_chat(sipe_private, chat_session);
1559         sipe_conf_modify_user_role(sipe_private, session, buddy_name);
1560 }
1561
1562 void sipe_core_conf_remove_from(struct sipe_core_public *sipe_public,
1563                                 gpointer parameter,
1564                                 const gchar *buddy_name)
1565 {
1566         struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
1567         struct sipe_chat_session *chat_session = parameter;
1568         struct sip_session *session;
1569
1570         SIPE_DEBUG_INFO("sipe_core_conf_remove_from: chat_title=%s",
1571                         chat_session->title);
1572
1573         session = sipe_session_find_chat(sipe_private, chat_session);
1574         sipe_conf_delete_user(sipe_private, session, buddy_name);
1575 }
1576
1577 gchar *
1578 sipe_conf_build_uri(const gchar *focus_uri, const gchar *session_type)
1579 {
1580         gchar **parts = g_strsplit(focus_uri, ":focus:", 2);
1581         gchar *result = NULL;
1582
1583         if (g_strv_length(parts) == 2) {
1584                 result = g_strconcat(parts[0], ":", session_type, ":", parts[1],
1585                                      NULL);
1586         }
1587
1588         g_strfreev(parts);
1589         return result;
1590 }
1591
1592 static gchar *
1593 access_numbers_info(struct sipe_core_public *sipe_public)
1594 {
1595         GString *result = g_string_new("");
1596
1597 #if GLIB_CHECK_VERSION(2,16,0)
1598         GList *keys = g_hash_table_get_keys(SIPE_CORE_PRIVATE->access_numbers);
1599         keys = g_list_sort(keys, (GCompareFunc)g_strcmp0);
1600
1601         for (; keys; keys = g_list_delete_link(keys, keys)) {
1602                 gchar *value;
1603                 value = g_hash_table_lookup(SIPE_CORE_PRIVATE->access_numbers,
1604                                             keys->data);
1605
1606                 g_string_append(result, keys->data);
1607                 g_string_append(result, "&nbsp;&nbsp;&nbsp;&nbsp;");
1608                 g_string_append(result, value);
1609                 g_string_append(result, "<br/>");
1610         }
1611 #else
1612         (void)sipe_public; /* keep compiler happy */
1613 #endif
1614
1615         return g_string_free(result, FALSE);
1616 }
1617
1618 gchar *
1619 sipe_core_conf_entry_info(struct sipe_core_public *sipe_public,
1620                           struct sipe_chat_session *chat_session)
1621 {
1622         gchar *access_info = access_numbers_info(sipe_public);
1623         gchar *result = g_strdup_printf(
1624                         "<b><font size=\"+1\">%s</font></b><br/>"
1625                         "<b>%s:</b> %s<br/>"
1626                         "<b>%s:</b> %s<br/>"
1627                         "<br/>"
1628                         "<b>%s:</b><br/>"
1629                         "%s<br/>"
1630                         "<br/>"
1631                         "<b>%s:</b> %s<br/>"
1632                         "<br/>"
1633                         "<b><font size=\"+1\">%s</font></b><br/>"
1634                         "%s",
1635                         _("Dial-in info"),
1636                         _("Number"),
1637                         SIPE_CORE_PRIVATE->default_access_number ? SIPE_CORE_PRIVATE->default_access_number : "",
1638                         _("Conference ID"),
1639                         chat_session->dial_in_conf_id ? chat_session->dial_in_conf_id : "",
1640                         _("Meeting link"),
1641                         chat_session->join_url ? chat_session->join_url : "",
1642                         _("Organizer"),
1643                         chat_session->organizer ? chat_session->organizer : "",
1644                         _("Alternative dial-in numbers"),
1645                         access_info);
1646
1647         g_free(access_info);
1648
1649         return result;
1650 }
1651
1652 /*
1653   Local Variables:
1654   mode: c
1655   c-file-style: "bsd"
1656   indent-tabs-mode: t
1657   tab-width: 8
1658   End:
1659 */