src/core/sipe-chat.c

   1 /**
   2  * @file sipe-chat.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2009-2019 SIPE Project <http://sipe.sourceforge.net/>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <time.h>
  30
  31 #include <glib.h>
  32
  33 #include "sipe-common.h"
  34 #include "sipmsg.h"
  35 #include "sip-transport.h"
  36 #include "sipe-backend.h"
  37 #include "sipe-chat.h"
  38 #include "sipe-conf.h"
  39 #include "sipe-core.h"
  40 #include "sipe-core-private.h"
  41 #include "sipe-dialog.h"
  42 #include "sipe-groupchat.h"
  43 #include "sipe-im.h"
  44 #include "sipe-nls.h"
  45 #include "sipe-schedule.h"
  46 #include "sipe-session.h"
  47 #include "sipe-user.h"
  48 #include "sipe-utils.h"
  49 #include "sipe-xml.h"
  50
  51 /**
  52  * Invite @who to chat
  53  *
  54  * @param sipe_private SIPE core private data
  55  * @param session SIPE session for chat
  56  * @param who URI whom to invite to chat.
  57  */
  58 static void
  59 sipe_invite_to_chat(struct sipe_core_private *sipe_private,
  60                     struct sip_session *session,
  61                     const gchar *who);
  62
  63 static GList *chat_sessions = NULL;
  64
  65 struct sipe_chat_session *sipe_chat_create_session(guint type,
  66                                                    const gchar *id,
  67                                                    const gchar *title)
  68 {
  69         struct sipe_chat_session *session = g_new0(struct sipe_chat_session, 1);
  70         if (id)
  71                 session->id = g_strdup(id);
  72         session->title = g_strdup(title);
  73         session->type  = type;
  74         chat_sessions  = g_list_prepend(chat_sessions, session);
  75         return(session);
  76 }
  77
  78 void sipe_chat_remove_session(struct sipe_chat_session *session)
  79 {
  80         chat_sessions = g_list_remove(chat_sessions, session);
  81         sipe_backend_chat_session_destroy(session->backend);
  82         g_free(session->title);
  83         g_free(session->id);
  84         g_free(session->join_url);
  85         g_free(session->dial_in_conf_id);
  86         g_free(session->organizer);
  87
  88         if (session->appshare_ask_ctx) {
  89                 sipe_user_close_ask(session->appshare_ask_ctx);
  90         }
  91
  92         g_free(session);
  93 }
  94
  95 void sipe_chat_destroy(void)
  96 {
  97         while (chat_sessions) {
  98                 struct sipe_chat_session *chat_session = chat_sessions->data;
  99                 SIPE_DEBUG_INFO("sipe_chat_destroy: '%s' (%s)",
 100                                 chat_session->title, chat_session->id);
 101                 sipe_chat_remove_session(chat_session);
 102         }
 103 }
 104
 105 const gchar *sipe_core_chat_id(SIPE_UNUSED_PARAMETER struct sipe_core_public *sipe_public,
 106                                struct sipe_chat_session *chat_session)
 107 {
 108         return(chat_session->id);
 109 }
 110
 111 guint sipe_core_chat_type(struct sipe_chat_session *chat_session)
 112 {
 113         return(chat_session ? chat_session->type : SIPE_CHAT_TYPE_UNKNOWN);
 114 }
 115
 116 void sipe_core_chat_invite(struct sipe_core_public *sipe_public,
 117                            struct sipe_chat_session *chat_session,
 118                            const char *name)
 119 {
 120         struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
 121
 122         SIPE_DEBUG_INFO("sipe_core_chat_create: who '%s'", name);
 123
 124         switch (chat_session->type) {
 125         case SIPE_CHAT_TYPE_MULTIPARTY:
 126         case SIPE_CHAT_TYPE_CONFERENCE:
 127                 {
 128                         struct sip_session *session = sipe_session_find_chat(sipe_private,
 129                                                                              chat_session);
 130
 131                         if (session) {
 132                                 gchar *uri = sip_uri(name);
 133                                 sipe_invite_to_chat(sipe_private, session, uri);
 134                                 g_free(uri);
 135                         }
 136                 }
 137                 break;
 138         case SIPE_CHAT_TYPE_GROUPCHAT:
 139                 /* @TODO */
 140                 SIPE_DEBUG_INFO_NOFORMAT("GROUP CHAT: INVITE NOT IMPLEMENTED!");
 141                 break;
 142         default:
 143                 break;
 144         }
 145 }
 146
 147 void sipe_core_chat_rejoin(struct sipe_core_public *sipe_public,
 148                            struct sipe_chat_session *chat_session)
 149 {
 150         struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
 151
 152         SIPE_DEBUG_INFO("sipe_core_chat_rejoin: '%s'", chat_session->title);
 153
 154         switch (chat_session->type) {
 155         case SIPE_CHAT_TYPE_MULTIPARTY:
 156                 {
 157                         struct sip_session *session = sipe_session_add_chat(sipe_private,
 158                                                                             chat_session,
 159                                                                             TRUE,
 160                                                                             NULL);
 161                         gchar *self = sip_uri_self(sipe_private);
 162
 163                         sipe_invite_to_chat(sipe_private, session, self);
 164                         sipe_backend_chat_rejoin(SIPE_CORE_PUBLIC,
 165                                                  chat_session->backend,
 166                                                  self,
 167                                                  chat_session->title);
 168                         g_free(self);
 169                 }
 170                 break;
 171         case SIPE_CHAT_TYPE_CONFERENCE:
 172                 sipe_conf_create(sipe_private, chat_session, NULL);
 173                 break;
 174         case SIPE_CHAT_TYPE_GROUPCHAT:
 175                 sipe_groupchat_rejoin(sipe_private, chat_session);
 176                 break;
 177         default:
 178                 break;
 179         }
 180 }
 181
 182 void sipe_core_chat_leave(struct sipe_core_public *sipe_public,
 183                           struct sipe_chat_session *chat_session)
 184 {
 185         struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
 186
 187         SIPE_DEBUG_INFO("sipe_core_chat_leave: '%s'", chat_session->title);
 188
 189         switch (chat_session->type) {
 190         case SIPE_CHAT_TYPE_MULTIPARTY:
 191         case SIPE_CHAT_TYPE_CONFERENCE:
 192                 {
 193                         struct sip_session *session = sipe_session_find_chat(sipe_private,
 194                                                                              chat_session);
 195
 196                         if (session) {
 197                                 sipe_session_close(sipe_private, session);
 198                         }
 199                 }
 200                 break;
 201         case SIPE_CHAT_TYPE_GROUPCHAT:
 202                 sipe_groupchat_leave(sipe_private, chat_session);
 203                 break;
 204         default:
 205                 break;
 206         }
 207 }
 208
 209 void sipe_core_chat_send(struct sipe_core_public *sipe_public,
 210                          struct sipe_chat_session *chat_session,
 211                          const char *what)
 212 {
 213         struct sipe_core_private *sipe_private = SIPE_CORE_PRIVATE;
 214
 215         SIPE_DEBUG_INFO("sipe_core_chat_send: '%s' to '%s'",
 216                         what, chat_session->title);
 217
 218         switch (chat_session->type) {
 219         case SIPE_CHAT_TYPE_MULTIPARTY:
 220         case SIPE_CHAT_TYPE_CONFERENCE:
 221                 {
 222                         struct sip_session *session = sipe_session_find_chat(sipe_private,
 223                                                                              chat_session);
 224
 225                         if (session) {
 226                                 sipe_session_enqueue_message(session,
 227                                                              what,
 228                                                              NULL);
 229                                 sipe_im_process_queue(sipe_private, session);
 230                         }
 231                 }
 232                 break;
 233         case SIPE_CHAT_TYPE_GROUPCHAT:
 234                 sipe_groupchat_send(sipe_private, chat_session, what);
 235                 break;
 236         default:
 237                 break;
 238         }
 239 }
 240
 241 gchar *
 242 sipe_chat_get_name(void)
 243 {
 244         /**
 245          * A non-volatile ID counter.
 246          * Should survive connection drop & reconnect.
 247          */
 248         static guint chat_seq = 0;
 249
 250         /* Generate next ID */
 251         gchar *chat_name = g_strdup_printf(_("Chat #%d"), ++chat_seq);
 252         SIPE_DEBUG_INFO("sipe_chat_get_name: added new: %s", chat_name);
 253
 254         return chat_name;
 255 }
 256
 257 static void
 258 sipe_refer(struct sipe_core_private *sipe_private,
 259            struct sip_session *session,
 260            const gchar *who)
 261 {
 262         gchar *hdr;
 263         gchar *contact;
 264         struct sip_dialog *dialog = sipe_dialog_find(session,
 265                                                      session->chat_session->id);
 266         const char *ourtag = dialog && dialog->ourtag ? dialog->ourtag : NULL;
 267
 268         contact = get_contact(sipe_private);
 269         hdr = g_strdup_printf(
 270                 "Contact: %s\r\n"
 271                 "Refer-to: <%s>\r\n"
 272                 "Referred-By: <sip:%s>%s%s;epid=%s\r\n"
 273                 "Require: com.microsoft.rtc-multiparty\r\n",
 274                 contact,
 275                 who,
 276                 sipe_private->username,
 277                 ourtag ? ";tag=" : "",
 278                 ourtag ? ourtag : "",
 279                 sip_transport_epid(sipe_private));
 280
 281         sip_transport_request(sipe_private,
 282                               "REFER",
 283                               session->chat_session->id,
 284                               session->chat_session->id,
 285                               hdr,
 286                               NULL,
 287                               dialog,
 288                               NULL);
 289
 290         g_free(hdr);
 291         g_free(contact);
 292 }
 293
 294 static gboolean
 295 sipe_is_election_finished(struct sip_session *session)
 296 {
 297         gboolean res = TRUE;
 298
 299         SIPE_DIALOG_FOREACH {
 300                 if (dialog->election_vote == 0) {
 301                         res = FALSE;
 302                         break;
 303                 }
 304         } SIPE_DIALOG_FOREACH_END;
 305
 306         if (res) {
 307                 session->is_voting_in_progress = FALSE;
 308         }
 309         return res;
 310 }
 311
 312 static gboolean
 313 process_info_response(struct sipe_core_private *sipe_private,
 314                       struct sipmsg *msg,
 315                       struct transaction *trans);
 316
 317 static void
 318 sipe_send_election_set_rm(struct sipe_core_private *sipe_private,
 319                           struct sip_dialog *dialog)
 320 {
 321         const gchar *hdr = "Content-Type: application/x-ms-mim\r\n";
 322
 323         gchar *body = g_strdup_printf(
 324                 "<?xml version=\"1.0\"?>\r\n"
 325                 "<action xmlns=\"http://schemas.microsoft.com/sip/multiparty/\">"
 326                 "<SetRM uri=\"sip:%s\"/></action>\r\n",
 327                 sipe_private->username);
 328
 329         sip_transport_info(sipe_private,
 330                            hdr,
 331                            body,
 332                            dialog,
 333                            process_info_response);
 334
 335         g_free(body);
 336 }
 337
 338 void
 339 sipe_process_pending_invite_queue(struct sipe_core_private *sipe_private,
 340                                   struct sip_session *session)
 341 {
 342         gchar *invitee;
 343         GSList *entry = session->pending_invite_queue;
 344
 345         while (entry) {
 346                 invitee = entry->data;
 347                 sipe_invite_to_chat(sipe_private, session, invitee);
 348                 entry = session->pending_invite_queue = g_slist_remove(session->pending_invite_queue, invitee);
 349                 g_free(invitee);
 350         }
 351 }
 352
 353 void sipe_chat_set_roster_manager(struct sip_session *session,
 354                                   const gchar *roster_manager)
 355 {
 356         struct sipe_chat_session *chat_session = session->chat_session;
 357
 358         g_free(chat_session->id);
 359         chat_session->id = NULL;
 360         if (roster_manager)
 361                 chat_session->id = g_strdup(roster_manager);
 362 }
 363
 364 static void
 365 sipe_election_result(struct sipe_core_private *sipe_private,
 366                      void *sess)
 367 {
 368         struct sip_session *session = (struct sip_session *)sess;
 369         const gchar *rival = NULL;
 370
 371         if (session->chat_session->id) {
 372                 SIPE_DEBUG_INFO(
 373                         "sipe_election_result: RM has already been elected in the meantime. It is %s",
 374                         session->chat_session->id);
 375                 return;
 376         }
 377
 378         session->is_voting_in_progress = FALSE;
 379
 380         SIPE_DIALOG_FOREACH {
 381                 if (dialog->election_vote < 0) {
 382                         rival = dialog->with;
 383                         break;
 384                 }
 385         } SIPE_DIALOG_FOREACH_END;
 386
 387         if (rival) {
 388                 SIPE_DEBUG_INFO("sipe_election_result: we loose RM election to %s", rival);
 389         } else {
 390                 gchar *self = sip_uri_self(sipe_private);
 391
 392                 SIPE_DEBUG_INFO_NOFORMAT("sipe_election_result: we have won RM election!");
 393
 394                 sipe_chat_set_roster_manager(session, self);
 395                 g_free(self);
 396
 397                 SIPE_DIALOG_FOREACH {
 398                         /* send SetRM to each chat participant*/
 399                         sipe_send_election_set_rm(sipe_private, dialog);
 400                 } SIPE_DIALOG_FOREACH_END;
 401         }
 402         session->bid = 0;
 403
 404         sipe_process_pending_invite_queue(sipe_private, session);
 405 }
 406
 407 static gboolean
 408 process_info_response(struct sipe_core_private *sipe_private,
 409                       struct sipmsg *msg,
 410                       SIPE_UNUSED_PARAMETER struct transaction *trans)
 411 {
 412         const gchar *contenttype = sipmsg_find_content_type_header(msg);
 413         const gchar *callid = sipmsg_find_call_id_header(msg);
 414         struct sip_dialog *dialog;
 415         struct sip_session *session;
 416
 417         session = sipe_session_find_chat_by_callid(sipe_private, callid);
 418         if (!session) {
 419                 SIPE_DEBUG_INFO("process_info_response: failed find dialog for callid %s, exiting.", callid);
 420                 return FALSE;
 421         }
 422
 423         if (msg->response == 200 && g_str_has_prefix(contenttype, "application/x-ms-mim")) {
 424                 sipe_xml *xn_action                    = sipe_xml_parse(msg->body, msg->bodylen);
 425                 const sipe_xml *xn_request_rm_response = sipe_xml_child(xn_action, "RequestRMResponse");
 426                 const sipe_xml *xn_set_rm_response     = sipe_xml_child(xn_action, "SetRMResponse");
 427
 428                 if (xn_request_rm_response) {
 429                         const char *with = sipe_xml_attribute(xn_request_rm_response, "uri");
 430                         const char *allow = sipe_xml_attribute(xn_request_rm_response, "allow");
 431
 432                         dialog = sipe_dialog_find(session, with);
 433                         if (!dialog) {
 434                                 SIPE_DEBUG_INFO("process_info_response: failed find dialog for %s, exiting.", with);
 435                                 sipe_xml_free(xn_action);
 436                                 return FALSE;
 437                         }
 438
 439                         if (allow && !g_ascii_strcasecmp(allow, "true")) {
 440                                 SIPE_DEBUG_INFO("process_info_response: %s has voted PRO", with);
 441                                 dialog->election_vote = 1;
 442                         } else if (allow && !g_ascii_strcasecmp(allow, "false")) {
 443                                 SIPE_DEBUG_INFO("process_info_response: %s has voted CONTRA", with);
 444                                 dialog->election_vote = -1;
 445                         }
 446
 447                         if (sipe_is_election_finished(session)) {
 448                                 sipe_election_result(sipe_private,
 449                                                      session);
 450                         }
 451
 452                 } else if (xn_set_rm_response) {
 453
 454                 }
 455                 sipe_xml_free(xn_action);
 456
 457         }
 458
 459         return TRUE;
 460 }
 461
 462 static void
 463 sipe_send_election_request_rm(struct sipe_core_private *sipe_private,
 464                               struct sip_dialog *dialog,
 465                               int bid)
 466 {
 467         const gchar *hdr = "Content-Type: application/x-ms-mim\r\n";
 468
 469         gchar *body = g_strdup_printf(
 470                 "<?xml version=\"1.0\"?>\r\n"
 471                 "<action xmlns=\"http://schemas.microsoft.com/sip/multiparty/\">"
 472                 "<RequestRM uri=\"sip:%s\" bid=\"%d\"/></action>\r\n",
 473                 sipe_private->username, bid);
 474
 475         sip_transport_info(sipe_private,
 476                            hdr,
 477                            body,
 478                            dialog,
 479                            process_info_response);
 480
 481         g_free(body);
 482 }
 483
 484 static void
 485 sipe_election_start(struct sipe_core_private *sipe_private,
 486                     struct sip_session *session)
 487 {
 488         if (session->is_voting_in_progress) {
 489                 SIPE_DEBUG_INFO_NOFORMAT("sipe_election_start: other election is in progress, exiting.");
 490                 return;
 491         } else {
 492                 session->is_voting_in_progress = TRUE;
 493         }
 494         session->bid = rand();
 495
 496         SIPE_DEBUG_INFO("sipe_election_start: RM election has initiated. Our bid=%d", session->bid);
 497
 498         SIPE_DIALOG_FOREACH {
 499                 /* reset election_vote for each chat participant */
 500                 dialog->election_vote = 0;
 501
 502                 /* send RequestRM to each chat participant*/
 503                 sipe_send_election_request_rm(sipe_private, dialog, session->bid);
 504         } SIPE_DIALOG_FOREACH_END;
 505
 506         sipe_schedule_seconds(sipe_private,
 507                               "<+election-result>",
 508                               session,
 509                               15,
 510                               sipe_election_result,
 511                               NULL);
 512 }
 513
 514 static void
 515 sipe_invite_to_chat(struct sipe_core_private *sipe_private,
 516                     struct sip_session *session,
 517                     const gchar *who)
 518 {
 519         /* a conference */
 520         if (session->chat_session->type == SIPE_CHAT_TYPE_CONFERENCE)
 521         {
 522                 sipe_invite_conf(sipe_private, session, who);
 523         }
 524         else /* a multi-party chat */
 525         {
 526                 gchar *self = sip_uri_self(sipe_private);
 527                 if (session->chat_session->id) {
 528                         if (sipe_strcase_equal(session->chat_session->id, self)) {
 529                                 sipe_im_invite(sipe_private, session, who, NULL, NULL, NULL, FALSE);
 530                         } else {
 531                                 sipe_refer(sipe_private, session, who);
 532                         }
 533                 } else {
 534                         SIPE_DEBUG_INFO_NOFORMAT("sipe_invite_to_chat: no RM available");
 535
 536                         session->pending_invite_queue = sipe_utils_slist_insert_unique_sorted(session->pending_invite_queue,
 537                                                                                               g_strdup(who),
 538                                                                                               (GCompareFunc)strcmp,
 539                                                                                               g_free);
 540                         sipe_election_start(sipe_private, session);
 541                 }
 542                 g_free(self);
 543         }
 544 }
 545
 546 /*
 547   Local Variables:
 548   mode: c
 549   c-file-style: "bsd"
 550   indent-tabs-mode: t
 551   tab-width: 8
 552   End:
 553 */