src/core/sipe-incoming.c

   1 /**
   2  * @file sipe-incoming.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2010-2017 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
  30 #include <glib.h>
  31
  32 #include "sipmsg.h"
  33 #include "sip-csta.h"
  34 #include "sip-transport.h"
  35 #include "sipe-appshare.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-ft.h"
  43 #include "sipe-ft-lync.h"
  44 #include "sipe-groupchat.h"
  45 #include "sipe-im.h"
  46 #include "sipe-incoming.h"
  47 #include "sipe-media.h"
  48 #include "sipe-mime.h"
  49 #include "sipe-nls.h"
  50 #include "sipe-schedule.h"
  51 #include "sipe-session.h"
  52 #include "sipe-user.h"
  53 #include "sipe-utils.h"
  54 #include "sipe-xml.h"
  55
  56 void process_incoming_bye(struct sipe_core_private *sipe_private,
  57                           struct sipmsg *msg)
  58 {
  59         const gchar *callid = sipmsg_find_header(msg, "Call-ID");
  60         gchar *from = parse_from(sipmsg_find_header(msg, "From"));
  61         struct sip_session *session;
  62         struct sip_dialog *dialog;
  63
  64 #ifdef HAVE_VV
  65         struct sipe_media_call_private *call_private =
  66                         g_hash_table_lookup(sipe_private->media_calls, callid);
  67         if (is_media_session_msg(call_private, msg)) {
  68                 // BYE ends a media call
  69                 sipe_media_hangup(call_private);
  70         }
  71 #endif
  72
  73         /* collect dialog identification
  74          * we need callid, ourtag and theirtag to unambiguously identify dialog
  75          */
  76         /* take data before 'msg' will be modified by sip_transport_response */
  77         dialog = g_new0(struct sip_dialog, 1);
  78         dialog->callid = g_strdup(callid);
  79         dialog->cseq = sipmsg_parse_cseq(msg);
  80         dialog->with = g_strdup(from);
  81         sipe_dialog_parse(dialog, msg, FALSE);
  82
  83         sip_transport_response(sipe_private, msg, 200, "OK", NULL);
  84
  85         session = sipe_session_find_chat_or_im(sipe_private, callid, from);
  86         if (!session) {
  87                 SIPE_DEBUG_INFO_NOFORMAT("process_incoming_bye: couldn't find session. Ignoring");
  88                 sipe_dialog_free(dialog);
  89                 g_free(from);
  90                 return;
  91         }
  92
  93         SIPE_DEBUG_INFO("process_incoming_bye: session found (chat ID %s)",
  94                         (session->chat_session && session->chat_session->id) ?
  95                         session->chat_session->id : "<NO CHAT>");
  96
  97         if (session->chat_session &&
  98             (session->chat_session->type == SIPE_CHAT_TYPE_MULTIPARTY) &&
  99             session->chat_session->id &&
 100             !g_ascii_strcasecmp(from, session->chat_session->id))
 101                 sipe_chat_set_roster_manager(session, NULL);
 102
 103         sipe_im_cancel_unconfirmed(sipe_private, session, callid, from);
 104
 105         /* This what BYE is essentially for - terminating dialog */
 106         sipe_dialog_remove_3(session, dialog);
 107         sipe_dialog_free(dialog);
 108         if (session->chat_session) {
 109                 if ((session->chat_session->type == SIPE_CHAT_TYPE_CONFERENCE) &&
 110                     !g_ascii_strcasecmp(from, session->im_mcu_uri)) {
 111                         SIPE_DEBUG_INFO("process_incoming_bye: disconnected from conference %s",
 112                                         session->im_mcu_uri);
 113                         sipe_conf_immcu_closed(sipe_private, session);
 114                 } else if (session->chat_session->type == SIPE_CHAT_TYPE_MULTIPARTY) {
 115                         SIPE_DEBUG_INFO_NOFORMAT("process_incoming_bye: disconnected from multiparty chat");
 116                         sipe_backend_chat_remove(session->chat_session->backend,
 117                                                  from);
 118                 }
 119         }
 120
 121         g_free(from);
 122 }
 123
 124 void process_incoming_cancel(struct sipe_core_private *sipe_private,
 125                              struct sipmsg *msg)
 126 {
 127         const gchar *callid = sipmsg_find_header(msg, "Call-ID");
 128
 129 #ifdef HAVE_VV
 130         struct sipe_media_call_private *call_private =
 131                         g_hash_table_lookup(sipe_private->media_calls, callid);
 132         if (is_media_session_msg(call_private, msg)) {
 133                 process_incoming_cancel_call(call_private, msg);
 134                 return;
 135         }
 136 #endif
 137
 138         if (!sipe_session_find_chat_by_callid(sipe_private, callid))
 139                 sipe_conf_cancel_unaccepted(sipe_private, msg);
 140 }
 141
 142 void process_incoming_info(struct sipe_core_private *sipe_private,
 143                            struct sipmsg *msg)
 144 {
 145         const gchar *contenttype = sipmsg_find_header(msg, "Content-Type");
 146         const gchar *callid = sipmsg_find_header(msg, "Call-ID");
 147         gchar *from;
 148         struct sip_session *session;
 149
 150         SIPE_DEBUG_INFO_NOFORMAT("process_incoming_info");
 151
 152         /* Call Control protocol */
 153         if (g_str_has_prefix(contenttype, "application/csta+xml"))
 154         {
 155                 process_incoming_info_csta(sipe_private, msg);
 156                 return;
 157         }
 158         else if (g_str_has_prefix(contenttype, "application/xml+conversationinfo"))
 159         {
 160                 process_incoming_info_conversation(sipe_private, msg);
 161                 return;
 162         }
 163 #ifdef HAVE_XDATA
 164         else if (g_str_has_prefix(contenttype, "application/ms-filetransfer+xml"))
 165         {
 166                 process_incoming_info_ft_lync(sipe_private, msg);
 167                 return;
 168         }
 169 #endif
 170
 171         from = parse_from(sipmsg_find_header(msg, "From"));
 172         session = sipe_session_find_chat_or_im(sipe_private, callid, from);
 173         if (!session) {
 174                 g_free(from);
 175                 return;
 176         }
 177
 178         /* Group Chat uses text/plain */
 179         if (session->is_groupchat) {
 180                 process_incoming_info_groupchat(sipe_private, msg, session);
 181                 g_free(from);
 182                 return;
 183         }
 184
 185         if (g_str_has_prefix(contenttype, "application/x-ms-mim"))
 186         {
 187                 sipe_xml *xn_action           = sipe_xml_parse(msg->body, msg->bodylen);
 188                 const sipe_xml *xn_request_rm = sipe_xml_child(xn_action, "RequestRM");
 189                 const sipe_xml *xn_set_rm     = sipe_xml_child(xn_action, "SetRM");
 190
 191                 sipmsg_add_header(msg, "Content-Type", "application/x-ms-mim");
 192
 193                 if (xn_request_rm) {
 194                         //const char *rm = sipe_xml_attribute(xn_request_rm, "uri");
 195                         int bid = sipe_xml_int_attribute(xn_request_rm, "bid", 0);
 196                         gchar *body = g_strdup_printf(
 197                                 "<?xml version=\"1.0\"?>\r\n"
 198                                 "<action xmlns=\"http://schemas.microsoft.com/sip/multiparty/\">"
 199                                 "<RequestRMResponse uri=\"sip:%s\" allow=\"%s\"/></action>\r\n",
 200                                 sipe_private->username,
 201                                 session->bid < bid ? "true" : "false");
 202                         sip_transport_response(sipe_private, msg, 200, "OK", body);
 203                         g_free(body);
 204                 } else if (xn_set_rm) {
 205                         gchar *body;
 206
 207                         sipe_chat_set_roster_manager(session,
 208                                                      sipe_xml_attribute(xn_set_rm, "uri"));
 209
 210                         body = g_strdup_printf(
 211                                 "<?xml version=\"1.0\"?>\r\n"
 212                                 "<action xmlns=\"http://schemas.microsoft.com/sip/multiparty/\">"
 213                                 "<SetRMResponse uri=\"sip:%s\"/></action>\r\n",
 214                                 sipe_private->username);
 215                         sip_transport_response(sipe_private, msg, 200, "OK", body);
 216                         g_free(body);
 217                 }
 218                 sipe_xml_free(xn_action);
 219
 220         }
 221         else
 222         {
 223                 /* looks like purple lacks typing notification for chat */
 224                 if (!session->chat_session) {
 225                         sipe_xml *xn_keyboard_activity  = sipe_xml_parse(msg->body, msg->bodylen);
 226                         const char *status = sipe_xml_attribute(sipe_xml_child(xn_keyboard_activity, "status"),
 227                                                                 "status");
 228                         if (sipe_strequal(status, "type")) {
 229                                 sipe_backend_user_feedback_typing(SIPE_CORE_PUBLIC,
 230                                                                   from);
 231                         } else if (sipe_strequal(status, "idle")) {
 232                                 sipe_backend_user_feedback_typing_stop(SIPE_CORE_PUBLIC,
 233                                                                        from);
 234                         }
 235                         sipe_xml_free(xn_keyboard_activity);
 236                 }
 237
 238                 sip_transport_response(sipe_private, msg, 200, "OK", NULL);
 239         }
 240         g_free(from);
 241 }
 242
 243 static gboolean sipe_process_incoming_x_msmsgsinvite(struct sipe_core_private *sipe_private,
 244                                                      struct sip_dialog *dialog,
 245                                                      GSList *parsed_body)
 246 {
 247         gboolean found = FALSE;
 248
 249         if (parsed_body) {
 250                 const gchar *invitation_command = sipe_utils_nameval_find(parsed_body, "Invitation-Command");
 251
 252                 if (sipe_strequal(invitation_command, "INVITE")) {
 253                         sipe_ft_incoming_transfer(sipe_private, dialog, parsed_body);
 254                         found = TRUE;
 255                 } else if (sipe_strequal(invitation_command, "CANCEL")) {
 256                         sipe_ft_incoming_cancel(dialog, parsed_body);
 257                         found = TRUE;
 258                 } else if (sipe_strequal(invitation_command, "ACCEPT")) {
 259                         sipe_ft_incoming_accept(dialog, parsed_body);
 260                         found = TRUE;
 261                 }
 262         }
 263         return found;
 264 }
 265
 266 #ifdef HAVE_VV
 267 static void sipe_invite_mime_cb(gpointer user_data, const GSList *fields,
 268                                 const gchar *body, gsize length)
 269 {
 270         const gchar *type = sipe_utils_nameval_find(fields, "Content-Type");
 271         const gchar *cd = sipe_utils_nameval_find(fields, "Content-Disposition");
 272
 273         if (!g_str_has_prefix(type, "application/sdp"))
 274                 return;
 275
 276         if (!cd || !strstr(cd, "ms-proxy-2007fallback")) {
 277                 struct sipmsg *msg = user_data;
 278                 const gchar* msg_ct = sipmsg_find_header(msg, "Content-Type");
 279
 280                 if (g_str_has_prefix(msg_ct, "application/sdp")) {
 281                         /* We have already found suitable alternative and set message's body
 282                          * and Content-Type accordingly */
 283                         return;
 284                 }
 285
 286                 sipmsg_remove_header_now(msg, "Content-Type");
 287                 sipmsg_add_header_now(msg, "Content-Type", type);
 288
 289                 /* Replace message body with chosen alternative, so we can continue to
 290                  * process it as a normal single part message. */
 291                 g_free(msg->body);
 292                 msg->body = g_strndup(body, length);
 293                 msg->bodylen = length;
 294         }
 295 }
 296 #endif
 297
 298 static void send_invite_response(struct sipe_core_private *sipe_private,
 299                                  struct sipmsg *msg)
 300 {
 301         gchar *body = g_strdup_printf(
 302                 "v=0\r\n"
 303                 "o=- 0 0 IN %s %s\r\n"
 304                 "s=session\r\n"
 305                 "c=IN %s %s\r\n"
 306                 "t=0 0\r\n"
 307                 "m=%s %d sip sip:%s\r\n"
 308                 "a=accept-types:" SDP_ACCEPT_TYPES "\r\n",
 309                 sip_transport_sdp_address_marker(sipe_private),
 310                 sip_transport_ip_address(sipe_private),
 311                 sip_transport_sdp_address_marker(sipe_private),
 312                 sip_transport_ip_address(sipe_private),
 313                 SIPE_CORE_PRIVATE_FLAG_IS(OCS2007) ? "message" : "x-ms-message",
 314                 sip_transport_port(sipe_private),
 315                 sipe_private->username);
 316         sipmsg_add_header(msg, "Content-Type", "application/sdp");
 317         sip_transport_response(sipe_private, msg, 200, "OK", body);
 318         g_free(body);
 319 }
 320
 321 struct sipe_delayed_invite {
 322         gchar *action;
 323         struct sipmsg *msg;
 324 };
 325
 326 static void delayed_invite_destroy(gpointer data)
 327 {
 328         struct sipe_delayed_invite *delayed_invite = data;
 329         sipmsg_free(delayed_invite->msg);
 330         g_free(delayed_invite->action);
 331         g_free(delayed_invite);
 332 }
 333
 334 static void delayed_invite_timeout(struct sipe_core_private *sipe_private,
 335                                    gpointer data)
 336 {
 337         struct sipe_delayed_invite *delayed_invite = data;
 338         send_invite_response(sipe_private, delayed_invite->msg);
 339 }
 340
 341 static void delayed_invite_response(struct sipe_core_private *sipe_private,
 342                                     struct sipmsg *msg,
 343                                     const gchar *callid)
 344 {
 345         struct sipe_delayed_invite *delayed_invite = g_new0(struct sipe_delayed_invite, 1);
 346
 347         delayed_invite->action = g_strdup_printf("<delayed-invite-%s>", callid);
 348         delayed_invite->msg    = sipmsg_copy(msg);
 349         sipe_schedule_seconds(sipe_private,
 350                               delayed_invite->action,
 351                               delayed_invite,
 352                               10,
 353                               delayed_invite_timeout,
 354                               delayed_invite_destroy);
 355 }
 356
 357 void sipe_incoming_cancel_delayed_invite(struct sipe_core_private *sipe_private,
 358                                          struct sip_dialog *dialog)
 359 {
 360         struct sipe_delayed_invite *delayed_invite = dialog->delayed_invite;
 361         dialog->delayed_invite = NULL;
 362         send_invite_response(sipe_private, delayed_invite->msg);
 363         sipe_schedule_cancel(sipe_private, delayed_invite->action);
 364 }
 365
 366 void process_incoming_invite(struct sipe_core_private *sipe_private,
 367                              struct sipmsg *msg)
 368 {
 369         gchar *newTag;
 370         const gchar *oldHeader;
 371         gchar *newHeader;
 372         gboolean is_multiparty = FALSE;
 373         gboolean was_multiparty = TRUE;
 374         gboolean just_joined = FALSE;
 375         gchar *from;
 376         const gchar *callid         = sipmsg_find_header(msg, "Call-ID");
 377         const gchar *roster_manager = sipmsg_find_header(msg, "Roster-Manager");
 378         const gchar *end_points_hdr = sipmsg_find_header(msg, "EndPoints");
 379         const gchar *trig_invite    = sipmsg_find_header(msg, "TriggeredInvite");
 380         const gchar *content_type   = sipmsg_find_header(msg, "Content-Type");
 381         const gchar *subject        = sipmsg_find_header(msg, "Subject");
 382         GSList *end_points = NULL;
 383         struct sip_session *session;
 384         struct sip_dialog *dialog;
 385         const gchar *ms_text_format;
 386         gboolean dont_delay = FALSE;
 387
 388 #ifdef HAVE_VV
 389         if (g_str_has_prefix(content_type, "multipart/alternative")) {
 390                 sipe_mime_parts_foreach(content_type, msg->body, sipe_invite_mime_cb, msg);
 391                 /* Reload Content-Type to get type of the selected message part */
 392                 content_type = sipmsg_find_header(msg, "Content-Type");
 393         }
 394 #endif
 395
 396         if (g_str_has_prefix(content_type, "multipart/mixed")) {
 397                 if (sipe_mime_parts_contain(content_type, msg->body,
 398                                             "application/ms-filetransfer+xml")) {
 399                         /* Lync 2010 file transfer */
 400 #ifdef HAVE_XDATA
 401                         process_incoming_invite_ft_lync(sipe_private, msg);
 402 #else
 403                         sip_transport_response(sipe_private, msg,
 404                                                488, "Not Acceptable Here", NULL);
 405 #endif
 406                         return;
 407                 }
 408         }
 409
 410         /* Invitation to join conference */
 411         if (g_str_has_prefix(content_type, "application/ms-conf-invite+xml")) {
 412                 process_incoming_invite_conf(sipe_private, msg);
 413                 return;
 414         }
 415
 416 #ifdef HAVE_VV
 417         /* Application sharing */
 418         if (sipe_strcase_equal(content_type, "application/sdp") && msg->body &&
 419             strstr(msg->body, "m=applicationsharing") &&
 420             sipe_strequal(sipmsg_find_header(msg, "CSeq"), "1 INVITE")) {
 421 #ifdef HAVE_APPSHARE
 422                 process_incoming_invite_appshare(sipe_private, msg);
 423 #else
 424                 sip_transport_response(sipe_private, msg,
 425                                        488, "Not Acceptable Here", NULL);
 426 #endif
 427                 return;
 428         }
 429
 430         /* Invitation to audio call or file transfer */
 431         if (msg->body &&
 432             (strstr(msg->body, "m=audio") || strstr(msg->body, "m=data") || strstr(msg->body, "m=applicationsharing"))) {
 433                 process_incoming_invite_call(sipe_private, msg, msg->body);
 434                 return;
 435         }
 436 #endif
 437
 438         /* Only accept text invitations */
 439         if (msg->body && !(strstr(msg->body, "m=message") || strstr(msg->body, "m=x-ms-message"))) {
 440                 sip_transport_response(sipe_private, msg, 501, "Not implemented", NULL);
 441                 return;
 442         }
 443
 444         // TODO There *must* be a better way to clean up the To header to add a tag...
 445         SIPE_DEBUG_INFO_NOFORMAT("Adding a Tag to the To Header on Invite Request...");
 446         oldHeader = sipmsg_find_header(msg, "To");
 447         newTag = gentag();
 448         newHeader = g_strdup_printf("%s;tag=%s", oldHeader, newTag);
 449         g_free(newTag);
 450         sipmsg_remove_header_now(msg, "To");
 451         sipmsg_add_header_now(msg, "To", newHeader);
 452         g_free(newHeader);
 453
 454         if (end_points_hdr) {
 455                 end_points = sipmsg_parse_endpoints_header(end_points_hdr);
 456
 457                 if (g_slist_length(end_points) > 2) {
 458                         is_multiparty = TRUE;
 459                 }
 460         }
 461         if (trig_invite && !g_ascii_strcasecmp(trig_invite, "TRUE")) {
 462                 is_multiparty = TRUE;
 463         }
 464
 465         /* Multiparty session */
 466         session = sipe_session_find_chat_by_callid(sipe_private, callid);
 467         if (is_multiparty) {
 468
 469                 if (session) {
 470                         if (session->chat_session) {
 471                                 /* Update roster manager for existing multiparty session */
 472                                 if (roster_manager)
 473                                         sipe_chat_set_roster_manager(session, roster_manager);
 474
 475                         } else {
 476                                 gchar *chat_title = sipe_chat_get_name();
 477
 478                                 /* Convert IM session to multiparty session */
 479                                 g_free(session->with);
 480                                 session->with = NULL;
 481                                 was_multiparty = FALSE;
 482                                 session->chat_session = sipe_chat_create_session(SIPE_CHAT_TYPE_MULTIPARTY,
 483                                                                                  roster_manager,
 484                                                                                  chat_title);
 485
 486                                 g_free(chat_title);
 487                         }
 488                 } else {
 489                         /* New multiparty session */
 490                         session = sipe_session_add_chat(sipe_private,
 491                                                         NULL,
 492                                                         TRUE,
 493                                                         roster_manager);
 494                 }
 495
 496                 /* Create chat */
 497                 if (!session->chat_session->backend) {
 498                         gchar *self = sip_uri_self(sipe_private);
 499                         session->chat_session->backend = sipe_backend_chat_create(SIPE_CORE_PUBLIC,
 500                                                                                   session->chat_session,
 501                                                                                   session->chat_session->title,
 502                                                                                   self);
 503                         g_free(self);
 504                 }
 505         }
 506
 507         /* IM session */
 508         from = parse_from(sipmsg_find_header(msg, "From"));
 509         if (!session)
 510                 session = sipe_session_find_or_add_im(sipe_private, from);
 511
 512         /* session is now initialized */
 513         g_free(session->callid);
 514         session->callid = g_strdup(callid);
 515
 516         if (is_multiparty && end_points) {
 517                 gchar *to = parse_from(sipmsg_find_header(msg, "To"));
 518                 GSList *entry = end_points;
 519                 while (entry) {
 520                         struct sipendpoint *end_point = entry->data;
 521                         entry = entry->next;
 522
 523                         if (!g_ascii_strcasecmp(from, end_point->contact) ||
 524                             !g_ascii_strcasecmp(to,   end_point->contact))
 525                                 continue;
 526
 527                         dialog = sipe_dialog_find(session, end_point->contact);
 528                         if (dialog) {
 529                                 g_free(dialog->theirepid);
 530                                 dialog->theirepid = end_point->epid;
 531                                 end_point->epid = NULL;
 532                         } else {
 533                                 dialog = sipe_dialog_add(session);
 534
 535                                 dialog->callid = g_strdup(session->callid);
 536                                 dialog->with = end_point->contact;
 537                                 end_point->contact = NULL;
 538                                 dialog->theirepid = end_point->epid;
 539                                 end_point->epid = NULL;
 540
 541                                 just_joined = TRUE;
 542
 543                                 /* send triggered INVITE */
 544                                 sipe_im_invite(sipe_private, session, dialog->with, NULL, NULL, NULL, TRUE);
 545                         }
 546                 }
 547                 g_free(to);
 548         }
 549
 550         if (end_points) {
 551                 GSList *entry = end_points;
 552                 while (entry) {
 553                         struct sipendpoint *end_point = entry->data;
 554                         entry = entry->next;
 555                         g_free(end_point->contact);
 556                         g_free(end_point->epid);
 557                         g_free(end_point);
 558                 }
 559                 g_slist_free(end_points);
 560         }
 561
 562         dialog = sipe_dialog_find(session, from);
 563         if (dialog) {
 564                 sipe_im_cancel_dangling(sipe_private, session, dialog, from,
 565                                         sipe_im_reenqueue_unconfirmed);
 566                 /* dialog is no longer valid */
 567         } else {
 568                 just_joined = TRUE;
 569         }
 570
 571         dialog = sipe_dialog_add(session);
 572         dialog->with = g_strdup(from);
 573         dialog->callid = g_strdup(session->callid);
 574         dialog->is_established = TRUE;
 575         sipe_dialog_parse(dialog, msg, FALSE);
 576
 577         if (is_multiparty && !was_multiparty) {
 578                 /* add current IM counterparty to chat */
 579                 sipe_backend_chat_add(session->chat_session->backend,
 580                                       sipe_dialog_first(session)->with,
 581                                       FALSE);
 582         }
 583
 584         /* add inviting party to chat */
 585         if (just_joined && session->chat_session) {
 586                 sipe_backend_chat_add(session->chat_session->backend,
 587                                       from,
 588                                       TRUE);
 589         }
 590
 591         if (!is_multiparty && subject)
 592                 sipe_im_topic(sipe_private, session, subject);
 593
 594         /* ms-text-format: text/plain; charset=UTF-8;msgr=WAAtAE0...DIADQAKAA0ACgA;ms-body=SGk= */
 595
 596         /* This used only in 2005 official client, not 2007 or Reuters.
 597            Disabled for most cases as interfering with audit of messages which only is applied to regular MESSAGEs.
 598            Only enabled for 2005 multiparty chats as otherwise the first message got lost completely.
 599         */
 600         /* also enabled for 2005 file transfer. Didn't work otherwise. */
 601         ms_text_format = sipmsg_find_header(msg, "ms-text-format");
 602         if (is_multiparty ||
 603             (ms_text_format && g_str_has_prefix(ms_text_format, "text/x-msmsgsinvite")) )
 604         {
 605                 if (ms_text_format) {
 606                         if (g_str_has_prefix(ms_text_format, "text/x-msmsgsinvite"))
 607                         {
 608                                 dont_delay = TRUE;
 609                         }
 610                         else if (g_str_has_prefix(ms_text_format, "text/plain") || g_str_has_prefix(ms_text_format, "text/html"))
 611                         {
 612                                 /* please do not optimize logic inside as this code may be re-enabled for other cases */
 613                                 gchar *html = get_html_message(ms_text_format, NULL);
 614                                 if (html) {
 615                                         if (is_multiparty) {
 616                                                 sipe_backend_chat_message(SIPE_CORE_PUBLIC,
 617                                                                           session->chat_session->backend,
 618                                                                           from,
 619                                                                           0,
 620                                                                           html);
 621                                         } else {
 622                                                 sipe_backend_im_message(SIPE_CORE_PUBLIC,
 623                                                                         from,
 624                                                                         html);
 625                                         }
 626                                         g_free(html);
 627                                         sipmsg_add_header(msg, "Supported", "ms-text-format"); /* accepts received message */
 628                                         dont_delay = TRUE;
 629                                 }
 630                         }
 631                 }
 632         }
 633
 634         g_free(from);
 635
 636         sipmsg_add_header(msg, "Supported", "com.microsoft.rtc-multiparty");
 637
 638         if (dont_delay || !SIPE_CORE_PRIVATE_FLAG_IS(MPOP)) {
 639                 send_invite_response(sipe_private, msg);
 640         } else {
 641                 delayed_invite_response(sipe_private, msg, session->callid);
 642         }
 643 }
 644
 645 void process_incoming_message(struct sipe_core_private *sipe_private,
 646                               struct sipmsg *msg)
 647 {
 648         gchar *from;
 649         const gchar *contenttype;
 650         gboolean found = FALSE;
 651
 652         from = parse_from(sipmsg_find_header(msg, "From"));
 653
 654         if (!from) return;
 655
 656         SIPE_DEBUG_INFO("got message from %s: %s", from, msg->body);
 657
 658         contenttype = sipmsg_find_header(msg, "Content-Type");
 659         if (g_str_has_prefix(contenttype, "text/plain")
 660             || g_str_has_prefix(contenttype, "text/html")
 661             || g_str_has_prefix(contenttype, "multipart/related")
 662             || g_str_has_prefix(contenttype, "multipart/alternative"))
 663         {
 664                 const gchar *callid = sipmsg_find_header(msg, "Call-ID");
 665                 gchar *html = get_html_message(contenttype, msg->body);
 666
 667                 struct sip_session *session = sipe_session_find_chat_or_im(sipe_private,
 668                                                                            callid,
 669                                                                            from);
 670                 if (session && session->chat_session) {
 671                         if (session->chat_session->type == SIPE_CHAT_TYPE_CONFERENCE) { /* a conference */
 672                                 gchar *tmp = parse_from(sipmsg_find_header(msg, "Ms-Sender"));
 673                                 gchar *sender = parse_from(tmp);
 674                                 g_free(tmp);
 675                                 sipe_backend_chat_message(SIPE_CORE_PUBLIC,
 676                                                           session->chat_session->backend,
 677                                                           sender,
 678                                                           0,
 679                                                           html);
 680                                 g_free(sender);
 681                         } else { /* a multiparty chat */
 682                                 sipe_backend_chat_message(SIPE_CORE_PUBLIC,
 683                                                           session->chat_session->backend,
 684                                                           from,
 685                                                           0,
 686                                                           html);
 687                         }
 688                 } else {
 689                         sipe_backend_im_message(SIPE_CORE_PUBLIC,
 690                                                 from,
 691                                                 html);
 692                 }
 693                 g_free(html);
 694                 sip_transport_response(sipe_private, msg, 200, "OK", NULL);
 695                 found = TRUE;
 696
 697         } else if (g_str_has_prefix(contenttype, "application/im-iscomposing+xml")) {
 698                 sipe_xml *isc = sipe_xml_parse(msg->body, msg->bodylen);
 699                 const sipe_xml *state;
 700                 gchar *statedata;
 701
 702                 if (!isc) {
 703                         SIPE_DEBUG_INFO_NOFORMAT("process_incoming_message: can not parse iscomposing");
 704                         g_free(from);
 705                         return;
 706                 }
 707
 708                 state = sipe_xml_child(isc, "state");
 709
 710                 if (!state) {
 711                         SIPE_DEBUG_INFO_NOFORMAT("process_incoming_message: no state found");
 712                         sipe_xml_free(isc);
 713                         g_free(from);
 714                         return;
 715                 }
 716
 717                 statedata = sipe_xml_data(state);
 718                 if (statedata) {
 719                         if (strstr(statedata, "active")) {
 720                                 sipe_backend_user_feedback_typing(SIPE_CORE_PUBLIC,
 721                                                                   from);
 722                         } else {
 723                                 sipe_backend_user_feedback_typing_stop(SIPE_CORE_PUBLIC,
 724                                                                        from);
 725                         }
 726                         g_free(statedata);
 727                 }
 728                 sipe_xml_free(isc);
 729                 sip_transport_response(sipe_private, msg, 200, "OK", NULL);
 730                 found = TRUE;
 731         } else if (g_str_has_prefix(contenttype, "text/x-msmsgsinvite")) {
 732                 const gchar *callid = sipmsg_find_header(msg, "Call-ID");
 733                 struct sip_session *session = sipe_session_find_chat_or_im(sipe_private,
 734                                                                            callid,
 735                                                                            from);
 736                 if (session) {
 737                         struct sip_dialog *dialog = sipe_dialog_find(session, from);
 738                         GSList *body = sipe_ft_parse_msg_body(msg->body);
 739                         found = sipe_process_incoming_x_msmsgsinvite(sipe_private, dialog, body);
 740                         sipe_utils_nameval_free(body);
 741                         if (found) {
 742                                 sip_transport_response(sipe_private, msg, 200, "OK", NULL);
 743                         }
 744                 } else {
 745                         sip_transport_response(sipe_private, msg, 481,
 746                                                "Call Leg/Transaction Does Not Exist", NULL);
 747                         found = TRUE;
 748                 }
 749         }
 750         if (!found) {
 751                 const gchar *callid = sipmsg_find_header(msg, "Call-ID");
 752                 struct sip_session *session = sipe_session_find_chat_or_im(sipe_private,
 753                                                                            callid,
 754                                                                            from);
 755                 if (session) {
 756                         gchar *errmsg = g_strdup_printf(_("Received a message with unrecognized contents from %s"),
 757                                                         from);
 758                         sipe_user_present_error(sipe_private, session, errmsg);
 759                         g_free(errmsg);
 760                 }
 761
 762                 SIPE_DEBUG_INFO("got unknown mime-type '%s'", contenttype);
 763                 sip_transport_response(sipe_private, msg, 415, "Unsupported media type", NULL);
 764         }
 765         g_free(from);
 766 }
 767
 768 void process_incoming_options(struct sipe_core_private *sipe_private,
 769                               struct sipmsg *msg)
 770 {
 771         gchar *body;
 772
 773         sipmsg_add_header(msg, "Allow", "INVITE, MESSAGE, INFO, SUBSCRIBE, OPTIONS, BYE, CANCEL, NOTIFY, ACK, REFER, BENOTIFY");
 774         sipmsg_add_header(msg, "Content-Type", "application/sdp");
 775
 776         body = g_strdup_printf(
 777                 "v=0\r\n"
 778                 "o=- 0 0 IN IP4 0.0.0.0\r\n"
 779                 "s=session\r\n"
 780                 "c=IN IP4 0.0.0.0\r\n"
 781                 "t=0 0\r\n"
 782                 "m=%s %d sip sip:%s\r\n"
 783                 "a=accept-types:" SDP_ACCEPT_TYPES "\r\n",
 784                 SIPE_CORE_PRIVATE_FLAG_IS(OCS2007) ? "message" : "x-ms-message",
 785                 sip_transport_port(sipe_private),
 786                 sipe_private->username);
 787         sip_transport_response(sipe_private, msg, 200, "OK", body);
 788         g_free(body);
 789 }
 790
 791 void process_incoming_refer(struct sipe_core_private *sipe_private,
 792                             struct sipmsg *msg)
 793 {
 794         gchar *self = sip_uri_self(sipe_private);
 795         const gchar *callid = sipmsg_find_header(msg, "Call-ID");
 796         gchar *from = parse_from(sipmsg_find_header(msg, "From"));
 797         gchar *refer_to = parse_from(sipmsg_find_header(msg, "Refer-to"));
 798         gchar *referred_by = g_strdup(sipmsg_find_header(msg, "Referred-By"));
 799         struct sip_session *session;
 800         struct sip_dialog *dialog;
 801
 802         session = sipe_session_find_chat_by_callid(sipe_private, callid);
 803         dialog = sipe_dialog_find(session, from);
 804
 805         if (!session || !dialog || !session->chat_session ||
 806             (session->chat_session->type != SIPE_CHAT_TYPE_MULTIPARTY) ||
 807             !session->chat_session->id ||
 808             !sipe_strcase_equal(session->chat_session->id, self)) {
 809                 sip_transport_response(sipe_private, msg, 500, "Server Internal Error", NULL);
 810         } else {
 811                 sip_transport_response(sipe_private, msg, 202, "Accepted", NULL);
 812
 813                 sipe_im_invite(sipe_private, session, refer_to, NULL, NULL, referred_by, FALSE);
 814         }
 815
 816         g_free(self);
 817         g_free(from);
 818         g_free(refer_to);
 819         g_free(referred_by);
 820 }
 821
 822 /*
 823   Local Variables:
 824   mode: c
 825   c-file-style: "bsd"
 826   indent-tabs-mode: t
 827   tab-width: 8
 828   End:
 829 */