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