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
 440 PurpleMimeDocument *
 441 purple_mime_document_parsen(const char *buf, gsize len)
 442 {
 443         PurpleMimeDocument *doc;
 444
 445         char *b = (char *) buf;
 446         gsize n = len;
 447
 448         g_return_val_if_fail(buf != NULL, NULL);
 449
 450         doc = purple_mime_document_new();
 451
 452         if (!len)
 453                 return doc;
 454
 455         fields_load(&doc->fields, &b, &n);
 456
 457         {
 458                 const char *ct = fields_get(&doc->fields, "content-type");
 459                 if(ct && purple_str_has_prefix(ct, "multipart")) {
 460                         char *bd = strrchr(ct, '=');
 461                         if(bd++) {
 462                                 doc_parts_load(doc, bd, b, n);
 463                         }
 464                 }
 465         }
 466
 467         return doc;
 468 }
 469
 470
 471 PurpleMimeDocument *
 472 purple_mime_document_parse(const char *buf)
 473 {
 474         g_return_val_if_fail(buf != NULL, NULL);
 475         return purple_mime_document_parsen(buf, strlen(buf));
 476 }
 477
 478
 479 void
 480 purple_mime_document_write(PurpleMimeDocument *doc, GString *str)
 481 {
 482         const char *bd = NULL;
 483
 484         g_return_if_fail(doc != NULL);
 485         g_return_if_fail(str != NULL);
 486
 487         {
 488                 const char *ct = fields_get(&doc->fields, "content-type");
 489                 if(ct && purple_str_has_prefix(ct, "multipart")) {
 490                         char *b = strrchr(ct, '=');
 491                         if(b++) bd = b;
 492                 }
 493         }
 494
 495         fields_write(&doc->fields, str);
 496
 497         if(bd) {
 498                 GList *l;
 499
 500                 for(l = doc->parts; l; l = l->next) {
 501                         g_string_append_printf(str, "--%s\r\n", bd);
 502
 503                         part_write(l->data, str);
 504
 505                         if(! l->next) {
 506                                 g_string_append_printf(str, "--%s--\r\n", bd);
 507                         }
 508                 }
 509         }
 510 }
 511
 512
 513 GList *
 514 purple_mime_document_get_fields(PurpleMimeDocument *doc)
 515 {
 516         g_return_val_if_fail(doc != NULL, NULL);
 517         return doc->fields.keys;
 518 }
 519
 520
 521 const char *
 522 purple_mime_document_get_field(PurpleMimeDocument *doc, const char *field)
 523 {
 524         g_return_val_if_fail(doc != NULL, NULL);
 525         return fields_get(&doc->fields, field);
 526 }
 527
 528
 529 void
 530 purple_mime_document_set_field(PurpleMimeDocument *doc, const char *field, const char *value)
 531 {
 532         g_return_if_fail(doc != NULL);
 533         fields_set(&doc->fields, field, value);
 534 }
 535
 536
 537 GList *
 538 purple_mime_document_get_parts(PurpleMimeDocument *doc)
 539 {
 540         g_return_val_if_fail(doc != NULL, NULL);
 541         return doc->parts;
 542 }
 543
 544
 545 void
 546 purple_mime_document_free(PurpleMimeDocument *doc)
 547 {
 548         if (!doc)
 549                 return;
 550
 551         fields_destroy(&doc->fields);
 552
 553         while(doc->parts) {
 554                 part_free(doc->parts->data);
 555                 doc->parts = g_list_delete_link(doc->parts, doc->parts);
 556         }
 557
 558         g_free(doc);
 559 }