src/core/sipe-conf.c

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