src/core/sipmsg.c

   1 /**
   2  * @file sipmsg.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2010-2019 SIPE Project <http://sipe.sourceforge.net/>
   7  * Copyright (C) 2008 Novell, Inc.
   8  * Copyright (C) 2005 Thomas Butter <butter@uni-mannheim.de>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  */
  24
  25 #include <stdlib.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <time.h>
  29
  30 #include <glib.h>
  31
  32 #include "sipmsg.h"
  33 #include "sipe-backend.h"
  34 #include "sipe-mime.h"
  35 #include "sipe-rtf.h"
  36 #include "sipe-utils.h"
  37
  38 struct sipmsg *sipmsg_parse_msg(const gchar *msg) {
  39         const char *tmp = strstr(msg, "\r\n\r\n");
  40         char *line;
  41         struct sipmsg *smsg;
  42
  43         if(!tmp) return NULL;
  44
  45         line = g_strndup(msg, tmp - msg);
  46
  47         smsg = sipmsg_parse_header(line);
  48         smsg->body = g_strdup(tmp + 4);
  49
  50         g_free(line);
  51         return smsg;
  52 }
  53
  54 struct sipmsg *sipmsg_parse_header(const gchar *header) {
  55         struct sipmsg *msg = g_new0(struct sipmsg,1);
  56         gchar **lines = g_strsplit(header,"\r\n",0);
  57         gchar **parts;
  58         const gchar *contentlength;
  59         if(!lines[0]) {
  60                 g_strfreev(lines);
  61                 g_free(msg);
  62                 return NULL;
  63         }
  64         parts = g_strsplit(lines[0], " ", 3);
  65         if(!parts[0] || !parts[1] || !parts[2]) {
  66                 g_strfreev(parts);
  67                 g_strfreev(lines);
  68                 g_free(msg);
  69                 return NULL;
  70         }
  71         if(strstr(parts[0],"SIP") || strstr(parts[0],"HTTP")) { /* numeric response */
  72                 msg->responsestr = g_strdup(parts[2]);
  73                 msg->response = strtol(parts[1],NULL,10);
  74         } else { /* request */
  75                 msg->method = g_strdup(parts[0]);
  76                 msg->target = g_strdup(parts[1]);
  77                 msg->response = 0;
  78         }
  79         g_strfreev(parts);
  80         if (sipe_utils_parse_lines(&msg->headers, lines + 1, ":") == FALSE) {
  81                 g_strfreev(lines);
  82                 sipmsg_free(msg);
  83                 return NULL;
  84         }
  85         g_strfreev(lines);
  86         contentlength = sipmsg_find_header(msg, "Content-Length");
  87         if (contentlength) {
  88                 msg->bodylen = strtol(contentlength,NULL,10);
  89         } else {
  90                 const gchar *tmp = sipmsg_find_header(msg, "Transfer-Encoding");
  91                 if (tmp && sipe_strcase_equal(tmp, "chunked")) {
  92                         msg->bodylen = SIPMSG_BODYLEN_CHUNKED;
  93                 } else {
  94                         tmp = sipmsg_find_header(msg, "Content-Type");
  95                         if (tmp) {
  96                                 /*
  97                                  * This is a fatal error situation: the message
  98                                  * is corrupted and we can't proceed. Set the
  99                                  * response code to a special value so that the
 100                                  * caller can abort correctly.
 101                                  */
 102                                 SIPE_DEBUG_ERROR_NOFORMAT("sipmsg_parse_header: Content-Length header not found. Aborting!");
 103                                 msg->response = SIPMSG_RESPONSE_FATAL_ERROR;
 104                                 return(msg);
 105                         } else {
 106                                 msg->bodylen = 0;
 107                         }
 108                 }
 109         }
 110         if(msg->response) {
 111                 const gchar *tmp;
 112                 tmp = sipmsg_find_header(msg, "CSeq");
 113                 if(!tmp) {
 114                         /* SHOULD NOT HAPPEN */
 115                         msg->method = 0;
 116                 } else {
 117                         parts = g_strsplit(tmp, " ", 2);
 118                         msg->method = g_strdup(parts[1]);
 119                         g_strfreev(parts);
 120                 }
 121         }
 122         return msg;
 123 }
 124
 125 struct sipmsg *sipmsg_copy(const struct sipmsg *other) {
 126         struct sipmsg *msg = g_new0(struct sipmsg, 1);
 127         GSList *list;
 128
 129         msg->response           = other->response;
 130         msg->responsestr        = g_strdup(other->responsestr);
 131         msg->method             = g_strdup(other->method);
 132         msg->target             = g_strdup(other->target);
 133
 134         list = other->headers;
 135         while(list) {
 136                 struct sipnameval *elem = list->data;
 137                 sipmsg_add_header_now(msg, elem->name, elem->value);
 138                 list = list->next;
 139         }
 140
 141         list = other->new_headers;
 142         while(list) {
 143                 struct sipnameval *elem = list->data;
 144                 sipmsg_add_header(msg, elem->name, elem->value);
 145                 list = list->next;
 146         }
 147
 148         msg->bodylen    = other->bodylen;
 149         msg->body       = g_strdup(other->body);
 150         msg->signature  = g_strdup(other->signature);
 151         msg->rand       = g_strdup(other->rand);
 152         msg->num        = g_strdup(other->num);
 153
 154         return msg;
 155 }
 156
 157 char *sipmsg_to_string(const struct sipmsg *msg) {
 158         GSList *cur;
 159         GString *outstr = g_string_new("");
 160         struct sipnameval *elem;
 161
 162         if(msg->response)
 163                 g_string_append_printf(outstr, "SIP/2.0 %d Unknown\r\n",
 164                         msg->response);
 165         else
 166                 g_string_append_printf(outstr, "%s %s SIP/2.0\r\n",
 167                         msg->method, msg->target);
 168
 169         cur = msg->headers;
 170         while(cur) {
 171                 elem = cur->data;
 172                 /*Todo: remove the LFCR in a good way*/
 173                 /*if(sipe_strequal(elem->name,"Proxy-Authorization"))
 174                   g_string_append_printf(outstr, "%s: %s", elem->name,
 175                         elem->value);
 176                 else     */
 177                    g_string_append_printf(outstr, "%s: %s\r\n", elem->name,
 178                         elem->value);
 179                 cur = g_slist_next(cur);
 180         }
 181
 182         g_string_append_printf(outstr, "\r\n%s", msg->bodylen ? msg->body : "");
 183
 184         return g_string_free(outstr, FALSE);
 185 }
 186
 187 /**
 188  * Adds header to current message headers
 189  */
 190 void sipmsg_add_header_now(struct sipmsg *msg, const gchar *name, const gchar *value) {
 191         struct sipnameval *element = g_new0(struct sipnameval,1);
 192
 193         /* SANITY CHECK: the calling code must be fixed if this happens! */
 194         if (!value) {
 195                 SIPE_DEBUG_ERROR("sipmsg_add_header_now: NULL value for %s",
 196                                  name);
 197                 value = "";
 198         }
 199
 200         element->name = g_strdup(name);
 201         element->value = g_strdup(value);
 202         msg->headers = g_slist_append(msg->headers, element);
 203 }
 204
 205 /**
 206  * Adds header to separate storage for future merge
 207  */
 208 void sipmsg_add_header(struct sipmsg *msg, const gchar *name, const gchar *value) {
 209         struct sipnameval *element = g_new0(struct sipnameval,1);
 210
 211         /* SANITY CHECK: the calling code must be fixed if this happens! */
 212         if (!value) {
 213                 SIPE_DEBUG_ERROR("sipmsg_add_header: NULL value for %s", name);
 214                 value = "";
 215         }
 216
 217         element->name = g_strdup(name);
 218         element->value = g_strdup(value);
 219         msg->new_headers = g_slist_append(msg->new_headers, element);
 220 }
 221
 222 /**
 223  * Removes header if it's not in keepers array
 224  */
 225 void sipmsg_strip_headers(struct sipmsg *msg, const gchar *keepers[]) {
 226         GSList *entry;
 227         struct sipnameval *elem;
 228
 229         entry = msg->headers;
 230         while(entry) {
 231                 int i = 0;
 232                 gboolean keeper = FALSE;
 233
 234                 elem = entry->data;
 235                 while (keepers[i]) {
 236                         if (!g_ascii_strcasecmp(elem->name, keepers[i])) {
 237                                 keeper = TRUE;
 238                                 break;
 239                         }
 240                         i++;
 241                 }
 242
 243                 if (!keeper) {
 244                         GSList *to_delete = entry;
 245                         SIPE_DEBUG_INFO("sipmsg_strip_headers: removing %s", elem->name);
 246                         entry = g_slist_next(entry);
 247                         msg->headers = g_slist_delete_link(msg->headers, to_delete);
 248                         g_free(elem->name);
 249                         g_free(elem->value);
 250                         g_free(elem);
 251                 } else {
 252                         entry = g_slist_next(entry);
 253                 }
 254         }
 255 }
 256
 257 /**
 258  * Merges newly added headers to message
 259  */
 260 void sipmsg_merge_new_headers(struct sipmsg *msg) {
 261         while(msg->new_headers) {
 262                 msg->headers = g_slist_append(msg->headers, msg->new_headers->data);
 263                 msg->new_headers = g_slist_remove(msg->new_headers, msg->new_headers->data);
 264         }
 265 }
 266
 267 void sipmsg_free(struct sipmsg *msg) {
 268         if (msg) {
 269                 sipe_utils_nameval_free(msg->headers);
 270                 sipe_utils_nameval_free(msg->new_headers);
 271                 g_free(msg->signature);
 272                 g_free(msg->rand);
 273                 g_free(msg->num);
 274                 g_free(msg->responsestr);
 275                 g_free(msg->method);
 276                 g_free(msg->target);
 277                 g_free(msg->body);
 278                 g_free(msg);
 279         }
 280 }
 281
 282 void sipmsg_remove_header_now(struct sipmsg *msg, const gchar *name) {
 283         struct sipnameval *elem;
 284         GSList *tmp = msg->headers;
 285         while(tmp) {
 286                 elem = tmp->data;
 287                 // OCS2005 can send the same header in either all caps or mixed case
 288                 if (sipe_strcase_equal(elem->name, name)) {
 289                         msg->headers = g_slist_remove(msg->headers, elem);
 290                         g_free(elem->name);
 291                         g_free(elem->value);
 292                         g_free(elem);
 293                         return;
 294                 }
 295                 tmp = g_slist_next(tmp);
 296         }
 297         return;
 298 }
 299
 300 const gchar *sipmsg_find_header(const struct sipmsg *msg, const gchar *name) {
 301         return sipe_utils_nameval_find_instance (msg->headers, name, 0);
 302 }
 303
 304 const gchar *sipmsg_find_header_instance(const struct sipmsg *msg, const gchar *name, int which) {
 305         return sipe_utils_nameval_find_instance(msg->headers, name, which);
 306 }
 307
 308 gchar *sipmsg_find_part_of_header(const char *hdr, const char * before, const char * after, const char * def) {
 309         const char *tmp;
 310         const char *tmp2;
 311         gchar *res2;
 312         if (!hdr) {
 313                 return NULL;
 314         }
 315
 316         //printf("partof %s w/ %s before and %s after\n", hdr, before, after);
 317
 318         tmp = before == NULL ? hdr : strstr(hdr, before);
 319         if (!tmp) {
 320                 //printf ("not found, returning null\n");
 321                 return (gchar *)def;
 322         }
 323
 324         if (before != NULL) {
 325                 tmp += strlen(before);
 326                 //printf ("tmp now %s\n", tmp);
 327         }
 328
 329         if (after != NULL && (tmp2 = strstr(tmp, after))) {
 330                 gchar * res = g_strndup(tmp, tmp2 - tmp);
 331                 //printf("returning %s\n", res);
 332                 return res;
 333         }
 334         res2 = g_strdup(tmp);
 335         //printf("returning %s\n", res2);
 336         return res2;
 337 }
 338
 339 int sipmsg_parse_cseq(struct sipmsg *msg)
 340 {
 341         int res = -1;
 342         gchar **items;
 343         items = g_strsplit(sipmsg_find_header(msg, "CSeq"), " ", 1);
 344         if (items[0]) {
 345                 res = atoi(items[0]);
 346         }
 347         g_strfreev(items);
 348         return res;
 349 }
 350
 351 /**
 352  * Parse EndPoints header from INVITE request
 353  * Returns a list of end points: contact URI plus optional epid.
 354  * You must free the values and the list.
 355  *
 356  * Example headers:
 357  * EndPoints: "alice alisson" <sip:alice@atlanta.local>, <sip:bob@atlanta.local>;epid=ebca82d94d, <sip:carol@atlanta.local>
 358  * EndPoints: "alice, alisson" <sip:alice@atlanta.local>, <sip:bob@atlanta.local>
 359  * EndPoints: "alice alisson" <sip:alice@atlanta.local>, "Super, Man" <sip:super@atlanta.local>
 360  *
 361  * @param header (in) EndPoints header contents
 362  *
 363  * @return GSList with struct sipendpoint as elements
 364  */
 365 GSList *sipmsg_parse_endpoints_header(const gchar *header)
 366 {
 367         GSList *list = NULL;
 368         gchar **parts = g_strsplit(header, ",", 0);
 369         gchar *part;
 370         int i;
 371
 372         for (i = 0; (part = parts[i]) != NULL; i++) {
 373                 /* Does the part contain a URI? */
 374                 gchar *contact = sipmsg_find_part_of_header(part, "<", ">", NULL);
 375                 if (contact) {
 376                         struct sipendpoint *end_point = g_new(struct sipendpoint, 1);
 377                         end_point->contact = contact;
 378                         end_point->epid = sipmsg_find_part_of_header(part, "epid=", NULL, NULL);
 379                         list = g_slist_append(list, end_point);
 380                 }
 381         }
 382         g_strfreev(parts);
 383
 384         return(list);
 385 }
 386
 387 void sipmsg_parse_p_asserted_identity(const gchar *header, gchar **sip_uri,
 388                                       gchar **tel_uri) {
 389         gchar **parts, **p;
 390
 391         *sip_uri = NULL;
 392         *tel_uri = NULL;
 393
 394         if (g_ascii_strncasecmp(header, "tel:", 4) == 0) {
 395                 *tel_uri = g_strdup(header);
 396                 return;
 397         }
 398
 399         parts = g_strsplit(header, ",", 0);
 400
 401         for (p = parts; *p; p++) {
 402                 gchar *uri = sipmsg_find_part_of_header(*p, "<", ">", NULL);
 403                 if (!uri)
 404                         continue;
 405
 406                 if (g_ascii_strncasecmp(uri, "sip:", 4) == 0) {
 407                         if (*sip_uri) {
 408                                 SIPE_DEBUG_WARNING_NOFORMAT("More than one "
 409                                         "sip: URI found in P-Asserted-Identity!");
 410                         } else {
 411                                 *sip_uri = uri;
 412                                 uri = NULL;
 413                         }
 414                 } else if (g_ascii_strncasecmp(uri, "tel:", 4) == 0){
 415                         if (*tel_uri) {
 416                                 SIPE_DEBUG_WARNING_NOFORMAT("More than one "
 417                                         "tel: URI found in P-Asserted-Identity!");
 418                         } else {
 419                                 *tel_uri = uri;
 420                                 uri = NULL;
 421                         }
 422                 }
 423
 424                 g_free(uri);
 425         }
 426
 427         g_strfreev(parts);
 428 }
 429
 430 /*
 431  *  sipmsg_find_auth_header will return the particular WWW-Authenticate
 432  *  header specified by *name.
 433  *
 434  *  Use this function when you want to look for a specific authentication
 435  *  method such as NTLM or Kerberos
 436  */
 437
 438 const gchar *sipmsg_find_auth_header(struct sipmsg *msg, const gchar *name) {
 439         GSList *tmp;
 440         struct sipnameval *elem;
 441         int name_len;
 442
 443         if (!name) {
 444                 SIPE_DEBUG_INFO_NOFORMAT("sipmsg_find_auth_header: no authentication scheme specified");
 445                 return NULL;
 446         }
 447
 448         name_len = strlen(name);
 449         tmp = msg->headers;
 450         while(tmp) {
 451                 elem = tmp->data;
 452                 /* SIPE_DEBUG_INFO("Current header: %s", elem->value); */
 453                 if (elem && elem->name &&
 454                     (sipe_strcase_equal(elem->name,"WWW-Authenticate") ||
 455                      sipe_strcase_equal(elem->name,"Authentication-Info")) ) {
 456                         if (!g_ascii_strncasecmp((gchar *)elem->value, name, name_len)) {
 457                                 /* SIPE_DEBUG_INFO("elem->value: %s", elem->value); */
 458                                 return elem->value;
 459                         }
 460                 }
 461                 /* SIPE_DEBUG_INFO_NOFORMAT("moving to next header"); */
 462                 tmp = g_slist_next(tmp);
 463         }
 464         SIPE_DEBUG_INFO("sipmsg_find_auth_header: '%s' not found", name);
 465         return NULL;
 466 }
 467
 468 /**
 469  * Parses headers-like 'msgr' attribute of INVITE's 'ms_text_format' header.
 470  * Then retrieves value of 'X-MMS-IM-Format'.
 471
 472  * 'msgr' typically looks like:
 473  * X-MMS-IM-Format: FN=Microsoft%20Sans%20Serif; EF=BI; CO=800000; CS=0; PF=22
 474  */
 475 static gchar *sipmsg_get_x_mms_im_format(gchar *msgr) {
 476         gchar *msgr2;
 477         gsize msgr_dec64_len;
 478         guchar *msgr_dec64;
 479         gchar *msgr_utf8;
 480         gchar **lines;
 481         gchar **parts;
 482         gchar *x_mms_im_format;
 483         gchar *tmp;
 484
 485         if (!msgr) return NULL;
 486         msgr2 = g_strdup(msgr);
 487         while (strlen(msgr2) % 4 != 0) {
 488                 gchar *tmp_msgr2 = msgr2;
 489                 msgr2 = g_strdup_printf("%s=", msgr2);
 490                 g_free(tmp_msgr2);
 491         }
 492         msgr_dec64 = g_base64_decode(msgr2, &msgr_dec64_len);
 493         msgr_utf8 = g_convert((gchar *) msgr_dec64, msgr_dec64_len, "UTF-8", "UTF-16LE", NULL, NULL, NULL);
 494         g_free(msgr_dec64);
 495         g_free(msgr2);
 496         lines = g_strsplit(msgr_utf8,"\r\n\r\n",0);
 497         g_free(msgr_utf8);
 498         //@TODO: make extraction like parsing of message headers.
 499         parts = g_strsplit(lines[0],"X-MMS-IM-Format:",0);
 500         x_mms_im_format = g_strdup(parts[1]);
 501         g_strfreev(parts);
 502         g_strfreev(lines);
 503         tmp = x_mms_im_format;
 504         if (x_mms_im_format) {
 505                 while(*x_mms_im_format==' ' || *x_mms_im_format=='\t') x_mms_im_format++;
 506         }
 507         x_mms_im_format = g_strdup(x_mms_im_format);
 508         g_free(tmp);
 509         return x_mms_im_format;
 510 }
 511
 512 gchar *sipmsg_get_msgr_string(gchar *x_mms_im_format) {
 513         gchar *msgr_orig;
 514         gsize msgr_utf16_len;
 515         gchar *msgr_utf16;
 516         gchar *msgr_enc;
 517         gchar *res;
 518         int len;
 519
 520         if (!x_mms_im_format) return NULL;
 521         msgr_orig = g_strdup_printf("X-MMS-IM-Format: %s\r\n\r\n", x_mms_im_format);
 522         msgr_utf16 = g_convert(msgr_orig, -1, "UTF-16LE", "UTF-8", NULL, &msgr_utf16_len, NULL);
 523         g_free(msgr_orig);
 524         msgr_enc = g_base64_encode((guchar *) msgr_utf16, msgr_utf16_len);
 525         g_free(msgr_utf16);
 526         len = strlen(msgr_enc);
 527         while (msgr_enc[len - 1] == '=') len--;
 528         res = g_strndup(msgr_enc, len);
 529         g_free(msgr_enc);
 530         return res;
 531 }
 532
 533 static void msn_parse_format(const char *mime, char **pre_ret, char **post_ret);
 534
 535 /**
 536  * Translates X-MMS-IM format to HTML presentation.
 537  */
 538 static gchar *sipmsg_apply_x_mms_im_format(const char *x_mms_im_format, gchar *body) {
 539         char *pre, *post;
 540         gchar *res;
 541
 542         if (!x_mms_im_format) {
 543                 return body ? g_strdup(body) : NULL;
 544         }
 545         msn_parse_format(x_mms_im_format, &pre, &post);
 546         res = g_strdup_printf("%s%s%s", pre ? pre :  "", body ? body : "", post ? post : "");
 547         g_free(pre);
 548         g_free(post);
 549         return res;
 550 }
 551
 552 struct html_message_data {
 553         gchar *ms_text_format;
 554         gchar *body;
 555         gboolean preferred;
 556 };
 557
 558 static void get_html_message_mime_cb(gpointer user_data,
 559                                      const GSList *fields,
 560                                      const gchar *body,
 561                                      gsize length)
 562 {
 563         const gchar *type = sipe_utils_nameval_find(fields, "Content-Type");
 564         struct html_message_data *data = user_data;
 565
 566         if (!data->preferred) {
 567                 gboolean copy = FALSE;
 568
 569                 /* preferred formats */
 570                 if (g_str_has_prefix(type, "text/html") ||
 571                     g_str_has_prefix(type, "text/rtf")) {
 572                         copy = TRUE;
 573                         data->preferred = TRUE;
 574
 575                 /* fallback format */
 576                 } else if (g_str_has_prefix(type, "text/plain")) {
 577                         copy = TRUE;
 578                 }
 579
 580                 if (copy) {
 581                         g_free(data->ms_text_format);
 582                         g_free(data->body);
 583                         data->ms_text_format = g_strdup(type);
 584                         data->body = g_strndup(body, length);
 585                 }
 586         }
 587 }
 588
 589 /* ms-text-format: text/plain; charset=UTF-8;msgr=WAAtAE0...DIADQAKAA0ACgA;ms-body=SGk= */
 590 gchar *get_html_message(const gchar *ms_text_format_in, const gchar *body_in)
 591 {
 592         gchar *msgr;
 593         gchar *res;
 594         gchar *ms_text_format = NULL;
 595         gchar *body = NULL;
 596
 597         if (g_str_has_prefix(ms_text_format_in, "multipart/related") ||
 598             g_str_has_prefix(ms_text_format_in, "multipart/alternative")) {
 599                 struct html_message_data data = { NULL, NULL, FALSE };
 600
 601                 sipe_mime_parts_foreach(ms_text_format_in, body_in,
 602                                         get_html_message_mime_cb, &data);
 603
 604                 ms_text_format = data.ms_text_format;
 605                 body = data.body;
 606
 607         } else {
 608                 ms_text_format = g_strdup(ms_text_format_in);
 609                 body = g_strdup(body_in);
 610         }
 611
 612         if (body) {
 613                 res = body;
 614         } else {
 615                 gchar *tmp = sipmsg_find_part_of_header(ms_text_format, "ms-body=", NULL, NULL);
 616                 gsize len;
 617                 if (!tmp) {
 618                         g_free(ms_text_format);
 619                         return NULL;
 620                 }
 621                 res = (gchar *) g_base64_decode(tmp, &len);
 622                 g_free(tmp);
 623                 if (!res) {
 624                         g_free(ms_text_format);
 625                         return NULL;
 626                 }
 627         }
 628
 629         if (g_str_has_prefix(ms_text_format, "text/html")) {
 630                 /*
 631                  * HTML uses tags for formatting, not line breaks. But
 632                  * clients still might render them, so we need to remove
 633                  * them to avoid incorrect text rendering.
 634                  */
 635                 gchar *d = res;
 636                 const gchar *s = res;
 637                 gchar c;
 638
 639                 /* No ANSI C nor glib function seems to exist for this :-( */
 640                 while ((c = *s++))
 641                         if ((c != '\n') && (c != '\r'))
 642                                 *d++ = c;
 643                 *d = c;
 644
 645         } else if (g_str_has_prefix(ms_text_format, "text/rtf")) {
 646                 char *tmp = res;
 647                 res = sipe_rtf_to_html(res);
 648                 g_free(tmp);
 649         } else {
 650                 char *tmp = res;
 651                 res = g_markup_escape_text(res, -1); // as this is not html
 652                 g_free(tmp);
 653         }
 654
 655         msgr = sipmsg_find_part_of_header(ms_text_format, "msgr=", ";", NULL);
 656         if (msgr) {
 657                 gchar *x_mms_im_format = sipmsg_get_x_mms_im_format(msgr);
 658                 gchar *tmp = res;
 659                 g_free(msgr);
 660                 res = sipmsg_apply_x_mms_im_format(x_mms_im_format, res);
 661                 g_free(tmp);
 662                 g_free(x_mms_im_format);
 663         }
 664
 665         g_free(ms_text_format);
 666
 667         return res;
 668 }
 669
 670 static gchar *
 671 get_reason(struct sipmsg *msg, const gchar *header)
 672 {
 673         const gchar *diagnostics = sipmsg_find_header(msg, header);
 674         if (diagnostics)
 675                 return sipmsg_find_part_of_header(diagnostics, "reason=\"", "\"", NULL);
 676
 677         return NULL;
 678 }
 679
 680 gchar *
 681 sipmsg_get_ms_diagnostics_reason(struct sipmsg *msg)
 682 {
 683         return get_reason(msg, "ms-diagnostics");
 684 }
 685
 686 gchar *
 687 sipmsg_get_ms_diagnostics_public_reason(struct sipmsg *msg)
 688 {
 689         return get_reason(msg, "ms-diagnostics-public");
 690 }
 691
 692 int
 693 sipmsg_parse_warning(struct sipmsg *msg, gchar **reason)
 694 {
 695         /*
 696          * Example header:
 697          * Warning: 310 lcs.microsoft.com "You are currently not using the recommended version of the client"
 698          */
 699         const gchar *hdr = sipmsg_find_header(msg, "Warning");
 700         int code = -1;
 701
 702         if (reason)
 703                 *reason = NULL;
 704
 705         if (hdr) {
 706                 gchar **parts = g_strsplit(hdr, " ", 3);
 707
 708                 if (parts[0]) {
 709                         code = atoi(parts[0]);
 710
 711                         if (reason && parts[1] && parts[2]) {
 712                                 size_t len = strlen(parts[2]);
 713                                 if (len > 2 && parts[2][0] == '"' && parts[2][len - 1] == '"')
 714                                         *reason = g_strndup(parts[2] + 1, len - 2);
 715                         }
 716                 }
 717
 718                 g_strfreev(parts);
 719         }
 720
 721         return code;
 722 }
 723
 724 gchar *sipmsg_parse_address_from_header(struct sipmsg *msg,
 725                                         const gchar *name) {
 726         return(parse_from(sipmsg_find_header(msg, name)));
 727 }
 728
 729 gchar *sipmsg_parse_from_address(struct sipmsg *msg) {
 730         return(sipmsg_parse_address_from_header(msg, "From"));
 731 }
 732
 733 gchar *sipmsg_parse_to_address(struct sipmsg *msg) {
 734         return(sipmsg_parse_address_from_header(msg, "To"));
 735 }
 736
 737 void sipmsg_update_to_header_tag(struct sipmsg *msg) {
 738         const gchar *old = sipmsg_find_header(msg, "To");
 739         gchar *tag       = gentag();
 740         gchar *new       = g_strdup_printf("%s;tag=%s", old, tag);
 741         g_free(tag);
 742         sipmsg_remove_header_now(msg, "To");
 743         sipmsg_add_header_now(msg, "To", new);
 744         g_free(new);
 745 }
 746
 747
 748 //------------------------------------------------------------------------------------------
 749 //TEMP solution to include it here (copy from purple's msn protocol
 750 //How to reuse msn's util methods from sipe?
 751
 752 /* from internal.h */
 753 #define MSG_LEN 2048
 754 #define BUF_LEN MSG_LEN
 755
 756 void
 757 msn_parse_format(const char *mime, char **pre_ret, char **post_ret)
 758 {
 759         char *cur;
 760         GString *pre  = g_string_new(NULL);
 761         GString *post = g_string_new(NULL);
 762         unsigned int colors[3];
 763
 764         if (pre_ret  != NULL) *pre_ret  = NULL;
 765         if (post_ret != NULL) *post_ret = NULL;
 766
 767         cur = strstr(mime, "FN=");
 768
 769         if (cur && (*(cur = cur + 3) != ';'))
 770         {
 771                 pre = g_string_append(pre, "<FONT FACE=\"");
 772
 773                 while (*cur && *cur != ';')
 774                 {
 775                         pre = g_string_append_c(pre, *cur);
 776                         cur++;
 777                 }
 778
 779                 pre = g_string_append(pre, "\">");
 780                 post = g_string_prepend(post, "</FONT>");
 781         }
 782
 783         cur = strstr(mime, "EF=");
 784
 785         if (cur && (*(cur = cur + 3) != ';'))
 786         {
 787                 while (*cur && *cur != ';')
 788                 {
 789                         pre = g_string_append_c(pre, '<');
 790                         pre = g_string_append_c(pre, *cur);
 791                         pre = g_string_append_c(pre, '>');
 792                         post = g_string_prepend_c(post, '>');
 793                         post = g_string_prepend_c(post, *cur);
 794                         post = g_string_prepend_c(post, '/');
 795                         post = g_string_prepend_c(post, '<');
 796                         cur++;
 797                 }
 798         }
 799
 800         cur = strstr(mime, "CO=");
 801
 802         if (cur && (*(cur = cur + 3) != ';'))
 803         {
 804                 int i;
 805
 806                 i = sscanf(cur, "%02x%02x%02x;", &colors[0], &colors[1], &colors[2]);
 807
 808                 if (i > 0)
 809                 {
 810                         char tag[64];
 811
 812                         if (i == 1)
 813                         {
 814                                 colors[1] = 0;
 815                                 colors[2] = 0;
 816                         }
 817                         else if (i == 2)
 818                         {
 819                                 unsigned int temp = colors[0];
 820
 821                                 colors[0] = colors[1];
 822                                 colors[1] = temp;
 823                                 colors[2] = 0;
 824                         }
 825                         else if (i == 3)
 826                         {
 827                                 unsigned int temp = colors[2];
 828
 829                                 colors[2] = colors[0];
 830                                 colors[0] = temp;
 831                         }
 832
 833                         /* hh is undefined in mingw's gcc 4.4
 834                          *  https://sourceforge.net/tracker/index.php?func=detail&aid=2818436&group_id=2435&atid=102435
 835                          */
 836                         g_snprintf(tag, sizeof(tag),
 837                                            "<FONT COLOR=\"#%02x%02x%02x\">",
 838                                            (unsigned char)colors[0], (unsigned char)colors[1], (unsigned char)colors[2]);
 839
 840                         pre = g_string_append(pre, tag);
 841                         post = g_string_prepend(post, "</FONT>");
 842                 }
 843         }
 844
 845         cur = strstr(mime, "RL=");
 846
 847         if (cur && (*(cur = cur + 3) != ';'))
 848         {
 849                 if (*cur == '1')
 850                 {
 851                         /* RTL text was received */
 852                         pre = g_string_append(pre, "<SPAN style=\"direction:rtl;text-align:right;\">");
 853                         post = g_string_prepend(post, "</SPAN>");
 854                 }
 855         }
 856
 857         cur = sipe_utils_uri_unescape(pre->str);
 858         g_string_free(pre, TRUE);
 859
 860         if (pre_ret != NULL)
 861                 *pre_ret = cur;
 862         else
 863                 g_free(cur);
 864
 865         cur = sipe_utils_uri_unescape(post->str);
 866         g_string_free(post, TRUE);
 867
 868         if (post_ret != NULL)
 869                 *post_ret = cur;
 870         else
 871                 g_free(cur);
 872 }
 873
 874 static const char *
 875 encode_spaces(const char *str)
 876 {
 877         static char buf[BUF_LEN];
 878         const char *c;
 879         char *d;
 880
 881         g_return_val_if_fail(str != NULL, NULL);
 882
 883         for (c = str, d = buf; *c != '\0'; c++)
 884         {
 885                 if (*c == ' ')
 886                 {
 887                         *d++ = '%';
 888                         *d++ = '2';
 889                         *d++ = '0';
 890                 }
 891                 else
 892                         *d++ = *c;
 893         }
 894         *d = '\0';
 895
 896         return buf;
 897 }
 898
 899 void
 900 sipe_parse_html(const char *html, char **attributes, char **message)
 901 {
 902         int len, retcount = 0;
 903         const char *c;
 904         char *msg;
 905         char *fontface = NULL;
 906         char fonteffect[4];
 907         char fontcolor[7];
 908         char direction = '0';
 909
 910         gboolean has_bold = FALSE;
 911         gboolean has_italic = FALSE;
 912         gboolean has_underline = FALSE;
 913         gboolean has_strikethrough = FALSE;
 914
 915         g_return_if_fail(html       != NULL);
 916         g_return_if_fail(attributes != NULL);
 917         g_return_if_fail(message    != NULL);
 918
 919 #define _HTML_UNESCAPE \
 920         if (!g_ascii_strncasecmp(c, "&lt;", 4)) { \
 921                 msg[retcount++] = '<'; \
 922                 c += 4; \
 923         } else if (!g_ascii_strncasecmp(c, "&gt;", 4)) { \
 924                 msg[retcount++] = '>'; \
 925                 c += 4; \
 926         } else if (!g_ascii_strncasecmp(c, "&nbsp;", 6)) { \
 927                 msg[retcount++] = ' '; \
 928                 c += 6; \
 929         } else if (!g_ascii_strncasecmp(c, "&quot;", 6)) { \
 930                 msg[retcount++] = '"'; \
 931                 c += 6; \
 932         } else if (!g_ascii_strncasecmp(c, "&amp;", 5)) { \
 933                 msg[retcount++] = '&'; \
 934                 c += 5; \
 935         } else if (!g_ascii_strncasecmp(c, "&apos;", 6)) { \
 936                 msg[retcount++] = '\''; \
 937                 c += 6; \
 938         } else { \
 939                 msg[retcount++] = *c++; \
 940         }
 941
 942         len = strlen(html);
 943         msg = g_malloc0(len + 1);
 944
 945         memset(fontcolor, 0, sizeof(fontcolor));
 946         strcat(fontcolor, "0");
 947         memset(fonteffect, 0, sizeof(fonteffect));
 948
 949         for (c = html; *c != '\0';)
 950         {
 951                 if (*c == '<')
 952                 {
 953                         if (!g_ascii_strncasecmp(c + 1, "br>", 3))
 954                         {
 955                                 msg[retcount++] = '\r';
 956                                 msg[retcount++] = '\n';
 957                                 c += 4;
 958                         }
 959                         else if (!g_ascii_strncasecmp(c + 1, "div>", 4))
 960                         {
 961                                 msg[retcount++] = '\r';
 962                                 msg[retcount++] = '\n';
 963                                 c += 5;
 964                                 if (!g_ascii_strncasecmp(c, "<br></div>", 10)) {
 965                                         /* This is an empty paragraph; replace it with
 966                                          * one line break. */
 967                                         c += 10;
 968                                 }
 969                         }
 970                         else if (!g_ascii_strncasecmp(c + 1, "i>", 2))
 971                         {
 972                                 if (!has_italic)
 973                                 {
 974                                         strcat(fonteffect, "I");
 975                                         has_italic = TRUE;
 976                                 }
 977                                 c += 3;
 978                         }
 979                         else if (!g_ascii_strncasecmp(c + 1, "b>", 2))
 980                         {
 981                                 if (!has_bold)
 982                                 {
 983                                         strcat(fonteffect, "B");
 984                                         has_bold = TRUE;
 985                                 }
 986                                 c += 3;
 987                         }
 988                         else if (!g_ascii_strncasecmp(c + 1, "u>", 2))
 989                         {
 990                                 if (!has_underline)
 991                                 {
 992                                         strcat(fonteffect, "U");
 993                                         has_underline = TRUE;
 994                                 }
 995                                 c += 3;
 996                         }
 997                         else if (!g_ascii_strncasecmp(c + 1, "s>", 2))
 998                         {
 999                                 if (!has_strikethrough)
1000                                 {
1001                                         strcat(fonteffect, "S");
1002                                         has_strikethrough = TRUE;
1003                                 }
1004                                 c += 3;
1005                         }
1006                         else if (!g_ascii_strncasecmp(c + 1, "a href=\"", 8))
1007                         {
1008                                 c += 9;
1009
1010                                 if (!g_ascii_strncasecmp(c, "mailto:", 7))
1011                                         c += 7;
1012
1013                                 while ((*c != '\0') && g_ascii_strncasecmp(c, "\">", 2))
1014                                         if (*c == '&') {
1015                                                 _HTML_UNESCAPE;
1016                                         } else
1017                                                 msg[retcount++] = *c++;
1018
1019                                 if (*c != '\0')
1020                                         c += 2;
1021
1022                                 /* ignore descriptive string */
1023                                 while ((*c != '\0') && g_ascii_strncasecmp(c, "</a>", 4))
1024                                         c++;
1025
1026                                 if (*c != '\0')
1027                                         c += 4;
1028                         }
1029                         else if (!g_ascii_strncasecmp(c + 1, "span", 4))
1030                         {
1031                                 /* Bi-directional text support using CSS properties in span tags */
1032                                 c += 5;
1033
1034                                 while (*c != '\0' && *c != '>')
1035                                 {
1036                                         while (*c == ' ')
1037                                                 c++;
1038                                         if (!g_ascii_strncasecmp(c, "dir=\"rtl\"", 9))
1039                                         {
1040                                                 c += 9;
1041                                                 direction = '1';
1042                                         }
1043                                         else if (!g_ascii_strncasecmp(c, "style=\"", 7))
1044                                         {
1045                                                 /* Parse inline CSS attributes */
1046                                                 int attr_len = 0;
1047                                                 c += 7;
1048                                                 while (*(c + attr_len) != '\0' && *(c + attr_len) != '"')
1049                                                         attr_len++;
1050                                                 if (*(c + attr_len) == '"')
1051                                                 {
1052                                                         char *css_attributes;
1053                                                         char *attr_dir;
1054                                                         css_attributes = g_strndup(c, attr_len);
1055                                                         attr_dir = sipe_backend_markup_css_property(css_attributes, "direction");
1056                                                         g_free(css_attributes);
1057                                                         if (attr_dir && (!g_ascii_strncasecmp(attr_dir, "RTL", 3)))
1058                                                                 direction = '1';
1059                                                         g_free(attr_dir);
1060                                                 }
1061
1062                                         }
1063                                         else
1064                                         {
1065                                                 c++;
1066                                         }
1067                                 }
1068                                 if (*c == '>')
1069                                         c++;
1070                         }
1071                         else if (!g_ascii_strncasecmp(c + 1, "font", 4))
1072                         {
1073                                 c += 5;
1074
1075                                 while ((*c != '\0') && !g_ascii_strncasecmp(c, " ", 1))
1076                                         c++;
1077
1078                                 if (!g_ascii_strncasecmp(c, "color=\"#", 7))
1079                                 {
1080                                         c += 8;
1081
1082                                         fontcolor[0] = *(c + 4);
1083                                         fontcolor[1] = *(c + 5);
1084                                         fontcolor[2] = *(c + 2);
1085                                         fontcolor[3] = *(c + 3);
1086                                         fontcolor[4] = *c;
1087                                         fontcolor[5] = *(c + 1);
1088
1089                                         c += 8;
1090                                 }
1091                                 else if (!g_ascii_strncasecmp(c, "face=\"", 6))
1092                                 {
1093                                         const char *end = NULL;
1094                                         const char *comma = NULL;
1095                                         unsigned int namelen = 0;
1096
1097                                         c += 6;
1098                                         end = strchr(c, '\"');
1099                                         comma = strchr(c, ',');
1100
1101                                         if (comma == NULL || comma > end)
1102                                                 namelen = (unsigned int)(end - c);
1103                                         else
1104                                                 namelen = (unsigned int)(comma - c);
1105
1106                                         g_free(fontface);
1107                                         fontface = g_strndup(c, namelen);
1108                                         c = end + 2;
1109                                 }
1110                                 else
1111                                 {
1112                                         /* Drop all unrecognized/misparsed font tags */
1113                                         while ((*c != '\0') && g_ascii_strncasecmp(c, "\">", 2))
1114                                                 c++;
1115
1116                                         if (*c != '\0')
1117                                                 c += 2;
1118                                 }
1119                         }
1120                         else
1121                         {
1122                                 while ((*c != '\0') && (*c != '>'))
1123                                         c++;
1124                                 if (*c != '\0')
1125                                         c++;
1126                         }
1127                 }
1128                 else if (*c == '&')
1129                 {
1130                         _HTML_UNESCAPE;
1131                 }
1132                 else
1133                         msg[retcount++] = *c++;
1134         }
1135
1136         if (fontface == NULL)
1137                 fontface = g_strdup("MS Sans Serif");
1138
1139         *attributes = g_strdup_printf("FN=%s; EF=%s; CO=%s; PF=0; RL=%c",
1140                                                                   encode_spaces(fontface),
1141                                                                   fonteffect, fontcolor, direction);
1142         *message = msg;
1143
1144         g_free(fontface);
1145
1146 #undef _HTML_UNESCAPE
1147 }
1148 // End of TEMP
1149
1150 /*
1151   Local Variables:
1152   mode: c
1153   c-file-style: "bsd"
1154   indent-tabs-mode: t
1155   tab-width: 8
1156   End:
1157 */