src/core/sipe-conf.c

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