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 "formdata.h"
28: #if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_MIME)
29:
30: #if defined(HAVE_LIBGEN_H) && defined(HAVE_BASENAME)
31: #include <libgen.h>
32: #endif
33:
34: #include "urldata.h" /* for struct Curl_easy */
35: #include "mime.h"
36: #include "non-ascii.h"
37: #include "vtls/vtls.h"
38: #include "strcase.h"
39: #include "sendf.h"
40: #include "strdup.h"
41: #include "rand.h"
42: #include "warnless.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:
49: #define HTTPPOST_PTRNAME CURL_HTTPPOST_PTRNAME
50: #define HTTPPOST_FILENAME CURL_HTTPPOST_FILENAME
51: #define HTTPPOST_PTRCONTENTS CURL_HTTPPOST_PTRCONTENTS
52: #define HTTPPOST_READFILE CURL_HTTPPOST_READFILE
53: #define HTTPPOST_PTRBUFFER CURL_HTTPPOST_PTRBUFFER
54: #define HTTPPOST_CALLBACK CURL_HTTPPOST_CALLBACK
55: #define HTTPPOST_BUFFER CURL_HTTPPOST_BUFFER
56:
57: /***************************************************************************
58: *
59: * AddHttpPost()
60: *
61: * Adds a HttpPost structure to the list, if parent_post is given becomes
62: * a subpost of parent_post instead of a direct list element.
63: *
64: * Returns newly allocated HttpPost on success and NULL if malloc failed.
65: *
66: ***************************************************************************/
67: static struct curl_httppost *
68: AddHttpPost(char *name, size_t namelength,
69: char *value, curl_off_t contentslength,
70: char *buffer, size_t bufferlength,
71: char *contenttype,
72: long flags,
73: struct curl_slist *contentHeader,
74: char *showfilename, char *userp,
75: struct curl_httppost *parent_post,
76: struct curl_httppost **httppost,
77: struct curl_httppost **last_post)
78: {
79: struct curl_httppost *post;
80: post = calloc(1, sizeof(struct curl_httppost));
81: if(post) {
82: post->name = name;
83: post->namelength = (long)(name?(namelength?namelength:strlen(name)):0);
84: post->contents = value;
85: post->contentlen = contentslength;
86: post->buffer = buffer;
87: post->bufferlength = (long)bufferlength;
88: post->contenttype = contenttype;
89: post->contentheader = contentHeader;
90: post->showfilename = showfilename;
91: post->userp = userp;
92: post->flags = flags | CURL_HTTPPOST_LARGE;
93: }
94: else
95: return NULL;
96:
97: if(parent_post) {
98: /* now, point our 'more' to the original 'more' */
99: post->more = parent_post->more;
100:
101: /* then move the original 'more' to point to ourselves */
102: parent_post->more = post;
103: }
104: else {
105: /* make the previous point to this */
106: if(*last_post)
107: (*last_post)->next = post;
108: else
109: (*httppost) = post;
110:
111: (*last_post) = post;
112: }
113: return post;
114: }
115:
116: /***************************************************************************
117: *
118: * AddFormInfo()
119: *
120: * Adds a FormInfo structure to the list presented by parent_form_info.
121: *
122: * Returns newly allocated FormInfo on success and NULL if malloc failed/
123: * parent_form_info is NULL.
124: *
125: ***************************************************************************/
126: static FormInfo * AddFormInfo(char *value,
127: char *contenttype,
128: FormInfo *parent_form_info)
129: {
130: FormInfo *form_info;
131: form_info = calloc(1, sizeof(struct FormInfo));
132: if(form_info) {
133: if(value)
134: form_info->value = value;
135: if(contenttype)
136: form_info->contenttype = contenttype;
137: form_info->flags = HTTPPOST_FILENAME;
138: }
139: else
140: return NULL;
141:
142: if(parent_form_info) {
143: /* now, point our 'more' to the original 'more' */
144: form_info->more = parent_form_info->more;
145:
146: /* then move the original 'more' to point to ourselves */
147: parent_form_info->more = form_info;
148: }
149:
150: return form_info;
151: }
152:
153: /***************************************************************************
154: *
155: * FormAdd()
156: *
157: * Stores a formpost parameter and builds the appropriate linked list.
158: *
159: * Has two principal functionalities: using files and byte arrays as
160: * post parts. Byte arrays are either copied or just the pointer is stored
161: * (as the user requests) while for files only the filename and not the
162: * content is stored.
163: *
164: * While you may have only one byte array for each name, multiple filenames
165: * are allowed (and because of this feature CURLFORM_END is needed after
166: * using CURLFORM_FILE).
167: *
168: * Examples:
169: *
170: * Simple name/value pair with copied contents:
171: * curl_formadd (&post, &last, CURLFORM_COPYNAME, "name",
172: * CURLFORM_COPYCONTENTS, "value", CURLFORM_END);
173: *
174: * name/value pair where only the content pointer is remembered:
175: * curl_formadd (&post, &last, CURLFORM_COPYNAME, "name",
176: * CURLFORM_PTRCONTENTS, ptr, CURLFORM_CONTENTSLENGTH, 10, CURLFORM_END);
177: * (if CURLFORM_CONTENTSLENGTH is missing strlen () is used)
178: *
179: * storing a filename (CONTENTTYPE is optional!):
180: * curl_formadd (&post, &last, CURLFORM_COPYNAME, "name",
181: * CURLFORM_FILE, "filename1", CURLFORM_CONTENTTYPE, "plain/text",
182: * CURLFORM_END);
183: *
184: * storing multiple filenames:
185: * curl_formadd (&post, &last, CURLFORM_COPYNAME, "name",
186: * CURLFORM_FILE, "filename1", CURLFORM_FILE, "filename2", CURLFORM_END);
187: *
188: * Returns:
189: * CURL_FORMADD_OK on success
190: * CURL_FORMADD_MEMORY if the FormInfo allocation fails
191: * CURL_FORMADD_OPTION_TWICE if one option is given twice for one Form
192: * CURL_FORMADD_NULL if a null pointer was given for a char
193: * CURL_FORMADD_MEMORY if the allocation of a FormInfo struct failed
194: * CURL_FORMADD_UNKNOWN_OPTION if an unknown option was used
195: * CURL_FORMADD_INCOMPLETE if the some FormInfo is not complete (or error)
196: * CURL_FORMADD_MEMORY if a HttpPost struct cannot be allocated
197: * CURL_FORMADD_MEMORY if some allocation for string copying failed.
198: * CURL_FORMADD_ILLEGAL_ARRAY if an illegal option is used in an array
199: *
200: ***************************************************************************/
201:
202: static
203: CURLFORMcode FormAdd(struct curl_httppost **httppost,
204: struct curl_httppost **last_post,
205: va_list params)
206: {
207: FormInfo *first_form, *current_form, *form = NULL;
208: CURLFORMcode return_value = CURL_FORMADD_OK;
209: const char *prevtype = NULL;
210: struct curl_httppost *post = NULL;
211: CURLformoption option;
212: struct curl_forms *forms = NULL;
213: char *array_value = NULL; /* value read from an array */
214:
215: /* This is a state variable, that if TRUE means that we're parsing an
216: array that we got passed to us. If FALSE we're parsing the input
217: va_list arguments. */
218: bool array_state = FALSE;
219:
220: /*
221: * We need to allocate the first struct to fill in.
222: */
223: first_form = calloc(1, sizeof(struct FormInfo));
224: if(!first_form)
225: return CURL_FORMADD_MEMORY;
226:
227: current_form = first_form;
228:
229: /*
230: * Loop through all the options set. Break if we have an error to report.
231: */
232: while(return_value == CURL_FORMADD_OK) {
233:
234: /* first see if we have more parts of the array param */
235: if(array_state && forms) {
236: /* get the upcoming option from the given array */
237: option = forms->option;
238: array_value = (char *)forms->value;
239:
240: forms++; /* advance this to next entry */
241: if(CURLFORM_END == option) {
242: /* end of array state */
243: array_state = FALSE;
244: continue;
245: }
246: }
247: else {
248: /* This is not array-state, get next option */
249: option = va_arg(params, CURLformoption);
250: if(CURLFORM_END == option)
251: break;
252: }
253:
254: switch(option) {
255: case CURLFORM_ARRAY:
256: if(array_state)
257: /* we don't support an array from within an array */
258: return_value = CURL_FORMADD_ILLEGAL_ARRAY;
259: else {
260: forms = va_arg(params, struct curl_forms *);
261: if(forms)
262: array_state = TRUE;
263: else
264: return_value = CURL_FORMADD_NULL;
265: }
266: break;
267:
268: /*
269: * Set the Name property.
270: */
271: case CURLFORM_PTRNAME:
272: #ifdef CURL_DOES_CONVERSIONS
273: /* Treat CURLFORM_PTR like CURLFORM_COPYNAME so that libcurl will copy
274: * the data in all cases so that we'll have safe memory for the eventual
275: * conversion.
276: */
277: #else
278: current_form->flags |= HTTPPOST_PTRNAME; /* fall through */
279: #endif
280: /* FALLTHROUGH */
281: case CURLFORM_COPYNAME:
282: if(current_form->name)
283: return_value = CURL_FORMADD_OPTION_TWICE;
284: else {
285: char *name = array_state?
286: array_value:va_arg(params, char *);
287: if(name)
288: current_form->name = name; /* store for the moment */
289: else
290: return_value = CURL_FORMADD_NULL;
291: }
292: break;
293: case CURLFORM_NAMELENGTH:
294: if(current_form->namelength)
295: return_value = CURL_FORMADD_OPTION_TWICE;
296: else
297: current_form->namelength =
298: array_state?(size_t)array_value:(size_t)va_arg(params, long);
299: break;
300:
301: /*
302: * Set the contents property.
303: */
304: case CURLFORM_PTRCONTENTS:
305: current_form->flags |= HTTPPOST_PTRCONTENTS;
306: /* FALLTHROUGH */
307: case CURLFORM_COPYCONTENTS:
308: if(current_form->value)
309: return_value = CURL_FORMADD_OPTION_TWICE;
310: else {
311: char *value =
312: array_state?array_value:va_arg(params, char *);
313: if(value)
314: current_form->value = value; /* store for the moment */
315: else
316: return_value = CURL_FORMADD_NULL;
317: }
318: break;
319: case CURLFORM_CONTENTSLENGTH:
320: current_form->contentslength =
321: array_state?(size_t)array_value:(size_t)va_arg(params, long);
322: break;
323:
324: case CURLFORM_CONTENTLEN:
325: current_form->flags |= CURL_HTTPPOST_LARGE;
326: current_form->contentslength =
327: array_state?(curl_off_t)(size_t)array_value:va_arg(params, curl_off_t);
328: break;
329:
330: /* Get contents from a given file name */
331: case CURLFORM_FILECONTENT:
332: if(current_form->flags & (HTTPPOST_PTRCONTENTS|HTTPPOST_READFILE))
333: return_value = CURL_FORMADD_OPTION_TWICE;
334: else {
335: const char *filename = array_state?
336: array_value:va_arg(params, char *);
337: if(filename) {
338: current_form->value = strdup(filename);
339: if(!current_form->value)
340: return_value = CURL_FORMADD_MEMORY;
341: else {
342: current_form->flags |= HTTPPOST_READFILE;
343: current_form->value_alloc = TRUE;
344: }
345: }
346: else
347: return_value = CURL_FORMADD_NULL;
348: }
349: break;
350:
351: /* We upload a file */
352: case CURLFORM_FILE:
353: {
354: const char *filename = array_state?array_value:
355: va_arg(params, char *);
356:
357: if(current_form->value) {
358: if(current_form->flags & HTTPPOST_FILENAME) {
359: if(filename) {
360: char *fname = strdup(filename);
361: if(!fname)
362: return_value = CURL_FORMADD_MEMORY;
363: else {
364: form = AddFormInfo(fname, NULL, current_form);
365: if(!form) {
366: free(fname);
367: return_value = CURL_FORMADD_MEMORY;
368: }
369: else {
370: form->value_alloc = TRUE;
371: current_form = form;
372: form = NULL;
373: }
374: }
375: }
376: else
377: return_value = CURL_FORMADD_NULL;
378: }
379: else
380: return_value = CURL_FORMADD_OPTION_TWICE;
381: }
382: else {
383: if(filename) {
384: current_form->value = strdup(filename);
385: if(!current_form->value)
386: return_value = CURL_FORMADD_MEMORY;
387: else {
388: current_form->flags |= HTTPPOST_FILENAME;
389: current_form->value_alloc = TRUE;
390: }
391: }
392: else
393: return_value = CURL_FORMADD_NULL;
394: }
395: break;
396: }
397:
398: case CURLFORM_BUFFERPTR:
399: current_form->flags |= HTTPPOST_PTRBUFFER|HTTPPOST_BUFFER;
400: if(current_form->buffer)
401: return_value = CURL_FORMADD_OPTION_TWICE;
402: else {
403: char *buffer =
404: array_state?array_value:va_arg(params, char *);
405: if(buffer) {
406: current_form->buffer = buffer; /* store for the moment */
407: current_form->value = buffer; /* make it non-NULL to be accepted
408: as fine */
409: }
410: else
411: return_value = CURL_FORMADD_NULL;
412: }
413: break;
414:
415: case CURLFORM_BUFFERLENGTH:
416: if(current_form->bufferlength)
417: return_value = CURL_FORMADD_OPTION_TWICE;
418: else
419: current_form->bufferlength =
420: array_state?(size_t)array_value:(size_t)va_arg(params, long);
421: break;
422:
423: case CURLFORM_STREAM:
424: current_form->flags |= HTTPPOST_CALLBACK;
425: if(current_form->userp)
426: return_value = CURL_FORMADD_OPTION_TWICE;
427: else {
428: char *userp =
429: array_state?array_value:va_arg(params, char *);
430: if(userp) {
431: current_form->userp = userp;
432: current_form->value = userp; /* this isn't strictly true but we
433: derive a value from this later on
434: and we need this non-NULL to be
435: accepted as a fine form part */
436: }
437: else
438: return_value = CURL_FORMADD_NULL;
439: }
440: break;
441:
442: case CURLFORM_CONTENTTYPE:
443: {
444: const char *contenttype =
445: array_state?array_value:va_arg(params, char *);
446: if(current_form->contenttype) {
447: if(current_form->flags & HTTPPOST_FILENAME) {
448: if(contenttype) {
449: char *type = strdup(contenttype);
450: if(!type)
451: return_value = CURL_FORMADD_MEMORY;
452: else {
453: form = AddFormInfo(NULL, type, current_form);
454: if(!form) {
455: free(type);
456: return_value = CURL_FORMADD_MEMORY;
457: }
458: else {
459: form->contenttype_alloc = TRUE;
460: current_form = form;
461: form = NULL;
462: }
463: }
464: }
465: else
466: return_value = CURL_FORMADD_NULL;
467: }
468: else
469: return_value = CURL_FORMADD_OPTION_TWICE;
470: }
471: else {
472: if(contenttype) {
473: current_form->contenttype = strdup(contenttype);
474: if(!current_form->contenttype)
475: return_value = CURL_FORMADD_MEMORY;
476: else
477: current_form->contenttype_alloc = TRUE;
478: }
479: else
480: return_value = CURL_FORMADD_NULL;
481: }
482: break;
483: }
484: case CURLFORM_CONTENTHEADER:
485: {
486: /* this "cast increases required alignment of target type" but
487: we consider it OK anyway */
488: struct curl_slist *list = array_state?
489: (struct curl_slist *)(void *)array_value:
490: va_arg(params, struct curl_slist *);
491:
492: if(current_form->contentheader)
493: return_value = CURL_FORMADD_OPTION_TWICE;
494: else
495: current_form->contentheader = list;
496:
497: break;
498: }
499: case CURLFORM_FILENAME:
500: case CURLFORM_BUFFER:
501: {
502: const char *filename = array_state?array_value:
503: va_arg(params, char *);
504: if(current_form->showfilename)
505: return_value = CURL_FORMADD_OPTION_TWICE;
506: else {
507: current_form->showfilename = strdup(filename);
508: if(!current_form->showfilename)
509: return_value = CURL_FORMADD_MEMORY;
510: else
511: current_form->showfilename_alloc = TRUE;
512: }
513: break;
514: }
515: default:
516: return_value = CURL_FORMADD_UNKNOWN_OPTION;
517: break;
518: }
519: }
520:
521: if(CURL_FORMADD_OK != return_value) {
522: /* On error, free allocated fields for all nodes of the FormInfo linked
523: list without deallocating nodes. List nodes are deallocated later on */
524: FormInfo *ptr;
525: for(ptr = first_form; ptr != NULL; ptr = ptr->more) {
526: if(ptr->name_alloc) {
527: Curl_safefree(ptr->name);
528: ptr->name_alloc = FALSE;
529: }
530: if(ptr->value_alloc) {
531: Curl_safefree(ptr->value);
532: ptr->value_alloc = FALSE;
533: }
534: if(ptr->contenttype_alloc) {
535: Curl_safefree(ptr->contenttype);
536: ptr->contenttype_alloc = FALSE;
537: }
538: if(ptr->showfilename_alloc) {
539: Curl_safefree(ptr->showfilename);
540: ptr->showfilename_alloc = FALSE;
541: }
542: }
543: }
544:
545: if(CURL_FORMADD_OK == return_value) {
546: /* go through the list, check for completeness and if everything is
547: * alright add the HttpPost item otherwise set return_value accordingly */
548:
549: post = NULL;
550: for(form = first_form;
551: form != NULL;
552: form = form->more) {
553: if(((!form->name || !form->value) && !post) ||
554: ( (form->contentslength) &&
555: (form->flags & HTTPPOST_FILENAME) ) ||
556: ( (form->flags & HTTPPOST_FILENAME) &&
557: (form->flags & HTTPPOST_PTRCONTENTS) ) ||
558:
559: ( (!form->buffer) &&
560: (form->flags & HTTPPOST_BUFFER) &&
561: (form->flags & HTTPPOST_PTRBUFFER) ) ||
562:
563: ( (form->flags & HTTPPOST_READFILE) &&
564: (form->flags & HTTPPOST_PTRCONTENTS) )
565: ) {
566: return_value = CURL_FORMADD_INCOMPLETE;
567: break;
568: }
569: if(((form->flags & HTTPPOST_FILENAME) ||
570: (form->flags & HTTPPOST_BUFFER)) &&
571: !form->contenttype) {
572: char *f = (form->flags & HTTPPOST_BUFFER)?
573: form->showfilename : form->value;
574: char const *type;
575: type = Curl_mime_contenttype(f);
576: if(!type)
577: type = prevtype;
578: if(!type)
579: type = FILE_CONTENTTYPE_DEFAULT;
580:
581: /* our contenttype is missing */
582: form->contenttype = strdup(type);
583: if(!form->contenttype) {
584: return_value = CURL_FORMADD_MEMORY;
585: break;
586: }
587: form->contenttype_alloc = TRUE;
588: }
589: if(form->name && form->namelength) {
590: /* Name should not contain nul bytes. */
591: size_t i;
592: for(i = 0; i < form->namelength; i++)
593: if(!form->name[i]) {
594: return_value = CURL_FORMADD_NULL;
595: break;
596: }
597: if(return_value != CURL_FORMADD_OK)
598: break;
599: }
600: if(!(form->flags & HTTPPOST_PTRNAME) &&
601: (form == first_form) ) {
602: /* Note that there's small risk that form->name is NULL here if the
603: app passed in a bad combo, so we better check for that first. */
604: if(form->name) {
605: /* copy name (without strdup; possibly not nul-terminated) */
606: form->name = Curl_memdup(form->name, form->namelength?
607: form->namelength:
608: strlen(form->name) + 1);
609: }
610: if(!form->name) {
611: return_value = CURL_FORMADD_MEMORY;
612: break;
613: }
614: form->name_alloc = TRUE;
615: }
616: if(!(form->flags & (HTTPPOST_FILENAME | HTTPPOST_READFILE |
617: HTTPPOST_PTRCONTENTS | HTTPPOST_PTRBUFFER |
618: HTTPPOST_CALLBACK)) && form->value) {
619: /* copy value (without strdup; possibly contains null characters) */
620: size_t clen = (size_t) form->contentslength;
621: if(!clen)
622: clen = strlen(form->value) + 1;
623:
624: form->value = Curl_memdup(form->value, clen);
625:
626: if(!form->value) {
627: return_value = CURL_FORMADD_MEMORY;
628: break;
629: }
630: form->value_alloc = TRUE;
631: }
632: post = AddHttpPost(form->name, form->namelength,
633: form->value, form->contentslength,
634: form->buffer, form->bufferlength,
635: form->contenttype, form->flags,
636: form->contentheader, form->showfilename,
637: form->userp,
638: post, httppost,
639: last_post);
640:
641: if(!post) {
642: return_value = CURL_FORMADD_MEMORY;
643: break;
644: }
645:
646: if(form->contenttype)
647: prevtype = form->contenttype;
648: }
649: if(CURL_FORMADD_OK != return_value) {
650: /* On error, free allocated fields for nodes of the FormInfo linked
651: list which are not already owned by the httppost linked list
652: without deallocating nodes. List nodes are deallocated later on */
653: FormInfo *ptr;
654: for(ptr = form; ptr != NULL; ptr = ptr->more) {
655: if(ptr->name_alloc) {
656: Curl_safefree(ptr->name);
657: ptr->name_alloc = FALSE;
658: }
659: if(ptr->value_alloc) {
660: Curl_safefree(ptr->value);
661: ptr->value_alloc = FALSE;
662: }
663: if(ptr->contenttype_alloc) {
664: Curl_safefree(ptr->contenttype);
665: ptr->contenttype_alloc = FALSE;
666: }
667: if(ptr->showfilename_alloc) {
668: Curl_safefree(ptr->showfilename);
669: ptr->showfilename_alloc = FALSE;
670: }
671: }
672: }
673: }
674:
675: /* Always deallocate FormInfo linked list nodes without touching node
676: fields given that these have either been deallocated or are owned
677: now by the httppost linked list */
678: while(first_form) {
679: FormInfo *ptr = first_form->more;
680: free(first_form);
681: first_form = ptr;
682: }
683:
684: return return_value;
685: }
686:
687: /*
688: * curl_formadd() is a public API to add a section to the multipart formpost.
689: *
690: * @unittest: 1308
691: */
692:
693: CURLFORMcode curl_formadd(struct curl_httppost **httppost,
694: struct curl_httppost **last_post,
695: ...)
696: {
697: va_list arg;
698: CURLFORMcode result;
699: va_start(arg, last_post);
700: result = FormAdd(httppost, last_post, arg);
701: va_end(arg);
702: return result;
703: }
704:
705: /*
706: * curl_formget()
707: * Serialize a curl_httppost struct.
708: * Returns 0 on success.
709: *
710: * @unittest: 1308
711: */
712: int curl_formget(struct curl_httppost *form, void *arg,
713: curl_formget_callback append)
714: {
715: CURLcode result;
716: curl_mimepart toppart;
717:
718: Curl_mime_initpart(&toppart, NULL); /* default form is empty */
719: result = Curl_getformdata(NULL, &toppart, form, NULL);
720: if(!result)
721: result = Curl_mime_prepare_headers(&toppart, "multipart/form-data",
722: NULL, MIMESTRATEGY_FORM);
723:
724: while(!result) {
725: char buffer[8192];
726: size_t nread = Curl_mime_read(buffer, 1, sizeof(buffer), &toppart);
727:
728: if(!nread)
729: break;
730:
731: if(nread > sizeof(buffer) || append(arg, buffer, nread) != nread) {
732: result = CURLE_READ_ERROR;
733: if(nread == CURL_READFUNC_ABORT)
734: result = CURLE_ABORTED_BY_CALLBACK;
735: }
736: }
737:
738: Curl_mime_cleanpart(&toppart);
739: return (int) result;
740: }
741:
742: /*
743: * curl_formfree() is an external function to free up a whole form post
744: * chain
745: */
746: void curl_formfree(struct curl_httppost *form)
747: {
748: struct curl_httppost *next;
749:
750: if(!form)
751: /* no form to free, just get out of this */
752: return;
753:
754: do {
755: next = form->next; /* the following form line */
756:
757: /* recurse to sub-contents */
758: curl_formfree(form->more);
759:
760: if(!(form->flags & HTTPPOST_PTRNAME))
761: free(form->name); /* free the name */
762: if(!(form->flags &
763: (HTTPPOST_PTRCONTENTS|HTTPPOST_BUFFER|HTTPPOST_CALLBACK))
764: )
765: free(form->contents); /* free the contents */
766: free(form->contenttype); /* free the content type */
767: free(form->showfilename); /* free the faked file name */
768: free(form); /* free the struct */
769: form = next;
770: } while(form); /* continue */
771: }
772:
773:
774: /* Set mime part name, taking care of non nul-terminated name string. */
775: static CURLcode setname(curl_mimepart *part, const char *name, size_t len)
776: {
777: char *zname;
778: CURLcode res;
779:
780: if(!name || !len)
781: return curl_mime_name(part, name);
782: zname = malloc(len + 1);
783: if(!zname)
784: return CURLE_OUT_OF_MEMORY;
785: memcpy(zname, name, len);
786: zname[len] = '\0';
787: res = curl_mime_name(part, zname);
788: free(zname);
789: return res;
790: }
791:
792: /*
793: * Curl_getformdata() converts a linked list of "meta data" into a mime
794: * structure. The input list is in 'post', while the output is stored in
795: * mime part at '*finalform'.
796: *
797: * This function will not do a failf() for the potential memory failures but
798: * should for all other errors it spots. Just note that this function MAY get
799: * a NULL pointer in the 'data' argument.
800: */
801:
802: CURLcode Curl_getformdata(struct Curl_easy *data,
803: curl_mimepart *finalform,
804: struct curl_httppost *post,
805: curl_read_callback fread_func)
806: {
807: CURLcode result = CURLE_OK;
808: curl_mime *form = NULL;
809: curl_mimepart *part;
810: struct curl_httppost *file;
811:
812: Curl_mime_cleanpart(finalform); /* default form is empty */
813:
814: if(!post)
815: return result; /* no input => no output! */
816:
817: form = curl_mime_init(data);
818: if(!form)
819: result = CURLE_OUT_OF_MEMORY;
820:
821: if(!result)
822: result = curl_mime_subparts(finalform, form);
823:
824: /* Process each top part. */
825: for(; !result && post; post = post->next) {
826: /* If we have more than a file here, create a mime subpart and fill it. */
827: curl_mime *multipart = form;
828: if(post->more) {
829: part = curl_mime_addpart(form);
830: if(!part)
831: result = CURLE_OUT_OF_MEMORY;
832: if(!result)
833: result = setname(part, post->name, post->namelength);
834: if(!result) {
835: multipart = curl_mime_init(data);
836: if(!multipart)
837: result = CURLE_OUT_OF_MEMORY;
838: }
839: if(!result)
840: result = curl_mime_subparts(part, multipart);
841: }
842:
843: /* Generate all the part contents. */
844: for(file = post; !result && file; file = file->more) {
845: /* Create the part. */
846: part = curl_mime_addpart(multipart);
847: if(!part)
848: result = CURLE_OUT_OF_MEMORY;
849:
850: /* Set the headers. */
851: if(!result)
852: result = curl_mime_headers(part, file->contentheader, 0);
853:
854: /* Set the content type. */
855: if(!result && file->contenttype)
856: result = curl_mime_type(part, file->contenttype);
857:
858: /* Set field name. */
859: if(!result && !post->more)
860: result = setname(part, post->name, post->namelength);
861:
862: /* Process contents. */
863: if(!result) {
864: curl_off_t clen = post->contentslength;
865:
866: if(post->flags & CURL_HTTPPOST_LARGE)
867: clen = post->contentlen;
868: if(!clen)
869: clen = -1;
870:
871: if(post->flags & (HTTPPOST_FILENAME | HTTPPOST_READFILE)) {
872: if(!strcmp(file->contents, "-")) {
873: /* There are a few cases where the code below won't work; in
874: particular, freopen(stdin) by the caller is not guaranteed
875: to result as expected. This feature has been kept for backward
876: compatibility: use of "-" pseudo file name should be avoided. */
877: result = curl_mime_data_cb(part, (curl_off_t) -1,
878: (curl_read_callback) fread,
879: CURLX_FUNCTION_CAST(curl_seek_callback,
880: fseek),
881: NULL, (void *) stdin);
882: }
883: else
884: result = curl_mime_filedata(part, file->contents);
885: if(!result && (post->flags & HTTPPOST_READFILE))
886: result = curl_mime_filename(part, NULL);
887: }
888: else if(post->flags & HTTPPOST_BUFFER)
889: result = curl_mime_data(part, post->buffer,
890: post->bufferlength? post->bufferlength: -1);
891: else if(post->flags & HTTPPOST_CALLBACK)
892: /* the contents should be read with the callback and the size is set
893: with the contentslength */
894: result = curl_mime_data_cb(part, clen,
895: fread_func, NULL, NULL, post->userp);
896: else {
897: result = curl_mime_data(part, post->contents, (ssize_t) clen);
898: #ifdef CURL_DOES_CONVERSIONS
899: /* Convert textual contents now. */
900: if(!result && data && part->datasize)
901: result = Curl_convert_to_network(data, part->data, part->datasize);
902: #endif
903: }
904: }
905:
906: /* Set fake file name. */
907: if(!result && post->showfilename)
908: if(post->more || (post->flags & (HTTPPOST_FILENAME | HTTPPOST_BUFFER |
909: HTTPPOST_CALLBACK)))
910: result = curl_mime_filename(part, post->showfilename);
911: }
912: }
913:
914: if(result)
915: Curl_mime_cleanpart(finalform);
916:
917: return result;
918: }
919:
920: #else
921: /* if disabled */
922: CURLFORMcode curl_formadd(struct curl_httppost **httppost,
923: struct curl_httppost **last_post,
924: ...)
925: {
926: (void)httppost;
927: (void)last_post;
928: return CURL_FORMADD_DISABLED;
929: }
930:
931: int curl_formget(struct curl_httppost *form, void *arg,
932: curl_formget_callback append)
933: {
934: (void) form;
935: (void) arg;
936: (void) append;
937: return CURL_FORMADD_DISABLED;
938: }
939:
940: void curl_formfree(struct curl_httppost *form)
941: {
942: (void)form;
943: /* does nothing HTTP is disabled */
944: }
945:
946: #endif /* if disabled */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to formdata.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