lib/mime.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2017, Daniel Stenberg, <daniel@haxx.se>, et al.
   9  *
  10  * This software is licensed as described in the file COPYING, which
  11  * you should have received as part of this distribution. The terms
  12  * are also available at https://curl.haxx.se/docs/copyright.html.
  13  *
  14  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15  * copies of the Software, and permit persons to whom the Software is
  16  * furnished to do so, under the terms of the COPYING file.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ***************************************************************************/
  22
  23 #include "curl_setup.h"
  24
  25 #include <curl/curl.h>
  26
  27 #include "mime.h"
  28 #include "non-ascii.h"
  29 #include "urldata.h"
  30 #include "sendf.h"
  31
  32 #if !defined(CURL_DISABLE_HTTP) || !defined(CURL_DISABLE_SMTP) || \
  33     !defined(CURL_DISABLE_IMAP)
  34
  35 #if defined(HAVE_LIBGEN_H) && defined(HAVE_BASENAME)
  36 #include <libgen.h>
  37 #endif
  38
  39 #include "rand.h"
  40 #include "slist.h"
  41 #include "strcase.h"
  42 /* The last 3 #include files should be in this order */
  43 #include "curl_printf.h"
  44 #include "curl_memory.h"
  45 #include "memdebug.h"
  46
  47 #ifdef WIN32
  48 # ifndef R_OK
  49 #  define R_OK 4
  50 # endif
  51 #endif
  52
  53
  54 #define FILE_CONTENTTYPE_DEFAULT        "application/octet-stream"
  55 #define MULTIPART_CONTENTTYPE_DEFAULT   "multipart/mixed"
  56 #define DISPOSITION_DEFAULT             "attachment"
  57
  58 #define READ_ERROR                      ((size_t) -1)
  59
  60 /* Encoders. */
  61 static size_t encoder_nop_read(char *buffer, size_t size, bool ateof,
  62                                 curl_mimepart *part);
  63 static curl_off_t encoder_nop_size(curl_mimepart *part);
  64 static size_t encoder_7bit_read(char *buffer, size_t size, bool ateof,
  65                                 curl_mimepart *part);
  66 static size_t encoder_base64_read(char *buffer, size_t size, bool ateof,
  67                                 curl_mimepart *part);
  68 static curl_off_t encoder_base64_size(curl_mimepart *part);
  69 static size_t encoder_qp_read(char *buffer, size_t size, bool ateof,
  70                               curl_mimepart *part);
  71 static curl_off_t encoder_qp_size(curl_mimepart *part);
  72
  73 static const mime_encoder encoders[] = {
  74   {"binary", encoder_nop_read, encoder_nop_size},
  75   {"8bit", encoder_nop_read, encoder_nop_size},
  76   {"7bit", encoder_7bit_read, encoder_nop_size},
  77   {"base64", encoder_base64_read, encoder_base64_size},
  78   {"quoted-printable", encoder_qp_read, encoder_qp_size},
  79   {ZERO_NULL, ZERO_NULL, ZERO_NULL}
  80 };
  81
  82 /* Base64 encoding table */
  83 static const char base64[] =
  84   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  85
  86 /* Quoted-printable character class table.
  87  *
  88  * We cannot rely on ctype functions since quoted-printable input data
  89  * is assumed to be ascii-compatible, even on non-ascii platforms. */
  90 #define QP_OK           1       /* Can be represented by itself. */
  91 #define QP_SP           2       /* Space or tab. */
  92 #define QP_CR           3       /* Carriage return. */
  93 #define QP_LF           4       /* Line-feed. */
  94 static const unsigned char qp_class[] = {
  95  0,     0,     0,     0,     0,     0,     0,     0,            /* 00 - 07 */
  96  0,     QP_SP, QP_LF, 0,     0,     QP_CR, 0,     0,            /* 08 - 0F */
  97  0,     0,     0,     0,     0,     0,     0,     0,            /* 10 - 17 */
  98  0,     0,     0,     0,     0,     0,     0,     0,            /* 18 - 1F */
  99  QP_SP, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK,        /* 20 - 27 */
 100  QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK,        /* 28 - 2F */
 101  QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK,        /* 30 - 37 */
 102  QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, 0    , QP_OK, QP_OK,        /* 38 - 3F */
 103  QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK,        /* 40 - 47 */
 104  QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK,        /* 48 - 4F */
 105  QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK,        /* 50 - 57 */
 106  QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK,        /* 58 - 5F */
 107  QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK,        /* 60 - 67 */
 108  QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK,        /* 68 - 6F */
 109  QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK,        /* 70 - 77 */
 110  QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, 0,            /* 78 - 7F */
 111  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                /* 80 - 8F */
 112  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                /* 90 - 9F */
 113  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                /* A0 - AF */
 114  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                /* B0 - BF */
 115  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                /* C0 - CF */
 116  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                /* D0 - DF */
 117  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                /* E0 - EF */
 118  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0                 /* F0 - FF */
 119 };
 120
 121
 122 /* Binary --> hexadecimal ASCII table. */
 123 static const char aschex[] =
 124   "\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x41\x42\x43\x44\x45\x46";
 125
 126
 127
 128 #ifndef __VMS
 129 #define filesize(name, stat_data) (stat_data.st_size)
 130 #define fopen_read fopen
 131
 132 #else
 133
 134 #include <fabdef.h>
 135 /*
 136  * get_vms_file_size does what it takes to get the real size of the file
 137  *
 138  * For fixed files, find out the size of the EOF block and adjust.
 139  *
 140  * For all others, have to read the entire file in, discarding the contents.
 141  * Most posted text files will be small, and binary files like zlib archives
 142  * and CD/DVD images should be either a STREAM_LF format or a fixed format.
 143  *
 144  */
 145 curl_off_t VmsRealFileSize(const char *name,
 146                            const struct_stat *stat_buf)
 147 {
 148   char buffer[8192];
 149   curl_off_t count;
 150   int ret_stat;
 151   FILE * file;
 152
 153   file = fopen(name, FOPEN_READTEXT); /* VMS */
 154   if(file == NULL)
 155     return 0;
 156
 157   count = 0;
 158   ret_stat = 1;
 159   while(ret_stat > 0) {
 160     ret_stat = fread(buffer, 1, sizeof(buffer), file);
 161     if(ret_stat != 0)
 162       count += ret_stat;
 163   }
 164   fclose(file);
 165
 166   return count;
 167 }
 168
 169 /*
 170  *
 171  *  VmsSpecialSize checks to see if the stat st_size can be trusted and
 172  *  if not to call a routine to get the correct size.
 173  *
 174  */
 175 static curl_off_t VmsSpecialSize(const char *name,
 176                                  const struct_stat *stat_buf)
 177 {
 178   switch(stat_buf->st_fab_rfm) {
 179   case FAB$C_VAR:
 180   case FAB$C_VFC:
 181     return VmsRealFileSize(name, stat_buf);
 182     break;
 183   default:
 184     return stat_buf->st_size;
 185   }
 186 }
 187
 188 #define filesize(name, stat_data) VmsSpecialSize(name, &stat_data)
 189
 190 /*
 191  * vmsfopenread
 192  *
 193  * For upload to work as expected on VMS, different optional
 194  * parameters must be added to the fopen command based on
 195  * record format of the file.
 196  *
 197  */
 198 static FILE * vmsfopenread(const char *file, const char *mode)
 199 {
 200   struct_stat statbuf;
 201   int result;
 202
 203   result = stat(file, &statbuf);
 204
 205   switch(statbuf.st_fab_rfm) {
 206   case FAB$C_VAR:
 207   case FAB$C_VFC:
 208   case FAB$C_STMCR:
 209     return fopen(file, FOPEN_READTEXT); /* VMS */
 210     break;
 211   default:
 212     return fopen(file, FOPEN_READTEXT, "rfm=stmlf", "ctx=stm");
 213   }
 214 }
 215
 216 #define fopen_read vmsfopenread
 217 #endif
 218
 219
 220 #ifndef HAVE_BASENAME
 221 /*
 222   (Quote from The Open Group Base Specifications Issue 6 IEEE Std 1003.1, 2004
 223   Edition)
 224
 225   The basename() function shall take the pathname pointed to by path and
 226   return a pointer to the final component of the pathname, deleting any
 227   trailing '/' characters.
 228
 229   If the string pointed to by path consists entirely of the '/' character,
 230   basename() shall return a pointer to the string "/". If the string pointed
 231   to by path is exactly "//", it is implementation-defined whether '/' or "//"
 232   is returned.
 233
 234   If path is a null pointer or points to an empty string, basename() shall
 235   return a pointer to the string ".".
 236
 237   The basename() function may modify the string pointed to by path, and may
 238   return a pointer to static storage that may then be overwritten by a
 239   subsequent call to basename().
 240
 241   The basename() function need not be reentrant. A function that is not
 242   required to be reentrant is not required to be thread-safe.
 243
 244 */
 245 static char *Curl_basename(char *path)
 246 {
 247   /* Ignore all the details above for now and make a quick and simple
 248      implementaion here */
 249   char *s1;
 250   char *s2;
 251
 252   s1 = strrchr(path, '/');
 253   s2 = strrchr(path, '\\');
 254
 255   if(s1 && s2) {
 256     path = (s1 > s2? s1 : s2) + 1;
 257   }
 258   else if(s1)
 259     path = s1 + 1;
 260   else if(s2)
 261     path = s2 + 1;
 262
 263   return path;
 264 }
 265
 266 #define basename(x)  Curl_basename((x))
 267 #endif
 268
 269
 270 /* Set readback state. */
 271 static void mimesetstate(mime_state *state, enum mimestate tok, void *ptr)
 272 {
 273   state->state = tok;
 274   state->ptr = ptr;
 275   state->offset = 0;
 276 }
 277
 278
 279 /* Escape header string into allocated memory. */
 280 static char *escape_string(const char *src)
 281 {
 282   size_t bytecount = 0;
 283   size_t i;
 284   char *dst;
 285
 286   for(i = 0; src[i]; i++)
 287     if(src[i] == '"' || src[i] == '\\')
 288       bytecount++;
 289
 290   bytecount += i;
 291   dst = malloc(bytecount + 1);
 292   if(!dst)
 293     return NULL;
 294
 295   for(i = 0; *src; src++) {
 296     if(*src == '"' || *src == '\\')
 297       dst[i++] = '\\';
 298     dst[i++] = *src;
 299   }
 300
 301   dst[i] = '\0';
 302   return dst;
 303 }
 304
 305 /* Check if header matches. */
 306 static char *match_header(struct curl_slist *hdr, const char *lbl, size_t len)
 307 {
 308   char *value = NULL;
 309
 310   if(strncasecompare(hdr->data, lbl, len) && hdr->data[len] == ':')
 311     for(value = hdr->data + len + 1; *value == ' '; value++)
 312       ;
 313   return value;
 314 }
 315
 316 /* Get a header from an slist. */
 317 static char *search_header(struct curl_slist *hdrlist, const char *hdr)
 318 {
 319   size_t len = strlen(hdr);
 320   char *value = NULL;
 321
 322   for(; !value && hdrlist; hdrlist = hdrlist->next)
 323     value = match_header(hdrlist, hdr, len);
 324
 325   return value;
 326 }
 327
 328 static char *strippath(const char *fullfile)
 329 {
 330   char *filename;
 331   char *base;
 332   filename = strdup(fullfile); /* duplicate since basename() may ruin the
 333                                   buffer it works on */
 334   if(!filename)
 335     return NULL;
 336   base = strdup(basename(filename));
 337
 338   free(filename); /* free temporary buffer */
 339
 340   return base; /* returns an allocated string or NULL ! */
 341 }
 342
 343 /* Initialize data encoder state. */
 344 static void cleanup_encoder_state(mime_encoder_state *p)
 345 {
 346   p->pos = 0;
 347   p->bufbeg = 0;
 348   p->bufend = 0;
 349 }
 350
 351
 352 /* Dummy encoder. This is used for 8bit and binary content encodings. */
 353 static size_t encoder_nop_read(char *buffer, size_t size, bool ateof,
 354                                curl_mimepart *part)
 355 {
 356   mime_encoder_state *st = &part->encstate;
 357   size_t insize = st->bufend - st->bufbeg;
 358
 359   (void) ateof;
 360
 361   if(size > insize)
 362     size = insize;
 363   if(size)
 364     memcpy(buffer, st->buf, size);
 365   st->bufbeg += size;
 366   return size;
 367 }
 368
 369 static curl_off_t encoder_nop_size(curl_mimepart *part)
 370 {
 371   return part->datasize;
 372 }
 373
 374
 375 /* 7bit encoder: the encoder is just a data validity check. */
 376 static size_t encoder_7bit_read(char *buffer, size_t size, bool ateof,
 377                                 curl_mimepart *part)
 378 {
 379   mime_encoder_state *st = &part->encstate;
 380   size_t cursize = st->bufend - st->bufbeg;
 381
 382   (void) ateof;
 383
 384   if(size > cursize)
 385     size = cursize;
 386
 387   for(cursize = 0; cursize < size; cursize++) {
 388     *buffer = st->buf[st->bufbeg];
 389     if(*buffer++ & 0x80)
 390       return cursize? cursize: READ_ERROR;
 391     st->bufbeg++;
 392   }
 393
 394   return cursize;
 395 }
 396
 397
 398 /* Base64 content encoder. */
 399 static size_t encoder_base64_read(char *buffer, size_t size, bool ateof,
 400                                 curl_mimepart *part)
 401 {
 402   mime_encoder_state *st = &part->encstate;
 403   size_t cursize = 0;
 404   int i;
 405   char *ptr = buffer;
 406
 407   while(st->bufbeg < st->bufend) {
 408     /* Line full ? */
 409     if(st->pos > MAX_ENCODED_LINE_LENGTH - 4) {
 410       /* Yes, we need 2 characters for CRLF. */
 411       if(size < 2)
 412         break;
 413       *ptr++ = '\r';
 414       *ptr++ = '\n';
 415       st->pos = 0;
 416       cursize += 2;
 417       size -= 2;
 418     }
 419
 420     /* Be sure there is enough space and input data for a base64 group. */
 421     if(size < 4 || st->bufend - st->bufbeg < 3)
 422       break;
 423
 424     /* Encode three bytes as four characters. */
 425     i = st->buf[st->bufbeg++] & 0xFF;
 426     i = (i << 8) | (st->buf[st->bufbeg++] & 0xFF);
 427     i = (i << 8) | (st->buf[st->bufbeg++] & 0xFF);
 428     *ptr++ = base64[(i >> 18) & 0x3F];
 429     *ptr++ = base64[(i >> 12) & 0x3F];
 430     *ptr++ = base64[(i >> 6) & 0x3F];
 431     *ptr++ = base64[i & 0x3F];
 432     cursize += 4;
 433     st->pos += 4;
 434     size -= 4;
 435   }
 436
 437   /* If at eof, we have to flush the buffered data. */
 438   if(ateof && size >= 4) {
 439     /* Buffered data size can only be 0, 1 or 2. */
 440     ptr[2] = ptr[3] = '=';
 441     i = 0;
 442     switch(st->bufend - st->bufbeg) {
 443     case 2:
 444       i = (st->buf[st->bufbeg + 1] & 0xFF) << 8;
 445       /* FALLTHROUGH */
 446     case 1:
 447       i |= (st->buf[st->bufbeg] & 0xFF) << 16;
 448       ptr[0] = base64[(i >> 18) & 0x3F];
 449       ptr[1] = base64[(i >> 12) & 0x3F];
 450       if(++st->bufbeg != st->bufend) {
 451         ptr[2] = base64[(i >> 6) & 0x3F];
 452         st->bufbeg++;
 453       }
 454       cursize += 4;
 455       st->pos += 4;
 456       break;
 457     }
 458   }
 459
 460 #ifdef CURL_DOES_CONVERSIONS
 461   /* This is now textual data, Convert character codes. */
 462   if(part->easy && cursize) {
 463     CURLcode result = Curl_convert_to_network(part->easy, buffer, cursize);
 464     if(result)
 465       return READ_ERROR;
 466   }
 467 #endif
 468
 469   return cursize;
 470 }
 471
 472 static curl_off_t encoder_base64_size(curl_mimepart *part)
 473 {
 474   curl_off_t size = part->datasize;
 475
 476   if(size <= 0)
 477     return size;    /* Unknown size or no data. */
 478
 479   /* Compute base64 character count. */
 480   size = 4 * (1 + (size - 1) / 3);
 481
 482   /* Effective character count must include CRLFs. */
 483   return size + 2 * ((size - 1) / MAX_ENCODED_LINE_LENGTH);
 484 }
 485
 486
 487 /* Quoted-printable lookahead.
 488  *
 489  * Check if a CRLF or end of data is in input buffer at current position + n.
 490  * Return -1 if more data needed, 1 if CRLF or end of data, else 0.
 491  */
 492 static int qp_lookahead_eol(mime_encoder_state *st, int ateof, size_t n)
 493 {
 494   n += st->bufbeg;
 495   if(n >= st->bufend && ateof)
 496     return 1;
 497   if(n + 2 > st->bufend)
 498     return ateof? 0: -1;
 499   if(qp_class[st->buf[n] & 0xFF] == QP_CR &&
 500      qp_class[st->buf[n + 1] & 0xFF] == QP_LF)
 501     return 1;
 502   return 0;
 503 }
 504
 505 /* Quoted-printable encoder. */
 506 static size_t encoder_qp_read(char *buffer, size_t size, bool ateof,
 507                               curl_mimepart *part)
 508 {
 509   mime_encoder_state *st = &part->encstate;
 510   char *ptr = buffer;
 511   size_t cursize = 0;
 512   int i;
 513   size_t len;
 514   size_t consumed;
 515   int softlinebreak;
 516   char buf[4];
 517
 518   /* On all platforms, input is supposed to be ASCII compatible: for this
 519      reason, we use hexadecimal ASCII codes in this function rather than
 520      character constants that can be interpreted as non-ascii on some
 521      platforms. Preserve ASCII encoding on output too. */
 522   while(st->bufbeg < st->bufend) {
 523     len = 1;
 524     consumed = 1;
 525     i = st->buf[st->bufbeg];
 526     buf[0] = (char) i;
 527     buf[1] = aschex[(i >> 4) & 0xF];
 528     buf[2] = aschex[i & 0xF];
 529
 530     switch(qp_class[st->buf[st->bufbeg] & 0xFF]) {
 531     case QP_OK:          /* Not a special character. */
 532       break;
 533     case QP_SP:          /* Space or tab. */
 534       /* Spacing must be escaped if followed by CRLF. */
 535       switch(qp_lookahead_eol(st, ateof, 1)) {
 536       case -1:          /* More input data needed. */
 537         return cursize;
 538       case 0:           /* No encoding needed. */
 539         break;
 540       default:          /* CRLF after space or tab. */
 541         buf[0] = '\x3D';    /* '=' */
 542         len = 3;
 543         break;
 544       }
 545       break;
 546     case QP_CR:         /* Carriage return. */
 547       /* If followed by a line-feed, output the CRLF pair.
 548          Else escape it. */
 549       switch(qp_lookahead_eol(st, ateof, 0)) {
 550       case -1:          /* Need more data. */
 551         return cursize;
 552       case 1:           /* CRLF found. */
 553         buf[len++] = '\x0A';    /* Append '\n'. */
 554         consumed = 2;
 555         break;
 556       default:          /* Not followed by LF: escape. */
 557         buf[0] = '\x3D';    /* '=' */
 558         len = 3;
 559         break;
 560       }
 561       break;
 562     default:            /* Character must be escaped. */
 563       buf[0] = '\x3D';    /* '=' */
 564       len = 3;
 565       break;
 566     }
 567
 568     /* Be sure the encoded character fits within maximum line length. */
 569     if(buf[len - 1] != '\x0A') {    /* '\n' */
 570       softlinebreak = st->pos + len > MAX_ENCODED_LINE_LENGTH;
 571       if(!softlinebreak && st->pos + len == MAX_ENCODED_LINE_LENGTH) {
 572         /* We may use the current line only if end of data or followed by
 573            a CRLF. */
 574         switch(qp_lookahead_eol(st, ateof, consumed)) {
 575         case -1:        /* Need more data. */
 576           return cursize;
 577           break;
 578         case 0:         /* Not followed by a CRLF. */
 579           softlinebreak = 1;
 580           break;
 581         }
 582       }
 583       if(softlinebreak) {
 584         strcpy(buf, "\x3D\x0D\x0A");    /* "=\r\n" */
 585         len = 3;
 586         consumed = 0;
 587       }
 588     }
 589
 590     /* If the output buffer would overflow, do not store. */
 591     if(len > size)
 592       break;
 593
 594     /* Append to output buffer. */
 595     memcpy(ptr, buf, len);
 596     cursize += len;
 597     ptr += len;
 598     size -= len;
 599     st->pos += len;
 600     if(buf[len - 1] == '\x0A')    /* '\n' */
 601       st->pos = 0;
 602     st->bufbeg += consumed;
 603   }
 604
 605   return cursize;
 606 }
 607
 608 static curl_off_t encoder_qp_size(curl_mimepart *part)
 609 {
 610   /* Determining the size can only be done by reading the data: unless the
 611      data size is 0, we return it as unknown (-1). */
 612   return part->datasize? -1: 0;
 613 }
 614
 615
 616 /* In-memory data callbacks. */
 617 /* Argument is a pointer to the mime part. */
 618 static size_t mime_mem_read(char *buffer, size_t size, size_t nitems,
 619                             void *instream)
 620 {
 621   curl_mimepart *part = (curl_mimepart *) instream;
 622   size_t sz = (size_t) part->datasize - part->state.offset;
 623   (void) size;   /* Always 1.*/
 624
 625   if(sz > nitems)
 626     sz = nitems;
 627
 628   if(sz)
 629     memcpy(buffer, (char *) &part->data[part->state.offset], sz);
 630
 631   part->state.offset += sz;
 632   return sz;
 633 }
 634
 635 static int mime_mem_seek(void *instream, curl_off_t offset, int whence)
 636 {
 637   curl_mimepart *part = (curl_mimepart *) instream;
 638
 639   switch(whence) {
 640   case SEEK_CUR:
 641     offset += part->state.offset;
 642     break;
 643   case SEEK_END:
 644     offset += part->datasize;
 645     break;
 646   }
 647
 648   if(offset < 0 || offset > part->datasize)
 649     return CURL_SEEKFUNC_FAIL;
 650
 651   part->state.offset = (size_t) offset;
 652   return CURL_SEEKFUNC_OK;
 653 }
 654
 655 static void mime_mem_free(void *ptr)
 656 {
 657   Curl_safefree(((curl_mimepart *) ptr)->data);
 658 }
 659
 660
 661 /* Named file callbacks. */
 662 /* Argument is a pointer to the mime part. */
 663 static int mime_open_file(curl_mimepart * part)
 664 {
 665   /* Open a MIMEKIND_FILE part. */
 666
 667   if(part->fp)
 668     return 0;
 669   part->fp = fopen_read(part->data, "rb");
 670   return part->fp? 0: -1;
 671 }
 672
 673 static size_t mime_file_read(char *buffer, size_t size, size_t nitems,
 674                              void *instream)
 675 {
 676   curl_mimepart *part = (curl_mimepart *) instream;
 677
 678   if(mime_open_file(part))
 679     return READ_ERROR;
 680
 681   return fread(buffer, size, nitems, part->fp);
 682 }
 683
 684 static int mime_file_seek(void *instream, curl_off_t offset, int whence)
 685 {
 686   curl_mimepart *part = (curl_mimepart *) instream;
 687
 688   if(whence == SEEK_SET && !offset && !part->fp)
 689     return CURL_SEEKFUNC_OK;   /* Not open: implicitly already at BOF. */
 690
 691   if(mime_open_file(part))
 692     return CURL_SEEKFUNC_FAIL;
 693
 694   return fseek(part->fp, (long) offset, whence)?
 695                CURL_SEEKFUNC_CANTSEEK: CURL_SEEKFUNC_OK;
 696 }
 697
 698 static void mime_file_free(void *ptr)
 699 {
 700   curl_mimepart *part = (curl_mimepart *) ptr;
 701
 702   if(part->fp) {
 703     fclose(part->fp);
 704     part->fp = NULL;
 705   }
 706   Curl_safefree(part->data);
 707   part->data = NULL;
 708 }
 709
 710
 711 /* Subparts callbacks. */
 712 /* Argument is a pointer to the mime structure. */
 713
 714 /* Readback a byte string segment. */
 715 static size_t readback_bytes(mime_state *state,
 716                              char *buffer, size_t bufsize,
 717                              const char *bytes, size_t numbytes,
 718                              const char *trail)
 719 {
 720   size_t sz;
 721
 722   sz = numbytes - state->offset;
 723
 724   if(numbytes > state->offset) {
 725     sz = numbytes - state->offset;
 726     bytes += state->offset;
 727   }
 728   else {
 729     size_t tsz = strlen(trail);
 730
 731     sz = state->offset - numbytes;
 732     if(sz >= tsz)
 733       return 0;
 734     bytes = trail + sz;
 735     sz = tsz - sz;
 736   }
 737
 738   if(sz > bufsize)
 739     sz = bufsize;
 740
 741   memcpy(buffer, bytes, sz);
 742   state->offset += sz;
 743   return sz;
 744 }
 745
 746 /* Read a non-encoded part content. */
 747 static size_t read_part_content(curl_mimepart *part,
 748                                 char *buffer, size_t bufsize)
 749 {
 750   size_t sz = 0;
 751
 752   if(part->readfunc)
 753     sz = part->readfunc(buffer, 1, bufsize, part->arg);
 754   return sz;
 755 }
 756
 757 /* Read and encode part content. */
 758 static size_t read_encoded_part_content(curl_mimepart *part,
 759                                         char *buffer, size_t bufsize)
 760 {
 761   mime_encoder_state *st = &part->encstate;
 762   size_t cursize = 0;
 763   size_t sz;
 764   bool ateof = FALSE;
 765
 766   while(bufsize) {
 767     if(st->bufbeg < st->bufend || ateof) {
 768       /* Encode buffered data. */
 769       sz = part->encoder->encodefunc(buffer, bufsize, ateof, part);
 770       switch(sz) {
 771       case 0:
 772         if(ateof)
 773           return cursize;
 774         break;
 775       case CURL_READFUNC_ABORT:
 776       case CURL_READFUNC_PAUSE:
 777       case READ_ERROR:
 778         return cursize? cursize: sz;
 779       default:
 780         cursize += sz;
 781         buffer += sz;
 782         bufsize -= sz;
 783         continue;
 784       }
 785     }
 786
 787     /* We need more data in input buffer. */
 788     if(st->bufbeg) {
 789       size_t len = st->bufend - st->bufbeg;
 790
 791       if(len)
 792         memmove(st->buf, st->buf + st->bufbeg, len);
 793       st->bufbeg = 0;
 794       st->bufend = len;
 795     }
 796     if(st->bufend >= sizeof st->buf)
 797       return cursize? cursize: READ_ERROR;    /* Buffer full. */
 798     sz = read_part_content(part, st->buf + st->bufend,
 799                            sizeof st->buf - st->bufend);
 800     switch(sz) {
 801     case 0:
 802       ateof = TRUE;
 803       break;
 804     case CURL_READFUNC_ABORT:
 805     case CURL_READFUNC_PAUSE:
 806     case READ_ERROR:
 807       return cursize? cursize: sz;
 808     default:
 809       st->bufend += sz;
 810       break;
 811     }
 812   }
 813
 814   return cursize;
 815 }
 816
 817 /* Readback a mime part. */
 818 static size_t readback_part(curl_mimepart *part,
 819                             char *buffer, size_t bufsize)
 820 {
 821   size_t cursize = 0;
 822   size_t sz;
 823   struct curl_slist *hdr;
 824 #ifdef CURL_DOES_CONVERSIONS
 825   char *convbuf = buffer;
 826 #endif
 827
 828   /* Readback from part. */
 829
 830   while(bufsize) {
 831     sz = 0;
 832     hdr = (struct curl_slist *) part->state.ptr;
 833     switch(part->state.state) {
 834     case MIMESTATE_BEGIN:
 835       mimesetstate(&part->state, part->flags & MIME_BODY_ONLY? MIMESTATE_BODY:
 836                                  MIMESTATE_CURLHEADERS, part->curlheaders);
 837       break;
 838     case MIMESTATE_USERHEADERS:
 839       if(!hdr) {
 840         mimesetstate(&part->state, MIMESTATE_EOH, NULL);
 841         break;
 842       }
 843       if(match_header(hdr, "Content-Type", 12)) {
 844         mimesetstate(&part->state, MIMESTATE_USERHEADERS, hdr->next);
 845         break;
 846       }
 847       /* FALLTHROUGH */
 848     case MIMESTATE_CURLHEADERS:
 849       if(!hdr)
 850         mimesetstate(&part->state, MIMESTATE_USERHEADERS, part->userheaders);
 851       else {
 852         sz = readback_bytes(&part->state, buffer, bufsize,
 853                             hdr->data, strlen(hdr->data), "\r\n");
 854         if(!sz)
 855           mimesetstate(&part->state, part->state.state, hdr->next);
 856       }
 857       break;
 858     case MIMESTATE_EOH:
 859       sz = readback_bytes(&part->state, buffer, bufsize, "\r\n", 2, "");
 860       if(!sz)
 861         mimesetstate(&part->state, MIMESTATE_BODY, NULL);
 862       break;
 863     case MIMESTATE_BODY:
 864 #ifdef CURL_DOES_CONVERSIONS
 865       if(part->easy && convbuf < buffer) {
 866         CURLcode result = Curl_convert_to_network(part->easy, convbuf,
 867                                                   buffer - convbuf);
 868         if(result)
 869           return READ_ERROR;
 870         convbuf = buffer;
 871       }
 872 #endif
 873       cleanup_encoder_state(&part->encstate);
 874       mimesetstate(&part->state, MIMESTATE_CONTENT, NULL);
 875       break;
 876     case MIMESTATE_CONTENT:
 877       if(part->encoder)
 878         sz = read_encoded_part_content(part, buffer, bufsize);
 879       else
 880         sz = read_part_content(part, buffer, bufsize);
 881       switch(sz) {
 882       case 0:
 883         mimesetstate(&part->state, MIMESTATE_END, NULL);
 884         /* Try sparing open file descriptors. */
 885         if(part->kind == MIMEKIND_FILE && part->fp) {
 886           fclose(part->fp);
 887           part->fp = NULL;
 888         }
 889         /* FALLTHROUGH */
 890       case CURL_READFUNC_ABORT:
 891       case CURL_READFUNC_PAUSE:
 892       case READ_ERROR:
 893         return cursize? cursize: sz;
 894       }
 895       break;
 896     case MIMESTATE_END:
 897       return cursize;
 898     default:
 899       break;    /* Other values not in part state. */
 900     }
 901
 902     /* Bump buffer and counters according to read size. */
 903     cursize += sz;
 904     buffer += sz;
 905     bufsize -= sz;
 906   }
 907
 908 #ifdef CURL_DOES_CONVERSIONS
 909       if(part->easy && convbuf < buffer &&
 910          part->state.state < MIMESTATE_BODY) {
 911         CURLcode result = Curl_convert_to_network(part->easy, convbuf,
 912                                                   buffer - convbuf);
 913         if(result)
 914           return READ_ERROR;
 915       }
 916 #endif
 917
 918   return cursize;
 919 }
 920
 921 /* Readback from mime. */
 922 static size_t mime_subparts_read(char *buffer, size_t size, size_t nitems,
 923                                  void *instream)
 924 {
 925   curl_mime *mime = (curl_mime *) instream;
 926   size_t cursize = 0;
 927   size_t sz;
 928   curl_mimepart *part;
 929 #ifdef CURL_DOES_CONVERSIONS
 930   char *convbuf = buffer;
 931 #endif
 932
 933   (void) size;   /* Always 1. */
 934
 935   while(nitems) {
 936     sz = 0;
 937     part = mime->state.ptr;
 938     switch(mime->state.state) {
 939     case MIMESTATE_BEGIN:
 940     case MIMESTATE_BODY:
 941 #ifdef CURL_DOES_CONVERSIONS
 942       convbuf = buffer;
 943 #endif
 944       mimesetstate(&mime->state, MIMESTATE_BOUNDARY1, mime->firstpart);
 945       /* The first boundary always follows the header termination empty line,
 946          so is always preceded by a CRLK. We can then spare 2 characters
 947          by skipping the leading CRLF in boundary. */
 948       mime->state.offset += 2;
 949       break;
 950     case MIMESTATE_BOUNDARY1:
 951       sz = readback_bytes(&mime->state, buffer, nitems, "\r\n--", 4, "");
 952       if(!sz)
 953         mimesetstate(&mime->state, MIMESTATE_BOUNDARY2, part);
 954       break;
 955     case MIMESTATE_BOUNDARY2:
 956       sz = readback_bytes(&mime->state, buffer, nitems, mime->boundary,
 957                           strlen(mime->boundary), part? "\r\n": "--\r\n");
 958       if(!sz) {
 959 #ifdef CURL_DOES_CONVERSIONS
 960         if(mime->easy && convbuf < buffer) {
 961           CURLcode result = Curl_convert_to_network(mime->easy, convbuf,
 962                                                     buffer - convbuf);
 963           if(result)
 964             return READ_ERROR;
 965           convbuf = buffer;
 966         }
 967 #endif
 968         mimesetstate(&mime->state, MIMESTATE_CONTENT, part);
 969       }
 970       break;
 971     case MIMESTATE_CONTENT:
 972       if(!part) {
 973         mimesetstate(&mime->state, MIMESTATE_END, NULL);
 974         break;
 975       }
 976       sz = readback_part(part, buffer, nitems);
 977       switch(sz) {
 978       case CURL_READFUNC_ABORT:
 979       case CURL_READFUNC_PAUSE:
 980       case READ_ERROR:
 981         return cursize? cursize: sz;
 982       case 0:
 983 #ifdef CURL_DOES_CONVERSIONS
 984         convbuf = buffer;
 985 #endif
 986         mimesetstate(&mime->state, MIMESTATE_BOUNDARY1, part->nextpart);
 987         break;
 988       }
 989       break;
 990     case MIMESTATE_END:
 991       return cursize;
 992     default:
 993       break;    /* other values not used in mime state. */
 994     }
 995
 996     /* Bump buffer and counters according to read size. */
 997     cursize += sz;
 998     buffer += sz;
 999     nitems -= sz;
1000   }
1001
1002 #ifdef CURL_DOES_CONVERSIONS
1003       if(mime->easy && convbuf < buffer &&
1004          mime->state.state <= MIMESTATE_CONTENT) {
1005         CURLcode result = Curl_convert_to_network(mime->easy, convbuf,
1006                                                   buffer - convbuf);
1007         if(result)
1008           return READ_ERROR;
1009       }
1010 #endif
1011
1012   return cursize;
1013 }
1014
1015 static int mime_part_rewind(curl_mimepart *part)
1016 {
1017   int res = CURL_SEEKFUNC_OK;
1018   enum mimestate targetstate = MIMESTATE_BEGIN;
1019
1020   if(part->flags & MIME_BODY_ONLY)
1021     targetstate = MIMESTATE_BODY;
1022   cleanup_encoder_state(&part->encstate);
1023   if(part->state.state > targetstate) {
1024     res = CURL_SEEKFUNC_CANTSEEK;
1025     if(part->seekfunc) {
1026       res = part->seekfunc(part->arg, (curl_off_t) 0, SEEK_SET);
1027       switch(res) {
1028       case CURL_SEEKFUNC_OK:
1029       case CURL_SEEKFUNC_FAIL:
1030       case CURL_SEEKFUNC_CANTSEEK:
1031         break;
1032       case -1:    /* For fseek() error. */
1033         res = CURL_SEEKFUNC_CANTSEEK;
1034         break;
1035       default:
1036         res = CURL_SEEKFUNC_FAIL;
1037         break;
1038       }
1039     }
1040   }
1041
1042   if(res == CURL_SEEKFUNC_OK)
1043     mimesetstate(&part->state, targetstate, NULL);
1044
1045   return res;
1046 }
1047
1048 static int mime_subparts_seek(void *instream, curl_off_t offset, int whence)
1049 {
1050   curl_mime *mime = (curl_mime *) instream;
1051   curl_mimepart *part;
1052   int result = CURL_SEEKFUNC_OK;
1053   int res;
1054
1055   if(whence != SEEK_SET || offset)
1056     return CURL_SEEKFUNC_CANTSEEK;    /* Only support full rewind. */
1057
1058   if(mime->state.state == MIMESTATE_BEGIN)
1059    return CURL_SEEKFUNC_OK;           /* Already rewound. */
1060
1061   for(part = mime->firstpart; part; part = part->nextpart) {
1062     res = mime_part_rewind(part);
1063     if(res != CURL_SEEKFUNC_OK)
1064       result = res;
1065   }
1066
1067   if(result == CURL_SEEKFUNC_OK)
1068     mimesetstate(&mime->state, MIMESTATE_BEGIN, NULL);
1069
1070   return result;
1071 }
1072
1073 /* Release part content. */
1074 static void cleanup_part_content(curl_mimepart *part)
1075 {
1076   if(part->freefunc)
1077     part->freefunc(part->arg);
1078
1079   part->readfunc = NULL;
1080   part->seekfunc = NULL;
1081   part->freefunc = NULL;
1082   part->arg = (void *) part;          /* Defaults to part itself. */
1083   part->data = NULL;
1084   part->fp = NULL;
1085   part->datasize = (curl_off_t) 0;    /* No size yet. */
1086   cleanup_encoder_state(&part->encstate);
1087   part->kind = MIMEKIND_NONE;
1088 }
1089
1090 static void mime_subparts_free(void *ptr)
1091 {
1092   curl_mime *mime = (curl_mime *) ptr;
1093
1094   if(mime && mime->parent) {
1095     mime->parent->freefunc = NULL;  /* Be sure we won't be called again. */
1096     cleanup_part_content(mime->parent);  /* Avoid dangling pointer in part. */
1097   }
1098   curl_mime_free(mime);
1099 }
1100
1101 /* Do not free subparts: unbind them. This is used for the top level only. */
1102 static void mime_subparts_unbind(void *ptr)
1103 {
1104   curl_mime *mime = (curl_mime *) ptr;
1105
1106   if(mime && mime->parent) {
1107     mime->parent->freefunc = NULL;  /* Be sure we won't be called again. */
1108     cleanup_part_content(mime->parent);  /* Avoid dangling pointer in part. */
1109     mime->parent = NULL;
1110   }
1111 }
1112
1113
1114 void Curl_mime_cleanpart(curl_mimepart *part)
1115 {
1116   cleanup_part_content(part);
1117   curl_slist_free_all(part->curlheaders);
1118   if(part->flags & MIME_USERHEADERS_OWNER)
1119     curl_slist_free_all(part->userheaders);
1120   Curl_safefree(part->mimetype);
1121   Curl_safefree(part->name);
1122   Curl_safefree(part->filename);
1123   Curl_mime_initpart(part, part->easy);
1124 }
1125
1126 /* Recursively delete a mime handle and its parts. */
1127 void curl_mime_free(curl_mime *mime)
1128 {
1129   curl_mimepart *part;
1130
1131   if(mime) {
1132     mime_subparts_unbind(mime);  /* Be sure it's not referenced anymore. */
1133     while(mime->firstpart) {
1134       part = mime->firstpart;
1135       mime->firstpart = part->nextpart;
1136       Curl_mime_cleanpart(part);
1137       free(part);
1138     }
1139
1140     free(mime->boundary);
1141     free(mime);
1142   }
1143 }
1144
1145 /*
1146  * Mime build functions.
1147  */
1148
1149 /* Create a mime handle. */
1150 curl_mime *curl_mime_init(struct Curl_easy *easy)
1151 {
1152   curl_mime *mime;
1153
1154   mime = (curl_mime *) malloc(sizeof *mime);
1155
1156   if(mime) {
1157     mime->easy = easy;
1158     mime->parent = NULL;
1159     mime->firstpart = NULL;
1160     mime->lastpart = NULL;
1161
1162     /* Get a part boundary. */
1163     mime->boundary = malloc(24 + MIME_RAND_BOUNDARY_CHARS + 1);
1164     if(!mime->boundary) {
1165       free(mime);
1166       return NULL;
1167     }
1168
1169     memset(mime->boundary, '-', 24);
1170     Curl_rand_hex(easy, (unsigned char *) mime->boundary + 24,
1171                   MIME_RAND_BOUNDARY_CHARS + 1);
1172     mimesetstate(&mime->state, MIMESTATE_BEGIN, NULL);
1173   }
1174
1175   return mime;
1176 }
1177
1178 /* Initialize a mime part. */
1179 void Curl_mime_initpart(curl_mimepart *part, struct Curl_easy *easy)
1180 {
1181   memset((char *) part, 0, sizeof *part);
1182   part->easy = easy;
1183   mimesetstate(&part->state, MIMESTATE_BEGIN, NULL);
1184 }
1185
1186 /* Create a mime part and append it to a mime handle's part list. */
1187 curl_mimepart *curl_mime_addpart(curl_mime *mime)
1188 {
1189   curl_mimepart *part;
1190
1191   if(!mime)
1192     return NULL;
1193
1194   part = (curl_mimepart *) malloc(sizeof *part);
1195
1196   if(part) {
1197     Curl_mime_initpart(part, mime->easy);
1198     part->parent = mime;
1199
1200     if(mime->lastpart)
1201       mime->lastpart->nextpart = part;
1202     else
1203       mime->firstpart = part;
1204
1205     mime->lastpart = part;
1206   }
1207
1208   return part;
1209 }
1210
1211 /* Set mime part name. */
1212 CURLcode curl_mime_name(curl_mimepart *part, const char *name)
1213 {
1214   if(!part)
1215     return CURLE_BAD_FUNCTION_ARGUMENT;
1216
1217   Curl_safefree(part->name);
1218   part->name = NULL;
1219
1220   if(name) {
1221     part->name = strdup(name);
1222     if(!part->name)
1223       return CURLE_OUT_OF_MEMORY;
1224   }
1225
1226   return CURLE_OK;
1227 }
1228
1229 /* Set mime part remote file name. */
1230 CURLcode curl_mime_filename(curl_mimepart *part, const char *filename)
1231 {
1232   if(!part)
1233     return CURLE_BAD_FUNCTION_ARGUMENT;
1234
1235   Curl_safefree(part->filename);
1236   part->filename = NULL;
1237
1238   if(filename) {
1239     part->filename = strdup(filename);
1240     if(!part->filename)
1241       return CURLE_OUT_OF_MEMORY;
1242   }
1243
1244   return CURLE_OK;
1245 }
1246
1247 /* Set mime part content from memory data. */
1248 CURLcode curl_mime_data(curl_mimepart *part,
1249                         const char *data, size_t datasize)
1250 {
1251   if(!part)
1252     return CURLE_BAD_FUNCTION_ARGUMENT;
1253
1254   cleanup_part_content(part);
1255
1256   if(data) {
1257     if(datasize == CURL_ZERO_TERMINATED)
1258       datasize = strlen(data);
1259
1260     part->data = malloc(datasize + 1);
1261     if(!part->data)
1262       return CURLE_OUT_OF_MEMORY;
1263
1264     part->datasize = datasize;
1265
1266     if(datasize)
1267       memcpy(part->data, data, datasize);
1268     part->data[datasize] = '\0';    /* Set a nul terminator as sentinel. */
1269
1270     part->readfunc = mime_mem_read;
1271     part->seekfunc = mime_mem_seek;
1272     part->freefunc = mime_mem_free;
1273     part->kind = MIMEKIND_DATA;
1274   }
1275
1276   return CURLE_OK;
1277 }
1278
1279 /* Set mime part content from named local file. */
1280 CURLcode curl_mime_filedata(curl_mimepart *part, const char *filename)
1281 {
1282   CURLcode result = CURLE_OK;
1283   char *base;
1284
1285   if(!part)
1286     return CURLE_BAD_FUNCTION_ARGUMENT;
1287
1288   cleanup_part_content(part);
1289
1290   if(filename) {
1291     struct_stat sbuf;
1292
1293     if(stat(filename, &sbuf) || access(filename, R_OK))
1294       result = CURLE_READ_ERROR;
1295
1296     part->data = strdup(filename);
1297     if(!part->data)
1298       result = CURLE_OUT_OF_MEMORY;
1299
1300     part->datasize = -1;
1301     if(!result && S_ISREG(sbuf.st_mode)) {
1302       part->datasize = filesize(filename, sbuf);
1303       part->seekfunc = mime_file_seek;
1304     }
1305
1306     part->readfunc = mime_file_read;
1307     part->freefunc = mime_file_free;
1308     part->kind = MIMEKIND_FILE;
1309
1310     /* As a side effect, set the filename to the current file's base name.
1311        It is possible to withdraw this by explicitly calling
1312        curl_mime_filename() with a NULL filename argument after the current
1313        call. */
1314     base = strippath(filename);
1315     if(!base)
1316       result = CURLE_OUT_OF_MEMORY;
1317     else {
1318       CURLcode res = curl_mime_filename(part, base);
1319
1320       if(res)
1321         result = res;
1322       free(base);
1323     }
1324   }
1325   return result;
1326 }
1327
1328 /* Set mime part type. */
1329 CURLcode curl_mime_type(curl_mimepart *part, const char *mimetype)
1330 {
1331   if(!part)
1332     return CURLE_BAD_FUNCTION_ARGUMENT;
1333
1334   Curl_safefree(part->mimetype);
1335   part->mimetype = NULL;
1336
1337   if(mimetype) {
1338     part->mimetype = strdup(mimetype);
1339     if(!part->mimetype)
1340       return CURLE_OUT_OF_MEMORY;
1341   }
1342
1343   return CURLE_OK;
1344 }
1345
1346 /* Set mime data transfer encoder. */
1347 CURLcode curl_mime_encoder(curl_mimepart *part, const char *encoding)
1348 {
1349   CURLcode result = CURLE_BAD_FUNCTION_ARGUMENT;
1350   const mime_encoder *mep;
1351
1352   if(!part)
1353     return result;
1354
1355   part->encoder = NULL;
1356
1357   if(!encoding)
1358     return CURLE_OK;    /* Removing current encoder. */
1359
1360   for(mep = encoders; mep->name; mep++)
1361     if(strcasecompare(encoding, mep->name)) {
1362       part->encoder = mep;
1363       result = CURLE_OK;
1364     }
1365
1366   return result;
1367 }
1368
1369 /* Set mime part headers. */
1370 CURLcode curl_mime_headers(curl_mimepart *part,
1371                            struct curl_slist *headers, int take_ownership)
1372 {
1373   if(!part)
1374     return CURLE_BAD_FUNCTION_ARGUMENT;
1375
1376   if(part->flags & MIME_USERHEADERS_OWNER) {
1377     if(part->userheaders != headers)  /* Allow setting twice the same list. */
1378       curl_slist_free_all(part->userheaders);
1379     part->flags &= ~MIME_USERHEADERS_OWNER;
1380   }
1381   part->userheaders = headers;
1382   if(headers && take_ownership)
1383     part->flags |= MIME_USERHEADERS_OWNER;
1384   return CURLE_OK;
1385 }
1386
1387 /* Set mime part content from callback. */
1388 CURLcode curl_mime_data_cb(curl_mimepart *part, curl_off_t datasize,
1389                            curl_read_callback readfunc,
1390                            curl_seek_callback seekfunc,
1391                            curl_free_callback freefunc, void *arg)
1392 {
1393   if(!part)
1394     return CURLE_BAD_FUNCTION_ARGUMENT;
1395
1396   cleanup_part_content(part);
1397
1398   if(readfunc) {
1399     part->readfunc = readfunc;
1400     part->seekfunc = seekfunc;
1401     part->freefunc = freefunc;
1402     part->arg = arg;
1403     part->datasize = datasize;
1404     part->kind = MIMEKIND_CALLBACK;
1405   }
1406
1407   return CURLE_OK;
1408 }
1409
1410 /* Set mime part content from subparts. */
1411 CURLcode Curl_mime_set_subparts(curl_mimepart *part,
1412                                 curl_mime *subparts, int take_ownership)
1413 {
1414   curl_mime *root;
1415
1416   if(!part)
1417     return CURLE_BAD_FUNCTION_ARGUMENT;
1418
1419   /* Accept setting twice the same subparts. */
1420   if(part->kind == MIMEKIND_MULTIPART && part->arg == subparts)
1421     return CURLE_OK;
1422
1423   cleanup_part_content(part);
1424
1425   if(subparts) {
1426     /* Must belong to the same data handle. */
1427     if(part->easy && subparts->easy && part->easy != subparts->easy)
1428       return CURLE_BAD_FUNCTION_ARGUMENT;
1429
1430     /* Should not have been attached already. */
1431     if(subparts->parent)
1432       return CURLE_BAD_FUNCTION_ARGUMENT;
1433
1434     /* Should not be the part's root. */
1435     root = part->parent;
1436     if(root) {
1437       while(root->parent && root->parent->parent)
1438         root = root->parent->parent;
1439       if(subparts == root) {
1440         if(part->easy)
1441           failf(part->easy, "Can't add itself as a subpart!");
1442         return CURLE_BAD_FUNCTION_ARGUMENT;
1443       }
1444     }
1445
1446     subparts->parent = part;
1447     part->readfunc = mime_subparts_read;
1448     part->seekfunc = mime_subparts_seek;
1449     part->freefunc = take_ownership? mime_subparts_free: mime_subparts_unbind;
1450     part->arg = subparts;
1451     part->datasize = -1;
1452     part->kind = MIMEKIND_MULTIPART;
1453   }
1454
1455   return CURLE_OK;
1456 }
1457
1458 CURLcode curl_mime_subparts(curl_mimepart *part, curl_mime *subparts)
1459 {
1460   return Curl_mime_set_subparts(part, subparts, TRUE);
1461 }
1462
1463
1464 /* Readback from top mime. */
1465 /* Argument is the dummy top part. */
1466 size_t Curl_mime_read(char *buffer, size_t size, size_t nitems, void *instream)
1467 {
1468   curl_mimepart *part = (curl_mimepart *) instream;
1469
1470   (void) size;   /* Always 1. */
1471   return readback_part(part, buffer, nitems);
1472 }
1473
1474 /* Rewind mime stream. */
1475 CURLcode Curl_mime_rewind(curl_mimepart *part)
1476 {
1477   return mime_part_rewind(part) == CURL_SEEKFUNC_OK?
1478          CURLE_OK: CURLE_SEND_FAIL_REWIND;
1479 }
1480
1481 /* Compute header list size. */
1482 static size_t slist_size(struct curl_slist *s,
1483                          size_t overhead, const char *skip)
1484 {
1485   size_t size = 0;
1486   size_t skiplen = skip? strlen(skip): 0;
1487
1488   for(; s; s = s->next)
1489     if(!skip || !match_header(s, skip, skiplen))
1490       size += strlen(s->data) + overhead;
1491   return size;
1492 }
1493
1494 /* Get/compute multipart size. */
1495 static curl_off_t multipart_size(curl_mime *mime)
1496 {
1497   curl_off_t size;
1498   curl_off_t sz;
1499   size_t boundarysize;
1500   curl_mimepart *part;
1501
1502   if(!mime)
1503     return 0;           /* Not present -> empty. */
1504
1505   boundarysize = 4 + strlen(mime->boundary) + 2;
1506   size = boundarysize;  /* Final boundary - CRLF after headers. */
1507
1508   for(part = mime->firstpart; part; part = part->nextpart) {
1509     sz = Curl_mime_size(part);
1510
1511     if(sz < 0)
1512       size = sz;
1513
1514     if(size >= 0)
1515       size += boundarysize + sz;
1516   }
1517
1518   return size;
1519 }
1520
1521 /* Get/compute mime size. */
1522 curl_off_t Curl_mime_size(curl_mimepart *part)
1523 {
1524   curl_off_t size;
1525
1526   if(part->kind == MIMEKIND_MULTIPART)
1527     part->datasize = multipart_size(part->arg);
1528
1529   size = part->datasize;
1530
1531   if(part->encoder)
1532     size = part->encoder->sizefunc(part);
1533
1534   if(size >= 0 && !(part->flags & MIME_BODY_ONLY)) {
1535     /* Compute total part size. */
1536     size += slist_size(part->curlheaders, 2, NULL);
1537     size += slist_size(part->userheaders, 2, "Content-Type");
1538     size += 2;    /* CRLF after headers. */
1539   }
1540   return size;
1541 }
1542
1543 /* Add a header. */
1544 /* VARARGS2 */
1545 CURLcode Curl_mime_add_header(struct curl_slist **slp, const char *fmt, ...)
1546 {
1547   struct curl_slist *hdr = NULL;
1548   char *s = NULL;
1549   va_list ap;
1550
1551   va_start(ap, fmt);
1552   s = curl_mvaprintf(fmt, ap);
1553   va_end(ap);
1554
1555   if(s) {
1556     hdr = Curl_slist_append_nodup(*slp, s);
1557     if(hdr)
1558       *slp = hdr;
1559     else
1560       free(s);
1561   }
1562
1563   return hdr? CURLE_OK: CURLE_OUT_OF_MEMORY;
1564 }
1565
1566 /* Add a content type header. */
1567 static CURLcode add_content_type(struct curl_slist **slp,
1568                                  const char *type, const char *boundary)
1569 {
1570   return Curl_mime_add_header(slp, "Content-Type: %s%s%s", type,
1571                               boundary? "; boundary=": "",
1572                               boundary? boundary: "");
1573 }
1574
1575
1576 static const char *ContentTypeForFilename(const char *filename)
1577 {
1578   unsigned int i;
1579
1580   /*
1581    * If no content type was specified, we scan through a few well-known
1582    * extensions and pick the first we match!
1583    */
1584   struct ContentType {
1585     const char *extension;
1586     const char *type;
1587   };
1588   static const struct ContentType ctts[] = {
1589     {".gif",  "image/gif"},
1590     {".jpg",  "image/jpeg"},
1591     {".jpeg", "image/jpeg"},
1592     {".png",  "image/png"},
1593     {".svg",  "image/svg+xml"},
1594     {".txt",  "text/plain"},
1595     {".htm",  "text/html"},
1596     {".html", "text/html"},
1597     {".pdf",  "application/pdf"},
1598     {".xml",  "application/xml"}
1599   };
1600
1601   if(filename) {
1602     size_t len1 = strlen(filename);
1603     const char *nameend = filename + len1;
1604
1605     for(i = 0; i < sizeof ctts / sizeof ctts[0]; i++) {
1606       size_t len2 = strlen(ctts[i].extension);
1607
1608       if(len1 >= len2 && strcasecompare(nameend - len2, ctts[i].extension))
1609           return ctts[i].type;
1610     }
1611   }
1612   return NULL;
1613 }
1614
1615 CURLcode Curl_mime_prepare_headers(curl_mimepart *part,
1616                                    const char *contenttype,
1617                                    const char *disposition,
1618                                    enum mimestrategy strategy)
1619 {
1620   curl_mime *mime = NULL;
1621   const char *boundary = NULL;
1622   char *customct;
1623   const char *cte = NULL;
1624   CURLcode ret = CURLE_OK;
1625
1626   /* Get rid of previously prepared headers. */
1627   curl_slist_free_all(part->curlheaders);
1628   part->curlheaders = NULL;
1629
1630   /* Be sure we won't access old headers later. */
1631   if(part->state.state == MIMESTATE_CURLHEADERS)
1632     mimesetstate(&part->state, MIMESTATE_CURLHEADERS, NULL);
1633
1634   /* Check if content type is specified. */
1635   customct = part->mimetype;
1636   if(!customct)
1637     customct = search_header(part->userheaders, "Content-Type");
1638   if(customct)
1639     contenttype = customct;
1640
1641   /* If content type is not specified, try to determine it. */
1642   if(!contenttype) {
1643     switch(part->kind) {
1644     case MIMEKIND_MULTIPART:
1645       contenttype = MULTIPART_CONTENTTYPE_DEFAULT;
1646       break;
1647     case MIMEKIND_FILE:
1648       contenttype = ContentTypeForFilename(part->filename);
1649       if(!contenttype)
1650         contenttype = ContentTypeForFilename(part->data);
1651       if(!contenttype && part->filename)
1652         contenttype = FILE_CONTENTTYPE_DEFAULT;
1653       break;
1654     default:
1655       contenttype = ContentTypeForFilename(part->filename);
1656       break;
1657     }
1658   }
1659
1660   if(part->kind == MIMEKIND_MULTIPART) {
1661     mime = (curl_mime *) part->arg;
1662     if(mime)
1663       boundary = mime->boundary;
1664   }
1665   else if(contenttype && !customct &&
1666           strcasecompare(contenttype, "text/plain"))
1667     if(strategy == MIMESTRATEGY_MAIL || !part->filename)
1668       contenttype = NULL;
1669
1670   /* Issue content-disposition header only if not already set by caller. */
1671   if(!search_header(part->userheaders, "Content-Disposition")) {
1672     if(!disposition)
1673       if(part->filename || part->name ||
1674         (contenttype && !strncasecompare(contenttype, "multipart/", 10)))
1675           disposition = DISPOSITION_DEFAULT;
1676     if(disposition && curl_strequal(disposition, "attachment") &&
1677      !part->name && !part->filename)
1678       disposition = NULL;
1679     if(disposition) {
1680       char *name = NULL;
1681       char *filename = NULL;
1682
1683       if(part->name) {
1684         name = escape_string(part->name);
1685         if(!name)
1686           ret = CURLE_OUT_OF_MEMORY;
1687       }
1688       if(!ret && part->filename) {
1689         filename = escape_string(part->filename);
1690         if(!filename)
1691           ret = CURLE_OUT_OF_MEMORY;
1692       }
1693       if(!ret)
1694         ret = Curl_mime_add_header(&part->curlheaders,
1695                                    "Content-Disposition: %s%s%s%s%s%s%s",
1696                                    disposition,
1697                                    name? "; name=\"": "",
1698                                    name? name: "",
1699                                    name? "\"": "",
1700                                    filename? "; filename=\"": "",
1701                                    filename? filename: "",
1702                                    filename? "\"": "");
1703       Curl_safefree(name);
1704       Curl_safefree(filename);
1705       if(ret)
1706         return ret;
1707       }
1708     }
1709
1710   /* Issue Content-Type header. */
1711   if(contenttype) {
1712     ret = add_content_type(&part->curlheaders, contenttype, boundary);
1713     if(ret)
1714       return ret;
1715   }
1716
1717   /* Content-Transfer-Encoding header. */
1718   if(!search_header(part->userheaders, "Content-Transfer-Encoding")) {
1719     if(part->encoder)
1720       cte = part->encoder->name;
1721     else if(contenttype && strategy == MIMESTRATEGY_MAIL &&
1722      part->kind != MIMEKIND_MULTIPART)
1723       cte = "8bit";
1724     if(cte) {
1725       ret = Curl_mime_add_header(&part->curlheaders,
1726                                  "Content-Transfer-Encoding: %s", cte);
1727       if(ret)
1728         return ret;
1729     }
1730   }
1731
1732   /* If we were reading curl-generated headers, restart with new ones (this
1733      should not occur). */
1734   if(part->state.state == MIMESTATE_CURLHEADERS)
1735     mimesetstate(&part->state, MIMESTATE_CURLHEADERS, part->curlheaders);
1736
1737   /* Process subparts. */
1738   if(part->kind == MIMEKIND_MULTIPART && mime) {
1739     curl_mimepart *subpart;
1740
1741     disposition = NULL;
1742     if(strcasecompare(contenttype, "multipart/form-data"))
1743       disposition = "form-data";
1744     for(subpart = mime->firstpart; subpart; subpart = subpart->nextpart) {
1745       ret = Curl_mime_prepare_headers(subpart, NULL, disposition, strategy);
1746       if(ret)
1747         return ret;
1748     }
1749   }
1750   return ret;
1751 }
1752
1753 #else /* !CURL_DISABLE_HTTP || !CURL_DISABLE_SMTP || !CURL_DISABLE_IMAP */
1754
1755 /* Mime not compiled in: define stubs for externally-referenced functions. */
1756 curl_mime *curl_mime_init(CURL *easy)
1757 {
1758   (void) easy;
1759   return NULL;
1760 }
1761
1762 void curl_mime_free(curl_mime *mime)
1763 {
1764   (void) mime;
1765 }
1766
1767 curl_mimepart *curl_mime_addpart(curl_mime *mime)
1768 {
1769   (void) mime;
1770   return NULL;
1771 }
1772
1773 CURLcode curl_mime_name(curl_mimepart *part, const char *name)
1774 {
1775   (void) part;
1776   (void) name;
1777   return CURLE_NOT_BUILT_IN;
1778 }
1779
1780 CURLcode curl_mime_filename(curl_mimepart *part, const char *filename)
1781 {
1782   (void) part;
1783   (void) filename;
1784   return CURLE_NOT_BUILT_IN;
1785 }
1786
1787 CURLcode curl_mime_type(curl_mimepart *part, const char *mimetype)
1788 {
1789   (void) part;
1790   (void) mimetype;
1791   return CURLE_NOT_BUILT_IN;
1792 }
1793
1794 CURLcode curl_mime_encoder(curl_mimepart *part, const char *encoding)
1795 {
1796   (void) part;
1797   (void) encoding;
1798   return CURLE_NOT_BUILT_IN;
1799 }
1800
1801 CURLcode curl_mime_data(curl_mimepart *part,
1802                         const char *data, size_t datasize)
1803 {
1804   (void) part;
1805   (void) data;
1806   (void) datasize;
1807   return CURLE_NOT_BUILT_IN;
1808 }
1809
1810 CURLcode curl_mime_filedata(curl_mimepart *part, const char *filename)
1811 {
1812   (void) part;
1813   (void) filename;
1814   return CURLE_NOT_BUILT_IN;
1815 }
1816
1817 CURLcode curl_mime_data_cb(curl_mimepart *part,
1818                            curl_off_t datasize,
1819                            curl_read_callback readfunc,
1820                            curl_seek_callback seekfunc,
1821                            curl_free_callback freefunc,
1822                            void *arg)
1823 {
1824   (void) part;
1825   (void) datasize;
1826   (void) readfunc;
1827   (void) seekfunc;
1828   (void) freefunc;
1829   (void) arg;
1830   return CURLE_NOT_BUILT_IN;
1831 }
1832
1833 CURLcode curl_mime_subparts(curl_mimepart *part, curl_mime *subparts)
1834 {
1835   (void) part;
1836   (void) subparts;
1837   return CURLE_NOT_BUILT_IN;
1838 }
1839
1840 CURLcode curl_mime_headers(curl_mimepart *part,
1841                            struct curl_slist *headers, int take_ownership)
1842 {
1843   (void) part;
1844   (void) headers;
1845   (void) take_ownership;
1846   return CURLE_NOT_BUILT_IN;
1847 }
1848
1849 void Curl_mime_initpart(curl_mimepart *part, struct Curl_easy *easy)
1850 {
1851   (void) part;
1852   (void) easy;
1853 }
1854
1855 void Curl_mime_cleanpart(curl_mimepart *part)
1856 {
1857   (void) part;
1858 }
1859
1860 CURLcode Curl_mime_set_subparts(curl_mimepart *part,
1861                                 curl_mime *subparts, int take_ownership)
1862 {
1863   (void) part;
1864   (void) subparts;
1865   (void) take_ownership;
1866   return CURLE_NOT_BUILT_IN;
1867 }
1868
1869 CURLcode Curl_mime_prepare_headers(curl_mimepart *part,
1870                                    const char *contenttype,
1871                                    const char *disposition,
1872                                    enum mimestrategy strategy)
1873 {
1874   (void) part;
1875   (void) contenttype;
1876   (void) disposition;
1877   (void) strategy;
1878   return CURLE_NOT_BUILT_IN;
1879 }
1880
1881 curl_off_t Curl_mime_size(curl_mimepart *part)
1882 {
1883   (void) part;
1884   return (curl_off_t) -1;
1885 }
1886
1887 size_t Curl_mime_read(char *buffer, size_t size, size_t nitems, void *instream)
1888 {
1889   (void) buffer;
1890   (void) size;
1891   (void) nitems;
1892   (void) instream;
1893   return 0;
1894 }
1895
1896 CURLcode Curl_mime_rewind(curl_mimepart *part)
1897 {
1898   (void) part;
1899   return CURLE_NOT_BUILT_IN;
1900 }
1901
1902 /* VARARGS2 */
1903 CURLcode Curl_mime_add_header(struct curl_slist **slp, const char *fmt, ...)
1904 {
1905   (void) slp;
1906   (void) fmt;
1907   return CURLE_NOT_BUILT_IN;
1908 }
1909
1910 #endif /* !CURL_DISABLE_HTTP || !CURL_DISABLE_SMTP || !CURL_DISABLE_IMAP */