src/core/sipe-conf.c

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