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