src/core/sipmsg.c

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