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