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