luna - curl/lib/mime.c

   1/***************************************************************************
   2 *                                  _   _ ____  _
   3 *  Project                     ___| | | |  _ \| |
   4 *                             / __| | | | |_) | |
   5 *                            | (__| |_| |  _ <| |___
   6 *                             \___|\___/|_| \_\_____|
   7 *
   8 * Copyright (C) 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.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 * SPDX-License-Identifier: curl
  22 *
  23 ***************************************************************************/
  24#include "curl_setup.h"
  25
  26struct Curl_easy;
  27
  28#include "mime.h"
  29#include "urldata.h"
  30#include "sendf.h"
  31#include "curl_trc.h"
  32#include "transfer.h"
  33#include "curlx/strdup.h"
  34#include "curlx/basename.h"
  35#include "curlx/strcopy.h"
  36#include "curlx/fopen.h"
  37#include "curlx/base64.h"
  38
  39#if !defined(CURL_DISABLE_MIME) && (!defined(CURL_DISABLE_HTTP) ||      \
  40                                    !defined(CURL_DISABLE_SMTP) ||      \
  41                                    !defined(CURL_DISABLE_IMAP))
  42
  43#include "rand.h"
  44#include "slist.h"
  45#include "curlx/dynbuf.h"
  46
  47#define MAX_MIME_LEVELS 40 /* avoid deep nesting */
  48
  49#define READ_ERROR   ((size_t)-1)
  50#define STOP_FILLING ((size_t)-2)
  51
  52static size_t mime_subparts_read(char *buffer, size_t size, size_t nitems,
  53                                 void *instream, bool *hasread,
  54                                 size_t call_depth);
  55static curl_off_t mime_size(curl_mimepart *part);
  56
  57/* Quoted-printable character class table.
  58 *
  59 * We cannot rely on ctype functions since quoted-printable input data
  60 * is assumed to be ASCII-compatible, even on non-ASCII platforms. */
  61#define QP_OK           1       /* Can be represented by itself. */
  62#define QP_SP           2       /* Space or tab. */
  63#define QP_CR           3       /* Carriage return. */
  64#define QP_LF           4       /* Line-feed. */
  65static const unsigned char qp_class[] = {
  66  0,     0,     0,     0,     0,     0,     0,     0,            /* 00 - 07 */
  67  0,     QP_SP, QP_LF, 0,     0,     QP_CR, 0,     0,            /* 08 - 0F */
  68  0,     0,     0,     0,     0,     0,     0,     0,            /* 10 - 17 */
  69  0,     0,     0,     0,     0,     0,     0,     0,            /* 18 - 1F */
  70  QP_SP, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK,        /* 20 - 27 */
  71  QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK,        /* 28 - 2F */
  72  QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK,        /* 30 - 37 */
  73  QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, 0    , QP_OK, QP_OK,        /* 38 - 3F */
  74  QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK,        /* 40 - 47 */
  75  QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK,        /* 48 - 4F */
  76  QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK,        /* 50 - 57 */
  77  QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK,        /* 58 - 5F */
  78  QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK,        /* 60 - 67 */
  79  QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK,        /* 68 - 6F */
  80  QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK,        /* 70 - 77 */
  81  QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, QP_OK, 0,            /* 78 - 7F */
  82  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                /* 80 - 8F */
  83  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                /* 90 - 9F */
  84  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                /* A0 - AF */
  85  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                /* B0 - BF */
  86  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                /* C0 - CF */
  87  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                /* D0 - DF */
  88  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                /* E0 - EF */
  89  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0                 /* F0 - FF */
  90};
  91
  92/* Binary --> hexadecimal ASCII table. */
  93static const char aschex[] =
  94  "\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x41\x42\x43\x44\x45\x46";
  95
  96#ifndef __VMS
  97#define filesize(name, stat_data) stat_data.st_size
  98#define fopen_read                curlx_fopen
  99
 100#else
 101
 102#include <fabdef.h>
 103/*
 104 * get_vms_file_size does what it takes to get the real size of the file
 105 *
 106 * For fixed files, find out the size of the EOF block and adjust.
 107 *
 108 * For all others, have to read the entire file in, discarding the contents.
 109 * Most posted text files will be small, and binary files like zlib archives
 110 * and CD/DVD images should be either a STREAM_LF format or a fixed format.
 111 *
 112 */
 113curl_off_t VmsRealFileSize(const char *name, const curlx_struct_stat *stat_buf)
 114{
 115  char buffer[8192];
 116  curl_off_t count;
 117  int ret_stat;
 118  FILE *file;
 119
 120  file = curlx_fopen(name, FOPEN_READTEXT); /* VMS */
 121  if(!file)
 122    return 0;
 123
 124  count = 0;
 125  ret_stat = 1;
 126  while(ret_stat > 0) {
 127    ret_stat = fread(buffer, 1, sizeof(buffer), file);
 128    if(ret_stat)
 129      count += ret_stat;
 130  }
 131  curlx_fclose(file);
 132
 133  return count;
 134}
 135
 136/*
 137 *
 138 *  VmsSpecialSize checks to see if the stat st_size can be trusted and
 139 *  if not to call a routine to get the correct size.
 140 *
 141 */
 142static curl_off_t VmsSpecialSize(const char *name,
 143                                 const curlx_struct_stat *stat_buf)
 144{
 145  switch(stat_buf->st_fab_rfm) {
 146  case FAB$C_VAR:
 147  case FAB$C_VFC:
 148    return VmsRealFileSize(name, stat_buf);
 149    break;
 150  default:
 151    return stat_buf->st_size;
 152  }
 153}
 154
 155#define filesize(name, stat_data) VmsSpecialSize(name, &stat_data)
 156
 157/*
 158 * vmsfopenread
 159 *
 160 * For upload to work as expected on VMS, different optional
 161 * parameters must be added to the fopen command based on
 162 * record format of the file.
 163 *
 164 */
 165static FILE *vmsfopenread(const char *file, const char *mode)
 166{
 167  curlx_struct_stat statbuf;
 168  int res = curlx_stat(file, &statbuf);
 169
 170  if(res != -1) {
 171    switch(statbuf.st_fab_rfm) {
 172    case FAB$C_VAR:
 173    case FAB$C_VFC:
 174    case FAB$C_STMCR:
 175      return curlx_fopen(file, FOPEN_READTEXT); /* VMS */
 176      break;
 177    default:
 178      return curlx_fopen(file, FOPEN_READTEXT, "rfm=stmlf", "ctx=stm");
 179    }
 180  }
 181  return NULL;
 182}
 183
 184#define fopen_read vmsfopenread
 185#endif /* !__VMS */
 186
 187/* Set readback state. */
 188static void mimesetstate(struct mime_state *state,
 189                         enum mimestate tok, void *ptr)
 190{
 191  state->state = tok;
 192  state->ptr = ptr;
 193  state->offset = 0;
 194}
 195
 196/* Escape header string into allocated memory. */
 197static char *escape_string(struct Curl_easy *data,
 198                           const char *src, enum mimestrategy strategy)
 199{
 200  CURLcode result;
 201  struct dynbuf db;
 202  const char * const *table;
 203  const char * const *p;
 204  /* replace first character by rest of string. */
 205  static const char * const mimetable[] = {
 206    "\\\\\\",
 207    "\"\\\"",
 208    NULL
 209  };
 210  /* WHATWG HTML living standard 4.10.21.8 2 specifies:
 211     For field names and filenames for file fields, the result of the
 212     encoding in the previous bullet point must be escaped by replacing
 213     any 0x0A (LF) bytes with the byte sequence `%0A`, 0x0D (CR) with `%0D`
 214     and 0x22 (") with `%22`.
 215     The user agent must not perform any other escapes. */
 216  static const char * const formtable[] = {
 217    "\"%22",
 218    "\r%0D",
 219    "\n%0A",
 220    NULL
 221  };
 222
 223  table = formtable;
 224  /* data can be NULL when this function is called indirectly from
 225     curl_formget(). */
 226  if(strategy == MIMESTRATEGY_MAIL || (data && (data->set.mime_formescape)))
 227    table = mimetable;
 228
 229  curlx_dyn_init(&db, CURL_MAX_INPUT_LENGTH);
 230
 231  for(result = curlx_dyn_addn(&db, STRCONST("")); !result && *src; src++) {
 232    for(p = table; *p && **p != *src; p++)
 233      ;
 234
 235    if(*p)
 236      result = curlx_dyn_add(&db, *p + 1);
 237    else
 238      result = curlx_dyn_addn(&db, src, 1);
 239  }
 240
 241  return curlx_dyn_ptr(&db);
 242}
 243
 244/* Check if header matches. */
 245static char *match_header(struct curl_slist *hdr, const char *lbl, size_t len)
 246{
 247  char *value = NULL;
 248
 249  if(curl_strnequal(hdr->data, lbl, len) && hdr->data[len] == ':')
 250    for(value = hdr->data + len + 1; *value == ' '; value++)
 251      ;
 252  return value;
 253}
 254
 255/* Get a header from an slist. */
 256static char *search_header(struct curl_slist *hdrlist,
 257                           const char *hdr, size_t len)
 258{
 259  char *value = NULL;
 260
 261  for(; !value && hdrlist; hdrlist = hdrlist->next)
 262    value = match_header(hdrlist, hdr, len);
 263
 264  return value;
 265}
 266
 267static char *strippath(const char *fullfile)
 268{
 269  char *filename;
 270  char *base;
 271  filename = curlx_strdup(fullfile); /* duplicate since basename() may ruin
 272                                        the buffer it works on */
 273  if(!filename)
 274    return NULL;
 275  base = curlx_strdup(curlx_basename(filename));
 276
 277  curlx_free(filename); /* free temporary buffer */
 278
 279  return base; /* returns an allocated string or NULL ! */
 280}
 281
 282/* Initialize data encoder state. */
 283static void cleanup_encoder_state(struct mime_encoder_state *p)
 284{
 285  p->pos = 0;
 286  p->bufbeg = 0;
 287  p->bufend = 0;
 288}
 289
 290/* Dummy encoder. This is used for 8-bit and binary content encodings. */
 291static size_t encoder_nop_read(char *buffer, size_t size, bool ateof,
 292                               struct curl_mimepart *part)
 293{
 294  struct mime_encoder_state *st = &part->encstate;
 295  size_t insize = st->bufend - st->bufbeg;
 296
 297  (void)ateof;
 298
 299  if(!size)
 300    return STOP_FILLING;
 301
 302  if(size > insize)
 303    size = insize;
 304
 305  if(size)
 306    memcpy(buffer, st->buf + st->bufbeg, size);
 307
 308  st->bufbeg += size;
 309  return size;
 310}
 311
 312static curl_off_t encoder_nop_size(curl_mimepart *part)
 313{
 314  return part->datasize;
 315}
 316
 317/* 7-bit encoder: the encoder is a data validity check. */
 318static size_t encoder_7bit_read(char *buffer, size_t size, bool ateof,
 319                                curl_mimepart *part)
 320{
 321  struct mime_encoder_state *st = &part->encstate;
 322  size_t cursize = st->bufend - st->bufbeg;
 323
 324  (void)ateof;
 325
 326  if(!size)
 327    return STOP_FILLING;
 328
 329  if(size > cursize)
 330    size = cursize;
 331
 332  for(cursize = 0; cursize < size; cursize++) {
 333    *buffer = st->buf[st->bufbeg];
 334    if(*buffer++ & 0x80)
 335      return cursize ? cursize : READ_ERROR;
 336    st->bufbeg++;
 337  }
 338
 339  return cursize;
 340}
 341
 342/* Base64 content encoder. */
 343static size_t encoder_base64_read(char *buffer, size_t size, bool ateof,
 344                                  curl_mimepart *part)
 345{
 346  struct mime_encoder_state *st = &part->encstate;
 347  size_t cursize = 0;
 348  int i;
 349  char *ptr = buffer;
 350
 351  while(st->bufbeg < st->bufend) {
 352    /* Line full ? */
 353    if(st->pos > MAX_ENCODED_LINE_LENGTH - 4) {
 354      /* Yes, we need 2 characters for CRLF. */
 355      if(size < 2) {
 356        if(!cursize)
 357          return STOP_FILLING;
 358        break;
 359      }
 360      *ptr++ = '\r';
 361      *ptr++ = '\n';
 362      st->pos = 0;
 363      cursize += 2;
 364      size -= 2;
 365    }
 366
 367    /* Be sure there is enough space and input data for a base64 group. */
 368    if(size < 4) {
 369      if(!cursize)
 370        return STOP_FILLING;
 371      break;
 372    }
 373    if(st->bufend - st->bufbeg < 3)
 374      break;
 375
 376    /* Encode three bytes as four characters. */
 377    i = st->buf[st->bufbeg++] & 0xFF;
 378    i = (i << 8) | (st->buf[st->bufbeg++] & 0xFF);
 379    i = (i << 8) | (st->buf[st->bufbeg++] & 0xFF);
 380    *ptr++ = curlx_base64encdec[(i >> 18) & 0x3F];
 381    *ptr++ = curlx_base64encdec[(i >> 12) & 0x3F];
 382    *ptr++ = curlx_base64encdec[(i >> 6) & 0x3F];
 383    *ptr++ = curlx_base64encdec[i & 0x3F];
 384    cursize += 4;
 385    st->pos += 4;
 386    size -= 4;
 387  }
 388
 389  /* If at eof, we have to flush the buffered data. */
 390  if(ateof) {
 391    if(size < 4) {
 392      if(!cursize)
 393        return STOP_FILLING;
 394    }
 395    else {
 396      /* Buffered data size can only be 0, 1 or 2. */
 397      ptr[2] = ptr[3] = '=';
 398      i = 0;
 399
 400      /* If there is buffered data */
 401      if(st->bufend != st->bufbeg) {
 402
 403        if(st->bufend - st->bufbeg == 2)
 404          i = (st->buf[st->bufbeg + 1] & 0xFF) << 8;
 405
 406        i |= (st->buf[st->bufbeg] & 0xFF) << 16;
 407        ptr[0] = curlx_base64encdec[(i >> 18) & 0x3F];
 408        ptr[1] = curlx_base64encdec[(i >> 12) & 0x3F];
 409        if(++st->bufbeg != st->bufend) {
 410          ptr[2] = curlx_base64encdec[(i >> 6) & 0x3F];
 411          st->bufbeg++;
 412        }
 413        cursize += 4;
 414        st->pos += 4;
 415      }
 416    }
 417  }
 418
 419  return cursize;
 420}
 421
 422static curl_off_t encoder_base64_size(curl_mimepart *part)
 423{
 424  curl_off_t size = part->datasize;
 425
 426  if(size <= 0)
 427    return size;    /* Unknown size or no data. */
 428
 429  /* Compute base64 character count. */
 430  size = 4 * (1 + ((size - 1) / 3));
 431
 432  /* Effective character count must include CRLFs. */
 433  return size + (2 * ((size - 1) / MAX_ENCODED_LINE_LENGTH));
 434}
 435
 436/* Quoted-printable lookahead.
 437 *
 438 * Check if a CRLF or end of data is in input buffer at current position + n.
 439 * Return -1 if more data needed, 1 if CRLF or end of data, else 0.
 440 */
 441static int qp_lookahead_eol(struct mime_encoder_state *st, int ateof, size_t n)
 442{
 443  n += st->bufbeg;
 444  if(n >= st->bufend && ateof)
 445    return 1;
 446  if(n + 2 > st->bufend)
 447    return ateof ? 0 : -1;
 448  if(qp_class[st->buf[n] & 0xFF] == QP_CR &&
 449     qp_class[st->buf[n + 1] & 0xFF] == QP_LF)
 450    return 1;
 451  return 0;
 452}
 453
 454/* Quoted-printable encoder. */
 455static size_t encoder_qp_read(char *buffer, size_t size, bool ateof,
 456                              curl_mimepart *part)
 457{
 458  struct mime_encoder_state *st = &part->encstate;
 459  char *ptr = buffer;
 460  size_t cursize = 0;
 461  int softlinebreak;
 462  char buf[4];
 463
 464  /* On all platforms, input is supposed to be ASCII compatible: for this
 465     reason, we use hexadecimal ASCII codes in this function rather than
 466     character constants that can be interpreted as non-ASCII on some
 467     platforms. Preserve ASCII encoding on output too. */
 468  while(st->bufbeg < st->bufend) {
 469    size_t len = 1;
 470    size_t consumed = 1;
 471    int i = (unsigned char)st->buf[st->bufbeg];
 472    buf[0] = (char)i;
 473    buf[1] = aschex[(i >> 4) & 0xF];
 474    buf[2] = aschex[i & 0xF];
 475
 476    switch(qp_class[st->buf[st->bufbeg] & 0xFF]) {
 477    case QP_OK:          /* Not a special character. */
 478      break;
 479    case QP_SP:          /* Space or tab. */
 480      /* Spacing must be escaped if followed by CRLF. */
 481      switch(qp_lookahead_eol(st, ateof, 1)) {
 482      case -1:          /* More input data needed. */
 483        return cursize;
 484      case 0:           /* No encoding needed. */
 485        break;
 486      default:          /* CRLF after space or tab. */
 487        buf[0] = '\x3D';    /* '=' */
 488        len = 3;
 489        break;
 490      }
 491      break;
 492    case QP_CR:         /* Carriage return. */
 493      /* If followed by a line-feed, output the CRLF pair.
 494         Else escape it. */
 495      switch(qp_lookahead_eol(st, ateof, 0)) {
 496      case -1:          /* Need more data. */
 497        return cursize;
 498      case 1:           /* CRLF found. */
 499        buf[len++] = '\x0A';    /* Append '\n'. */
 500        consumed = 2;
 501        break;
 502      default:          /* Not followed by LF: escape. */
 503        buf[0] = '\x3D';    /* '=' */
 504        len = 3;
 505        break;
 506      }
 507      break;
 508    default:            /* Character must be escaped. */
 509      buf[0] = '\x3D';    /* '=' */
 510      len = 3;
 511      break;
 512    }
 513
 514    /* Be sure the encoded character fits within maximum line length. */
 515    if(buf[len - 1] != '\x0A') {    /* '\n' */
 516      softlinebreak = st->pos + len > MAX_ENCODED_LINE_LENGTH;
 517      if(!softlinebreak && st->pos + len == MAX_ENCODED_LINE_LENGTH) {
 518        /* We may use the current line only if end of data or followed by
 519           a CRLF. */
 520        switch(qp_lookahead_eol(st, ateof, consumed)) {
 521        case -1:        /* Need more data. */
 522          return cursize;
 523        case 0:         /* Not followed by a CRLF. */
 524          softlinebreak = 1;
 525          break;
 526        }
 527      }
 528      if(softlinebreak) {
 529        curlx_strcopy(buf, sizeof(buf), STRCONST("\x3D\x0D\x0A")); /* =\r\n */
 530        len = 3;
 531        consumed = 0;
 532      }
 533    }
 534
 535    /* If the output buffer would overflow, do not store. */
 536    if(len > size) {
 537      if(!cursize)
 538        return STOP_FILLING;
 539      break;
 540    }
 541
 542    /* Append to output buffer. */
 543    memcpy(ptr, buf, len);
 544    cursize += len;
 545    ptr += len;
 546    size -= len;
 547    st->pos += len;
 548    if(buf[len - 1] == '\x0A')    /* '\n' */
 549      st->pos = 0;
 550    st->bufbeg += consumed;
 551  }
 552
 553  return cursize;
 554}
 555
 556static curl_off_t encoder_qp_size(curl_mimepart *part)
 557{
 558  /* Determining the size can only be done by reading the data: unless the
 559     data size is 0, we return it as unknown (-1). */
 560  return part->datasize ? -1 : 0;
 561}
 562
 563/* In-memory data callbacks. */
 564/* Argument is a pointer to the mime part. */
 565static size_t mime_mem_read(char *buffer, size_t size, size_t nitems,
 566                            void *instream)
 567{
 568  curl_mimepart *part = (curl_mimepart *)instream;
 569  size_t sz = curlx_sotouz(part->datasize - part->state.offset);
 570  (void)size;  /* Always 1 */
 571
 572  if(!nitems)
 573    return STOP_FILLING;
 574
 575  if(sz > nitems)
 576    sz = nitems;
 577
 578  if(sz)
 579    memcpy(buffer, part->data + curlx_sotouz(part->state.offset), sz);
 580
 581  return sz;
 582}
 583
 584static int mime_mem_seek(void *instream, curl_off_t offset, int whence)
 585{
 586  curl_mimepart *part = (curl_mimepart *)instream;
 587
 588  switch(whence) {
 589  case SEEK_CUR:
 590    offset += part->state.offset;
 591    break;
 592  case SEEK_END:
 593    offset += part->datasize;
 594    break;
 595  }
 596
 597  if(offset < 0 || offset > part->datasize)
 598    return CURL_SEEKFUNC_FAIL;
 599
 600  part->state.offset = offset;
 601  return CURL_SEEKFUNC_OK;
 602}
 603
 604static void mime_mem_free(void *ptr)
 605{
 606  curlx_safefree(((curl_mimepart *)ptr)->data);
 607}
 608
 609/* Named file callbacks. */
 610/* Argument is a pointer to the mime part. */
 611static bool mime_open_file(curl_mimepart *part)
 612{
 613  /* Open a MIMEKIND_FILE part. */
 614
 615  if(part->fp)
 616    return FALSE;
 617  part->fp = fopen_read(part->data, "rb");
 618  return part->fp ? FALSE : TRUE;
 619}
 620
 621static size_t mime_file_read(char *buffer, size_t size, size_t nitems,
 622                             void *instream)
 623{
 624  curl_mimepart *part = (curl_mimepart *)instream;
 625
 626  if(!nitems)
 627    return STOP_FILLING;
 628
 629  if(mime_open_file(part))
 630    return READ_ERROR;
 631
 632  return fread(buffer, size, nitems, part->fp);
 633}
 634
 635static int mime_file_seek(void *instream, curl_off_t offset, int whence)
 636{
 637  curl_mimepart *part = (curl_mimepart *)instream;
 638
 639  if(whence == SEEK_SET && !offset && !part->fp)
 640    return CURL_SEEKFUNC_OK;   /* Not open: implicitly already at BOF. */
 641
 642  if(mime_open_file(part))
 643    return CURL_SEEKFUNC_FAIL;
 644
 645  return curlx_fseek(part->fp, offset, whence) ?
 646    CURL_SEEKFUNC_CANTSEEK : CURL_SEEKFUNC_OK;
 647}
 648
 649static void mime_file_free(void *ptr)
 650{
 651  curl_mimepart *part = (curl_mimepart *)ptr;
 652
 653  if(part->fp) {
 654    curlx_fclose(part->fp);
 655    part->fp = NULL;
 656  }
 657  curlx_safefree(part->data);
 658}
 659
 660/* Subparts callbacks. */
 661/* Argument is a pointer to the mime structure. */
 662
 663/* Readback a byte string segment. */
 664static size_t readback_bytes(struct mime_state *state,
 665                             char *buffer, size_t bufsize,
 666                             const char *bytes, size_t numbytes,
 667                             const char *trail, size_t traillen)
 668{
 669  size_t sz;
 670  size_t offset = curlx_sotouz(state->offset);
 671
 672  if(numbytes > offset) {
 673    sz = numbytes - offset;
 674    bytes += offset;
 675  }
 676  else {
 677    sz = offset - numbytes;
 678    if(sz >= traillen)
 679      return 0;
 680    bytes = trail + sz;
 681    sz = traillen - sz;
 682  }
 683
 684  if(sz > bufsize)
 685    sz = bufsize;
 686
 687  memcpy(buffer, bytes, sz);
 688  state->offset += sz;
 689  return sz;
 690}
 691
 692/* Read a non-encoded part content. */
 693
 694static size_t read_part_content(curl_mimepart *part, char *buffer,
 695                                size_t bufsize, bool *hasread,
 696                                size_t call_depth)
 697{
 698  size_t sz = 0;
 699
 700  if(++call_depth > MAX_MIME_LEVELS)
 701    return READ_ERROR;
 702
 703  switch(part->lastreadstatus) {
 704  case 0:
 705  case CURL_READFUNC_ABORT:
 706  case CURL_READFUNC_PAUSE:
 707  case READ_ERROR:
 708    return part->lastreadstatus;
 709  default:
 710    break;
 711  }
 712
 713  /* If we can determine we are at end of part data, spare a read. */
 714  if(part->datasize != (curl_off_t)-1 &&
 715     part->state.offset >= part->datasize) {
 716    /* sz is already zero. */
 717  }
 718  else {
 719    switch(part->kind) {
 720    case MIMEKIND_MULTIPART:
 721      /*
 722       * Cannot be processed as other kinds since read function requires
 723       * an additional parameter and is highly recursive.
 724       */
 725      sz = mime_subparts_read(buffer, 1, bufsize, part->arg, hasread,
 726                              call_depth);
 727      break;
 728    case MIMEKIND_FILE:
 729      if(part->fp && feof(part->fp))
 730        break;  /* At EOF. */
 731      FALLTHROUGH();
 732    default:
 733      if(part->readfunc) {
 734        if(!(part->flags & MIME_FAST_READ)) {
 735          if(*hasread)
 736            return STOP_FILLING;
 737          *hasread = TRUE;
 738        }
 739        sz = part->readfunc(buffer, 1, bufsize, part->arg);
 740      }
 741      break;
 742    }
 743  }
 744
 745  switch(sz) {
 746  case STOP_FILLING:
 747    break;
 748  case 0:
 749  case CURL_READFUNC_ABORT:
 750  case CURL_READFUNC_PAUSE:
 751  case READ_ERROR:
 752    part->lastreadstatus = sz;
 753    break;
 754  default:
 755    part->state.offset += sz;
 756    part->lastreadstatus = sz;
 757    break;
 758  }
 759
 760  return sz;
 761}
 762
 763/* Read and encode part content. */
 764static size_t read_encoded_part_content(curl_mimepart *part, char *buffer,
 765                                        size_t bufsize, bool *hasread,
 766                                        size_t call_depth)
 767{
 768  struct mime_encoder_state *st = &part->encstate;
 769  size_t cursize = 0;
 770  size_t sz;
 771  bool ateof = FALSE;
 772
 773  if(++call_depth > MAX_MIME_LEVELS)
 774    return READ_ERROR;
 775
 776  for(;;) {
 777    if(st->bufbeg < st->bufend || ateof) {
 778      /* Encode buffered data. */
 779      sz = part->encoder->encodefunc(buffer, bufsize, ateof, part);
 780      switch(sz) {
 781      case 0:
 782        if(ateof)
 783          return cursize;
 784        break;
 785      case READ_ERROR:
 786      case STOP_FILLING:
 787        return cursize ? cursize : sz;
 788      default:
 789        cursize += sz;
 790        buffer += sz;
 791        bufsize -= sz;
 792        continue;
 793      }
 794    }
 795
 796    /* We need more data in input buffer. */
 797    if(st->bufbeg) {
 798      size_t len = st->bufend - st->bufbeg;
 799
 800      if(len)
 801        memmove(st->buf, st->buf + st->bufbeg, len);
 802      st->bufbeg = 0;
 803      st->bufend = len;
 804    }
 805    if(st->bufend >= sizeof(st->buf))
 806      return cursize ? cursize : READ_ERROR;    /* Buffer full. */
 807    sz = read_part_content(part, st->buf + st->bufend,
 808                           sizeof(st->buf) - st->bufend, hasread, call_depth);
 809    switch(sz) {
 810    case 0:
 811      ateof = TRUE;
 812      break;
 813    case CURL_READFUNC_ABORT:
 814    case CURL_READFUNC_PAUSE:
 815    case READ_ERROR:
 816    case STOP_FILLING:
 817      return cursize ? cursize : sz;
 818    default:
 819      st->bufend += sz;
 820      break;
 821    }
 822  }
 823
 824  /* NOTREACHED */
 825}
 826
 827/* Readback a mime part. */
 828static size_t readback_part(curl_mimepart *part,
 829                            char *buffer, size_t bufsize, bool *hasread,
 830                            size_t call_depth)
 831{
 832  size_t cursize = 0;
 833
 834  if(++call_depth > MAX_MIME_LEVELS)
 835    return READ_ERROR;
 836
 837  /* Readback from part. */
 838  while(bufsize) {
 839    size_t sz = 0;
 840    struct curl_slist *hdr = (struct curl_slist *)part->state.ptr;
 841    switch(part->state.state) {
 842    case MIMESTATE_BEGIN:
 843      mimesetstate(&part->state,
 844                   (part->flags & MIME_BODY_ONLY) ?
 845                   MIMESTATE_BODY : MIMESTATE_CURLHEADERS,
 846                   part->curlheaders);
 847      break;
 848    case MIMESTATE_USERHEADERS:
 849      if(!hdr) {
 850        mimesetstate(&part->state, MIMESTATE_EOH, NULL);
 851        break;
 852      }
 853      if(match_header(hdr, "Content-Type", 12)) {
 854        mimesetstate(&part->state, MIMESTATE_USERHEADERS, hdr->next);
 855        break;
 856      }
 857      FALLTHROUGH();
 858    case MIMESTATE_CURLHEADERS:
 859      if(!hdr)
 860        mimesetstate(&part->state, MIMESTATE_USERHEADERS, part->userheaders);
 861      else {
 862        sz = readback_bytes(&part->state, buffer, bufsize,
 863                            hdr->data, strlen(hdr->data), STRCONST("\r\n"));
 864        if(!sz)
 865          mimesetstate(&part->state, part->state.state, hdr->next);
 866      }
 867      break;
 868    case MIMESTATE_EOH:
 869      sz = readback_bytes(&part->state, buffer, bufsize, STRCONST("\r\n"),
 870                          STRCONST(""));
 871      if(!sz)
 872        mimesetstate(&part->state, MIMESTATE_BODY, NULL);
 873      break;
 874    case MIMESTATE_BODY:
 875      cleanup_encoder_state(&part->encstate);
 876      mimesetstate(&part->state, MIMESTATE_CONTENT, NULL);
 877      break;
 878    case MIMESTATE_CONTENT:
 879      if(part->encoder)
 880        sz = read_encoded_part_content(part, buffer, bufsize, hasread,
 881                                       call_depth);
 882      else
 883        sz = read_part_content(part, buffer, bufsize, hasread, call_depth);
 884      switch(sz) {
 885      case 0:
 886        mimesetstate(&part->state, MIMESTATE_END, NULL);
 887        /* Try sparing open file descriptors. */
 888        if(part->kind == MIMEKIND_FILE && part->fp) {
 889          curlx_fclose(part->fp);
 890          part->fp = NULL;
 891        }
 892        FALLTHROUGH();
 893      case CURL_READFUNC_ABORT:
 894      case CURL_READFUNC_PAUSE:
 895      case READ_ERROR:
 896      case STOP_FILLING:
 897        return cursize ? cursize : sz;
 898      }
 899      break;
 900    case MIMESTATE_END:
 901      return cursize;
 902    default:
 903      break;    /* Other values not in part state. */
 904    }
 905
 906    /* Bump buffer and counters according to read size. */
 907    cursize += sz;
 908    buffer += sz;
 909    bufsize -= sz;
 910  }
 911
 912  return cursize;
 913}
 914
 915/* Readback from mime. Warning: not a read callback function. */
 916static size_t mime_subparts_read(char *buffer, size_t size, size_t nitems,
 917                                 void *instream, bool *hasread,
 918                                 size_t call_depth)
 919{
 920  curl_mime *mime = (curl_mime *)instream;
 921  size_t cursize = 0;
 922  (void)size;  /* Always 1 */
 923
 924  if(++call_depth > MAX_MIME_LEVELS)
 925    return READ_ERROR;
 926
 927  while(nitems) {
 928    size_t sz = 0;
 929    curl_mimepart *part = mime->state.ptr;
 930    switch(mime->state.state) {
 931    case MIMESTATE_BEGIN:
 932    case MIMESTATE_BODY:
 933      mimesetstate(&mime->state, MIMESTATE_BOUNDARY1, mime->firstpart);
 934      /* The first boundary always follows the header termination empty line,
 935         so is always preceded by a CRLF. We can then spare 2 characters
 936         by skipping the leading CRLF in boundary. */
 937      mime->state.offset += 2;
 938      break;
 939    case MIMESTATE_BOUNDARY1:
 940      sz = readback_bytes(&mime->state, buffer, nitems, STRCONST("\r\n--"),
 941                          STRCONST(""));
 942      if(!sz)
 943        mimesetstate(&mime->state, MIMESTATE_BOUNDARY2, part);
 944      break;
 945    case MIMESTATE_BOUNDARY2:
 946      if(part)
 947        sz = readback_bytes(&mime->state, buffer, nitems, mime->boundary,
 948                            MIME_BOUNDARY_LEN, STRCONST("\r\n"));
 949      else
 950        sz = readback_bytes(&mime->state, buffer, nitems, mime->boundary,
 951                            MIME_BOUNDARY_LEN, STRCONST("--\r\n"));
 952      if(!sz) {
 953        mimesetstate(&mime->state, MIMESTATE_CONTENT, part);
 954      }
 955      break;
 956    case MIMESTATE_CONTENT:
 957      if(!part) {
 958        mimesetstate(&mime->state, MIMESTATE_END, NULL);
 959        break;
 960      }
 961      sz = readback_part(part, buffer, nitems, hasread, call_depth);
 962      switch(sz) {
 963      case CURL_READFUNC_ABORT:
 964      case CURL_READFUNC_PAUSE:
 965      case READ_ERROR:
 966      case STOP_FILLING:
 967        return cursize ? cursize : sz;
 968      case 0:
 969        mimesetstate(&mime->state, MIMESTATE_BOUNDARY1, part->nextpart);
 970        break;
 971      }
 972      break;
 973    case MIMESTATE_END:
 974      return cursize;
 975    default:
 976      break;    /* other values not used in mime state. */
 977    }
 978
 979    /* Bump buffer and counters according to read size. */
 980    cursize += sz;
 981    buffer += sz;
 982    nitems -= sz;
 983  }
 984
 985  return cursize;
 986}
 987
 988static int mime_part_rewind(curl_mimepart *part)
 989{
 990  int res = CURL_SEEKFUNC_OK;
 991  enum mimestate targetstate = MIMESTATE_BEGIN;
 992
 993  if(part->flags & MIME_BODY_ONLY)
 994    targetstate = MIMESTATE_BODY;
 995  cleanup_encoder_state(&part->encstate);
 996  if(part->state.state > targetstate) {
 997    res = CURL_SEEKFUNC_CANTSEEK;
 998    if(part->seekfunc) {
 999      res = part->seekfunc(part->arg, (curl_off_t)0, SEEK_SET);
1000      switch(res) {
1001      case CURL_SEEKFUNC_OK:
1002      case CURL_SEEKFUNC_FAIL:
1003      case CURL_SEEKFUNC_CANTSEEK:
1004        break;
1005      case -1:    /* For fseek() error. */
1006        res = CURL_SEEKFUNC_CANTSEEK;
1007        break;
1008      default:
1009        res = CURL_SEEKFUNC_FAIL;
1010        break;
1011      }
1012    }
1013  }
1014
1015  if(res == CURL_SEEKFUNC_OK)
1016    mimesetstate(&part->state, targetstate, NULL);
1017
1018  part->lastreadstatus = 1; /* Successful read status. */
1019  return res;
1020}
1021
1022static int mime_subparts_seek(void *instream, curl_off_t offset, int whence)
1023{
1024  curl_mime *mime = (curl_mime *)instream;
1025  curl_mimepart *part;
1026  int rc = CURL_SEEKFUNC_OK;
1027
1028  if(whence != SEEK_SET || offset)
1029    return CURL_SEEKFUNC_CANTSEEK;    /* Only support full rewind. */
1030
1031  if(mime->state.state == MIMESTATE_BEGIN)
1032    return CURL_SEEKFUNC_OK;           /* Already rewound. */
1033
1034  for(part = mime->firstpart; part; part = part->nextpart) {
1035    int res = mime_part_rewind(part);
1036    if(res != CURL_SEEKFUNC_OK)
1037      rc = res;
1038  }
1039
1040  if(rc == CURL_SEEKFUNC_OK)
1041    mimesetstate(&mime->state, MIMESTATE_BEGIN, NULL);
1042
1043  return rc;
1044}
1045
1046/* Release part content. */
1047static void cleanup_part_content(curl_mimepart *part)
1048{
1049  if(part->freefunc)
1050    part->freefunc(part->arg);
1051
1052  part->readfunc = NULL;
1053  part->seekfunc = NULL;
1054  part->freefunc = NULL;
1055  part->arg = (void *)part;           /* Defaults to part itself. */
1056  part->data = NULL;
1057  part->fp = NULL;
1058  part->datasize = (curl_off_t)0;     /* No size yet. */
1059  cleanup_encoder_state(&part->encstate);
1060  part->kind = MIMEKIND_NONE;
1061  part->flags &= ~(unsigned int)MIME_FAST_READ;
1062  part->lastreadstatus = 1; /* Successful read status. */
1063  part->state.state = MIMESTATE_BEGIN;
1064}
1065
1066static void mime_subparts_free(void *ptr)
1067{
1068  curl_mime *mime = (curl_mime *)ptr;
1069
1070  if(mime && mime->parent) {
1071    mime->parent->freefunc = NULL;  /* Be sure we will not be called again. */
1072    cleanup_part_content(mime->parent);  /* Avoid dangling pointer in part. */
1073  }
1074  curl_mime_free(mime);
1075}
1076
1077/* Do not free subparts: unbind them. This is used for the top level only. */
1078static void mime_subparts_unbind(void *ptr)
1079{
1080  curl_mime *mime = (curl_mime *)ptr;
1081
1082  if(mime && mime->parent) {
1083    mime->parent->freefunc = NULL;  /* Be sure we will not be called again. */
1084    cleanup_part_content(mime->parent);  /* Avoid dangling pointer in part. */
1085    mime->parent = NULL;
1086  }
1087}
1088
1089void Curl_mime_cleanpart(curl_mimepart *part)
1090{
1091  if(part) {
1092    cleanup_part_content(part);
1093    curl_slist_free_all(part->curlheaders);
1094    if(part->flags & MIME_USERHEADERS_OWNER)
1095      curl_slist_free_all(part->userheaders);
1096    curlx_safefree(part->mimetype);
1097    curlx_safefree(part->name);
1098    curlx_safefree(part->filename);
1099    Curl_mime_initpart(part);
1100  }
1101}
1102
1103/* Recursively delete a mime handle and its parts. */
1104void curl_mime_free(curl_mime *mime)
1105{
1106  curl_mimepart *part;
1107
1108  if(mime) {
1109    mime_subparts_unbind(mime);  /* Be sure it is not referenced anymore. */
1110    while(mime->firstpart) {
1111      part = mime->firstpart;
1112      mime->firstpart = part->nextpart;
1113      Curl_mime_cleanpart(part);
1114      curlx_free(part);
1115    }
1116    curlx_free(mime);
1117  }
1118}
1119
1120CURLcode Curl_mime_duppart(struct Curl_easy *data,
1121                           curl_mimepart *dst, const curl_mimepart *src)
1122{
1123  curl_mime *mime;
1124  curl_mimepart *d;
1125  const curl_mimepart *s;
1126  CURLcode res = CURLE_OK;
1127
1128  DEBUGASSERT(dst);
1129
1130  /* Duplicate content. */
1131  switch(src->kind) {
1132  case MIMEKIND_NONE:
1133    break;
1134  case MIMEKIND_DATA:
1135    res = curl_mime_data(dst, src->data, (size_t)src->datasize);
1136    break;
1137  case MIMEKIND_FILE:
1138    res = curl_mime_filedata(dst, src->data);
1139    /* Do not abort duplication if file is not readable. */
1140    if(res == CURLE_READ_ERROR)
1141      res = CURLE_OK;
1142    break;
1143  case MIMEKIND_CALLBACK:
1144    res = curl_mime_data_cb(dst, src->datasize, src->readfunc,
1145                            src->seekfunc, src->freefunc, src->arg);
1146    break;
1147  case MIMEKIND_MULTIPART:
1148    /* No one knows about the cloned subparts, thus always attach ownership
1149       to the part. */
1150    mime = curl_mime_init(data);
1151    res = mime ? curl_mime_subparts(dst, mime) : CURLE_OUT_OF_MEMORY;
1152
1153    /* Duplicate subparts. */
1154    for(s = ((curl_mime *)src->arg)->firstpart; !res && s; s = s->nextpart) {
1155      d = curl_mime_addpart(mime);
1156      res = d ? Curl_mime_duppart(data, d, s) : CURLE_OUT_OF_MEMORY;
1157    }
1158    break;
1159  default:  /* Invalid kind: should not occur. */
1160    DEBUGF(infof(data, "invalid MIMEKIND* attempt"));
1161    res = CURLE_BAD_FUNCTION_ARGUMENT;  /* Internal error? */
1162    break;
1163  }
1164
1165  /* Duplicate headers. */
1166  if(!res && src->userheaders) {
1167    struct curl_slist *hdrs = Curl_slist_duplicate(src->userheaders);
1168
1169    if(!hdrs)
1170      res = CURLE_OUT_OF_MEMORY;
1171    else {
1172      /* No one but this procedure knows about the new header list,
1173         so always take ownership. */
1174      res = curl_mime_headers(dst, hdrs, TRUE);
1175      if(res)
1176        curl_slist_free_all(hdrs);
1177    }
1178  }
1179
1180  if(!res) {
1181    /* Duplicate other fields. */
1182    dst->encoder = src->encoder;
1183    res = curl_mime_type(dst, src->mimetype);
1184  }
1185  if(!res)
1186    res = curl_mime_name(dst, src->name);
1187  if(!res)
1188    res = curl_mime_filename(dst, src->filename);
1189
1190  /* If an error occurred, rollback. */
1191  if(res)
1192    Curl_mime_cleanpart(dst);
1193
1194  return res;
1195}
1196
1197/*
1198 * Mime build functions.
1199 */
1200
1201/* Create a mime handle. */
1202curl_mime *curl_mime_init(void *easy)
1203{
1204  curl_mime *mime;
1205
1206  mime = (curl_mime *)curlx_malloc(sizeof(*mime));
1207
1208  if(mime) {
1209    mime->parent = NULL;
1210    mime->firstpart = NULL;
1211    mime->lastpart = NULL;
1212
1213    memset(mime->boundary, '-', MIME_BOUNDARY_DASHES);
1214    if(Curl_rand_alnum(easy,
1215                       (unsigned char *)&mime->boundary[MIME_BOUNDARY_DASHES],
1216                       MIME_RAND_BOUNDARY_CHARS + 1)) {
1217      /* failed to get random separator, bail out */
1218      curlx_free(mime);
1219      return NULL;
1220    }
1221    mimesetstate(&mime->state, MIMESTATE_BEGIN, NULL);
1222  }
1223
1224  return mime;
1225}
1226
1227/* Initialize a mime part. */
1228void Curl_mime_initpart(curl_mimepart *part)
1229{
1230  memset(part, 0, sizeof(*part));
1231  part->lastreadstatus = 1; /* Successful read status. */
1232  mimesetstate(&part->state, MIMESTATE_BEGIN, NULL);
1233}
1234
1235/* Create a mime part and append it to a mime handle's part list. */
1236curl_mimepart *curl_mime_addpart(curl_mime *mime)
1237{
1238  curl_mimepart *part;
1239
1240  if(!mime)
1241    return NULL;
1242
1243  part = (curl_mimepart *)curlx_malloc(sizeof(*part));
1244
1245  if(part) {
1246    Curl_mime_initpart(part);
1247    part->parent = mime;
1248
1249    if(mime->lastpart)
1250      mime->lastpart->nextpart = part;
1251    else
1252      mime->firstpart = part;
1253
1254    mime->lastpart = part;
1255  }
1256
1257  return part;
1258}
1259
1260/* Set mime part name. */
1261CURLcode curl_mime_name(curl_mimepart *part, const char *name)
1262{
1263  if(!part)
1264    return CURLE_BAD_FUNCTION_ARGUMENT;
1265
1266  curlx_safefree(part->name);
1267
1268  if(name) {
1269    part->name = curlx_strdup(name);
1270    if(!part->name)
1271      return CURLE_OUT_OF_MEMORY;
1272  }
1273
1274  return CURLE_OK;
1275}
1276
1277/* Set mime part remote filename. */
1278CURLcode curl_mime_filename(curl_mimepart *part, const char *filename)
1279{
1280  if(!part)
1281    return CURLE_BAD_FUNCTION_ARGUMENT;
1282
1283  curlx_safefree(part->filename);
1284
1285  if(filename) {
1286    part->filename = curlx_strdup(filename);
1287    if(!part->filename)
1288      return CURLE_OUT_OF_MEMORY;
1289  }
1290
1291  return CURLE_OK;
1292}
1293
1294/* Set mime part content from memory data. */
1295CURLcode curl_mime_data(curl_mimepart *part, const char *data, size_t datasize)
1296{
1297  if(!part)
1298    return CURLE_BAD_FUNCTION_ARGUMENT;
1299
1300  cleanup_part_content(part);
1301
1302  if(data) {
1303    if(datasize == CURL_ZERO_TERMINATED)
1304      datasize = strlen(data);
1305
1306    part->data = curlx_memdup0(data, datasize);
1307    if(!part->data)
1308      return CURLE_OUT_OF_MEMORY;
1309
1310    part->datasize = datasize;
1311    part->readfunc = mime_mem_read;
1312    part->seekfunc = mime_mem_seek;
1313    part->freefunc = mime_mem_free;
1314    part->flags |= MIME_FAST_READ;
1315    part->kind = MIMEKIND_DATA;
1316  }
1317
1318  return CURLE_OK;
1319}
1320
1321/* Set mime part content from named local file. */
1322CURLcode curl_mime_filedata(curl_mimepart *part, const char *filename)
1323{
1324  CURLcode result = CURLE_OK;
1325
1326  if(!part)
1327    return CURLE_BAD_FUNCTION_ARGUMENT;
1328
1329  cleanup_part_content(part);
1330
1331  if(filename) {
1332    char *base;
1333    curlx_struct_stat sbuf;
1334
1335    if(curlx_stat(filename, &sbuf))
1336      result = CURLE_READ_ERROR;
1337    else {
1338      part->data = curlx_strdup(filename);
1339      if(!part->data)
1340        result = CURLE_OUT_OF_MEMORY;
1341      else {
1342        part->datasize = -1;
1343        if(S_ISREG(sbuf.st_mode)) {
1344          part->datasize = filesize(filename, sbuf);
1345          part->seekfunc = mime_file_seek;
1346        }
1347
1348        part->readfunc = mime_file_read;
1349        part->freefunc = mime_file_free;
1350        part->kind = MIMEKIND_FILE;
1351
1352        /* As a side effect, set the filename to the current file's base name.
1353           It is possible to withdraw this by explicitly calling
1354           curl_mime_filename() with a NULL filename argument after the current
1355           call. */
1356        base = strippath(filename);
1357        if(!base)
1358          result = CURLE_OUT_OF_MEMORY;
1359        else {
1360          result = curl_mime_filename(part, base);
1361          curlx_free(base);
1362        }
1363      }
1364    }
1365  }
1366  return result;
1367}
1368
1369/* Set mime part type. */
1370CURLcode curl_mime_type(curl_mimepart *part, const char *mimetype)
1371{
1372  if(!part)
1373    return CURLE_BAD_FUNCTION_ARGUMENT;
1374
1375  curlx_safefree(part->mimetype);
1376
1377  if(mimetype) {
1378    part->mimetype = curlx_strdup(mimetype);
1379    if(!part->mimetype)
1380      return CURLE_OUT_OF_MEMORY;
1381  }
1382
1383  return CURLE_OK;
1384}
1385
1386static const struct mime_encoder encoders[] = {
1387  { "binary", encoder_nop_read, encoder_nop_size },
1388  { "8bit", encoder_nop_read, encoder_nop_size },
1389  { "7bit", encoder_7bit_read, encoder_nop_size },
1390  { "base64", encoder_base64_read, encoder_base64_size },
1391  { "quoted-printable", encoder_qp_read, encoder_qp_size },
1392  { ZERO_NULL, ZERO_NULL, ZERO_NULL }
1393};
1394
1395/* Set mime data transfer encoder. */
1396CURLcode curl_mime_encoder(curl_mimepart *part, const char *encoding)
1397{
1398  CURLcode result = CURLE_BAD_FUNCTION_ARGUMENT;
1399  const struct mime_encoder *mep;
1400
1401  if(!part)
1402    return result;
1403
1404  part->encoder = NULL;
1405
1406  if(!encoding)
1407    return CURLE_OK;    /* Removing current encoder. */
1408
1409  for(mep = encoders; mep->name; mep++)
1410    if(curl_strequal(encoding, mep->name)) {
1411      part->encoder = mep;
1412      result = CURLE_OK;
1413    }
1414
1415  return result;
1416}
1417
1418/* Set mime part headers. */
1419CURLcode curl_mime_headers(curl_mimepart *part,
1420                           struct curl_slist *headers, int take_ownership)
1421{
1422  if(!part)
1423    return CURLE_BAD_FUNCTION_ARGUMENT;
1424
1425  if(part->flags & MIME_USERHEADERS_OWNER) {
1426    if(part->userheaders != headers)  /* Allow setting twice the same list. */
1427      curl_slist_free_all(part->userheaders);
1428    part->flags &= ~(unsigned int)MIME_USERHEADERS_OWNER;
1429  }
1430  part->userheaders = headers;
1431  if(headers && take_ownership)
1432    part->flags |= MIME_USERHEADERS_OWNER;
1433  return CURLE_OK;
1434}
1435
1436/* Set mime part content from callback. */
1437CURLcode curl_mime_data_cb(curl_mimepart *part, curl_off_t datasize,
1438                           curl_read_callback readfunc,
1439                           curl_seek_callback seekfunc,
1440                           curl_free_callback freefunc, void *arg)
1441{
1442  if(!part)
1443    return CURLE_BAD_FUNCTION_ARGUMENT;
1444
1445  cleanup_part_content(part);
1446
1447  if(readfunc) {
1448    part->readfunc = readfunc;
1449    part->seekfunc = seekfunc;
1450    part->freefunc = freefunc;
1451    part->arg = arg;
1452    part->datasize = datasize;
1453    part->kind = MIMEKIND_CALLBACK;
1454  }
1455
1456  return CURLE_OK;
1457}
1458
1459/* Set mime part content from subparts. */
1460CURLcode Curl_mime_set_subparts(curl_mimepart *part,
1461                                curl_mime *subparts, int take_ownership)
1462{
1463  curl_mime *root;
1464
1465  if(!part)
1466    return CURLE_BAD_FUNCTION_ARGUMENT;
1467
1468  /* Accept setting twice the same subparts. */
1469  if(part->kind == MIMEKIND_MULTIPART && part->arg == subparts)
1470    return CURLE_OK;
1471
1472  cleanup_part_content(part);
1473
1474  if(subparts) {
1475    /* Should not have been attached already. */
1476    if(subparts->parent)
1477      return CURLE_BAD_FUNCTION_ARGUMENT;
1478
1479    /* Should not be the part's root. */
1480    root = part->parent;
1481    if(root) {
1482      while(root->parent && root->parent->parent)
1483        root = root->parent->parent;
1484      if(subparts == root) {
1485        /* cannot add as a subpart of itself. */
1486        return CURLE_BAD_FUNCTION_ARGUMENT;
1487      }
1488    }
1489
1490    /* If subparts have already been used as a top-level MIMEPOST,
1491       they might not be positioned at start. Rewind them now, as
1492       a future check while rewinding the parent may cause this
1493       content to be skipped. */
1494    if(mime_subparts_seek(subparts, (curl_off_t)0, SEEK_SET) !=
1495       CURL_SEEKFUNC_OK)
1496      return CURLE_SEND_FAIL_REWIND;
1497
1498    subparts->parent = part;
1499    /* Subparts are processed internally: no read callback. */
1500    part->seekfunc = mime_subparts_seek;
1501    part->freefunc = take_ownership ? mime_subparts_free :
1502      mime_subparts_unbind;
1503    part->arg = subparts;
1504    part->datasize = -1;
1505    part->kind = MIMEKIND_MULTIPART;
1506  }
1507
1508  return CURLE_OK;
1509}
1510
1511CURLcode curl_mime_subparts(curl_mimepart *part, curl_mime *subparts)
1512{
1513  return Curl_mime_set_subparts(part, subparts, TRUE);
1514}
1515
1516/* Readback from top mime. */
1517/* Argument is the dummy top part. */
1518size_t Curl_mime_read(char *buffer, size_t size, size_t nitems, void *instream)
1519{
1520  curl_mimepart *part = (curl_mimepart *)instream;
1521  size_t ret;
1522  bool hasread;
1523
1524  (void)size;  /* Always 1 */
1525
1526  /* If `nitems` is <= 4, some encoders will return STOP_FILLING without
1527   * adding any data and this loops infinitely. */
1528  do {
1529    hasread = FALSE;
1530    ret = readback_part(part, buffer, nitems, &hasread, 0);
1531    /*
1532     * If this is not possible to get some data without calling more than
1533     * one read callback (probably because a content encoder is not able to
1534     * deliver a new bunch for the few data accumulated so far), force another
1535     * read until we get enough data or a special exit code.
1536     */
1537  } while(ret == STOP_FILLING);
1538
1539  return ret;
1540}
1541
1542/* Rewind mime stream. */
1543static CURLcode mime_rewind(curl_mimepart *part)
1544{
1545  return mime_part_rewind(part) == CURL_SEEKFUNC_OK ?
1546         CURLE_OK : CURLE_SEND_FAIL_REWIND;
1547}
1548
1549/* Compute header list size. */
1550static size_t slist_size(struct curl_slist *s,
1551                         size_t overhead, const char *skip, size_t skiplen)
1552{
1553  size_t size = 0;
1554
1555  for(; s; s = s->next)
1556    if(!skip || !match_header(s, skip, skiplen))
1557      size += strlen(s->data) + overhead;
1558  return size;
1559}
1560
1561/* Get/compute multipart size. */
1562static curl_off_t multipart_size(curl_mime *mime)
1563{
1564  curl_off_t size;
1565  curl_off_t boundarysize;
1566  curl_mimepart *part;
1567
1568  if(!mime)
1569    return 0;           /* Not present -> empty. */
1570
1571  boundarysize = 4 + MIME_BOUNDARY_LEN + 2;
1572  size = boundarysize;  /* Final boundary - CRLF after headers. */
1573
1574  for(part = mime->firstpart; part; part = part->nextpart) {
1575    curl_off_t sz = mime_size(part);
1576
1577    if(sz < 0)
1578      size = sz;
1579
1580    if(size >= 0)
1581      size += boundarysize + sz;
1582  }
1583
1584  return size;
1585}
1586
1587/* Get/compute mime size. */
1588static curl_off_t mime_size(curl_mimepart *part)
1589{
1590  curl_off_t size;
1591
1592  if(part->kind == MIMEKIND_MULTIPART)
1593    part->datasize = multipart_size(part->arg);
1594
1595  size = part->datasize;
1596
1597  if(part->encoder)
1598    size = part->encoder->sizefunc(part);
1599
1600  if(size >= 0 && !(part->flags & MIME_BODY_ONLY)) {
1601    /* Compute total part size. */
1602    size += slist_size(part->curlheaders, 2, NULL, 0);
1603    size += slist_size(part->userheaders, 2, STRCONST("Content-Type"));
1604    size += 2;    /* CRLF after headers. */
1605  }
1606  return size;
1607}
1608
1609/* Add a header. */
1610/* VARARGS2 */
1611CURLcode Curl_mime_add_header(struct curl_slist **slp, const char *fmt, ...)
1612{
1613  struct curl_slist *hdr = NULL;
1614  char *s = NULL;
1615  va_list ap;
1616
1617  va_start(ap, fmt);
1618  s = curl_mvaprintf(fmt, ap);
1619  va_end(ap);
1620
1621  if(s) {
1622    hdr = Curl_slist_append_nodup(*slp, s);
1623    if(hdr)
1624      *slp = hdr;
1625    else
1626      curlx_free(s);
1627  }
1628
1629  return hdr ? CURLE_OK : CURLE_OUT_OF_MEMORY;
1630}
1631
1632/* Add a content type header. */
1633static CURLcode add_content_type(struct curl_slist **slp,
1634                                 const char *type, const char *boundary)
1635{
1636  return Curl_mime_add_header(slp, "Content-Type: %s%s%s", type,
1637                              boundary ? "; boundary=" : "",
1638                              boundary ? boundary : "");
1639}
1640
1641const char *Curl_mime_contenttype(const char *filename)
1642{
1643  /*
1644   * If no content type was specified, we scan through a few well-known
1645   * extensions and pick the first we match!
1646   */
1647  struct ContentType {
1648    const char *extension;
1649    const char *type;
1650  };
1651  static const struct ContentType ctts[] = {
1652    { ".gif",  "image/gif" },
1653    { ".jpg",  "image/jpeg" },
1654    { ".jpeg", "image/jpeg" },
1655    { ".png",  "image/png" },
1656    { ".svg",  "image/svg+xml" },
1657    { ".txt",  "text/plain" },
1658    { ".htm",  "text/html" },
1659    { ".html", "text/html" },
1660    { ".pdf",  "application/pdf" },
1661    { ".xml",  "application/xml" }
1662  };
1663
1664  if(filename) {
1665    size_t len1 = strlen(filename);
1666    const char *nameend = filename + len1;
1667    unsigned int i;
1668
1669    for(i = 0; i < CURL_ARRAYSIZE(ctts); i++) {
1670      size_t len2 = strlen(ctts[i].extension);
1671
1672      if(len1 >= len2 && curl_strequal(nameend - len2, ctts[i].extension))
1673        return ctts[i].type;
1674    }
1675  }
1676  return NULL;
1677}
1678
1679static bool content_type_match(const char *contenttype,
1680                               const char *target, size_t len)
1681{
1682  if(contenttype && curl_strnequal(contenttype, target, len))
1683    switch(contenttype[len]) {
1684    case '\0':
1685    case '\t':
1686    case '\r':
1687    case '\n':
1688    case ' ':
1689    case ';':
1690      return TRUE;
1691    }
1692  return FALSE;
1693}
1694
1695static CURLcode add_content_disposition(struct Curl_easy *data,
1696                                        curl_mimepart *part,
1697                                        const char *disposition,
1698                                        const char *contenttype,
1699                                        enum mimestrategy strategy)
1700{
1701  if(!disposition)
1702    if(part->filename || part->name ||
1703       (contenttype && !curl_strnequal(contenttype, "multipart/", 10)))
1704      disposition = DISPOSITION_DEFAULT;
1705  if(disposition && curl_strequal(disposition, "attachment") &&
1706     !part->name && !part->filename)
1707    disposition = NULL;
1708  if(disposition) {
1709    CURLcode result = CURLE_OK;
1710    char *name = NULL;
1711    char *filename = NULL;
1712
1713    if(part->name) {
1714      name = escape_string(data, part->name, strategy);
1715      if(!name)
1716        return CURLE_OUT_OF_MEMORY;
1717    }
1718    if(part->filename) {
1719      filename = escape_string(data, part->filename, strategy);
1720      if(!filename)
1721        result = CURLE_OUT_OF_MEMORY;
1722    }
1723    if(!result)
1724      result = Curl_mime_add_header(&part->curlheaders,
1725                                    "Content-Disposition: %s%s%s%s%s%s%s",
1726                                    disposition,
1727                                    name ? "; name=\"" : "",
1728                                    name ? name : "",
1729                                    name ? "\"" : "",
1730                                    filename ? "; filename=\"" : "",
1731                                    filename ? filename : "",
1732                                    filename ? "\"" : "");
1733    curlx_safefree(name);
1734    curlx_safefree(filename);
1735    if(result)
1736      return result;
1737  }
1738  return CURLE_OK;
1739}
1740
1741CURLcode Curl_mime_prepare_headers(struct Curl_easy *data,
1742                                   curl_mimepart *part,
1743                                   const char *contenttype,
1744                                   const char *disposition,
1745                                   enum mimestrategy strategy)
1746{
1747  curl_mime *mime = NULL;
1748  const char *boundary = NULL;
1749  char *customct;
1750  const char *cte = NULL;
1751  CURLcode result = CURLE_OK;
1752
1753  /* Get rid of previously prepared headers. */
1754  curl_slist_free_all(part->curlheaders);
1755  part->curlheaders = NULL;
1756
1757  /* Be sure we will not access old headers later. */
1758  if(part->state.state == MIMESTATE_CURLHEADERS)
1759    mimesetstate(&part->state, MIMESTATE_CURLHEADERS, NULL);
1760
1761  /* Check if content type is specified. */
1762  customct = part->mimetype;
1763  if(!customct)
1764    customct = search_header(part->userheaders, STRCONST("Content-Type"));
1765  if(customct)
1766    contenttype = customct;
1767
1768  /* If content type is not specified, try to determine it. */
1769  if(!contenttype) {
1770    switch(part->kind) {
1771    case MIMEKIND_MULTIPART:
1772      contenttype = MULTIPART_CONTENTTYPE_DEFAULT;
1773      break;
1774    case MIMEKIND_FILE:
1775      contenttype = Curl_mime_contenttype(part->filename);
1776      if(!contenttype)
1777        contenttype = Curl_mime_contenttype(part->data);
1778      if(!contenttype && part->filename)
1779        contenttype = FILE_CONTENTTYPE_DEFAULT;
1780      break;
1781    default:
1782      contenttype = Curl_mime_contenttype(part->filename);
1783      break;
1784    }
1785  }
1786
1787  if(part->kind == MIMEKIND_MULTIPART) {
1788    mime = (curl_mime *)part->arg;
1789    if(mime)
1790      boundary = mime->boundary;
1791  }
1792  else if(contenttype && !customct &&
1793          content_type_match(contenttype, STRCONST("text/plain")))
1794    if(strategy == MIMESTRATEGY_MAIL || !part->filename)
1795      contenttype = NULL;
1796
1797  /* Issue content-disposition header only if not already set by caller. */
1798  if(!search_header(part->userheaders, STRCONST("Content-Disposition"))) {
1799    result = add_content_disposition(data, part, disposition,
1800                                     contenttype, strategy);
1801    if(result)
1802      return result;
1803  }
1804
1805  /* Issue Content-Type header. */
1806  if(contenttype) {
1807    result = add_content_type(&part->curlheaders, contenttype, boundary);
1808    if(result)
1809      return result;
1810  }
1811
1812  /* Content-Transfer-Encoding header. */
1813  if(!search_header(part->userheaders,
1814                    STRCONST("Content-Transfer-Encoding"))) {
1815    if(part->encoder)
1816      cte = part->encoder->name;
1817    else if(contenttype && strategy == MIMESTRATEGY_MAIL &&
1818            part->kind != MIMEKIND_MULTIPART)
1819      cte = "8bit";
1820    if(cte) {
1821      result = Curl_mime_add_header(&part->curlheaders,
1822                                    "Content-Transfer-Encoding: %s", cte);
1823      if(result)
1824        return result;
1825    }
1826  }
1827
1828  /* If we were reading curl-generated headers, restart with new ones (this
1829     should not occur). */
1830  if(part->state.state == MIMESTATE_CURLHEADERS)
1831    mimesetstate(&part->state, MIMESTATE_CURLHEADERS, part->curlheaders);
1832
1833  /* Process subparts. */
1834  if(part->kind == MIMEKIND_MULTIPART && mime) {
1835    curl_mimepart *subpart;
1836
1837    disposition = NULL;
1838    if(content_type_match(contenttype, STRCONST("multipart/form-data")))
1839      disposition = "form-data";
1840    for(subpart = mime->firstpart; subpart; subpart = subpart->nextpart) {
1841      result = Curl_mime_prepare_headers(data, subpart, NULL,
1842                                         disposition, strategy);
1843      if(result)
1844        return result;
1845    }
1846  }
1847  return result;
1848}
1849
1850/* Recursively reset paused status in the given part. */
1851static void mime_unpause(curl_mimepart *part)
1852{
1853  if(part) {
1854    if(part->lastreadstatus == CURL_READFUNC_PAUSE)
1855      part->lastreadstatus = 1; /* Successful read status. */
1856    if(part->kind == MIMEKIND_MULTIPART) {
1857      curl_mime *mime = (curl_mime *)part->arg;
1858
1859      if(mime) {
1860        curl_mimepart *subpart;
1861
1862        for(subpart = mime->firstpart; subpart; subpart = subpart->nextpart)
1863          mime_unpause(subpart);
1864      }
1865    }
1866  }
1867}
1868
1869struct cr_mime_ctx {
1870  struct Curl_creader super;
1871  curl_mimepart *part;
1872  curl_off_t total_len;
1873  curl_off_t read_len;
1874  CURLcode error_result;
1875  struct bufq tmpbuf;
1876  BIT(seen_eos);
1877  BIT(errored);
1878};
1879
1880static CURLcode cr_mime_init(struct Curl_easy *data,
1881                             struct Curl_creader *reader)
1882{
1883  struct cr_mime_ctx *ctx = reader->ctx;
1884  (void)data;
1885  ctx->total_len = -1;
1886  ctx->read_len = 0;
1887  Curl_bufq_init2(&ctx->tmpbuf, 1024, 1, BUFQ_OPT_NO_SPARES);
1888  return CURLE_OK;
1889}
1890
1891static void cr_mime_close(struct Curl_easy *data,
1892                          struct Curl_creader *reader)
1893{
1894  struct cr_mime_ctx *ctx = reader->ctx;
1895  (void)data;
1896  Curl_bufq_free(&ctx->tmpbuf);
1897}
1898
1899/* Real client reader to installed client callbacks. */
1900static CURLcode cr_mime_read(struct Curl_easy *data,
1901                             struct Curl_creader *reader,
1902                             char *buf, size_t blen,
1903                             size_t *pnread, bool *peos)
1904{
1905  struct cr_mime_ctx *ctx = reader->ctx;
1906  CURLcode result = CURLE_OK;
1907  size_t nread;
1908  char tmp[256];
1909
1910  /* Once we have errored, we will return the same error forever */
1911  if(ctx->errored) {
1912    CURL_TRC_READ(data, "cr_mime_read(len=%zu) is errored -> %d, eos=0",
1913                  blen, ctx->error_result);
1914    *pnread = 0;
1915    *peos = FALSE;
1916    return ctx->error_result;
1917  }
1918  if(ctx->seen_eos) {
1919    CURL_TRC_READ(data, "cr_mime_read(len=%zu) seen eos -> 0, eos=1", blen);
1920    *pnread = 0;
1921    *peos = TRUE;
1922    return CURLE_OK;
1923  }
1924  /* respect length limitations */
1925  if(ctx->total_len >= 0) {
1926    curl_off_t remain = ctx->total_len - ctx->read_len;
1927    if(remain <= 0)
1928      blen = 0;
1929    else if(remain < (curl_off_t)blen)
1930      blen = (size_t)remain;
1931  }
1932
1933  if(!Curl_bufq_is_empty(&ctx->tmpbuf)) {
1934    result = Curl_bufq_read(&ctx->tmpbuf, (unsigned char *)buf, blen, &nread);
1935    if(result) {
1936      ctx->errored = TRUE;
1937      ctx->error_result = result;
1938      return result;
1939    }
1940  }
1941  else if(blen <= 4) {
1942    /* Curl_mime_read() may go into an infinite loop when reading
1943     * via a base64 encoder, as it stalls when the read buffer is too small
1944     * to contain a complete 3 byte encoding. Read into a larger buffer
1945     * and use that until empty. */
1946    CURL_TRC_READ(data, "cr_mime_read(len=%zu), small read, using tmp", blen);
1947    nread = Curl_mime_read(tmp, 1, sizeof(tmp), ctx->part);
1948    if(nread <= sizeof(tmp)) {
1949      size_t n;
1950      result = Curl_bufq_write(&ctx->tmpbuf, (unsigned char *)tmp, nread, &n);
1951      if(result) {
1952        ctx->errored = TRUE;
1953        ctx->error_result = result;
1954        return result;
1955      }
1956      /* stored it, read again */
1957      result = Curl_bufq_cread(&ctx->tmpbuf, buf, blen, &nread);
1958      if(result) {
1959        ctx->errored = TRUE;
1960        ctx->error_result = result;
1961        return result;
1962      }
1963    }
1964  }
1965  else
1966    nread = Curl_mime_read(buf, 1, blen, ctx->part);
1967
1968  CURL_TRC_READ(data, "cr_mime_read(len=%zu), mime_read() -> %zu",
1969                blen, nread);
1970
1971  switch(nread) {
1972  case 0:
1973    if((ctx->total_len >= 0) && (ctx->read_len < ctx->total_len)) {
1974      failf(data, "client mime read EOF fail, "
1975            "only %" FMT_OFF_T "/%" FMT_OFF_T
1976            " of needed bytes read", ctx->read_len, ctx->total_len);
1977      return CURLE_READ_ERROR;
1978    }
1979    *pnread = 0;
1980    *peos = TRUE;
1981    ctx->seen_eos = TRUE;
1982    break;
1983
1984  case CURL_READFUNC_ABORT:
1985    failf(data, "operation aborted by callback");
1986    *pnread = 0;
1987    *peos = FALSE;
1988    ctx->errored = TRUE;
1989    ctx->error_result = CURLE_ABORTED_BY_CALLBACK;
1990    result = CURLE_ABORTED_BY_CALLBACK;
1991    break;
1992
1993  case CURL_READFUNC_PAUSE:
1994    /* CURL_READFUNC_PAUSE pauses read callbacks that feed socket writes */
1995    CURL_TRC_READ(data, "cr_mime_read(len=%zu), paused by callback", blen);
1996    *pnread = 0;
1997    *peos = FALSE;
1998    result = Curl_xfer_pause_send(data, TRUE);
1999    break; /* nothing was read */
2000
2001  case STOP_FILLING:
2002  case READ_ERROR:
2003    failf(data, "read error getting mime data");
2004    *pnread = 0;
2005    *peos = FALSE;
2006    ctx->errored = TRUE;
2007    ctx->error_result = CURLE_READ_ERROR;
2008    result = CURLE_READ_ERROR;
2009    break;
2010
2011  default:
2012    if(nread > blen) {
2013      /* the read function returned a too large value */
2014      failf(data, "read function returned funny value");
2015      *pnread = 0;
2016      *peos = FALSE;
2017      ctx->errored = TRUE;
2018      ctx->error_result = CURLE_READ_ERROR;
2019      return CURLE_READ_ERROR;
2020    }
2021    ctx->read_len += nread;
2022    if(ctx->total_len >= 0)
2023      ctx->seen_eos = (ctx->read_len >= ctx->total_len);
2024    *pnread = nread;
2025    *peos = (bool)ctx->seen_eos;
2026    break;
2027  }
2028
2029  CURL_TRC_READ(data, "cr_mime_read(len=%zu, total=%" FMT_OFF_T
2030                ", read=%" FMT_OFF_T ") -> %d, %zu, %d",
2031                blen, ctx->total_len, ctx->read_len, result, *pnread, *peos);
2032  return result;
2033}
2034
2035static bool cr_mime_needs_rewind(struct Curl_easy *data,
2036                                 struct Curl_creader *reader)
2037{
2038  struct cr_mime_ctx *ctx = reader->ctx;
2039  (void)data;
2040  return ctx->read_len > 0;
2041}
2042
2043static curl_off_t cr_mime_total_length(struct Curl_easy *data,
2044                                       struct Curl_creader *reader)
2045{
2046  struct cr_mime_ctx *ctx = reader->ctx;
2047  (void)data;
2048  return ctx->total_len;
2049}
2050
2051static CURLcode cr_mime_resume_from(struct Curl_easy *data,
2052                                    struct Curl_creader *reader,
2053                                    curl_off_t offset)
2054{
2055  struct cr_mime_ctx *ctx = reader->ctx;
2056
2057  if(offset > 0) {
2058    curl_off_t passed = 0;
2059
2060    do {
2061      char scratch[4 * 1024];
2062      size_t readthisamountnow =
2063        (offset - passed > (curl_off_t)sizeof(scratch)) ?
2064        sizeof(scratch) :
2065        curlx_sotouz(offset - passed);
2066      size_t nread;
2067
2068      nread = Curl_mime_read(scratch, 1, readthisamountnow, ctx->part);
2069      passed += (curl_off_t)nread;
2070      if((nread == 0) || (nread > readthisamountnow)) {
2071        /* this checks for greater-than only to make sure that the
2072           CURL_READFUNC_ABORT return code still aborts */
2073        failf(data, "Could only read %" FMT_OFF_T
2074              " bytes from the mime post", passed);
2075        return CURLE_READ_ERROR;
2076      }
2077    } while(passed < offset);
2078
2079    /* now, decrease the size of the read */
2080    if(ctx->total_len > 0) {
2081      ctx->total_len -= offset;
2082
2083      if(ctx->total_len <= 0) {
2084        failf(data, "Mime post already completely uploaded");
2085        return CURLE_PARTIAL_FILE;
2086      }
2087    }
2088    /* we have passed, proceed as normal */
2089  }
2090  return CURLE_OK;
2091}
2092
2093static CURLcode cr_mime_cntrl(struct Curl_easy *data,
2094                              struct Curl_creader *reader,
2095                              Curl_creader_cntrl opcode)
2096{
2097  struct cr_mime_ctx *ctx = reader->ctx;
2098  switch(opcode) {
2099  case CURL_CRCNTRL_REWIND: {
2100    CURLcode result = mime_rewind(ctx->part);
2101    if(result)
2102      failf(data, "Cannot rewind mime/post data");
2103    return result;
2104  }
2105  case CURL_CRCNTRL_UNPAUSE:
2106    mime_unpause(ctx->part);
2107    break;
2108  case CURL_CRCNTRL_CLEAR_EOS:
2109    ctx->seen_eos = FALSE;
2110    break;
2111  default:
2112    break;
2113  }
2114  return CURLE_OK;
2115}
2116
2117static bool cr_mime_is_paused(struct Curl_easy *data,
2118                              struct Curl_creader *reader)
2119{
2120  struct cr_mime_ctx *ctx = reader->ctx;
2121  (void)data;
2122  return ctx->part && ctx->part->lastreadstatus == CURL_READFUNC_PAUSE;
2123}
2124
2125static const struct Curl_crtype cr_mime = {
2126  "cr-mime",
2127  cr_mime_init,
2128  cr_mime_read,
2129  cr_mime_close,
2130  cr_mime_needs_rewind,
2131  cr_mime_total_length,
2132  cr_mime_resume_from,
2133  cr_mime_cntrl,
2134  cr_mime_is_paused,
2135  Curl_creader_def_done,
2136  sizeof(struct cr_mime_ctx)
2137};
2138
2139CURLcode Curl_creader_set_mime(struct Curl_easy *data, curl_mimepart *part)
2140{
2141  struct Curl_creader *r;
2142  struct cr_mime_ctx *ctx;
2143  CURLcode result;
2144
2145  result = Curl_creader_create(&r, data, &cr_mime, CURL_CR_CLIENT);
2146  if(result)
2147    return result;
2148  ctx = r->ctx;
2149  ctx->part = part;
2150  /* Make sure we will read the entire mime structure. */
2151  result = mime_rewind(ctx->part);
2152  if(result) {
2153    Curl_creader_free(data, r);
2154    return result;
2155  }
2156  ctx->total_len = mime_size(ctx->part);
2157
2158  return Curl_creader_set(data, r);
2159}
2160
2161#else /* !CURL_DISABLE_MIME && (!CURL_DISABLE_HTTP ||
2162                                !CURL_DISABLE_SMTP ||
2163                                !CURL_DISABLE_IMAP) */
2164
2165/* Mime not compiled in: define stubs for externally-referenced functions. */
2166curl_mime *curl_mime_init(CURL *easy)
2167{
2168  (void)easy;
2169  return NULL;
2170}
2171
2172void curl_mime_free(curl_mime *mime)
2173{
2174  (void)mime;
2175}
2176
2177curl_mimepart *curl_mime_addpart(curl_mime *mime)
2178{
2179  (void)mime;
2180  return NULL;
2181}
2182
2183CURLcode curl_mime_name(curl_mimepart *part, const char *name)
2184{
2185  (void)part;
2186  (void)name;
2187  return CURLE_NOT_BUILT_IN;
2188}
2189
2190CURLcode curl_mime_filename(curl_mimepart *part, const char *filename)
2191{
2192  (void)part;
2193  (void)filename;
2194  return CURLE_NOT_BUILT_IN;
2195}
2196
2197CURLcode curl_mime_type(curl_mimepart *part, const char *mimetype)
2198{
2199  (void)part;
2200  (void)mimetype;
2201  return CURLE_NOT_BUILT_IN;
2202}
2203
2204CURLcode curl_mime_encoder(curl_mimepart *part, const char *encoding)
2205{
2206  (void)part;
2207  (void)encoding;
2208  return CURLE_NOT_BUILT_IN;
2209}
2210
2211CURLcode curl_mime_data(curl_mimepart *part, const char *data, size_t datasize)
2212{
2213  (void)part;
2214  (void)data;
2215  (void)datasize;
2216  return CURLE_NOT_BUILT_IN;
2217}
2218
2219CURLcode curl_mime_filedata(curl_mimepart *part, const char *filename)
2220{
2221  (void)part;
2222  (void)filename;
2223  return CURLE_NOT_BUILT_IN;
2224}
2225
2226CURLcode curl_mime_data_cb(curl_mimepart *part, curl_off_t datasize,
2227                           curl_read_callback readfunc,
2228                           curl_seek_callback seekfunc,
2229                           curl_free_callback freefunc,
2230                           void *arg)
2231{
2232  (void)part;
2233  (void)datasize;
2234  (void)readfunc;
2235  (void)seekfunc;
2236  (void)freefunc;
2237  (void)arg;
2238  return CURLE_NOT_BUILT_IN;
2239}
2240
2241CURLcode curl_mime_subparts(curl_mimepart *part, curl_mime *subparts)
2242{
2243  (void)part;
2244  (void)subparts;
2245  return CURLE_NOT_BUILT_IN;
2246}
2247
2248CURLcode curl_mime_headers(curl_mimepart *part,
2249                           struct curl_slist *headers, int take_ownership)
2250{
2251  (void)part;
2252  (void)headers;
2253  (void)take_ownership;
2254  return CURLE_NOT_BUILT_IN;
2255}
2256
2257CURLcode Curl_mime_add_header(struct curl_slist **slp, const char *fmt, ...)
2258{
2259  (void)slp;
2260  (void)fmt;
2261  return CURLE_NOT_BUILT_IN;
2262}
2263
2264#endif /* if disabled */