src/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 #ifndef _WIN32
  25 #include <sys/socket.h>
  26 #include <sys/ioctl.h>
  27 #include <sys/types.h>
  28 #include <netinet/in.h>
  29 #include <net/if.h>
  30 #else /* _WIN32 */
  31 #ifdef _DLL
  32 #define _WS2TCPIP_H_
  33 #define _WINSOCK2API_
  34 #define _LIBC_INTERNAL_
  35 #endif /* _DLL */
  36
  37 #include "internal.h"
  38 #endif /* _WIN32 */
  39
  40 #include <string.h>
  41
  42 #include "accountopt.h"
  43 #include "blist.h"
  44 #include "conversation.h"
  45 #include "debug.h"
  46 #include "notify.h"
  47 #include "prpl.h"
  48 #include "plugin.h"
  49 #include "util.h"
  50 #include "version.h"
  51
  52 #include "sipe.h"
  53 #include "sipmsg.h"
  54
  55 struct sipmsg *sipmsg_parse_msg(const gchar *msg) {
  56         const char *tmp = strstr(msg, "\r\n\r\n");
  57         char *line;
  58         struct sipmsg *smsg;
  59
  60         if(!tmp) return NULL;
  61
  62         line = g_strndup(msg, tmp - msg);
  63
  64         smsg = sipmsg_parse_header(line);
  65         smsg->body = g_strdup(tmp + 4);
  66
  67         g_free(line);
  68         return smsg;
  69 }
  70
  71 struct sipmsg *sipmsg_parse_header(const gchar *header) {
  72         struct sipmsg *msg = g_new0(struct sipmsg,1);
  73         gchar **lines = g_strsplit(header,"\r\n",0);
  74         gchar **parts;
  75         gchar *dummy;
  76         gchar *dummy2;
  77         gchar *tmp;
  78         gchar *contentlength;
  79         int i=1;
  80         if(!lines[0]) return NULL;
  81         parts = g_strsplit(lines[0], " ", 3);
  82         if(!parts[0] || !parts[1] || !parts[2]) {
  83                 g_strfreev(parts);
  84                 g_strfreev(lines);
  85                 g_free(msg);
  86                 return NULL;
  87         }
  88         if(strstr(parts[0],"SIP")) { /* numeric response */
  89                 msg->method = g_strdup(parts[2]);
  90                 msg->response = strtol(parts[1],NULL,10);
  91         } else { /* request */
  92                 msg->method = g_strdup(parts[0]);
  93                 msg->target = g_strdup(parts[1]);
  94                 msg->response = 0;
  95         }
  96         g_strfreev(parts);
  97         for(i=1; lines[i] && strlen(lines[i])>2; i++) {
  98                 parts = g_strsplit(lines[i], ":", 2);
  99                 if(!parts[0] || !parts[1]) {
 100                         g_strfreev(parts);
 101                         g_strfreev(lines);
 102                         sipmsg_free(msg);
 103                         return NULL;
 104                 }
 105                 dummy = parts[1];
 106                 dummy2 = 0;
 107                 while(*dummy==' ' || *dummy=='\t') dummy++;
 108                 dummy2 = g_strdup(dummy);
 109                 while(lines[i+1] && (lines[i+1][0]==' ' || lines[i+1][0]=='\t')) {
 110                         i++;
 111                         dummy = lines[i];
 112                         while(*dummy==' ' || *dummy=='\t') dummy++;
 113                         tmp = g_strdup_printf("%s %s",dummy2, dummy);
 114                         g_free(dummy2);
 115                         dummy2 = tmp;
 116                 }
 117                 sipmsg_add_header(msg, parts[0], dummy2);
 118                 g_free(dummy2);
 119                 g_strfreev(parts);
 120         }
 121         g_strfreev(lines);
 122         contentlength = sipmsg_find_header(msg, "Content-Length");
 123         if (contentlength) {
 124                 msg->bodylen = strtol(contentlength,NULL,10);
 125         } else {
 126                 purple_debug_fatal("sipe", "sipmsg_parse_header(): Content-Length header not found\n");
 127         }
 128         if(msg->response) {
 129                 g_free(msg->method);
 130                 tmp = sipmsg_find_header(msg, "CSeq");
 131                 if(!tmp) {
 132                         /* SHOULD NOT HAPPEN */
 133                         msg->method = 0;
 134                 } else {
 135                         parts = g_strsplit(tmp, " ", 2);
 136                         msg->method = g_strdup(parts[1]);
 137                         g_strfreev(parts);
 138                 }
 139         }
 140         return msg;
 141 }
 142
 143 void sipmsg_print(const struct sipmsg *msg) {
 144         GSList *cur;
 145         struct siphdrelement *elem;
 146         purple_debug(PURPLE_DEBUG_MISC, "sipe", "SIP MSG\n");
 147         purple_debug(PURPLE_DEBUG_MISC, "sipe", "response: %d\nmethod: %s\nbodylen: %d\n",msg->response,msg->method,msg->bodylen);
 148         if(msg->target) purple_debug(PURPLE_DEBUG_MISC, "sipe", "target: %s\n",msg->target);
 149         cur = msg->headers;
 150         while(cur) {
 151                 elem = cur->data;
 152                 purple_debug(PURPLE_DEBUG_MISC, "sipe", "name: %s value: %s\n",elem->name, elem->value);
 153                 cur = g_slist_next(cur);
 154         }
 155 }
 156
 157 char *sipmsg_to_string(const struct sipmsg *msg) {
 158         GSList *cur;
 159         GString *outstr = g_string_new("");
 160         struct siphdrelement *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(!strcmp(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 void sipmsg_add_header(struct sipmsg *msg, const gchar *name, const gchar *value) {
 188         struct siphdrelement *element = g_new0(struct siphdrelement,1);
 189         element->name = g_strdup(name);
 190         element->value = g_strdup(value);
 191         msg->headers = g_slist_append(msg->headers, element);
 192 }
 193
 194 void sipmsg_add_header_pos(struct sipmsg *msg, const gchar *name, const gchar *value, int pos) {
 195         struct siphdrelement *element = g_new0(struct siphdrelement,1);
 196         element->name = g_strdup(name);
 197         element->value = g_strdup(value);
 198         msg->headers = g_slist_insert(msg->headers, element,pos);
 199 }
 200
 201 void sipmsg_free(struct sipmsg *msg) {
 202         struct siphdrelement *elem;
 203         while(msg->headers) {
 204                 elem = msg->headers->data;
 205                 msg->headers = g_slist_remove(msg->headers,elem);
 206                 g_free(elem->name);
 207                 g_free(elem->value);
 208                 g_free(elem);
 209         }
 210         g_free(msg->signature);
 211         g_free(msg->rand);
 212         g_free(msg->num);
 213         g_free(msg->method);
 214         g_free(msg->target);
 215         g_free(msg->body);
 216         g_free(msg);
 217 }
 218
 219 void sipmsg_remove_header(struct sipmsg *msg, const gchar *name) {
 220         struct siphdrelement *elem;
 221         GSList *tmp = msg->headers;
 222         while(tmp) {
 223                 elem = tmp->data;
 224                 // OCS2005 can send the same header in either all caps or mixed case
 225                 if (g_ascii_strcasecmp(elem->name, name)==0) {
 226                         msg->headers = g_slist_remove(msg->headers, elem);
 227                         g_free(elem->name);
 228                         g_free(elem->value);
 229                         g_free(elem);
 230                         return;
 231                 }
 232                 tmp = g_slist_next(tmp);
 233         }
 234         return;
 235 }
 236
 237 gchar *sipmsg_find_header(struct sipmsg *msg, const gchar *name) {
 238         return sipmsg_find_header_instance (msg, name, 0);
 239 }
 240
 241 gchar *sipmsg_find_header_instance(struct sipmsg *msg, const gchar *name, int which) {
 242         GSList *tmp;
 243         struct siphdrelement *elem;
 244         int i = 0;
 245         tmp = msg->headers;
 246         while(tmp) {
 247                 elem = tmp->data;
 248                 // OCS2005 can send the same header in either all caps or mixed case
 249                 if (g_ascii_strcasecmp(elem->name,name)==0) {
 250                         if (i == which) {
 251                                 return elem->value;
 252                         }
 253                         i++;
 254                 }
 255                 tmp = g_slist_next(tmp);
 256         }
 257         return NULL;
 258 }
 259
 260 gchar *sipmsg_find_part_of_header(const char *hdr, const char * before, const char * after, const char * def) {
 261         const char *tmp;
 262         const char *tmp2;
 263         gchar *res2;
 264         if (!hdr) {
 265                 return NULL;
 266         }
 267
 268         //printf("partof %s w/ %s before and %s after\n", hdr, before, after);
 269
 270         tmp = before == NULL ? hdr : strstr(hdr, before);
 271         if (!tmp) {
 272                 //printf ("not found, returning null\n");
 273                 return (gchar *)def;
 274         }
 275
 276         if (before != NULL) {
 277                 tmp += strlen(before);
 278                 //printf ("tmp now %s\n", tmp);
 279         }
 280
 281         if (after != NULL && (tmp2 = strstr(tmp, after))) {
 282                 gchar * res = g_strndup(tmp, tmp2 - tmp);
 283                 //printf("returning %s\n", res);
 284                 return res;
 285         }
 286         res2 = g_strdup(tmp);
 287         //printf("returning %s\n", res2);
 288         return res2;
 289 }
 290
 291 /*
 292  *  sipmsg_find_auth_header will return the particular WWW-Authenticate
 293  *  header specified by *name.
 294  *
 295  *  Use this function when you want to look for a specific authentication
 296  *  method such as NTLM or Kerberos
 297  */
 298
 299 gchar *sipmsg_find_auth_header(struct sipmsg *msg, const gchar *name) {
 300         GSList *tmp;
 301         struct siphdrelement *elem;
 302         int name_len = strlen(name);
 303         tmp = msg->headers;
 304         while(tmp) {
 305                 elem = tmp->data;
 306                 //purple_debug(PURPLE_DEBUG_MISC, "sipmsg", "Current header: %s\r\n", elem->value);
 307                 if (elem && elem->name && !g_ascii_strcasecmp(elem->name,"WWW-Authenticate")) {
 308                         if (!g_strncasecmp((gchar *)elem->value, name, name_len)) {
 309                                 //purple_debug(PURPLE_DEBUG_MISC, "sipmsg", "elem->value: %s\r\n", elem->value);
 310                                 return elem->value;
 311                         }
 312                 }
 313                 //purple_debug(PURPLE_DEBUG_MISC, "sipmsg", "moving to next header\r\n");
 314                 tmp = g_slist_next(tmp);
 315         }
 316         purple_debug(PURPLE_DEBUG_MISC, "sipmsg", "Did not found auth header %s\r\n", name);
 317         return NULL;
 318 }
 319
 320 gchar *sipmsg_get_x_mms_im_format(gchar *msgr) {
 321         gchar *msgr2;
 322         gsize msgr_dec64_len;
 323         guchar *msgr_dec64;
 324         gchar *msgr_utf8;
 325         gchar **lines;
 326         gchar **parts;
 327         gchar *x_mms_im_format;
 328         gchar *tmp;
 329
 330         if (!msgr) return NULL;
 331         msgr2 = g_strdup(msgr);
 332         while (strlen(msgr2) % 4 != 0) {
 333                 gchar *tmp_msgr2 = msgr2;
 334                 msgr2 = g_strdup_printf("%s=", msgr2);
 335                 g_free(tmp_msgr2);
 336         }
 337         msgr_dec64 = purple_base64_decode(msgr2, &msgr_dec64_len);
 338         msgr_utf8 = g_convert(msgr_dec64, msgr_dec64_len, "UTF-8", "UTF-16LE", NULL, NULL, NULL);
 339         g_free(msgr_dec64);
 340         g_free(msgr2);
 341         lines = g_strsplit(msgr_utf8,"\r\n\r\n",0);
 342         g_free(msgr_utf8);
 343         //@TODO: make extraction like parsing of message headers.
 344         parts = g_strsplit(lines[0],"X-MMS-IM-Format:",0);
 345         x_mms_im_format = g_strdup(parts[1]);
 346         g_strfreev(parts);
 347         g_strfreev(lines);
 348         tmp = x_mms_im_format;
 349         if (x_mms_im_format) {
 350                 while(*x_mms_im_format==' ' || *x_mms_im_format=='\t') x_mms_im_format++;
 351         }
 352         x_mms_im_format = g_strdup(x_mms_im_format);
 353         g_free(tmp);
 354         return x_mms_im_format;
 355 }
 356
 357 gchar *sipmsg_get_msgr_string(gchar *x_mms_im_format) {
 358         gchar *msgr_orig;
 359         gsize msgr_utf16_len;
 360         gchar *msgr_utf16;
 361         gchar *msgr_enc;
 362         gchar *res;
 363         int len;
 364
 365         if (!x_mms_im_format) return NULL;
 366         msgr_orig = g_strdup_printf("X-MMS-IM-Format: %s\r\n\r\n", x_mms_im_format);
 367         msgr_utf16 = g_convert(msgr_orig, -1, "UTF-16LE", "UTF-8", NULL, &msgr_utf16_len, NULL);
 368         g_free(msgr_orig);
 369         msgr_enc = purple_base64_encode(msgr_utf16, msgr_utf16_len);
 370         g_free(msgr_utf16);
 371         len = strlen(msgr_enc);
 372         while (msgr_enc[len - 1] == '=') len--;
 373         res = g_strndup(msgr_enc, len);
 374         g_free(msgr_enc);
 375         return res;
 376 }
 377
 378 gchar *sipmsg_apply_x_mms_im_format(const char *x_mms_im_format, gchar *body) {
 379         char *pre, *post;
 380         gchar *res;
 381
 382         if (!x_mms_im_format) {
 383                 return body ? g_strdup(body) : NULL;
 384         }
 385         msn_parse_format(x_mms_im_format, &pre, &post);
 386         res = g_strdup_printf("%s%s%s", pre ? pre :  "", body ? body : "", post ? post : "");
 387         g_free(pre);
 388         g_free(post);
 389         return res;
 390 }
 391
 392
 393
 394
 395
 396 //------------------------------------------------------------------------------------------
 397 //TEMP solution to include it here (copy from purple's msn protocol
 398 //How to reuse msn's util methods from sipe?
 399
 400 // from internal.h for linux compilation
 401 #ifndef _WIN32
 402 #define MSG_LEN 2048
 403 #define BUF_LEN MSG_LEN
 404 #endif
 405 void
 406 msn_parse_format(const char *mime, char **pre_ret, char **post_ret)
 407 {
 408         char *cur;
 409         GString *pre  = g_string_new(NULL);
 410         GString *post = g_string_new(NULL);
 411         unsigned int colors[3];
 412
 413         if (pre_ret  != NULL) *pre_ret  = NULL;
 414         if (post_ret != NULL) *post_ret = NULL;
 415
 416         cur = strstr(mime, "FN=");
 417
 418         if (cur && (*(cur = cur + 3) != ';'))
 419         {
 420                 pre = g_string_append(pre, "<FONT FACE=\"");
 421
 422                 while (*cur && *cur != ';')
 423                 {
 424                         pre = g_string_append_c(pre, *cur);
 425                         cur++;
 426                 }
 427
 428                 pre = g_string_append(pre, "\">");
 429                 post = g_string_prepend(post, "</FONT>");
 430         }
 431
 432         cur = strstr(mime, "EF=");
 433
 434         if (cur && (*(cur = cur + 3) != ';'))
 435         {
 436                 while (*cur && *cur != ';')
 437                 {
 438                         pre = g_string_append_c(pre, '<');
 439                         pre = g_string_append_c(pre, *cur);
 440                         pre = g_string_append_c(pre, '>');
 441                         post = g_string_prepend_c(post, '>');
 442                         post = g_string_prepend_c(post, *cur);
 443                         post = g_string_prepend_c(post, '/');
 444                         post = g_string_prepend_c(post, '<');
 445                         cur++;
 446                 }
 447         }
 448
 449         cur = strstr(mime, "CO=");
 450
 451         if (cur && (*(cur = cur + 3) != ';'))
 452         {
 453                 int i;
 454
 455                 i = sscanf(cur, "%02x%02x%02x;", &colors[0], &colors[1], &colors[2]);
 456
 457                 if (i > 0)
 458                 {
 459                         char tag[64];
 460
 461                         if (i == 1)
 462                         {
 463                                 colors[1] = 0;
 464                                 colors[2] = 0;
 465                         }
 466                         else if (i == 2)
 467                         {
 468                                 unsigned int temp = colors[0];
 469
 470                                 colors[0] = colors[1];
 471                                 colors[1] = temp;
 472                                 colors[2] = 0;
 473                         }
 474                         else if (i == 3)
 475                         {
 476                                 unsigned int temp = colors[2];
 477
 478                                 colors[2] = colors[0];
 479                                 colors[0] = temp;
 480                         }
 481
 482                         g_snprintf(tag, sizeof(tag),
 483                                            "<FONT COLOR=\"#%02hhx%02hhx%02hhx\">",
 484                                            colors[0], colors[1], colors[2]);
 485
 486                         pre = g_string_append(pre, tag);
 487                         post = g_string_prepend(post, "</FONT>");
 488                 }
 489         }
 490
 491         cur = strstr(mime, "RL=");
 492
 493         if (cur && (*(cur = cur + 3) != ';'))
 494         {
 495                 if (*cur == '1')
 496                 {
 497                         /* RTL text was received */
 498                         pre = g_string_append(pre, "<SPAN style=\"direction:rtl;text-align:right;\">");
 499                         post = g_string_prepend(post, "</SPAN>");
 500                 }
 501         }
 502
 503         cur = g_strdup(purple_url_decode(pre->str));
 504         g_string_free(pre, TRUE);
 505
 506         if (pre_ret != NULL)
 507                 *pre_ret = cur;
 508         else
 509                 g_free(cur);
 510
 511         cur = g_strdup(purple_url_decode(post->str));
 512         g_string_free(post, TRUE);
 513
 514         if (post_ret != NULL)
 515                 *post_ret = cur;
 516         else
 517                 g_free(cur);
 518 }
 519
 520 static const char *
 521 encode_spaces(const char *str)
 522 {
 523         static char buf[BUF_LEN];
 524         const char *c;
 525         char *d;
 526
 527         g_return_val_if_fail(str != NULL, NULL);
 528
 529         for (c = str, d = buf; *c != '\0'; c++)
 530         {
 531                 if (*c == ' ')
 532                 {
 533                         *d++ = '%';
 534                         *d++ = '2';
 535                         *d++ = '0';
 536                 }
 537                 else
 538                         *d++ = *c;
 539         }
 540         *d = '\0';
 541
 542         return buf;
 543 }
 544
 545 void
 546 msn_import_html(const char *html, char **attributes, char **message)
 547 {
 548         int len, retcount = 0;
 549         const char *c;
 550         char *msg;
 551         char *fontface = NULL;
 552         char fonteffect[4];
 553         char fontcolor[7];
 554         char direction = '0';
 555
 556         gboolean has_bold = FALSE;
 557         gboolean has_italic = FALSE;
 558         gboolean has_underline = FALSE;
 559         gboolean has_strikethrough = FALSE;
 560
 561         g_return_if_fail(html       != NULL);
 562         g_return_if_fail(attributes != NULL);
 563         g_return_if_fail(message    != NULL);
 564
 565         len = strlen(html);
 566         msg = g_malloc0(len + 1);
 567
 568         memset(fontcolor, 0, sizeof(fontcolor));
 569         strcat(fontcolor, "0");
 570         memset(fonteffect, 0, sizeof(fonteffect));
 571
 572         for (c = html; *c != '\0';)
 573         {
 574                 if (*c == '<')
 575                 {
 576                         if (!g_ascii_strncasecmp(c + 1, "br>", 3))
 577                         {
 578                                 msg[retcount++] = '\r';
 579                                 msg[retcount++] = '\n';
 580                                 c += 4;
 581                         }
 582                         else if (!g_ascii_strncasecmp(c + 1, "i>", 2))
 583                         {
 584                                 if (!has_italic)
 585                                 {
 586                                         strcat(fonteffect, "I");
 587                                         has_italic = TRUE;
 588                                 }
 589                                 c += 3;
 590                         }
 591                         else if (!g_ascii_strncasecmp(c + 1, "b>", 2))
 592                         {
 593                                 if (!has_bold)
 594                                 {
 595                                         strcat(fonteffect, "B");
 596                                         has_bold = TRUE;
 597                                 }
 598                                 c += 3;
 599                         }
 600                         else if (!g_ascii_strncasecmp(c + 1, "u>", 2))
 601                         {
 602                                 if (!has_underline)
 603                                 {
 604                                         strcat(fonteffect, "U");
 605                                         has_underline = TRUE;
 606                                 }
 607                                 c += 3;
 608                         }
 609                         else if (!g_ascii_strncasecmp(c + 1, "s>", 2))
 610                         {
 611                                 if (!has_strikethrough)
 612                                 {
 613                                         strcat(fonteffect, "S");
 614                                         has_strikethrough = TRUE;
 615                                 }
 616                                 c += 3;
 617                         }
 618                         else if (!g_ascii_strncasecmp(c + 1, "a href=\"", 8))
 619                         {
 620                                 c += 9;
 621
 622                                 if (!g_ascii_strncasecmp(c, "mailto:", 7))
 623                                         c += 7;
 624
 625                                 while ((*c != '\0') && g_ascii_strncasecmp(c, "\">", 2))
 626                                         msg[retcount++] = *c++;
 627
 628                                 if (*c != '\0')
 629                                         c += 2;
 630
 631                                 /* ignore descriptive string */
 632                                 while ((*c != '\0') && g_ascii_strncasecmp(c, "</a>", 4))
 633                                         c++;
 634
 635                                 if (*c != '\0')
 636                                         c += 4;
 637                         }
 638                         else if (!g_ascii_strncasecmp(c + 1, "span", 4))
 639                         {
 640                                 /* Bi-directional text support using CSS properties in span tags */
 641                                 c += 5;
 642
 643                                 while (*c != '\0' && *c != '>')
 644                                 {
 645                                         while (*c == ' ')
 646                                                 c++;
 647                                         if (!g_ascii_strncasecmp(c, "dir=\"rtl\"", 9))
 648                                         {
 649                                                 c += 9;
 650                                                 direction = '1';
 651                                         }
 652                                         else if (!g_ascii_strncasecmp(c, "style=\"", 7))
 653                                         {
 654                                                 /* Parse inline CSS attributes */
 655                                                 char *attributes;
 656                                                 int attr_len = 0;
 657                                                 c += 7;
 658                                                 while (*(c + attr_len) != '\0' && *(c + attr_len) != '"')
 659                                                         attr_len++;
 660                                                 if (*(c + attr_len) == '"')
 661                                                 {
 662                                                         char *attr_dir;
 663                                                         attributes = g_strndup(c, attr_len);
 664                                                         attr_dir = purple_markup_get_css_property(attributes, "direction");
 665                                                         if (attr_dir && (!g_ascii_strncasecmp(attr_dir, "RTL", 3)))
 666                                                                 direction = '1';
 667                                                         g_free(attr_dir);
 668                                                         g_free(attributes);
 669                                                 }
 670
 671                                         }
 672                                         else
 673                                         {
 674                                                 c++;
 675                                         }
 676                                 }
 677                                 if (*c == '>')
 678                                         c++;
 679                         }
 680                         else if (!g_ascii_strncasecmp(c + 1, "font", 4))
 681                         {
 682                                 c += 5;
 683
 684                                 while ((*c != '\0') && !g_ascii_strncasecmp(c, " ", 1))
 685                                         c++;
 686
 687                                 if (!g_ascii_strncasecmp(c, "color=\"#", 7))
 688                                 {
 689                                         c += 8;
 690
 691                                         fontcolor[0] = *(c + 4);
 692                                         fontcolor[1] = *(c + 5);
 693                                         fontcolor[2] = *(c + 2);
 694                                         fontcolor[3] = *(c + 3);
 695                                         fontcolor[4] = *c;
 696                                         fontcolor[5] = *(c + 1);
 697
 698                                         c += 8;
 699                                 }
 700                                 else if (!g_ascii_strncasecmp(c, "face=\"", 6))
 701                                 {
 702                                         const char *end = NULL;
 703                                         const char *comma = NULL;
 704                                         unsigned int namelen = 0;
 705
 706                                         c += 6;
 707                                         end = strchr(c, '\"');
 708                                         comma = strchr(c, ',');
 709
 710                                         if (comma == NULL || comma > end)
 711                                                 namelen = (unsigned int)(end - c);
 712                                         else
 713                                                 namelen = (unsigned int)(comma - c);
 714
 715                                         fontface = g_strndup(c, namelen);
 716                                         c = end + 2;
 717                                 }
 718                                 else
 719                                 {
 720                                         /* Drop all unrecognized/misparsed font tags */
 721                                         while ((*c != '\0') && g_ascii_strncasecmp(c, "\">", 2))
 722                                                 c++;
 723
 724                                         if (*c != '\0')
 725                                                 c += 2;
 726                                 }
 727                         }
 728                         else
 729                         {
 730                                 while ((*c != '\0') && (*c != '>'))
 731                                         c++;
 732                                 if (*c != '\0')
 733                                         c++;
 734                         }
 735                 }
 736                 else if (*c == '&')
 737                 {
 738                         if (!g_ascii_strncasecmp(c, "&lt;", 4))
 739                         {
 740                                 msg[retcount++] = '<';
 741                                 c += 4;
 742                         }
 743                         else if (!g_ascii_strncasecmp(c, "&gt;", 4))
 744                         {
 745                                 msg[retcount++] = '>';
 746                                 c += 4;
 747                         }
 748                         else if (!g_ascii_strncasecmp(c, "&nbsp;", 6))
 749                         {
 750                                 msg[retcount++] = ' ';
 751                                 c += 6;
 752                         }
 753                         else if (!g_ascii_strncasecmp(c, "&quot;", 6))
 754                         {
 755                                 msg[retcount++] = '"';
 756                                 c += 6;
 757                         }
 758                         else if (!g_ascii_strncasecmp(c, "&amp;", 5))
 759                         {
 760                                 msg[retcount++] = '&';
 761                                 c += 5;
 762                         }
 763                         else if (!g_ascii_strncasecmp(c, "&apos;", 6))
 764                         {
 765                                 msg[retcount++] = '\'';
 766                                 c += 6;
 767                         }
 768                         else
 769                                 msg[retcount++] = *c++;
 770                 }
 771                 else
 772                         msg[retcount++] = *c++;
 773         }
 774
 775         if (fontface == NULL)
 776                 fontface = g_strdup("MS Sans Serif");
 777
 778         *attributes = g_strdup_printf("FN=%s; EF=%s; CO=%s; PF=0; RL=%c",
 779                                                                   encode_spaces(fontface),
 780                                                                   fonteffect, fontcolor, direction);
 781         *message = msg;
 782
 783         g_free(fontface);
 784 }
 785 // End of TEMP
 786