src/core/sipe-conf.c

   1 /**
   2  * @file sipe-conf.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2010 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-chat.h"
  40 #include "sipe-conf.h"
  41 #include "sipe-core.h"
  42 #include "sipe-core-private.h"
  43 #include "sipe-dialog.h"
  44 #include "sipe-nls.h"
  45 #include "sipe-session.h"
  46 #include "sipe-utils.h"
  47 #include "sipe-xml.h"
  48 #include "sipe.h"
  49
  50 /**
  51  * Add Conference request to FocusFactory.
  52  * @param focus_factory_uri (%s) Ex.: sip:bob7@boston.local;gruu;opaque=app:conf:focusfactory
  53  * @param from              (%s) Ex.: sip:bob7@boston.local
  54  * @param request_id        (%d) Ex.: 1094520
  55  * @param conference_id     (%s) Ex.: 8386E6AEAAA41E4AA6627BA76D43B6D1
  56  * @param expiry_time       (%s) Ex.: 2009-07-13T17:57:09Z , Default duration: 7 hours
  57  */
  58 #define SIPE_SEND_CONF_ADD \
  59 "<?xml version=\"1.0\"?>"\
  60 "<request xmlns=\"urn:ietf:params:xml:ns:cccp\" "\
  61         "xmlns:mscp=\"http://schemas.microsoft.com/rtc/2005/08/cccpextensions\" "\
  62         "C3PVersion=\"1\" "\
  63         "to=\"%s\" "\
  64         "from=\"%s\" "\
  65         "requestId=\"%d\">"\
  66         "<addConference>"\
  67                 "<ci:conference-info xmlns:ci=\"urn:ietf:params:xml:ns:conference-info\" entity=\"\" xmlns:msci=\"http://schemas.microsoft.com/rtc/2005/08/confinfoextensions\">"\
  68                         "<ci:conference-description>"\
  69                                 "<ci:subject/>"\
  70                                 "<msci:conference-id>%s</msci:conference-id>"\
  71                                 "<msci:expiry-time>%s</msci:expiry-time>"\
  72                                 "<msci:admission-policy>openAuthenticated</msci:admission-policy>"\
  73                         "</ci:conference-description>"\
  74                         "<msci:conference-view>"\
  75                                 "<msci:entity-view entity=\"chat\"/>"\
  76                         "</msci:conference-view>"\
  77                 "</ci:conference-info>"\
  78         "</addConference>"\
  79 "</request>"
  80
  81 /**
  82  * AddUser request to Focus.
  83  * Params:
  84  * focus_URI, from, request_id, focus_URI, from, endpoint_GUID
  85  */
  86 #define SIPE_SEND_CONF_ADD_USER \
  87 "<?xml version=\"1.0\"?>"\
  88 "<request xmlns=\"urn:ietf:params:xml:ns:cccp\" xmlns:mscp=\"http://schemas.microsoft.com/rtc/2005/08/cccpextensions\" "\
  89         "C3PVersion=\"1\" "\
  90         "to=\"%s\" "\
  91         "from=\"%s\" "\
  92         "requestId=\"%d\">"\
  93         "<addUser>"\
  94                 "<conferenceKeys confEntity=\"%s\"/>"\
  95                 "<ci:user xmlns:ci=\"urn:ietf:params:xml:ns:conference-info\" entity=\"%s\">"\
  96                         "<ci:roles>"\
  97                                 "<ci:entry>attendee</ci:entry>"\
  98                         "</ci:roles>"\
  99                         "<ci:endpoint entity=\"{%s}\" xmlns:msci=\"http://schemas.microsoft.com/rtc/2005/08/confinfoextensions\"/>"\
 100                 "</ci:user>"\
 101         "</addUser>"\
 102 "</request>"
 103
 104 /**
 105  * ModifyUserRoles request to Focus. Makes user a leader.
 106  * @param focus_uri (%s)
 107  * @param from (%s)
 108  * @param request_id (%d)
 109  * @param focus_uri (%s)
 110  * @param who (%s)
 111  */
 112 #define SIPE_SEND_CONF_MODIFY_USER_ROLES \
 113 "<?xml version=\"1.0\"?>"\
 114 "<request xmlns=\"urn:ietf:params:xml:ns:cccp\" xmlns:mscp=\"http://schemas.microsoft.com/rtc/2005/08/cccpextensions\" "\
 115         "C3PVersion=\"1\" "\
 116         "to=\"%s\" "\
 117         "from=\"%s\" "\
 118         "requestId=\"%d\">"\
 119         "<modifyUserRoles>"\
 120                 "<userKeys confEntity=\"%s\" userEntity=\"%s\"/>"\
 121                 "<user-roles xmlns=\"urn:ietf:params:xml:ns:conference-info\">"\
 122                         "<entry>presenter</entry>"\
 123                 "</user-roles>"\
 124         "</modifyUserRoles>"\
 125 "</request>"
 126
 127 /**
 128  * ModifyConferenceLock request to Focus. Locks/unlocks conference.
 129  * @param focus_uri (%s)
 130  * @param from (%s)
 131  * @param request_id (%d)
 132  * @param focus_uri (%s)
 133  * @param locked (%s) "true" or "false" values applicable
 134  */
 135 #define SIPE_SEND_CONF_MODIFY_CONF_LOCK \
 136 "<?xml version=\"1.0\"?>"\
 137 "<request xmlns=\"urn:ietf:params:xml:ns:cccp\" xmlns:mscp=\"http://schemas.microsoft.com/rtc/2005/08/cccpextensions\" "\
 138         "C3PVersion=\"1\" "\
 139         "to=\"%s\" "\
 140         "from=\"%s\" "\
 141         "requestId=\"%d\">"\
 142         "<modifyConferenceLock>"\
 143                 "<conferenceKeys confEntity=\"%s\"/>"\
 144                 "<locked>%s</locked>"\
 145         "</modifyConferenceLock>"\
 146 "</request>"
 147
 148 /**
 149  * ModifyConferenceLock request to Focus. Locks/unlocks conference.
 150  * @param focus_uri (%s)
 151  * @param from (%s)
 152  * @param request_id (%d)
 153  * @param focus_uri (%s)
 154  * @param who (%s)
 155  */
 156 #define SIPE_SEND_CONF_DELETE_USER \
 157 "<?xml version=\"1.0\"?>"\
 158 "<request xmlns=\"urn:ietf:params:xml:ns:cccp\" xmlns:mscp=\"http://schemas.microsoft.com/rtc/2005/08/cccpextensions\" "\
 159         "C3PVersion=\"1\" "\
 160         "to=\"%s\" "\
 161         "from=\"%s\" "\
 162         "requestId=\"%d\">"\
 163         "<deleteUser>"\
 164                 "<userKeys confEntity=\"%s\" userEntity=\"%s\"/>"\
 165         "</deleteUser>"\
 166 "</request>"
 167
 168 /**
 169  * Invite counterparty to join conference.
 170  * @param focus_uri (%s)
 171  * @param subject (%s) of conference
 172  */
 173 #define SIPE_SEND_CONF_INVITE \
 174 "<Conferencing version=\"2.0\">"\
 175         "<focus-uri>%s</focus-uri>"\
 176         "<subject>%s</subject>"\
 177         "<im available=\"true\">"\
 178                 "<first-im/>"\
 179         "</im>"\
 180 "</Conferencing>"
 181
 182 /**
 183  * Generates random GUID.
 184  * This method is borrowed from pidgin's msnutils.c
 185  */
 186 static char *
 187 rand_guid()
 188 {
 189         return g_strdup_printf("%4X%4X-%4X-%4X-%4X-%4X%4X%4X",
 190                         rand() % 0xAAFF + 0x1111,
 191                         rand() % 0xAAFF + 0x1111,
 192                         rand() % 0xAAFF + 0x1111,
 193                         rand() % 0xAAFF + 0x1111,
 194                         rand() % 0xAAFF + 0x1111,
 195                         rand() % 0xAAFF + 0x1111,
 196                         rand() % 0xAAFF + 0x1111,
 197                         rand() % 0xAAFF + 0x1111);
 198 }
 199
 200 /**
 201  * @param expires not respected if set to negative value (E.g. -1)
 202  */
 203 static void
 204 sipe_subscribe_conference(struct sipe_core_private *sipe_private,
 205                           struct sip_session *session,
 206                           const int expires)
 207 {
 208         gchar *expires_hdr = (expires >= 0) ? g_strdup_printf("Expires: %d\r\n", expires) : g_strdup("");
 209         gchar *contact = get_contact(sipe_private);
 210         gchar *hdr = g_strdup_printf(
 211                 "Event: conference\r\n"
 212                 "%s"
 213                 "Accept: application/conference-info+xml\r\n"
 214                 "Supported: com.microsoft.autoextend\r\n"
 215                 "Supported: ms-benotify\r\n"
 216                 "Proxy-Require: ms-benotify\r\n"
 217                 "Supported: ms-piggyback-first-notify\r\n"
 218                 "Contact: %s\r\n",
 219                 expires_hdr,
 220                 contact);
 221         g_free(expires_hdr);
 222         g_free(contact);
 223
 224         sip_transport_subscribe(sipe_private,
 225                                 session->focus_uri,
 226                                 hdr,
 227                                 "",
 228                                 NULL,
 229                                 process_subscribe_response);
 230         g_free(hdr);
 231 }
 232
 233 /** Invite us to the focus callback */
 234 static gboolean
 235 process_invite_conf_focus_response(struct sipe_core_private *sipe_private,
 236                                    struct sipmsg *msg,
 237                                    SIPE_UNUSED_PARAMETER struct transaction *trans)
 238 {
 239         struct sip_session *session = NULL;
 240         char *focus_uri = parse_from(sipmsg_find_header(msg, "To"));
 241
 242         session = sipe_session_find_conference(sipe_private, focus_uri);
 243
 244         if (!session) {
 245                 SIPE_DEBUG_INFO("process_invite_conf_focus_response: unable to find conf session with focus=%s", focus_uri);
 246                 g_free(focus_uri);
 247                 return FALSE;
 248         }
 249
 250         if (!session->focus_dialog) {
 251                 SIPE_DEBUG_INFO_NOFORMAT("process_invite_conf_focus_response: session's focus_dialog is NULL");
 252                 g_free(focus_uri);
 253                 return FALSE;
 254         }
 255
 256         sipe_dialog_parse(session->focus_dialog, msg, TRUE);
 257
 258         if (msg->response >= 200) {
 259                 /* send ACK to focus */
 260                 session->focus_dialog->cseq = 0;
 261                 sip_transport_ack(sipe_private, session->focus_dialog);
 262                 session->focus_dialog->outgoing_invite = NULL;
 263                 session->focus_dialog->is_established = TRUE;
 264         }
 265
 266         if (msg->response >= 400) {
 267                 SIPE_DEBUG_INFO_NOFORMAT("process_invite_conf_focus_response: INVITE response is not 200. Failed to join focus.");
 268                 /* @TODO notify user of failure to join focus */
 269                 sipe_session_remove(sipe_private, session);
 270                 g_free(focus_uri);
 271                 return FALSE;
 272         } else if (msg->response == 200) {
 273                 sipe_xml *xn_response = sipe_xml_parse(msg->body, msg->bodylen);
 274                 const gchar *code = sipe_xml_attribute(xn_response, "code");
 275                 if (sipe_strequal(code, "success")) {
 276                         /* subscribe to focus */
 277                         sipe_subscribe_conference(sipe_private, session, -1);
 278                 }
 279                 sipe_xml_free(xn_response);
 280         }
 281
 282         g_free(focus_uri);
 283         return TRUE;
 284 }
 285
 286 /** Invite us to the focus */
 287 void
 288 sipe_invite_conf_focus(struct sipe_core_private *sipe_private,
 289                        struct sip_session *session)
 290 {
 291         gchar *hdr;
 292         gchar *contact;
 293         gchar *body;
 294         gchar *self;
 295
 296         if (session->focus_dialog && session->focus_dialog->is_established) {
 297                 SIPE_DEBUG_INFO("session with %s already has a dialog open", session->focus_uri);
 298                 return;
 299         }
 300
 301         if(!session->focus_dialog) {
 302                 session->focus_dialog = g_new0(struct sip_dialog, 1);
 303                 session->focus_dialog->callid = gencallid();
 304                 session->focus_dialog->with = g_strdup(session->focus_uri);
 305                 session->focus_dialog->endpoint_GUID = rand_guid();
 306         }
 307         if (!(session->focus_dialog->ourtag)) {
 308                 session->focus_dialog->ourtag = gentag();
 309         }
 310
 311         contact = get_contact(sipe_private);
 312         hdr = g_strdup_printf(
 313                 "Supported: ms-sender\r\n"
 314                 "Contact: %s\r\n"
 315                 "Content-Type: application/cccp+xml\r\n",
 316                 contact);
 317         g_free(contact);
 318
 319         /* @TODO put request_id to queue to further compare with incoming one */
 320         /* focus_URI, from, request_id, focus_URI, from, endpoint_GUID */
 321         self = sip_uri_self(sipe_private);
 322         body = g_strdup_printf(
 323                 SIPE_SEND_CONF_ADD_USER,
 324                 session->focus_dialog->with,
 325                 self,
 326                 session->request_id++,
 327                 session->focus_dialog->with,
 328                 self,
 329                 session->focus_dialog->endpoint_GUID);
 330         g_free(self);
 331
 332         session->focus_dialog->outgoing_invite =
 333                 sip_transport_invite(sipe_private,
 334                                      hdr,
 335                                      body,
 336                                      session->focus_dialog,
 337                                      process_invite_conf_focus_response);
 338         g_free(body);
 339         g_free(hdr);
 340 }
 341
 342 /** Modify User Role */
 343 void
 344 sipe_conf_modify_user_role(struct sipe_core_private *sipe_private,
 345                            struct sip_session *session,
 346                            const gchar* who)
 347 {
 348         gchar *hdr;
 349         gchar *body;
 350         gchar *self;
 351
 352         if (!session->focus_dialog || !session->focus_dialog->is_established) {
 353                 SIPE_DEBUG_INFO_NOFORMAT("sipe_conf_modify_user_role: no dialog with focus, exiting.");
 354                 return;
 355         }
 356
 357         hdr = g_strdup(
 358                 "Content-Type: application/cccp+xml\r\n");
 359
 360         /* @TODO put request_id to queue to further compare with incoming one */
 361         self = sip_uri_self(sipe_private);
 362         body = g_strdup_printf(
 363                 SIPE_SEND_CONF_MODIFY_USER_ROLES,
 364                 session->focus_dialog->with,
 365                 self,
 366                 session->request_id++,
 367                 session->focus_dialog->with,
 368                 who);
 369         g_free(self);
 370
 371         sip_transport_info(sipe_private,
 372                            hdr,
 373                            body,
 374                            session->focus_dialog,
 375                            NULL);
 376         g_free(body);
 377         g_free(hdr);
 378 }
 379
 380 /** Modify Conference Lock */
 381 void
 382 sipe_conf_modify_conference_lock(struct sipe_core_private *sipe_private,
 383                                  struct sip_session *session,
 384                                  const gboolean locked)
 385 {
 386         gchar *hdr;
 387         gchar *body;
 388         gchar *self;
 389
 390         if (!session->focus_dialog || !session->focus_dialog->is_established) {
 391                 SIPE_DEBUG_INFO_NOFORMAT("sipe_conf_modify_conference_lock: no dialog with focus, exiting.");
 392                 return;
 393         }
 394
 395         hdr = g_strdup(
 396                 "Content-Type: application/cccp+xml\r\n");
 397
 398         /* @TODO put request_id to queue to further compare with incoming one */
 399         self = sip_uri_self(sipe_private);
 400         body = g_strdup_printf(
 401                 SIPE_SEND_CONF_MODIFY_CONF_LOCK,
 402                 session->focus_dialog->with,
 403                 self,
 404                 session->request_id++,
 405                 session->focus_dialog->with,
 406                 locked ? "true" : "false");
 407         g_free(self);
 408
 409         sip_transport_info(sipe_private,
 410                            hdr,
 411                            body,
 412                            session->focus_dialog,
 413                            NULL);
 414         g_free(body);
 415         g_free(hdr);
 416 }
 417
 418 /** Modify Delete User */
 419 void
 420 sipe_conf_delete_user(struct sipe_core_private *sipe_private,
 421                       struct sip_session *session,
 422                       const gchar* who)
 423 {
 424         gchar *hdr;
 425         gchar *body;
 426         gchar *self;
 427
 428         if (!session->focus_dialog || !session->focus_dialog->is_established) {
 429                 SIPE_DEBUG_INFO_NOFORMAT("sipe_conf_delete_user: no dialog with focus, exiting.");
 430                 return;
 431         }
 432
 433         hdr = g_strdup(
 434                 "Content-Type: application/cccp+xml\r\n");
 435
 436         /* @TODO put request_id to queue to further compare with incoming one */
 437         self = sip_uri_self(sipe_private);
 438         body = g_strdup_printf(
 439                 SIPE_SEND_CONF_DELETE_USER,
 440                 session->focus_dialog->with,
 441                 self,
 442                 session->request_id++,
 443                 session->focus_dialog->with,
 444                 who);
 445         g_free(self);
 446
 447         sip_transport_info(sipe_private,
 448                            hdr,
 449                            body,
 450                            session->focus_dialog,
 451                            NULL);
 452         g_free(body);
 453         g_free(hdr);
 454 }
 455
 456 /** Invite counterparty to join conference callback */
 457 static gboolean
 458 process_invite_conf_response(struct sipe_core_private *sipe_private,
 459                              struct sipmsg *msg,
 460                              SIPE_UNUSED_PARAMETER struct transaction *trans)
 461 {
 462         struct sip_dialog *dialog = g_new0(struct sip_dialog, 1);
 463
 464         dialog->callid = g_strdup(sipmsg_find_header(msg, "Call-ID"));
 465         dialog->cseq = parse_cseq(sipmsg_find_header(msg, "CSeq"));
 466         dialog->with = parse_from(sipmsg_find_header(msg, "To"));
 467         sipe_dialog_parse(dialog, msg, TRUE);
 468
 469         if (msg->response >= 200) {
 470                 /* send ACK to counterparty */
 471                 dialog->cseq--;
 472                 sip_transport_ack(sipe_private, dialog);
 473                 dialog->outgoing_invite = NULL;
 474                 dialog->is_established = TRUE;
 475         }
 476
 477         if (msg->response >= 400) {
 478                 SIPE_DEBUG_INFO("process_invite_conf_response: INVITE response is not 200. Failed to invite %s.", dialog->with);
 479                 /* @TODO notify user of failure to invite counterparty */
 480                 sipe_dialog_free(dialog);
 481                 return FALSE;
 482         }
 483
 484         if (msg->response >= 200) {
 485                 struct sip_session *session = sipe_session_find_im(sipe_private, dialog->with);
 486                 struct sip_dialog *im_dialog = sipe_dialog_find(session, dialog->with);
 487
 488                 /* close IM session to counterparty */
 489                 if (im_dialog) {
 490                         sip_transport_bye(sipe_private, im_dialog);
 491                         sipe_dialog_remove(session, dialog->with);
 492                 }
 493         }
 494
 495         sipe_dialog_free(dialog);
 496         return TRUE;
 497 }
 498
 499 /**
 500  * Invites counterparty to join conference.
 501  */
 502 void
 503 sipe_invite_conf(struct sipe_core_private *sipe_private,
 504                  struct sip_session *session,
 505                  const gchar* who)
 506 {
 507         gchar *hdr;
 508         gchar *contact;
 509         gchar *body;
 510         struct sip_dialog *dialog = NULL;
 511
 512         /* It will be short lived special dialog.
 513          * Will not be stored in session.
 514          */
 515         dialog = g_new0(struct sip_dialog, 1);
 516         dialog->callid = gencallid();
 517         dialog->with = g_strdup(who);
 518         dialog->ourtag = gentag();
 519
 520         contact = get_contact(sipe_private);
 521         hdr = g_strdup_printf(
 522                 "Supported: ms-sender\r\n"
 523                 "Contact: %s\r\n"
 524                 "Content-Type: application/ms-conf-invite+xml\r\n",
 525                 contact);
 526         g_free(contact);
 527
 528         body = g_strdup_printf(
 529                 SIPE_SEND_CONF_INVITE,
 530                 session->focus_uri,
 531                 session->subject ? session->subject : ""
 532                 );
 533
 534         sip_transport_invite(sipe_private,
 535                              hdr,
 536                              body,
 537                              dialog,
 538                              process_invite_conf_response);
 539
 540         sipe_dialog_free(dialog);
 541         g_free(body);
 542         g_free(hdr);
 543 }
 544
 545 /** Create conference callback */
 546 static gboolean
 547 process_conf_add_response(struct sipe_core_private *sipe_private,
 548                           struct sipmsg *msg,
 549                           struct transaction *trans)
 550 {
 551         if (msg->response >= 400) {
 552                 SIPE_DEBUG_INFO_NOFORMAT("process_conf_add_response: SERVICE response is not 200. Failed to create conference.");
 553                 /* @TODO notify user of failure to create conference */
 554                 return FALSE;
 555         }
 556         if (msg->response == 200) {
 557                 sipe_xml *xn_response = sipe_xml_parse(msg->body, msg->bodylen);
 558                 if (sipe_strequal("success", sipe_xml_attribute(xn_response, "code")))
 559                 {
 560                         gchar *who = trans->payload->data;
 561                         struct sip_session *session;
 562                         const sipe_xml *xn_conference_info = sipe_xml_child(xn_response, "addConference/conference-info");
 563
 564                         session = sipe_session_add_chat(sipe_private);
 565                         session->is_multiparty = FALSE;
 566                         session->focus_uri = g_strdup(sipe_xml_attribute(xn_conference_info, "entity"));
 567                         SIPE_DEBUG_INFO("process_conf_add_response: session->focus_uri=%s",
 568                                         session->focus_uri ? session->focus_uri : "");
 569
 570                         session->pending_invite_queue = slist_insert_unique_sorted(
 571                                 session->pending_invite_queue, g_strdup(who), (GCompareFunc)strcmp);
 572
 573                         /* add self to conf */
 574                         sipe_invite_conf_focus(sipe_private, session);
 575                 }
 576                 sipe_xml_free(xn_response);
 577         }
 578
 579         return TRUE;
 580 }
 581
 582 /**
 583  * Creates conference.
 584  */
 585 void
 586 sipe_conf_add(struct sipe_core_private *sipe_private,
 587               const gchar* who)
 588 {
 589         gchar *hdr;
 590         gchar *conference_id;
 591         gchar *contact;
 592         gchar *body;
 593         gchar *self;
 594         struct transaction *trans;
 595         struct sip_dialog *dialog = NULL;
 596         time_t expiry = time(NULL) + 7*60*60; /* 7 hours */
 597         char *expiry_time;
 598         struct transaction_payload *payload;
 599
 600         contact = get_contact(sipe_private);
 601         hdr = g_strdup_printf(
 602                 "Supported: ms-sender\r\n"
 603                 "Contact: %s\r\n"
 604                 "Content-Type: application/cccp+xml\r\n",
 605                 contact);
 606         g_free(contact);
 607
 608         expiry_time = sipe_utils_time_to_str(expiry);
 609         self = sip_uri_self(sipe_private);
 610         conference_id = genconfid();
 611         body = g_strdup_printf(
 612                 SIPE_SEND_CONF_ADD,
 613                 sipe_private->focus_factory_uri,
 614                 self,
 615                 rand(),
 616                 conference_id,
 617                 expiry_time);
 618         g_free(self);
 619         g_free(conference_id);
 620         g_free(expiry_time);
 621
 622         trans = sip_transport_service(sipe_private,
 623                                       sipe_private->focus_factory_uri,
 624                                       hdr,
 625                                       body,
 626                                       process_conf_add_response);
 627
 628         payload = g_new0(struct transaction_payload, 1);
 629         payload->destroy = g_free;
 630         payload->data = g_strdup(who);
 631         trans->payload = payload;
 632
 633         sipe_dialog_free(dialog);
 634         g_free(body);
 635         g_free(hdr);
 636 }
 637
 638 void
 639 process_incoming_invite_conf(struct sipe_core_private *sipe_private,
 640                              struct sipmsg *msg)
 641 {
 642         struct sip_session *session = NULL;
 643         struct sip_dialog *dialog = NULL;
 644         sipe_xml *xn_conferencing = sipe_xml_parse(msg->body, msg->bodylen);
 645         const sipe_xml *xn_focus_uri = sipe_xml_child(xn_conferencing, "focus-uri");
 646         char *focus_uri = sipe_xml_data(xn_focus_uri);
 647         gchar *newTag = gentag();
 648         const gchar *oldHeader = sipmsg_find_header(msg, "To");
 649         gchar *newHeader;
 650
 651         sipe_xml_free(xn_conferencing);
 652
 653         /* send OK */
 654         SIPE_DEBUG_INFO("We have received invitation to Conference. Focus URI=%s", focus_uri);
 655
 656         newHeader = g_strdup_printf("%s;tag=%s", oldHeader, newTag);
 657         sipmsg_remove_header_now(msg, "To");
 658         sipmsg_add_header_now(msg, "To", newHeader);
 659         g_free(newHeader);
 660
 661         /* temporary dialog with invitor */
 662         /* take data before 'msg' will be modified by send_sip_response */
 663         dialog = g_new0(struct sip_dialog, 1);
 664         dialog->callid = g_strdup(sipmsg_find_header(msg, "Call-ID"));
 665         dialog->cseq = parse_cseq(sipmsg_find_header(msg, "CSeq"));
 666         dialog->with = parse_from(sipmsg_find_header(msg, "From"));
 667         sipe_dialog_parse(dialog, msg, FALSE);
 668
 669         sip_transport_response(sipe_private, msg, 200, "OK", NULL);
 670
 671         session = sipe_session_add_chat(sipe_private);
 672         session->focus_uri = focus_uri;
 673         session->is_multiparty = FALSE;
 674
 675         /* send BYE to invitor */
 676         sip_transport_bye(sipe_private, dialog);
 677         sipe_dialog_free(dialog);
 678
 679         /* add self to conf */
 680         sipe_invite_conf_focus(sipe_private, session);
 681 }
 682
 683 void
 684 sipe_process_conference(struct sipe_core_private *sipe_private,
 685                         struct sipmsg *msg)
 686 {
 687         sipe_xml *xn_conference_info;
 688         const sipe_xml *node;
 689         const sipe_xml *xn_subject;
 690         const gchar *focus_uri;
 691         struct sip_session *session;
 692         gboolean just_joined = FALSE;
 693
 694         if (msg->response != 0 && msg->response != 200) return;
 695
 696         if (msg->bodylen == 0 || msg->body == NULL || !sipe_strequal(sipmsg_find_header(msg, "Event"), "conference")) return;
 697
 698         xn_conference_info = sipe_xml_parse(msg->body, msg->bodylen);
 699         if (!xn_conference_info) return;
 700
 701         focus_uri = sipe_xml_attribute(xn_conference_info, "entity");
 702         session = sipe_session_find_conference(sipe_private, focus_uri);
 703
 704         if (!session) {
 705                 SIPE_DEBUG_INFO("sipe_process_conference: unable to find conf session with focus=%s", focus_uri);
 706                 return;
 707         }
 708
 709         if (session->focus_uri && !session->backend_session) {
 710                 gchar *chat_title = sipe_chat_get_name(session->focus_uri);
 711                 gchar *self = sip_uri_self(sipe_private);
 712
 713                 /* create or join existing chat */
 714                 session->backend_session = sipe_backend_chat_create(SIPE_CORE_PUBLIC,
 715                                                                     session->chat_id,
 716                                                                     chat_title,
 717                                                                     self,
 718                                                                     TRUE);
 719                 session->chat_title = chat_title;
 720                 just_joined = TRUE;
 721                 /* @TODO ask for full state (re-subscribe) if it was a partial one -
 722                  * this is to obtain full list of conference participants.
 723                  */
 724                  g_free(self);
 725         }
 726
 727         /* subject */
 728         if ((xn_subject = sipe_xml_child(xn_conference_info, "conference-description/subject"))) {
 729                 g_free(session->subject);
 730                 session->subject = sipe_xml_data(xn_subject);
 731                 sipe_backend_chat_topic(session->backend_session, session->subject);
 732                 SIPE_DEBUG_INFO("sipe_process_conference: subject=%s", session->subject ? session->subject : "");
 733         }
 734
 735         /* IM MCU URI */
 736         if (!session->im_mcu_uri) {
 737                 for (node = sipe_xml_child(xn_conference_info, "conference-description/conf-uris/entry");
 738                      node;
 739                      node = sipe_xml_twin(node))
 740                 {
 741                         gchar *purpose = sipe_xml_data(sipe_xml_child(node, "purpose"));
 742
 743                         if (sipe_strequal("chat", purpose)) {
 744                                 g_free(purpose);
 745                                 session->im_mcu_uri = sipe_xml_data(sipe_xml_child(node, "uri"));
 746                                 SIPE_DEBUG_INFO("sipe_process_conference: im_mcu_uri=%s", session->im_mcu_uri);
 747                                 break;
 748                         }
 749                         g_free(purpose);
 750                 }
 751         }
 752
 753         /* users */
 754         for (node = sipe_xml_child(xn_conference_info, "users/user"); node; node = sipe_xml_twin(node)) {
 755                 const gchar *user_uri = sipe_xml_attribute(node, "entity");
 756                 const gchar *state = sipe_xml_attribute(node, "state");
 757                 gchar *role = sipe_xml_data(sipe_xml_child(node, "roles/entry"));
 758                 gboolean is_operator = sipe_strequal(role, "presenter");
 759                 gboolean is_in_im_mcu = FALSE;
 760                 gchar *self = sip_uri_self(sipe_private);
 761
 762                 if (sipe_strequal("deleted", state)) {
 763                         if (sipe_backend_chat_find(session->backend_session, user_uri)) {
 764                                 sipe_backend_chat_remove(session->backend_session,
 765                                                          user_uri);
 766                         }
 767                 } else {
 768                         /* endpoints */
 769                         const sipe_xml *endpoint;
 770                         for (endpoint = sipe_xml_child(node, "endpoint"); endpoint; endpoint = sipe_xml_twin(endpoint)) {
 771                                 if (sipe_strequal("chat", sipe_xml_attribute(endpoint, "session-type"))) {
 772                                         gchar *status = sipe_xml_data(sipe_xml_child(endpoint, "status"));
 773                                         if (sipe_strequal("connected", status)) {
 774                                                 is_in_im_mcu = TRUE;
 775                                                 if (!sipe_backend_chat_find(session->backend_session, user_uri)) {
 776                                                         sipe_backend_chat_add(session->backend_session,
 777                                                                               user_uri,
 778                                                                               !just_joined && g_strcasecmp(user_uri, self));
 779                                                 }
 780                                                 if (is_operator) {
 781                                                         sipe_backend_chat_operator(session->backend_session,
 782                                                                                    user_uri);
 783                                                 }
 784                                         }
 785                                         g_free(status);
 786                                         break;
 787                                 }
 788                         }
 789                         if (!is_in_im_mcu) {
 790                                 if (sipe_backend_chat_find(session->backend_session, user_uri)) {
 791                                         sipe_backend_chat_remove(session->backend_session,
 792                                                                  user_uri);
 793                                 }
 794                         }
 795                 }
 796                 g_free(role);
 797                 g_free(self);
 798         }
 799
 800         /* entity-view, locked */
 801         for (node = sipe_xml_child(xn_conference_info, "conference-view/entity-view");
 802              node;
 803              node = sipe_xml_twin(node)) {
 804
 805                 const sipe_xml *xn_type = sipe_xml_child(node, "entity-state/media/entry/type");
 806                 gchar *tmp = NULL;
 807                 if (xn_type && sipe_strequal("chat", (tmp = sipe_xml_data(xn_type)))) {
 808                         const sipe_xml *xn_locked = sipe_xml_child(node, "entity-state/locked");
 809                         if (xn_locked) {
 810                                 gchar *locked = sipe_xml_data(xn_locked);
 811                                 gboolean prev_locked = session->locked;
 812                                 session->locked = sipe_strequal(locked, "true");
 813                                 if (prev_locked && !session->locked) {
 814                                         sipe_present_info(sipe_private, session,
 815                                                 _("This conference is no longer locked. Additional participants can now join."));
 816                                 }
 817                                 if (!prev_locked && session->locked) {
 818                                         sipe_present_info(sipe_private, session,
 819                                                 _("This conference is locked. Nobody else can join the conference while it is locked."));
 820                                 }
 821
 822                                 SIPE_DEBUG_INFO("sipe_process_conference: session->locked=%s",
 823                                                 session->locked ? "TRUE" : "FALSE");
 824                                 g_free(locked);
 825                         }
 826                 }
 827                 g_free(tmp);
 828         }
 829         sipe_xml_free(xn_conference_info);
 830
 831         if (session->im_mcu_uri) {
 832                 struct sip_dialog *dialog = sipe_dialog_find(session, session->im_mcu_uri);
 833                 if (!dialog) {
 834                         dialog = sipe_dialog_add(session);
 835
 836                         dialog->callid = g_strdup(session->callid);
 837                         dialog->with = g_strdup(session->im_mcu_uri);
 838
 839                         /* send INVITE to IM MCU */
 840                         sipe_invite(sipe_private, session, dialog->with, NULL, NULL, NULL, FALSE);
 841                 }
 842         }
 843
 844         sipe_process_pending_invite_queue(sipe_private, session);
 845 }
 846
 847 void
 848 sipe_conf_immcu_closed(struct sipe_core_private *sipe_private,
 849                        struct sip_session *session)
 850 {
 851         sipe_present_info(sipe_private, session,
 852                           _("You have been disconnected from this conference."));
 853         sipe_backend_chat_close(session->backend_session);
 854 }
 855
 856 void
 857 conf_session_close(struct sipe_core_private *sipe_private,
 858                    struct sip_session *session)
 859 {
 860         if (session) {
 861                 /* unsubscribe from focus */
 862                 sipe_subscribe_conference(sipe_private, session, 0);
 863
 864                 if (session->focus_dialog) {
 865                         /* send BYE to focus */
 866                         sip_transport_bye(sipe_private, session->focus_dialog);
 867                 }
 868         }
 869 }
 870
 871 void
 872 sipe_process_imdn(struct sipe_core_private *sipe_private,
 873                   struct sipmsg *msg)
 874 {
 875         gchar *with = parse_from(sipmsg_find_header(msg, "From"));
 876         const gchar *callid = sipmsg_find_header(msg, "Call-ID");
 877         static struct sip_session *session;
 878         sipe_xml *xn_imdn;
 879         const sipe_xml *node;
 880         gchar *message_id;
 881         gchar *message;
 882
 883         session = sipe_session_find_chat_or_im(sipe_private, callid, with);
 884         if (!session) {
 885                 SIPE_DEBUG_INFO("sipe_process_imdn: unable to find conf session with callid=%s", callid);
 886                 g_free(with);
 887                 return;
 888         }
 889
 890         xn_imdn = sipe_xml_parse(msg->body, msg->bodylen);
 891         message_id = sipe_xml_data(sipe_xml_child(xn_imdn, "message-id"));
 892
 893         message = g_hash_table_lookup(session->conf_unconfirmed_messages, message_id);
 894
 895         /* recipient */
 896         for (node = sipe_xml_child(xn_imdn, "recipient"); node; node = sipe_xml_twin(node)) {
 897                 gchar *tmp = parse_from(sipe_xml_attribute(node, "uri"));
 898                 gchar *uri = parse_from(tmp);
 899                 sipe_present_message_undelivered_err(sipe_private, session, -1, -1, uri, message);
 900                 g_free(tmp);
 901                 g_free(uri);
 902         }
 903
 904         sipe_xml_free(xn_imdn);
 905
 906         g_hash_table_remove(session->conf_unconfirmed_messages, message_id);
 907         SIPE_DEBUG_INFO("sipe_process_imdn: removed message %s from conf_unconfirmed_messages(count=%d)",
 908                         message_id, g_hash_table_size(session->conf_unconfirmed_messages));
 909         g_free(message_id);
 910         g_free(with);
 911 }
 912
 913
 914 /*
 915   Local Variables:
 916   mode: c
 917   c-file-style: "bsd"
 918   indent-tabs-mode: t
 919   tab-width: 8
 920   End:
 921 */