/*************************************************************************** * _ _ ____ _ * Project ___| | | | _ \| | * / __| | | | |_) | | * | (__| |_| | _ <| |___ * \___|\___/|_| \_\_____| * * Copyright (C) Daniel Stenberg, , et al. * * This software is licensed as described in the file COPYING, which * you should have received as part of this distribution. The terms * are also available at https://curl.se/docs/copyright.html. * * You may opt to use, copy, modify, merge, publish, distribute and/or sell * copies of the Software, and permit persons to whom the Software is * furnished to do so, under the terms of the COPYING file. * * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY * KIND, either express or implied. * * SPDX-License-Identifier: curl * ***************************************************************************/ #include "curl_setup.h" #include struct Curl_easy; #include "formdata.h" #if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_FORM_API) #include "urldata.h" /* for struct Curl_easy */ #include "mime.h" #include "vtls/vtls.h" #include "sendf.h" #include "strdup.h" #include "rand.h" #include "curlx/warnless.h" /* The last 3 #include files should be in this order */ #include "curl_printf.h" #include "curl_memory.h" #include "memdebug.h" #define HTTPPOST_PTRNAME CURL_HTTPPOST_PTRNAME #define HTTPPOST_FILENAME CURL_HTTPPOST_FILENAME #define HTTPPOST_PTRCONTENTS CURL_HTTPPOST_PTRCONTENTS #define HTTPPOST_READFILE CURL_HTTPPOST_READFILE #define HTTPPOST_PTRBUFFER CURL_HTTPPOST_PTRBUFFER #define HTTPPOST_CALLBACK CURL_HTTPPOST_CALLBACK #define HTTPPOST_BUFFER CURL_HTTPPOST_BUFFER /*************************************************************************** * * AddHttpPost() * * Adds an HttpPost structure to the list, if parent_post is given becomes * a subpost of parent_post instead of a direct list element. * * Returns newly allocated HttpPost on success and NULL if malloc failed. * ***************************************************************************/ static struct curl_httppost * AddHttpPost(struct FormInfo *src, struct curl_httppost *parent_post, struct curl_httppost **httppost, struct curl_httppost **last_post) { struct curl_httppost *post; size_t namelength = src->namelength; if(!namelength && src->name) namelength = strlen(src->name); if((src->bufferlength > LONG_MAX) || (namelength > LONG_MAX)) /* avoid overflow in typecasts below */ return NULL; post = calloc(1, sizeof(struct curl_httppost)); if(post) { post->name = src->name; post->namelength = (long)namelength; post->contents = src->value; post->contentlen = src->contentslength; post->buffer = src->buffer; post->bufferlength = (long)src->bufferlength; post->contenttype = src->contenttype; post->flags = src->flags | CURL_HTTPPOST_LARGE; post->contentheader = src->contentheader; post->showfilename = src->showfilename; post->userp = src->userp; } else return NULL; if(parent_post) { /* now, point our 'more' to the original 'more' */ post->more = parent_post->more; /* then move the original 'more' to point to ourselves */ parent_post->more = post; } else { /* make the previous point to this */ if(*last_post) (*last_post)->next = post; else (*httppost) = post; (*last_post) = post; } return post; } /*************************************************************************** * * AddFormInfo() * * Adds a FormInfo structure to the list presented by parent_form_info. * * Returns newly allocated FormInfo on success and NULL if malloc failed/ * parent_form_info is NULL. * ***************************************************************************/ static struct FormInfo *AddFormInfo(char *value, char *contenttype, struct FormInfo *parent_form_info) { struct FormInfo *form_info; form_info = calloc(1, sizeof(struct FormInfo)); if(!form_info) return NULL; if(value) form_info->value = value; if(contenttype) form_info->contenttype = contenttype; form_info->flags = HTTPPOST_FILENAME; if(parent_form_info) { /* now, point our 'more' to the original 'more' */ form_info->more = parent_form_info->more; /* then move the original 'more' to point to ourselves */ parent_form_info->more = form_info; } return form_info; } static void free_formlist(struct FormInfo *ptr) { for(; ptr != NULL; ptr = ptr->more) { if(ptr->name_alloc) { Curl_safefree(ptr->name); ptr->name_alloc = FALSE; } if(ptr->value_alloc) { Curl_safefree(ptr->value); ptr->value_alloc = FALSE; } if(ptr->contenttype_alloc) { Curl_safefree(ptr->contenttype); ptr->contenttype_alloc = FALSE; } if(ptr->showfilename_alloc) { Curl_safefree(ptr->showfilename); ptr->showfilename_alloc = FALSE; } } } /*************************************************************************** * * FormAdd() * * Stores a formpost parameter and builds the appropriate linked list. * * Has two principal functionalities: using files and byte arrays as * post parts. Byte arrays are either copied or just the pointer is stored * (as the user requests) while for files only the filename and not the * content is stored. * * While you may have only one byte array for each name, multiple filenames * are allowed (and because of this feature CURLFORM_END is needed after * using CURLFORM_FILE). * * Examples: * * Simple name/value pair with copied contents: * curl_formadd (&post, &last, CURLFORM_COPYNAME, "name", * CURLFORM_COPYCONTENTS, "value", CURLFORM_END); * * name/value pair where only the content pointer is remembered: * curl_formadd (&post, &last, CURLFORM_COPYNAME, "name", * CURLFORM_PTRCONTENTS, ptr, CURLFORM_CONTENTSLENGTH, 10, CURLFORM_END); * (if CURLFORM_CONTENTSLENGTH is missing strlen () is used) * * storing a filename (CONTENTTYPE is optional!): * curl_formadd (&post, &last, CURLFORM_COPYNAME, "name", * CURLFORM_FILE, "filename1", CURLFORM_CONTENTTYPE, "plain/text", * CURLFORM_END); * * storing multiple filenames: * curl_formadd (&post, &last, CURLFORM_COPYNAME, "name", * CURLFORM_FILE, "filename1", CURLFORM_FILE, "filename2", CURLFORM_END); * * Returns: * CURL_FORMADD_OK on success * CURL_FORMADD_MEMORY if the FormInfo allocation fails * CURL_FORMADD_OPTION_TWICE if one option is given twice for one Form * CURL_FORMADD_NULL if a null pointer was given for a char * CURL_FORMADD_MEMORY if the allocation of a FormInfo struct failed * CURL_FORMADD_UNKNOWN_OPTION if an unknown option was used * CURL_FORMADD_INCOMPLETE if the some FormInfo is not complete (or error) * CURL_FORMADD_MEMORY if an HttpPost struct cannot be allocated * CURL_FORMADD_MEMORY if some allocation for string copying failed. * CURL_FORMADD_ILLEGAL_ARRAY if an illegal option is used in an array * ***************************************************************************/ static CURLFORMcode FormAddCheck(struct FormInfo *first_form, struct curl_httppost **httppost, struct curl_httppost **last_post) { const char *prevtype = NULL; struct FormInfo *form = NULL; struct curl_httppost *post = NULL; /* go through the list, check for completeness and if everything is * alright add the HttpPost item otherwise set retval accordingly */ for(form = first_form; form != NULL; form = form->more) { if(((!form->name || !form->value) && !post) || ( (form->contentslength) && (form->flags & HTTPPOST_FILENAME) ) || ( (form->flags & HTTPPOST_FILENAME) && (form->flags & HTTPPOST_PTRCONTENTS) ) || ( (!form->buffer) && (form->flags & HTTPPOST_BUFFER) && (form->flags & HTTPPOST_PTRBUFFER) ) || ( (form->flags & HTTPPOST_READFILE) && (form->flags & HTTPPOST_PTRCONTENTS) ) ) { return CURL_FORMADD_INCOMPLETE; } if(((form->flags & HTTPPOST_FILENAME) || (form->flags & HTTPPOST_BUFFER)) && !form->contenttype) { char *f = (form->flags & HTTPPOST_BUFFER) ? form->showfilename : form->value; char const *type; type = Curl_mime_contenttype(f); if(!type) type = prevtype; if(!type) type = FILE_CONTENTTYPE_DEFAULT; /* our contenttype is missing */ form->contenttype = strdup(type); if(!form->contenttype) return CURL_FORMADD_MEMORY; form->contenttype_alloc = TRUE; } if(form->name && form->namelength) { if(memchr(form->name, 0, form->namelength)) return CURL_FORMADD_NULL; } if(!(form->flags & HTTPPOST_PTRNAME) && form->name) { /* Note that there is small risk that form->name is NULL here if the app passed in a bad combo, so we check for that. */ /* copy name (without strdup; possibly not null-terminated) */ char *dupname = Curl_memdup0(form->name, form->namelength ? form->namelength : strlen(form->name)); if(!dupname) return CURL_FORMADD_MEMORY; form->name = dupname; form->name_alloc = TRUE; } if(!(form->flags & (HTTPPOST_FILENAME | HTTPPOST_READFILE | HTTPPOST_PTRCONTENTS | HTTPPOST_PTRBUFFER | HTTPPOST_CALLBACK)) && form->value) { /* copy value (without strdup; possibly contains null characters) */ size_t clen = (size_t) form->contentslength; if(!clen) clen = strlen(form->value) + 1; form->value = Curl_memdup(form->value, clen); if(!form->value) return CURL_FORMADD_MEMORY; form->value_alloc = TRUE; } post = AddHttpPost(form, post, httppost, last_post); if(!post) return CURL_FORMADD_MEMORY; if(form->contenttype) prevtype = form->contenttype; } return CURL_FORMADD_OK; } /* Shallow cleanup. Remove the newly created chain, the structs only and not the content they point to */ static void free_chain(struct curl_httppost *c) { while(c) { struct curl_httppost *next = c->next; if(c->more) free_chain(c->more); free(c); c = next; } } static CURLFORMcode FormAdd(struct curl_httppost **httppost, struct curl_httppost **last_post, va_list params) { struct FormInfo *first_form, *curr, *form = NULL; CURLFORMcode retval = CURL_FORMADD_OK; CURLformoption option; struct curl_forms *forms = NULL; char *avalue = NULL; struct curl_httppost *newchain = NULL; struct curl_httppost *lastnode = NULL; /* This is a state variable, that if TRUE means that we are parsing an array that we got passed to us. If FALSE we are parsing the input va_list arguments. */ bool array_state = FALSE; /* * We need to allocate the first struct to fill in. */ first_form = calloc(1, sizeof(struct FormInfo)); if(!first_form) return CURL_FORMADD_MEMORY; curr = first_form; /* * Loop through all the options set. Break if we have an error to report. */ while(retval == CURL_FORMADD_OK) { /* first see if we have more parts of the array param */ if(array_state && forms) { /* get the upcoming option from the given array */ option = forms->option; avalue = (char *)CURL_UNCONST(forms->value); forms++; /* advance this to next entry */ if(CURLFORM_END == option) { /* end of array state */ array_state = FALSE; continue; } } else { /* This is not array-state, get next option. This gets an 'int' with va_arg() because CURLformoption might be a smaller type than int and might cause compiler warnings and wrong behavior. */ option = (CURLformoption)va_arg(params, int); if(CURLFORM_END == option) break; } switch(option) { case CURLFORM_ARRAY: if(array_state) /* we do not support an array from within an array */ retval = CURL_FORMADD_ILLEGAL_ARRAY; else { forms = va_arg(params, struct curl_forms *); if(forms) array_state = TRUE; else retval = CURL_FORMADD_NULL; } break; /* * Set the Name property. */ case CURLFORM_PTRNAME: curr->flags |= HTTPPOST_PTRNAME; /* fall through */ FALLTHROUGH(); case CURLFORM_COPYNAME: if(curr->name) retval = CURL_FORMADD_OPTION_TWICE; else { if(!array_state) avalue = va_arg(params, char *); if(avalue) curr->name = avalue; /* store for the moment */ else retval = CURL_FORMADD_NULL; } break; case CURLFORM_NAMELENGTH: if(curr->namelength) retval = CURL_FORMADD_OPTION_TWICE; else curr->namelength = array_state ? (size_t)avalue : (size_t)va_arg(params, long); break; /* * Set the contents property. */ case CURLFORM_PTRCONTENTS: curr->flags |= HTTPPOST_PTRCONTENTS; FALLTHROUGH(); case CURLFORM_COPYCONTENTS: if(curr->value) retval = CURL_FORMADD_OPTION_TWICE; else { if(!array_state) avalue = va_arg(params, char *); if(avalue) curr->value = avalue; /* store for the moment */ else retval = CURL_FORMADD_NULL; } break; case CURLFORM_CONTENTSLENGTH: curr->contentslength = array_state ? (size_t)avalue : (size_t)va_arg(params, long); break; case CURLFORM_CONTENTLEN: curr->flags |= CURL_HTTPPOST_LARGE; curr->contentslength = array_state ? (curl_off_t)(size_t)avalue : va_arg(params, curl_off_t); break; /* Get contents from a given filename */ case CURLFORM_FILECONTENT: if(curr->flags & (HTTPPOST_PTRCONTENTS|HTTPPOST_READFILE)) retval = CURL_FORMADD_OPTION_TWICE; else { if(!array_state) avalue = va_arg(params, char *); if(avalue) { curr->value = strdup(avalue); if(!curr->value) retval = CURL_FORMADD_MEMORY; else { curr->flags |= HTTPPOST_READFILE; curr->value_alloc = TRUE; } } else retval = CURL_FORMADD_NULL; } break; /* We upload a file */ case CURLFORM_FILE: if(!array_state) avalue = va_arg(params, char *); if(curr->value) { if(curr->flags & HTTPPOST_FILENAME) { if(avalue) { char *fname = strdup(avalue); if(!fname) retval = CURL_FORMADD_MEMORY; else { form = AddFormInfo(fname, NULL, curr); if(!form) { free(fname); retval = CURL_FORMADD_MEMORY; } else { form->value_alloc = TRUE; curr = form; form = NULL; } } } else retval = CURL_FORMADD_NULL; } else retval = CURL_FORMADD_OPTION_TWICE; } else { if(avalue) { curr->value = strdup(avalue); if(!curr->value) retval = CURL_FORMADD_MEMORY; else { curr->flags |= HTTPPOST_FILENAME; curr->value_alloc = TRUE; } } else retval = CURL_FORMADD_NULL; } break; case CURLFORM_BUFFERPTR: curr->flags |= HTTPPOST_PTRBUFFER|HTTPPOST_BUFFER; if(curr->buffer) retval = CURL_FORMADD_OPTION_TWICE; else { if(!array_state) avalue = va_arg(params, char *); if(avalue) { curr->buffer = avalue; /* store for the moment */ curr->value = avalue; /* make it non-NULL to be accepted as fine */ } else retval = CURL_FORMADD_NULL; } break; case CURLFORM_BUFFERLENGTH: if(curr->bufferlength) retval = CURL_FORMADD_OPTION_TWICE; else curr->bufferlength = array_state ? (size_t)avalue : (size_t)va_arg(params, long); break; case CURLFORM_STREAM: curr->flags |= HTTPPOST_CALLBACK; if(curr->userp) retval = CURL_FORMADD_OPTION_TWICE; else { if(!array_state) avalue = va_arg(params, char *); if(avalue) { curr->userp = avalue; curr->value = avalue; /* this is not strictly true but we derive a value from this later on and we need this non-NULL to be accepted as a fine form part */ } else retval = CURL_FORMADD_NULL; } break; case CURLFORM_CONTENTTYPE: if(!array_state) avalue = va_arg(params, char *); if(curr->contenttype) { if(curr->flags & HTTPPOST_FILENAME) { if(avalue) { char *type = strdup(avalue); if(!type) retval = CURL_FORMADD_MEMORY; else { form = AddFormInfo(NULL, type, curr); if(!form) { free(type); retval = CURL_FORMADD_MEMORY; } else { form->contenttype_alloc = TRUE; curr = form; form = NULL; } } } else retval = CURL_FORMADD_NULL; } else retval = CURL_FORMADD_OPTION_TWICE; } else { if(avalue) { curr->contenttype = strdup(avalue); if(!curr->contenttype) retval = CURL_FORMADD_MEMORY; else curr->contenttype_alloc = TRUE; } else retval = CURL_FORMADD_NULL; } break; case CURLFORM_CONTENTHEADER: { /* this "cast increases required alignment of target type" but we consider it OK anyway */ struct curl_slist *list = array_state ? (struct curl_slist *)(void *)avalue : va_arg(params, struct curl_slist *); if(curr->contentheader) retval = CURL_FORMADD_OPTION_TWICE; else curr->contentheader = list; break; } case CURLFORM_FILENAME: case CURLFORM_BUFFER: if(!array_state) avalue = va_arg(params, char *); if(curr->showfilename) retval = CURL_FORMADD_OPTION_TWICE; else { curr->showfilename = strdup(avalue); if(!curr->showfilename) retval = CURL_FORMADD_MEMORY; else curr->showfilename_alloc = TRUE; } break; default: retval = CURL_FORMADD_UNKNOWN_OPTION; break; } } if(!retval) retval = FormAddCheck(first_form, &newchain, &lastnode); if(retval) /* On error, free allocated fields for all nodes of the FormInfo linked list without deallocating nodes. List nodes are deallocated later on */ free_formlist(first_form); /* Always deallocate FormInfo linked list nodes without touching node fields given that these have either been deallocated or are owned now by the httppost linked list */ while(first_form) { struct FormInfo *ptr = first_form->more; free(first_form); first_form = ptr; } if(!retval) { /* Only if all is fine, link the new chain into the provided list */ if(*last_post) (*last_post)->next = newchain; else (*httppost) = newchain; (*last_post) = lastnode; } else free_chain(newchain); return retval; } /* * curl_formadd() is a public API to add a section to the multipart formpost. * * @unittest: 1308 */ CURLFORMcode curl_formadd(struct curl_httppost **httppost, struct curl_httppost **last_post, ...) { va_list arg; CURLFORMcode result; va_start(arg, last_post); result = FormAdd(httppost, last_post, arg); va_end(arg); return result; } /* * curl_formget() * Serialize a curl_httppost struct. * Returns 0 on success. * * @unittest: 1308 */ int curl_formget(struct curl_httppost *form, void *arg, curl_formget_callback append) { CURLcode result; curl_mimepart toppart; Curl_mime_initpart(&toppart); /* default form is empty */ result = Curl_getformdata(NULL, &toppart, form, NULL); if(!result) result = Curl_mime_prepare_headers(NULL, &toppart, "multipart/form-data", NULL, MIMESTRATEGY_FORM); while(!result) { char buffer[8192]; size_t nread = Curl_mime_read(buffer, 1, sizeof(buffer), &toppart); if(!nread) break; if(nread > sizeof(buffer) || append(arg, buffer, nread) != nread) { result = CURLE_READ_ERROR; if(nread == CURL_READFUNC_ABORT) result = CURLE_ABORTED_BY_CALLBACK; } } Curl_mime_cleanpart(&toppart); return (int) result; } /* * curl_formfree() is an external function to free up a whole form post * chain */ void curl_formfree(struct curl_httppost *form) { struct curl_httppost *next; if(!form) /* no form to free, just get out of this */ return; do { next = form->next; /* the following form line */ /* recurse to sub-contents */ curl_formfree(form->more); if(!(form->flags & HTTPPOST_PTRNAME)) free(form->name); /* free the name */ if(!(form->flags & (HTTPPOST_PTRCONTENTS|HTTPPOST_BUFFER|HTTPPOST_CALLBACK)) ) free(form->contents); /* free the contents */ free(form->contenttype); /* free the content type */ free(form->showfilename); /* free the faked filename */ free(form); /* free the struct */ form = next; } while(form); /* continue */ } /* Set mime part name, taking care of non null-terminated name string. */ static CURLcode setname(curl_mimepart *part, const char *name, size_t len) { char *zname; CURLcode res; if(!name || !len) return curl_mime_name(part, name); zname = Curl_memdup0(name, len); if(!zname) return CURLE_OUT_OF_MEMORY; res = curl_mime_name(part, zname); free(zname); return res; } /* wrap call to fseeko so it matches the calling convention of callback */ static int fseeko_wrapper(void *stream, curl_off_t offset, int whence) { #if defined(_WIN32) && defined(USE_WIN32_LARGE_FILES) return _fseeki64(stream, (__int64)offset, whence); #elif defined(HAVE_FSEEKO) && defined(HAVE_DECL_FSEEKO) return fseeko(stream, (off_t)offset, whence); #else if(offset > LONG_MAX) return -1; return fseek(stream, (long)offset, whence); #endif } /* * Curl_getformdata() converts a linked list of "meta data" into a mime * structure. The input list is in 'post', while the output is stored in * mime part at '*finalform'. * * This function will not do a failf() for the potential memory failures but * should for all other errors it spots. Just note that this function MAY get * a NULL pointer in the 'data' argument. */ CURLcode Curl_getformdata(CURL *data, curl_mimepart *finalform, struct curl_httppost *post, curl_read_callback fread_func) { CURLcode result = CURLE_OK; curl_mime *form = NULL; curl_mimepart *part; struct curl_httppost *file; Curl_mime_cleanpart(finalform); /* default form is empty */ if(!post) return result; /* no input => no output! */ form = curl_mime_init(data); if(!form) result = CURLE_OUT_OF_MEMORY; if(!result) result = curl_mime_subparts(finalform, form); /* Process each top part. */ for(; !result && post; post = post->next) { /* If we have more than a file here, create a mime subpart and fill it. */ curl_mime *multipart = form; if(post->more) { part = curl_mime_addpart(form); if(!part) result = CURLE_OUT_OF_MEMORY; if(!result) result = setname(part, post->name, post->namelength); if(!result) { multipart = curl_mime_init(data); if(!multipart) result = CURLE_OUT_OF_MEMORY; } if(!result) result = curl_mime_subparts(part, multipart); } /* Generate all the part contents. */ for(file = post; !result && file; file = file->more) { /* Create the part. */ part = curl_mime_addpart(multipart); if(!part) result = CURLE_OUT_OF_MEMORY; /* Set the headers. */ if(!result) result = curl_mime_headers(part, file->contentheader, 0); /* Set the content type. */ if(!result && file->contenttype) result = curl_mime_type(part, file->contenttype); /* Set field name. */ if(!result && !post->more) result = setname(part, post->name, post->namelength); /* Process contents. */ if(!result) { curl_off_t clen = post->contentslength; if(post->flags & CURL_HTTPPOST_LARGE) clen = post->contentlen; if(post->flags & (HTTPPOST_FILENAME | HTTPPOST_READFILE)) { if(!strcmp(file->contents, "-")) { /* There are a few cases where the code below will not work; in particular, freopen(stdin) by the caller is not guaranteed to result as expected. This feature has been kept for backward compatibility: use of "-" pseudo filename should be avoided. */ result = curl_mime_data_cb(part, (curl_off_t) -1, (curl_read_callback) fread, fseeko_wrapper, NULL, (void *) stdin); } else result = curl_mime_filedata(part, file->contents); if(!result && (post->flags & HTTPPOST_READFILE)) result = curl_mime_filename(part, NULL); } else if(post->flags & HTTPPOST_BUFFER) result = curl_mime_data(part, post->buffer, post->bufferlength ? post->bufferlength : -1); else if(post->flags & HTTPPOST_CALLBACK) { /* the contents should be read with the callback and the size is set with the contentslength */ if(!clen) clen = -1; result = curl_mime_data_cb(part, clen, fread_func, NULL, NULL, post->userp); } else { size_t uclen; if(!clen) uclen = CURL_ZERO_TERMINATED; else uclen = (size_t)clen; result = curl_mime_data(part, post->contents, uclen); } } /* Set fake filename. */ if(!result && post->showfilename) if(post->more || (post->flags & (HTTPPOST_FILENAME | HTTPPOST_BUFFER | HTTPPOST_CALLBACK))) result = curl_mime_filename(part, post->showfilename); } } if(result) Curl_mime_cleanpart(finalform); return result; } #else /* if disabled */ CURLFORMcode curl_formadd(struct curl_httppost **httppost, struct curl_httppost **last_post, ...) { (void)httppost; (void)last_post; return CURL_FORMADD_DISABLED; } int curl_formget(struct curl_httppost *form, void *arg, curl_formget_callback append) { (void) form; (void) arg; (void) append; return CURL_FORMADD_DISABLED; } void curl_formfree(struct curl_httppost *form) { (void)form; /* Nothing to do. */ } #endif /* if disabled */