953 lines
29 KiB
C
953 lines
29 KiB
C
/***************************************************************************
|
|
* _ _ ____ _
|
|
* Project ___| | | | _ \| |
|
|
* / __| | | | |_) | |
|
|
* | (__| |_| | _ <| |___
|
|
* \___|\___/|_| \_\_____|
|
|
*
|
|
* Copyright (C) 1998 - 2021, Daniel Stenberg, <daniel@haxx.se>, 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.
|
|
*
|
|
***************************************************************************/
|
|
|
|
#include "curl_setup.h"
|
|
|
|
#include <curl/curl.h>
|
|
|
|
#include "formdata.h"
|
|
#if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_MIME)
|
|
|
|
#if defined(HAVE_LIBGEN_H) && defined(HAVE_BASENAME)
|
|
#include <libgen.h>
|
|
#endif
|
|
|
|
#include "urldata.h" /* for struct Curl_easy */
|
|
#include "mime.h"
|
|
#include "non-ascii.h"
|
|
#include "vtls/vtls.h"
|
|
#include "strcase.h"
|
|
#include "sendf.h"
|
|
#include "strdup.h"
|
|
#include "rand.h"
|
|
#include "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 a 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(char *name, size_t namelength,
|
|
char *value, curl_off_t contentslength,
|
|
char *buffer, size_t bufferlength,
|
|
char *contenttype,
|
|
long flags,
|
|
struct curl_slist *contentHeader,
|
|
char *showfilename, char *userp,
|
|
struct curl_httppost *parent_post,
|
|
struct curl_httppost **httppost,
|
|
struct curl_httppost **last_post)
|
|
{
|
|
struct curl_httppost *post;
|
|
post = calloc(1, sizeof(struct curl_httppost));
|
|
if(post) {
|
|
post->name = name;
|
|
post->namelength = (long)(name?(namelength?namelength:strlen(name)):0);
|
|
post->contents = value;
|
|
post->contentlen = contentslength;
|
|
post->buffer = buffer;
|
|
post->bufferlength = (long)bufferlength;
|
|
post->contenttype = contenttype;
|
|
post->contentheader = contentHeader;
|
|
post->showfilename = showfilename;
|
|
post->userp = userp;
|
|
post->flags = flags | CURL_HTTPPOST_LARGE;
|
|
}
|
|
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) {
|
|
if(value)
|
|
form_info->value = value;
|
|
if(contenttype)
|
|
form_info->contenttype = contenttype;
|
|
form_info->flags = HTTPPOST_FILENAME;
|
|
}
|
|
else
|
|
return NULL;
|
|
|
|
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;
|
|
}
|
|
|
|
/***************************************************************************
|
|
*
|
|
* 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 a 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 FormAdd(struct curl_httppost **httppost,
|
|
struct curl_httppost **last_post,
|
|
va_list params)
|
|
{
|
|
struct FormInfo *first_form, *current_form, *form = NULL;
|
|
CURLFORMcode return_value = CURL_FORMADD_OK;
|
|
const char *prevtype = NULL;
|
|
struct curl_httppost *post = NULL;
|
|
CURLformoption option;
|
|
struct curl_forms *forms = NULL;
|
|
char *array_value = NULL; /* value read from an array */
|
|
|
|
/* This is a state variable, that if TRUE means that we're parsing an
|
|
array that we got passed to us. If FALSE we're 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;
|
|
|
|
current_form = first_form;
|
|
|
|
/*
|
|
* Loop through all the options set. Break if we have an error to report.
|
|
*/
|
|
while(return_value == 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;
|
|
array_value = (char *)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 */
|
|
option = va_arg(params, CURLformoption);
|
|
if(CURLFORM_END == option)
|
|
break;
|
|
}
|
|
|
|
switch(option) {
|
|
case CURLFORM_ARRAY:
|
|
if(array_state)
|
|
/* we don't support an array from within an array */
|
|
return_value = CURL_FORMADD_ILLEGAL_ARRAY;
|
|
else {
|
|
forms = va_arg(params, struct curl_forms *);
|
|
if(forms)
|
|
array_state = TRUE;
|
|
else
|
|
return_value = CURL_FORMADD_NULL;
|
|
}
|
|
break;
|
|
|
|
/*
|
|
* Set the Name property.
|
|
*/
|
|
case CURLFORM_PTRNAME:
|
|
#ifdef CURL_DOES_CONVERSIONS
|
|
/* Treat CURLFORM_PTR like CURLFORM_COPYNAME so that libcurl will copy
|
|
* the data in all cases so that we'll have safe memory for the eventual
|
|
* conversion.
|
|
*/
|
|
#else
|
|
current_form->flags |= HTTPPOST_PTRNAME; /* fall through */
|
|
#endif
|
|
/* FALLTHROUGH */
|
|
case CURLFORM_COPYNAME:
|
|
if(current_form->name)
|
|
return_value = CURL_FORMADD_OPTION_TWICE;
|
|
else {
|
|
char *name = array_state?
|
|
array_value:va_arg(params, char *);
|
|
if(name)
|
|
current_form->name = name; /* store for the moment */
|
|
else
|
|
return_value = CURL_FORMADD_NULL;
|
|
}
|
|
break;
|
|
case CURLFORM_NAMELENGTH:
|
|
if(current_form->namelength)
|
|
return_value = CURL_FORMADD_OPTION_TWICE;
|
|
else
|
|
current_form->namelength =
|
|
array_state?(size_t)array_value:(size_t)va_arg(params, long);
|
|
break;
|
|
|
|
/*
|
|
* Set the contents property.
|
|
*/
|
|
case CURLFORM_PTRCONTENTS:
|
|
current_form->flags |= HTTPPOST_PTRCONTENTS;
|
|
/* FALLTHROUGH */
|
|
case CURLFORM_COPYCONTENTS:
|
|
if(current_form->value)
|
|
return_value = CURL_FORMADD_OPTION_TWICE;
|
|
else {
|
|
char *value =
|
|
array_state?array_value:va_arg(params, char *);
|
|
if(value)
|
|
current_form->value = value; /* store for the moment */
|
|
else
|
|
return_value = CURL_FORMADD_NULL;
|
|
}
|
|
break;
|
|
case CURLFORM_CONTENTSLENGTH:
|
|
current_form->contentslength =
|
|
array_state?(size_t)array_value:(size_t)va_arg(params, long);
|
|
break;
|
|
|
|
case CURLFORM_CONTENTLEN:
|
|
current_form->flags |= CURL_HTTPPOST_LARGE;
|
|
current_form->contentslength =
|
|
array_state?(curl_off_t)(size_t)array_value:va_arg(params, curl_off_t);
|
|
break;
|
|
|
|
/* Get contents from a given file name */
|
|
case CURLFORM_FILECONTENT:
|
|
if(current_form->flags & (HTTPPOST_PTRCONTENTS|HTTPPOST_READFILE))
|
|
return_value = CURL_FORMADD_OPTION_TWICE;
|
|
else {
|
|
const char *filename = array_state?
|
|
array_value:va_arg(params, char *);
|
|
if(filename) {
|
|
current_form->value = strdup(filename);
|
|
if(!current_form->value)
|
|
return_value = CURL_FORMADD_MEMORY;
|
|
else {
|
|
current_form->flags |= HTTPPOST_READFILE;
|
|
current_form->value_alloc = TRUE;
|
|
}
|
|
}
|
|
else
|
|
return_value = CURL_FORMADD_NULL;
|
|
}
|
|
break;
|
|
|
|
/* We upload a file */
|
|
case CURLFORM_FILE:
|
|
{
|
|
const char *filename = array_state?array_value:
|
|
va_arg(params, char *);
|
|
|
|
if(current_form->value) {
|
|
if(current_form->flags & HTTPPOST_FILENAME) {
|
|
if(filename) {
|
|
char *fname = strdup(filename);
|
|
if(!fname)
|
|
return_value = CURL_FORMADD_MEMORY;
|
|
else {
|
|
form = AddFormInfo(fname, NULL, current_form);
|
|
if(!form) {
|
|
free(fname);
|
|
return_value = CURL_FORMADD_MEMORY;
|
|
}
|
|
else {
|
|
form->value_alloc = TRUE;
|
|
current_form = form;
|
|
form = NULL;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
return_value = CURL_FORMADD_NULL;
|
|
}
|
|
else
|
|
return_value = CURL_FORMADD_OPTION_TWICE;
|
|
}
|
|
else {
|
|
if(filename) {
|
|
current_form->value = strdup(filename);
|
|
if(!current_form->value)
|
|
return_value = CURL_FORMADD_MEMORY;
|
|
else {
|
|
current_form->flags |= HTTPPOST_FILENAME;
|
|
current_form->value_alloc = TRUE;
|
|
}
|
|
}
|
|
else
|
|
return_value = CURL_FORMADD_NULL;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case CURLFORM_BUFFERPTR:
|
|
current_form->flags |= HTTPPOST_PTRBUFFER|HTTPPOST_BUFFER;
|
|
if(current_form->buffer)
|
|
return_value = CURL_FORMADD_OPTION_TWICE;
|
|
else {
|
|
char *buffer =
|
|
array_state?array_value:va_arg(params, char *);
|
|
if(buffer) {
|
|
current_form->buffer = buffer; /* store for the moment */
|
|
current_form->value = buffer; /* make it non-NULL to be accepted
|
|
as fine */
|
|
}
|
|
else
|
|
return_value = CURL_FORMADD_NULL;
|
|
}
|
|
break;
|
|
|
|
case CURLFORM_BUFFERLENGTH:
|
|
if(current_form->bufferlength)
|
|
return_value = CURL_FORMADD_OPTION_TWICE;
|
|
else
|
|
current_form->bufferlength =
|
|
array_state?(size_t)array_value:(size_t)va_arg(params, long);
|
|
break;
|
|
|
|
case CURLFORM_STREAM:
|
|
current_form->flags |= HTTPPOST_CALLBACK;
|
|
if(current_form->userp)
|
|
return_value = CURL_FORMADD_OPTION_TWICE;
|
|
else {
|
|
char *userp =
|
|
array_state?array_value:va_arg(params, char *);
|
|
if(userp) {
|
|
current_form->userp = userp;
|
|
current_form->value = userp; /* this isn't 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
|
|
return_value = CURL_FORMADD_NULL;
|
|
}
|
|
break;
|
|
|
|
case CURLFORM_CONTENTTYPE:
|
|
{
|
|
const char *contenttype =
|
|
array_state?array_value:va_arg(params, char *);
|
|
if(current_form->contenttype) {
|
|
if(current_form->flags & HTTPPOST_FILENAME) {
|
|
if(contenttype) {
|
|
char *type = strdup(contenttype);
|
|
if(!type)
|
|
return_value = CURL_FORMADD_MEMORY;
|
|
else {
|
|
form = AddFormInfo(NULL, type, current_form);
|
|
if(!form) {
|
|
free(type);
|
|
return_value = CURL_FORMADD_MEMORY;
|
|
}
|
|
else {
|
|
form->contenttype_alloc = TRUE;
|
|
current_form = form;
|
|
form = NULL;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
return_value = CURL_FORMADD_NULL;
|
|
}
|
|
else
|
|
return_value = CURL_FORMADD_OPTION_TWICE;
|
|
}
|
|
else {
|
|
if(contenttype) {
|
|
current_form->contenttype = strdup(contenttype);
|
|
if(!current_form->contenttype)
|
|
return_value = CURL_FORMADD_MEMORY;
|
|
else
|
|
current_form->contenttype_alloc = TRUE;
|
|
}
|
|
else
|
|
return_value = 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 *)array_value:
|
|
va_arg(params, struct curl_slist *);
|
|
|
|
if(current_form->contentheader)
|
|
return_value = CURL_FORMADD_OPTION_TWICE;
|
|
else
|
|
current_form->contentheader = list;
|
|
|
|
break;
|
|
}
|
|
case CURLFORM_FILENAME:
|
|
case CURLFORM_BUFFER:
|
|
{
|
|
const char *filename = array_state?array_value:
|
|
va_arg(params, char *);
|
|
if(current_form->showfilename)
|
|
return_value = CURL_FORMADD_OPTION_TWICE;
|
|
else {
|
|
current_form->showfilename = strdup(filename);
|
|
if(!current_form->showfilename)
|
|
return_value = CURL_FORMADD_MEMORY;
|
|
else
|
|
current_form->showfilename_alloc = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
return_value = CURL_FORMADD_UNKNOWN_OPTION;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(CURL_FORMADD_OK != return_value) {
|
|
/* On error, free allocated fields for all nodes of the FormInfo linked
|
|
list without deallocating nodes. List nodes are deallocated later on */
|
|
struct FormInfo *ptr;
|
|
for(ptr = first_form; 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;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(CURL_FORMADD_OK == return_value) {
|
|
/* go through the list, check for completeness and if everything is
|
|
* alright add the HttpPost item otherwise set return_value accordingly */
|
|
|
|
post = NULL;
|
|
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_value = CURL_FORMADD_INCOMPLETE;
|
|
break;
|
|
}
|
|
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_value = CURL_FORMADD_MEMORY;
|
|
break;
|
|
}
|
|
form->contenttype_alloc = TRUE;
|
|
}
|
|
if(form->name && form->namelength) {
|
|
/* Name should not contain nul bytes. */
|
|
size_t i;
|
|
for(i = 0; i < form->namelength; i++)
|
|
if(!form->name[i]) {
|
|
return_value = CURL_FORMADD_NULL;
|
|
break;
|
|
}
|
|
if(return_value != CURL_FORMADD_OK)
|
|
break;
|
|
}
|
|
if(!(form->flags & HTTPPOST_PTRNAME) &&
|
|
(form == first_form) ) {
|
|
/* Note that there's small risk that form->name is NULL here if the
|
|
app passed in a bad combo, so we better check for that first. */
|
|
if(form->name) {
|
|
/* copy name (without strdup; possibly not null-terminated) */
|
|
form->name = Curl_memdup(form->name, form->namelength?
|
|
form->namelength:
|
|
strlen(form->name) + 1);
|
|
}
|
|
if(!form->name) {
|
|
return_value = CURL_FORMADD_MEMORY;
|
|
break;
|
|
}
|
|
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_value = CURL_FORMADD_MEMORY;
|
|
break;
|
|
}
|
|
form->value_alloc = TRUE;
|
|
}
|
|
post = AddHttpPost(form->name, form->namelength,
|
|
form->value, form->contentslength,
|
|
form->buffer, form->bufferlength,
|
|
form->contenttype, form->flags,
|
|
form->contentheader, form->showfilename,
|
|
form->userp,
|
|
post, httppost,
|
|
last_post);
|
|
|
|
if(!post) {
|
|
return_value = CURL_FORMADD_MEMORY;
|
|
break;
|
|
}
|
|
|
|
if(form->contenttype)
|
|
prevtype = form->contenttype;
|
|
}
|
|
if(CURL_FORMADD_OK != return_value) {
|
|
/* On error, free allocated fields for nodes of the FormInfo linked
|
|
list which are not already owned by the httppost linked list
|
|
without deallocating nodes. List nodes are deallocated later on */
|
|
struct FormInfo *ptr;
|
|
for(ptr = form; 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;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 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;
|
|
}
|
|
|
|
return return_value;
|
|
}
|
|
|
|
/*
|
|
* 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, NULL); /* default form is empty */
|
|
result = Curl_getformdata(NULL, &toppart, form, NULL);
|
|
if(!result)
|
|
result = Curl_mime_prepare_headers(&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 file name */
|
|
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 = malloc(len + 1);
|
|
if(!zname)
|
|
return CURLE_OUT_OF_MEMORY;
|
|
memcpy(zname, name, len);
|
|
zname[len] = '\0';
|
|
res = curl_mime_name(part, zname);
|
|
free(zname);
|
|
return res;
|
|
}
|
|
|
|
/*
|
|
* 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(struct Curl_easy *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 won't 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 file name should be avoided. */
|
|
result = curl_mime_data_cb(part, (curl_off_t) -1,
|
|
(curl_read_callback) fread,
|
|
CURLX_FUNCTION_CAST(curl_seek_callback,
|
|
fseek),
|
|
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);
|
|
#ifdef CURL_DOES_CONVERSIONS
|
|
/* Convert textual contents now. */
|
|
if(!result && data && part->datasize)
|
|
result = Curl_convert_to_network(data, part->data, part->datasize);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/* Set fake file name. */
|
|
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;
|
|
/* does nothing HTTP is disabled */
|
|
}
|
|
|
|
#endif /* if disabled */
|