libpurple/mime.c

   1 /*
   2  * Purple
   3  *
   4  * Purple is the legal property of its developers, whose names are too
   5  * numerous to list here. Please refer to the COPYRIGHT file distributed
   6  * with this source distribution
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or (at
  11  * your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301,
  21  * USA.
  22  */
  23
  24 #include "internal.h"
  25
  26 /* this should become "util.h" if we ever get this into purple proper */
  27 #include "debug.h"
  28 #include "mime.h"
  29 #include "util.h"
  30
  31 /**
  32  * @struct mime_fields
  33  *
  34  * Utility structure used in both MIME document and parts, which maps
  35  * field names to their values, and keeps an easily accessible list of
  36  * keys.
  37  */
  38 struct mime_fields {
  39         GHashTable *map;
  40         GList *keys;
  41 };
  42
  43 struct _PurpleMimeDocument {
  44         struct mime_fields fields;
  45         GList *parts;
  46 };
  47
  48 struct _PurpleMimePart {
  49         struct mime_fields fields;
  50         struct _PurpleMimeDocument *doc;
  51         GString *data;
  52 };
  53
  54 static void
  55 fields_set(struct mime_fields *mf, const char *key, const char *val)
  56 {
  57         char *k, *v;
  58
  59         g_return_if_fail(mf != NULL);
  60         g_return_if_fail(mf->map != NULL);
  61
  62         k = g_ascii_strdown(key, -1);
  63         v = g_strdup(val);
  64
  65         /* append to the keys list only if it's not already there */
  66         if(! g_hash_table_lookup(mf->map, k)) {
  67                 mf->keys = g_list_append(mf->keys, k);
  68         }
  69
  70         /* important to use insert. If the key is already in the table, then
  71                  it's already in the keys list. Insert will free the new instance
  72                  of the key rather than the old instance. */
  73         g_hash_table_insert(mf->map, k, v);
  74 }
  75
  76
  77 static const char *
  78 fields_get(struct mime_fields *mf, const char *key)
  79 {
  80         char *kdown;
  81         const char *ret;
  82
  83         g_return_val_if_fail(mf != NULL, NULL);
  84         g_return_val_if_fail(mf->map != NULL, NULL);
  85
  86         kdown = g_ascii_strdown(key, -1);
  87         ret = g_hash_table_lookup(mf->map, kdown);
  88         g_free(kdown);
  89
  90         return ret;
  91 }
  92
  93
  94 static void
  95 fields_init(struct mime_fields *mf)
  96 {
  97         g_return_if_fail(mf != NULL);
  98
  99         mf->map = g_hash_table_new_full(g_str_hash, g_str_equal,
 100                                         g_free, g_free);
 101 }
 102
 103
 104 static void
 105 fields_loadline(struct mime_fields *mf, const char *line, gsize len)
 106 {
 107         /* split the line into key: value */
 108         char *key, *newkey, *val;
 109         char **tokens;
 110
 111         /* feh, need it to be NUL terminated */
 112         key = g_strndup(line, len);
 113
 114         /* split */
 115         val = strchr(key, ':');
 116         if(! val) {
 117                 g_free(key);
 118                 return;
 119         }
 120         *val++ = '\0';
 121
 122         /* normalize whitespace (sorta) and trim on key and value */
 123         tokens = g_strsplit(key, "\t\r\n", 0);
 124         newkey = g_strjoinv("", tokens);
 125         g_strstrip(newkey);
 126         g_strfreev(tokens);
 127
 128         tokens = g_strsplit(val, "\t\r\n", 0);
 129         val = g_strjoinv("", tokens);
 130         g_strstrip(val);
 131         g_strfreev(tokens);
 132
 133         fields_set(mf, newkey, val);
 134
 135         g_free(newkey);
 136         g_free(key);
 137         g_free(val);
 138 }
 139
 140
 141 static void
 142 fields_load(struct mime_fields *mf, char **buf, gsize *len)
 143 {
 144         char *tail;
 145
 146         while ((tail = g_strstr_len(*buf, *len, "\r\n")))
 147         {
 148                 char *line;
 149                 gsize ln;
 150
 151                 /* determine the current line */
 152                 line = *buf;
 153                 ln = tail - line;
 154
 155                 /* advance our search space past the CRLF */
 156                 *buf = tail + 2;
 157                 *len -= (ln + 2);
 158
 159                 /* empty line, end of headers */
 160                 if(! ln) return;
 161
 162                 /* look out for line continuations */
 163                 if(line[ln-1] == ';') {
 164                         tail = g_strstr_len(*buf, *len, "\r\n");
 165                         if(tail) {
 166                                 gsize cln;
 167
 168                                 cln = tail - *buf;
 169                                 ln = tail - line;
 170
 171                                 /* advance our search space past the CRLF (again) */
 172                                 *buf = tail + 2;
 173                                 *len -= (cln + 2);
 174                         }
 175                 }
 176
 177                 /* process our super-cool line */
 178                 fields_loadline(mf, line, ln);
 179         }
 180 }
 181
 182
 183 static void
 184 field_write(const char *key, const char *val, GString *str)
 185 {
 186         g_string_append_printf(str, "%s: %s\r\n", key, val);
 187 }
 188
 189
 190 static void
 191 fields_write(struct mime_fields *mf, GString *str)
 192 {
 193         g_return_if_fail(mf != NULL);
 194
 195         g_hash_table_foreach(mf->map, (GHFunc) field_write, str);
 196         g_string_append(str, "\r\n");
 197 }
 198
 199
 200 static void
 201 fields_destroy(struct mime_fields *mf)
 202 {
 203         g_return_if_fail(mf != NULL);
 204
 205         g_hash_table_destroy(mf->map);
 206         g_list_free(mf->keys);
 207
 208         mf->map = NULL;
 209         mf->keys = NULL;
 210 }
 211
 212
 213 static PurpleMimePart *
 214 part_new(PurpleMimeDocument *doc)
 215 {
 216         PurpleMimePart *part;
 217
 218         part = g_new0(PurpleMimePart, 1);
 219         fields_init(&part->fields);
 220         part->doc = doc;
 221         part->data = g_string_new(NULL);
 222
 223         doc->parts = g_list_prepend(doc->parts, part);
 224
 225         return part;
 226 }
 227
 228
 229 static void
 230 part_load(PurpleMimePart *part, const char *buf, gsize len)
 231 {
 232
 233         char *b = (char *) buf;
 234         gsize n = len;
 235
 236         fields_load(&part->fields, &b, &n);
 237
 238         /* the remainder will have a blank line, if there's anything at all,
 239                  so check if there's anything then trim off the trailing four
 240                  bytes, \r\n\r\n */
 241         if(n > 4) n -= 4;
 242         g_string_append_len(part->data, b, n);
 243 }
 244
 245
 246 static void
 247 part_write(PurpleMimePart *part, GString *str)
 248 {
 249         fields_write(&part->fields, str);
 250         g_string_append_printf(str, "%s\r\n\r\n", part->data->str);
 251 }
 252
 253
 254 static void
 255 part_free(PurpleMimePart *part)
 256 {
 257
 258         fields_destroy(&part->fields);
 259
 260         g_string_free(part->data, TRUE);
 261         part->data = NULL;
 262
 263         g_free(part);
 264 }
 265
 266
 267 PurpleMimePart *
 268 purple_mime_part_new(PurpleMimeDocument *doc)
 269 {
 270         g_return_val_if_fail(doc != NULL, NULL);
 271         return part_new(doc);
 272 }
 273
 274
 275 GList *
 276 purple_mime_part_get_fields(PurpleMimePart *part)
 277 {
 278         g_return_val_if_fail(part != NULL, NULL);
 279         return part->fields.keys;
 280 }
 281
 282
 283 const char *
 284 purple_mime_part_get_field(PurpleMimePart *part, const char *field)
 285 {
 286         g_return_val_if_fail(part != NULL, NULL);
 287         return fields_get(&part->fields, field);
 288 }
 289
 290
 291 char *
 292 purple_mime_part_get_field_decoded(PurpleMimePart *part, const char *field)
 293 {
 294         const char *f;
 295
 296         g_return_val_if_fail(part != NULL, NULL);
 297
 298         f = fields_get(&part->fields, field);
 299         return purple_mime_decode_field(f);
 300 }
 301
 302
 303 void
 304 purple_mime_part_set_field(PurpleMimePart *part, const char *field, const char *value)
 305 {
 306         g_return_if_fail(part != NULL);
 307         fields_set(&part->fields, field, value);
 308 }
 309
 310
 311 const char *
 312 purple_mime_part_get_data(PurpleMimePart *part)
 313 {
 314         g_return_val_if_fail(part != NULL, NULL);
 315         g_return_val_if_fail(part->data != NULL, NULL);
 316
 317         return part->data->str;
 318 }
 319
 320
 321 void
 322 purple_mime_part_get_data_decoded(PurpleMimePart *part, guchar **data, gsize *len)
 323 {
 324         const char *enc;
 325
 326         g_return_if_fail(part != NULL);
 327         g_return_if_fail(data != NULL);
 328         g_return_if_fail(len != NULL);
 329
 330         g_return_if_fail(part->data != NULL);
 331
 332         enc = purple_mime_part_get_field(part, "content-transfer-encoding");
 333
 334         if(! enc) {
 335                 *data = (guchar *)g_strdup(part->data->str);
 336                 *len = part->data->len;
 337
 338         } else if(! g_ascii_strcasecmp(enc, "7bit")) {
 339                 *data = (guchar *)g_strdup(part->data->str);
 340                 *len = part->data->len;
 341
 342         } else if(! g_ascii_strcasecmp(enc, "8bit")) {
 343                 *data = (guchar *)g_strdup(part->data->str);
 344                 *len = part->data->len;
 345
 346         } else if(! g_ascii_strcasecmp(enc, "base16")) {
 347                 *data = purple_base16_decode(part->data->str, len);
 348
 349         } else if(! g_ascii_strcasecmp(enc, "base64")) {
 350                 *data = purple_base64_decode(part->data->str, len);
 351
 352         } else if(! g_ascii_strcasecmp(enc, "quoted-printable")) {
 353                 *data = purple_quotedp_decode(part->data->str, len);
 354
 355         } else {
 356                 purple_debug_warning("mime", "purple_mime_part_get_data_decoded:"
 357                                          " unknown encoding '%s'\n", enc);
 358                 *data = NULL;
 359                 *len = 0;
 360         }
 361 }
 362
 363
 364 gsize
 365 purple_mime_part_get_length(PurpleMimePart *part)
 366 {
 367         g_return_val_if_fail(part != NULL, 0);
 368         g_return_val_if_fail(part->data != NULL, 0);
 369
 370         return part->data->len;
 371 }
 372
 373
 374 void
 375 purple_mime_part_set_data(PurpleMimePart *part, const char *data)
 376 {
 377         g_return_if_fail(part != NULL);
 378         g_string_free(part->data, TRUE);
 379         part->data = g_string_new(data);
 380 }
 381
 382
 383 PurpleMimeDocument *
 384 purple_mime_document_new()
 385 {
 386         PurpleMimeDocument *doc;
 387
 388         doc = g_new0(PurpleMimeDocument, 1);
 389         fields_init(&doc->fields);
 390
 391         return doc;
 392 }
 393
 394
 395 static void
 396 doc_parts_load(PurpleMimeDocument *doc, const char *boundary, const char *buf, gsize len)
 397 {
 398         char *b = (char *) buf;
 399         gsize n = len;
 400
 401         char *bnd;
 402         gsize bl;
 403
 404         bnd = g_strdup_printf("--%s", boundary);
 405         bl = strlen(bnd);
 406
 407         for(b = g_strstr_len(b, n, bnd); b; ) {
 408                 char *tail;
 409
 410                 /* skip the boundary */
 411                 b += bl;
 412                 n -= bl;
 413
 414                 /* skip the trailing \r\n or -- as well */
 415                 if(n >= 2) {
 416                         b += 2;
 417                         n -= 2;
 418                 }
 419
 420                 /* find the next boundary */
 421                 tail = g_strstr_len(b, n, bnd);
 422
 423                 if(tail) {
 424                         gsize sl;
 425
 426                         sl = tail - b;
 427                         if(sl) {
 428                                 PurpleMimePart *part = part_new(doc);
 429                                 part_load(part, b, sl);
 430                         }
 431                 }
 432
 433                 b = tail;
 434         }
 435
 436         g_free(bnd);
 437 }
 438
 439 #define BOUNDARY "boundary="
 440 static char *
 441 parse_boundary(const char *ct)
 442 {
 443         char *boundary_begin = g_strstr_len(ct, -1, BOUNDARY);
 444         char *boundary_end;
 445
 446         if (!boundary_begin)
 447                 return NULL;
 448
 449         boundary_begin += sizeof(BOUNDARY) - 1;
 450
 451         if (*boundary_begin == '"') {
 452                 boundary_end = strchr(++boundary_begin, '"');
 453                 if (!boundary_end)
 454                         return NULL;
 455         } else {
 456                 boundary_end = strchr(boundary_begin, ' ');
 457                 if (!boundary_end) {
 458                         boundary_end = strchr(boundary_begin, ';');
 459                         if (!boundary_end)
 460                                 boundary_end = boundary_begin + strlen(boundary_begin);
 461                 }
 462         }
 463
 464         return g_strndup(boundary_begin, boundary_end - boundary_begin);
 465 }
 466 #undef BOUNDARY
 467
 468 PurpleMimeDocument *
 469 purple_mime_document_parsen(const char *buf, gsize len)
 470 {
 471         PurpleMimeDocument *doc;
 472
 473         char *b = (char *) buf;
 474         gsize n = len;
 475
 476         g_return_val_if_fail(buf != NULL, NULL);
 477
 478         doc = purple_mime_document_new();
 479
 480         if (!len)
 481                 return doc;
 482
 483         fields_load(&doc->fields, &b, &n);
 484
 485         {
 486                 const char *ct = fields_get(&doc->fields, "content-type");
 487                 if (ct && purple_str_has_prefix(ct, "multipart")) {
 488                         char *bd = parse_boundary(ct);
 489                         if (bd) {
 490                                 doc_parts_load(doc, bd, b, n);
 491                                 g_free(bd);
 492                         }
 493                 }
 494         }
 495
 496         return doc;
 497 }
 498
 499
 500 PurpleMimeDocument *
 501 purple_mime_document_parse(const char *buf)
 502 {
 503         g_return_val_if_fail(buf != NULL, NULL);
 504         return purple_mime_document_parsen(buf, strlen(buf));
 505 }
 506
 507
 508 void
 509 purple_mime_document_write(PurpleMimeDocument *doc, GString *str)
 510 {
 511         const char *bd = NULL;
 512
 513         g_return_if_fail(doc != NULL);
 514         g_return_if_fail(str != NULL);
 515
 516         {
 517                 const char *ct = fields_get(&doc->fields, "content-type");
 518                 if(ct && purple_str_has_prefix(ct, "multipart")) {
 519                         char *b = strrchr(ct, '=');
 520                         if(b++) bd = b;
 521                 }
 522         }
 523
 524         fields_write(&doc->fields, str);
 525
 526         if(bd) {
 527                 GList *l;
 528
 529                 for(l = doc->parts; l; l = l->next) {
 530                         g_string_append_printf(str, "--%s\r\n", bd);
 531
 532                         part_write(l->data, str);
 533
 534                         if(! l->next) {
 535                                 g_string_append_printf(str, "--%s--\r\n", bd);
 536                         }
 537                 }
 538         }
 539 }
 540
 541
 542 GList *
 543 purple_mime_document_get_fields(PurpleMimeDocument *doc)
 544 {
 545         g_return_val_if_fail(doc != NULL, NULL);
 546         return doc->fields.keys;
 547 }
 548
 549
 550 const char *
 551 purple_mime_document_get_field(PurpleMimeDocument *doc, const char *field)
 552 {
 553         g_return_val_if_fail(doc != NULL, NULL);
 554         return fields_get(&doc->fields, field);
 555 }
 556
 557
 558 void
 559 purple_mime_document_set_field(PurpleMimeDocument *doc, const char *field, const char *value)
 560 {
 561         g_return_if_fail(doc != NULL);
 562         fields_set(&doc->fields, field, value);
 563 }
 564
 565
 566 GList *
 567 purple_mime_document_get_parts(PurpleMimeDocument *doc)
 568 {
 569         g_return_val_if_fail(doc != NULL, NULL);
 570         return doc->parts;
 571 }
 572
 573
 574 void
 575 purple_mime_document_free(PurpleMimeDocument *doc)
 576 {
 577         if (!doc)
 578                 return;
 579
 580         fields_destroy(&doc->fields);
 581
 582         while(doc->parts) {
 583                 part_free(doc->parts->data);
 584                 doc->parts = g_list_delete_link(doc->parts, doc->parts);
 585         }
 586
 587         g_free(doc);
 588 }