| /*************************************************************************** |
| * _ _ ____ _ |
| * Project ___| | | | _ \| | |
| * / __| | | | |_) | | |
| * | (__| |_| | _ <| |___ |
| * \___|\___/|_| \_\_____| |
| * |
| * Copyright (C) 1998 - 2009, 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 http://curl.haxx.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. |
| * |
| * $Id$ |
| ***************************************************************************/ |
| |
| /* |
| Debug the form generator stand-alone by compiling this source file with: |
| |
| gcc -DHAVE_CONFIG_H -I../ -g -D_FORM_DEBUG -DCURLDEBUG -o formdata \ |
| -I../include formdata.c strequal.c memdebug.c mprintf.c strerror.c |
| |
| (depending on circumstances you may need further externals added) |
| |
| run the 'formdata' executable the output should end with: |
| All Tests seem to have worked ... |
| and the following parts should be there: |
| |
| Content-Disposition: form-data; name="simple_COPYCONTENTS" |
| value for simple COPYCONTENTS |
| |
| Content-Disposition: form-data; name="COPYCONTENTS_+_CONTENTTYPE" |
| Content-Type: image/gif |
| value for COPYCONTENTS + CONTENTTYPE |
| |
| Content-Disposition: form-data; name="PRNAME_+_NAMELENGTH_+_COPYNAME_+_CONTENTSLENGTH" |
| vlue for PTRNAME + NAMELENGTH + COPYNAME + CONTENTSLENGTH |
| (or you might see P^@RNAME and v^@lue at the start) |
| |
| Content-Disposition: form-data; name="simple_PTRCONTENTS" |
| value for simple PTRCONTENTS |
| |
| Content-Disposition: form-data; name="PTRCONTENTS_+_CONTENTSLENGTH" |
| vlue for PTRCONTENTS + CONTENTSLENGTH |
| (or you might see v^@lue at the start) |
| |
| Content-Disposition: form-data; name="PTRCONTENTS_+_CONTENTSLENGTH_+_CONTENTTYPE" |
| Content-Type: application/octet-stream |
| vlue for PTRCONTENTS + CONTENTSLENGTH + CONTENTTYPE |
| (or you might see v^@lue at the start) |
| |
| Content-Disposition: form-data; name="FILE1_+_CONTENTTYPE"; filename="formdata.h" |
| Content-Type: text/html |
| ... |
| |
| Content-Disposition: form-data; name="FILE1_+_FILE2" |
| Content-Type: multipart/mixed, boundary=curlz1s0dkticx49MV1KGcYP5cvfSsz |
| ... |
| Content-Disposition: attachment; filename="formdata.h" |
| Content-Type: application/octet-stream |
| ... |
| Content-Disposition: attachment; filename="Makefile.b32" |
| Content-Type: application/octet-stream |
| ... |
| |
| Content-Disposition: form-data; name="FILE1_+_FILE2_+_FILE3" |
| Content-Type: multipart/mixed, boundary=curlirkYPmPwu6FrJ1vJ1u1BmtIufh1 |
| ... |
| Content-Disposition: attachment; filename="formdata.h" |
| Content-Type: application/octet-stream |
| ... |
| Content-Disposition: attachment; filename="Makefile.b32" |
| Content-Type: application/octet-stream |
| ... |
| Content-Disposition: attachment; filename="formdata.h" |
| Content-Type: application/octet-stream |
| ... |
| |
| |
| Content-Disposition: form-data; name="ARRAY: FILE1_+_FILE2_+_FILE3" |
| Content-Type: multipart/mixed, boundary=curlirkYPmPwu6FrJ1vJ1u1BmtIufh1 |
| ... |
| Content-Disposition: attachment; filename="formdata.h" |
| Content-Type: application/octet-stream |
| ... |
| Content-Disposition: attachment; filename="Makefile.b32" |
| Content-Type: application/octet-stream |
| ... |
| Content-Disposition: attachment; filename="formdata.h" |
| Content-Type: application/octet-stream |
| ... |
| |
| Content-Disposition: form-data; name="FILECONTENT" |
| ... |
| |
| */ |
| |
| #include "setup.h" |
| #include <curl/curl.h> |
| |
| /* Length of the random boundary string. */ |
| #define BOUNDARY_LENGTH 40 |
| |
| /* Private pseudo-random number seed. Unsigned integer >= 32bit. Threads |
| mutual exclusion is not implemented to acess it since we do not require |
| high quality random numbers (only used in form boudary generation). */ |
| |
| static unsigned int randseed; |
| |
| #if !defined(CURL_DISABLE_HTTP) || defined(USE_SSLEAY) |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <stdarg.h> |
| #include <time.h> |
| #if defined(HAVE_LIBGEN_H) && defined(HAVE_BASENAME) |
| #include <libgen.h> |
| #endif |
| #include "urldata.h" /* for struct SessionHandle */ |
| #include "easyif.h" /* for Curl_convert_... prototypes */ |
| #include "formdata.h" |
| #include "strequal.h" |
| #include "curl_memory.h" |
| |
| #define _MPRINTF_REPLACE /* use our functions only */ |
| #include <curl/mprintf.h> |
| |
| /* The last #include file should be: */ |
| #include "memdebug.h" |
| |
| #endif /* !defined(CURL_DISABLE_HTTP) || defined(USE_SSLEAY) */ |
| |
| #ifndef CURL_DISABLE_HTTP |
| |
| #if defined(HAVE_BASENAME) && defined(NEED_BASENAME_PROTO) |
| /* This system has a basename() but no prototype for it! */ |
| char *basename(char *path); |
| #endif |
| |
| static size_t readfromfile(struct Form *form, char *buffer, size_t size); |
| |
| /* What kind of Content-Type to use on un-specified files with unrecognized |
| extensions. */ |
| #define HTTPPOST_CONTENTTYPE_DEFAULT "application/octet-stream" |
| |
| #define FORM_FILE_SEPARATOR ',' |
| #define FORM_TYPE_SEPARATOR ';' |
| |
| /*************************************************************************** |
| * |
| * 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, size_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(sizeof(struct curl_httppost), 1); |
| if(post) { |
| post->name = name; |
| post->namelength = (long)(name?(namelength?namelength:strlen(name)):0); |
| post->contents = value; |
| post->contentslength = (long)contentslength; |
| post->buffer = buffer; |
| post->bufferlength = (long)bufferlength; |
| post->contenttype = contenttype; |
| post->contentheader = contentHeader; |
| post->showfilename = showfilename; |
| post->userp = userp, |
| post->flags = flags; |
| } |
| 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 FormInfo * AddFormInfo(char *value, |
| char *contenttype, |
| FormInfo *parent_form_info) |
| { |
| FormInfo *form_info; |
| form_info = calloc(sizeof(FormInfo), 1); |
| 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; |
| } |
| else |
| return NULL; |
| |
| return form_info; |
| } |
| |
| /*************************************************************************** |
| * |
| * ContentTypeForFilename() |
| * |
| * Provides content type for filename if one of the known types (else |
| * (either the prevtype or the default is returned). |
| * |
| * Returns some valid contenttype for filename. |
| * |
| ***************************************************************************/ |
| static const char * ContentTypeForFilename (const char *filename, |
| const char *prevtype) |
| { |
| const char *contenttype = NULL; |
| unsigned int i; |
| /* |
| * No type was specified, we scan through a few well-known |
| * extensions and pick the first we match! |
| */ |
| struct ContentType { |
| char extension[6]; |
| const char *type; |
| }; |
| static const struct ContentType ctts[]={ |
| {".gif", "image/gif"}, |
| {".jpg", "image/jpeg"}, |
| {".jpeg", "image/jpeg"}, |
| {".txt", "text/plain"}, |
| {".html", "text/html"}, |
| {".xml", "application/xml"} |
| }; |
| |
| if(prevtype) |
| /* default to the previously set/used! */ |
| contenttype = prevtype; |
| else |
| contenttype = HTTPPOST_CONTENTTYPE_DEFAULT; |
| |
| if(filename) { /* in case a NULL was passed in */ |
| for(i=0; i<sizeof(ctts)/sizeof(ctts[0]); i++) { |
| if(strlen(filename) >= strlen(ctts[i].extension)) { |
| if(strequal(filename + |
| strlen(filename) - strlen(ctts[i].extension), |
| ctts[i].extension)) { |
| contenttype = ctts[i].type; |
| break; |
| } |
| } |
| } |
| } |
| /* we have a contenttype by now */ |
| return contenttype; |
| } |
| |
| /*************************************************************************** |
| * |
| * memdup() |
| * |
| * Copies the 'source' data to a newly allocated buffer buffer (that is |
| * returned). Uses buffer_length if not null, else uses strlen to determine |
| * the length of the buffer to be copied |
| * |
| * Returns the new pointer or NULL on failure. |
| * |
| ***************************************************************************/ |
| static char *memdup(const char *src, size_t buffer_length) |
| { |
| size_t length; |
| bool add = FALSE; |
| char *buffer; |
| |
| if(buffer_length) |
| length = buffer_length; |
| else if(src) { |
| length = strlen(src); |
| add = TRUE; |
| } |
| else |
| /* no length and a NULL src pointer! */ |
| return strdup(""); |
| |
| buffer = malloc(length+add); |
| if(!buffer) |
| return NULL; /* fail */ |
| |
| memcpy(buffer, src, length); |
| |
| /* if length unknown do null termination */ |
| if(add) |
| buffer[length] = '\0'; |
| |
| return buffer; |
| } |
| |
| /*************************************************************************** |
| * |
| * 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 an 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) |
| { |
| 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(sizeof(struct FormInfo), 1); |
| 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 ) { |
| /* 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 we'll |
| have safe memory for the eventual conversion */ |
| #else |
| current_form->flags |= HTTPPOST_PTRNAME; /* fall through */ |
| #endif |
| 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; /* fall through */ |
| 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: |
| if(current_form->contentslength) |
| return_value = CURL_FORMADD_OPTION_TWICE; |
| else |
| current_form->contentslength = |
| array_state?(size_t)array_value:(size_t)va_arg(params, long); |
| break; |
| |
| /* Get contents from a given file name */ |
| case CURLFORM_FILECONTENT: |
| if(current_form->flags != 0) |
| 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) { |
| if((current_form = AddFormInfo(strdup(filename), |
| NULL, current_form)) == NULL) |
| return_value = CURL_FORMADD_MEMORY; |
| } |
| 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_BUFFER: |
| { |
| const char *filename = array_state?array_value: |
| va_arg(params, char *); |
| |
| if(current_form->value) { |
| if(current_form->flags & HTTPPOST_BUFFER) { |
| if(filename) { |
| if((current_form = AddFormInfo(strdup(filename), |
| NULL, current_form)) == NULL) |
| return_value = CURL_FORMADD_MEMORY; |
| } |
| 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 |
| return_value = CURL_FORMADD_NULL; |
| current_form->flags |= HTTPPOST_BUFFER; |
| } |
| break; |
| } |
| |
| case CURLFORM_BUFFERPTR: |
| current_form->flags |= HTTPPOST_PTRBUFFER; |
| 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 */ |
| 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) { |
| if((current_form = AddFormInfo(NULL, |
| strdup(contenttype), |
| current_form)) == NULL) |
| return_value = CURL_FORMADD_MEMORY; |
| } |
| 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*)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: |
| { |
| 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; |
| } |
| } |
| |
| 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; |
| } |
| else { |
| if( ((form->flags & HTTPPOST_FILENAME) || |
| (form->flags & HTTPPOST_BUFFER)) && |
| !form->contenttype ) { |
| /* our contenttype is missing */ |
| form->contenttype |
| = strdup(ContentTypeForFilename(form->value, prevtype)); |
| if(!form->contenttype) { |
| return_value = CURL_FORMADD_MEMORY; |
| break; |
| } |
| form->contenttype_alloc = TRUE; |
| } |
| 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 contains null characters) */ |
| form->name = memdup(form->name, form->namelength); |
| 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)) ) { |
| /* copy value (without strdup; possibly contains null characters) */ |
| form->value = memdup(form->value, form->contentslength); |
| 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(return_value) { |
| /* we return on error, free possibly allocated fields */ |
| if(!form) |
| form = current_form; |
| if(form) { |
| if(form->name_alloc) |
| free(form->name); |
| if(form->value_alloc) |
| free(form->value); |
| if(form->contenttype_alloc) |
| free(form->contenttype); |
| if(form->showfilename_alloc) |
| free(form->showfilename); |
| } |
| } |
| |
| /* always delete the allocated memory before returning */ |
| form = first_form; |
| while(form != NULL) { |
| FormInfo *delete_form; |
| |
| delete_form = form; |
| form = form->more; |
| free (delete_form); |
| } |
| |
| return return_value; |
| } |
| |
| /* |
| * curl_formadd() is a public API to add a section to the multipart formpost. |
| */ |
| |
| 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; |
| } |
| |
| /* |
| * AddFormData() adds a chunk of data to the FormData linked list. |
| * |
| * size is incremented by the chunk length, unless it is NULL |
| */ |
| static CURLcode AddFormData(struct FormData **formp, |
| enum formtype type, |
| const void *line, |
| size_t length, |
| curl_off_t *size) |
| { |
| struct FormData *newform = malloc(sizeof(struct FormData)); |
| if(!newform) |
| return CURLE_OUT_OF_MEMORY; |
| newform->next = NULL; |
| |
| if(type <= FORM_CONTENT) { |
| /* we make it easier for plain strings: */ |
| if(!length) |
| length = strlen((char *)line); |
| |
| newform->line = malloc(length+1); |
| if(!newform->line) { |
| free(newform); |
| return CURLE_OUT_OF_MEMORY; |
| } |
| memcpy(newform->line, line, length); |
| newform->length = length; |
| newform->line[length]=0; /* zero terminate for easier debugging */ |
| } |
| else |
| /* For callbacks and files we don't have any actual data so we just keep a |
| pointer to whatever this points to */ |
| newform->line = (char *)line; |
| |
| newform->type = type; |
| |
| if(*formp) { |
| (*formp)->next = newform; |
| *formp = newform; |
| } |
| else |
| *formp = newform; |
| |
| if(size) { |
| if(type != FORM_FILE) |
| /* for static content as well as callback data we add the size given |
| as input argument */ |
| *size += length; |
| else { |
| /* Since this is a file to be uploaded here, add the size of the actual |
| file */ |
| if(!strequal("-", newform->line)) { |
| struct_stat file; |
| if(!stat(newform->line, &file)) { |
| *size += file.st_size; |
| } |
| } |
| } |
| } |
| return CURLE_OK; |
| } |
| |
| /* |
| * AddFormDataf() adds printf()-style formatted data to the formdata chain. |
| */ |
| |
| static CURLcode AddFormDataf(struct FormData **formp, |
| curl_off_t *size, |
| const char *fmt, ...) |
| { |
| char s[4096]; |
| va_list ap; |
| va_start(ap, fmt); |
| vsnprintf(s, sizeof(s), fmt, ap); |
| va_end(ap); |
| |
| return AddFormData(formp, FORM_DATA, s, 0, size); |
| } |
| |
| /* |
| * Curl_formclean() is used from http.c, this cleans a built FormData linked |
| * list |
| */ |
| void Curl_formclean(struct FormData **form_ptr) |
| { |
| struct FormData *next, *form; |
| |
| form = *form_ptr; |
| if(!form) |
| return; |
| |
| do { |
| next=form->next; /* the following form line */ |
| if(form->type <= FORM_CONTENT) |
| free(form->line); /* free the line */ |
| free(form); /* free the struct */ |
| |
| } while((form = next) != NULL); /* continue */ |
| |
| *form_ptr = NULL; |
| } |
| |
| #ifdef CURL_DOES_CONVERSIONS |
| /* |
| * Curl_formcovert() is used from http.c, this converts any |
| form items that need to be sent in the network encoding. |
| Returns CURLE_OK on success. |
| */ |
| CURLcode Curl_formconvert(struct SessionHandle *data, struct FormData *form) |
| { |
| struct FormData *next; |
| CURLcode rc; |
| |
| if(!form) |
| return CURLE_OK; |
| |
| if(!data) |
| return CURLE_BAD_FUNCTION_ARGUMENT; |
| |
| do { |
| next=form->next; /* the following form line */ |
| if(form->type == FORM_DATA) { |
| rc = Curl_convert_to_network(data, form->line, form->length); |
| /* Curl_convert_to_network calls failf if unsuccessful */ |
| if(rc != CURLE_OK) |
| return rc; |
| } |
| } while((form = next) != NULL); /* continue */ |
| return CURLE_OK; |
| } |
| #endif /* CURL_DOES_CONVERSIONS */ |
| |
| /* |
| * curl_formget() |
| * Serialize a curl_httppost struct. |
| * Returns 0 on success. |
| */ |
| int curl_formget(struct curl_httppost *form, void *arg, |
| curl_formget_callback append) |
| { |
| CURLcode rc; |
| curl_off_t size; |
| struct FormData *data, *ptr; |
| |
| rc = Curl_getFormData(&data, form, NULL, &size); |
| if(rc != CURLE_OK) |
| return (int)rc; |
| |
| for (ptr = data; ptr; ptr = ptr->next) { |
| if(ptr->type == FORM_FILE) { |
| char buffer[8192]; |
| size_t nread; |
| struct Form temp; |
| |
| Curl_FormInit(&temp, ptr); |
| |
| do { |
| nread = readfromfile(&temp, buffer, sizeof(buffer)); |
| if((nread == (size_t) -1) || (nread != append(arg, buffer, nread))) { |
| if(temp.fp) { |
| fclose(temp.fp); |
| } |
| Curl_formclean(&data); |
| return -1; |
| } |
| } while(nread == sizeof(buffer)); |
| } else { |
| if(ptr->length != append(arg, ptr->line, ptr->length)) { |
| Curl_formclean(&data); |
| return -1; |
| } |
| } |
| } |
| Curl_formclean(&data); |
| return 0; |
| } |
| |
| /* |
| * 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 */ |
| if(form->more) |
| curl_formfree(form->more); |
| |
| if( !(form->flags & HTTPPOST_PTRNAME) && form->name) |
| free(form->name); /* free the name */ |
| if( !(form->flags & (HTTPPOST_PTRCONTENTS|HTTPPOST_CALLBACK)) && |
| form->contents) |
| free(form->contents); /* free the contents */ |
| if(form->contenttype) |
| free(form->contenttype); /* free the content type */ |
| if(form->showfilename) |
| free(form->showfilename); /* free the faked file name */ |
| free(form); /* free the struct */ |
| |
| } while((form = next) != NULL); /* continue */ |
| } |
| |
| #ifndef HAVE_BASENAME |
| /* |
| (Quote from The Open Group Base Specifications Issue 6 IEEE Std 1003.1, 2004 |
| Edition) |
| |
| The basename() function shall take the pathname pointed to by path and |
| return a pointer to the final component of the pathname, deleting any |
| trailing '/' characters. |
| |
| If the string pointed to by path consists entirely of the '/' character, |
| basename() shall return a pointer to the string "/". If the string pointed |
| to by path is exactly "//", it is implementation-defined whether '/' or "//" |
| is returned. |
| |
| If path is a null pointer or points to an empty string, basename() shall |
| return a pointer to the string ".". |
| |
| The basename() function may modify the string pointed to by path, and may |
| return a pointer to static storage that may then be overwritten by a |
| subsequent call to basename(). |
| |
| The basename() function need not be reentrant. A function that is not |
| required to be reentrant is not required to be thread-safe. |
| |
| */ |
| static char *basename(char *path) |
| { |
| /* Ignore all the details above for now and make a quick and simple |
| implementaion here */ |
| char *s1; |
| char *s2; |
| |
| s1=strrchr(path, '/'); |
| s2=strrchr(path, '\\'); |
| |
| if(s1 && s2) { |
| path = (s1 > s2? s1 : s2)+1; |
| } |
| else if(s1) |
| path = s1 + 1; |
| else if(s2) |
| path = s2 + 1; |
| |
| return path; |
| } |
| #endif |
| |
| static char *strippath(const char *fullfile) |
| { |
| char *filename; |
| char *base; |
| filename = strdup(fullfile); /* duplicate since basename() may ruin the |
| buffer it works on */ |
| if(!filename) |
| return NULL; |
| base = strdup(basename(filename)); |
| |
| free(filename); /* free temporary buffer */ |
| |
| return base; /* returns an allocated string or NULL ! */ |
| } |
| |
| /* |
| * Curl_getFormData() converts a linked list of "meta data" into a complete |
| * (possibly huge) multipart formdata. The input list is in 'post', while the |
| * output resulting linked lists gets stored in '*finalform'. *sizep will get |
| * the total size of the whole POST. |
| * A multipart/form_data content-type is built, unless a custom content-type |
| * is passed in 'custom_content_type'. |
| */ |
| |
| CURLcode Curl_getFormData(struct FormData **finalform, |
| struct curl_httppost *post, |
| const char *custom_content_type, |
| curl_off_t *sizep) |
| { |
| struct FormData *form = NULL; |
| struct FormData *firstform; |
| struct curl_httppost *file; |
| CURLcode result = CURLE_OK; |
| |
| curl_off_t size=0; /* support potentially ENORMOUS formposts */ |
| char *boundary; |
| char *fileboundary=NULL; |
| struct curl_slist* curList; |
| |
| *finalform=NULL; /* default form is empty */ |
| |
| if(!post) |
| return result; /* no input => no output! */ |
| |
| boundary = Curl_FormBoundary(); |
| if(!boundary) |
| return CURLE_OUT_OF_MEMORY; |
| |
| /* Make the first line of the output */ |
| result = AddFormDataf(&form, NULL, |
| "%s; boundary=%s\r\n", |
| custom_content_type?custom_content_type: |
| "Content-Type: multipart/form-data", |
| boundary); |
| |
| if(result) { |
| free(boundary); |
| return result; |
| } |
| /* we DO NOT include that line in the total size of the POST, since it'll be |
| part of the header! */ |
| |
| firstform = form; |
| |
| do { |
| |
| if(size) { |
| result = AddFormDataf(&form, &size, "\r\n"); |
| if(result) |
| break; |
| } |
| |
| /* boundary */ |
| result = AddFormDataf(&form, &size, "--%s\r\n", boundary); |
| if(result) |
| break; |
| |
| /* Maybe later this should be disabled when a custom_content_type is |
| passed, since Content-Disposition is not meaningful for all multipart |
| types. |
| */ |
| result = AddFormDataf(&form, &size, |
| "Content-Disposition: form-data; name=\""); |
| if(result) |
| break; |
| |
| result = AddFormData(&form, FORM_DATA, post->name, post->namelength, |
| &size); |
| if(result) |
| break; |
| |
| result = AddFormDataf(&form, &size, "\""); |
| if(result) |
| break; |
| |
| if(post->more) { |
| /* If used, this is a link to more file names, we must then do |
| the magic to include several files with the same field name */ |
| |
| fileboundary = Curl_FormBoundary(); |
| |
| result = AddFormDataf(&form, &size, |
| "\r\nContent-Type: multipart/mixed," |
| " boundary=%s\r\n", |
| fileboundary); |
| if(result) |
| break; |
| } |
| |
| file = post; |
| |
| do { |
| |
| /* If 'showfilename' is set, that is a faked name passed on to us |
| to use to in the formpost. If that is not set, the actually used |
| local file name should be added. */ |
| |
| if(post->more) { |
| /* if multiple-file */ |
| char *filebasename= NULL; |
| if(!file->showfilename) { |
| filebasename = strippath(file->contents); |
| if(!filebasename) { |
| Curl_formclean(&firstform); |
| free(boundary); |
| return CURLE_OUT_OF_MEMORY; |
| } |
| } |
| |
| result = AddFormDataf(&form, &size, |
| "\r\n--%s\r\nContent-Disposition: " |
| "attachment; filename=\"%s\"", |
| fileboundary, |
| (file->showfilename?file->showfilename: |
| filebasename)); |
| if(filebasename) |
| free(filebasename); |
| if(result) |
| break; |
| } |
| else if(post->flags & (HTTPPOST_FILENAME|HTTPPOST_BUFFER| |
| HTTPPOST_CALLBACK)) { |
| /* it should be noted that for the HTTPPOST_FILENAME and |
| HTTPPOST_CALLBACK cases the ->showfilename struct member is always |
| assigned at this point */ |
| char *filebasename= |
| (!post->showfilename)?strippath(post->contents):NULL; |
| |
| result = AddFormDataf(&form, &size, |
| "; filename=\"%s\"", |
| (post->showfilename?post->showfilename: |
| filebasename)); |
| if(filebasename) |
| free(filebasename); |
| |
| if(result) |
| break; |
| } |
| |
| if(file->contenttype) { |
| /* we have a specified type */ |
| result = AddFormDataf(&form, &size, |
| "\r\nContent-Type: %s", |
| file->contenttype); |
| if(result) |
| break; |
| } |
| |
| curList = file->contentheader; |
| while( curList ) { |
| /* Process the additional headers specified for this form */ |
| result = AddFormDataf( &form, &size, "\r\n%s", curList->data ); |
| if(result) |
| break; |
| curList = curList->next; |
| } |
| if(result) { |
| Curl_formclean(&firstform); |
| free(boundary); |
| return result; |
| } |
| |
| #if 0 |
| /* The header Content-Transfer-Encoding: seems to confuse some receivers |
| * (like the built-in PHP engine). While I can't see any reason why it |
| * should, I can just as well skip this to the benefit of the users who |
| * are using such confused receivers. |
| */ |
| |
| if(file->contenttype && |
| !checkprefix("text/", file->contenttype)) { |
| /* this is not a text content, mention our binary encoding */ |
| result = AddFormDataf(&form, &size, |
| "\r\nContent-Transfer-Encoding: binary"); |
| if(result) |
| break; |
| } |
| #endif |
| |
| result = AddFormDataf(&form, &size, "\r\n\r\n"); |
| if(result) |
| break; |
| |
| if((post->flags & HTTPPOST_FILENAME) || |
| (post->flags & HTTPPOST_READFILE)) { |
| /* we should include the contents from the specified file */ |
| FILE *fileread; |
| |
| fileread = strequal("-", file->contents)? |
| stdin:fopen(file->contents, "rb"); /* binary read for win32 */ |
| |
| /* |
| * VMS: This only allows for stream files on VMS. Stream files are |
| * OK, as are FIXED & VAR files WITHOUT implied CC For implied CC, |
| * every record needs to have a \n appended & 1 added to SIZE |
| */ |
| |
| if(fileread) { |
| if(fileread != stdin) { |
| /* close the file again */ |
| fclose(fileread); |
| /* add the file name only - for later reading from this */ |
| result = AddFormData(&form, FORM_FILE, file->contents, 0, &size); |
| } |
| else { |
| /* When uploading from stdin, we can't know the size of the file, |
| * thus must read the full file as before. We *could* use chunked |
| * transfer-encoding, but that only works for HTTP 1.1 and we |
| * can't be sure we work with such a server. |
| */ |
| size_t nread; |
| char buffer[512]; |
| while((nread = fread(buffer, 1, sizeof(buffer), fileread)) != 0) { |
| result = AddFormData(&form, FORM_CONTENT, buffer, nread, &size); |
| if(result) |
| break; |
| } |
| } |
| |
| if(result) { |
| Curl_formclean(&firstform); |
| free(boundary); |
| return result; |
| } |
| |
| } |
| else { |
| #ifdef _FORM_DEBUG |
| fprintf(stderr, |
| "\n==> Curl_getFormData couldn't open/read \"%s\"\n", |
| file->contents); |
| #endif |
| Curl_formclean(&firstform); |
| free(boundary); |
| *finalform = NULL; |
| return CURLE_READ_ERROR; |
| } |
| |
| } |
| else if(post->flags & HTTPPOST_BUFFER) { |
| /* include contents of buffer */ |
| result = AddFormData(&form, FORM_CONTENT, post->buffer, |
| post->bufferlength, &size); |
| if(result) |
| break; |
| } |
| else if(post->flags & HTTPPOST_CALLBACK) { |
| /* the contents should be read with the callback and the size |
| is set with the contentslength */ |
| result = AddFormData(&form, FORM_CALLBACK, post->userp, |
| post->contentslength, &size); |
| if(result) |
| break; |
| } |
| else { |
| /* include the contents we got */ |
| result = AddFormData(&form, FORM_CONTENT, post->contents, |
| post->contentslength, &size); |
| if(result) |
| break; |
| } |
| } while((file = file->more) != NULL); /* for each specified file for this field */ |
| if(result) { |
| Curl_formclean(&firstform); |
| free(boundary); |
| return result; |
| } |
| |
| if(post->more) { |
| /* this was a multiple-file inclusion, make a termination file |
| boundary: */ |
| result = AddFormDataf(&form, &size, |
| "\r\n--%s--", |
| fileboundary); |
| free(fileboundary); |
| if(result) |
| break; |
| } |
| |
| } while((post = post->next) != NULL); /* for each field */ |
| if(result) { |
| Curl_formclean(&firstform); |
| free(boundary); |
| return result; |
| } |
| |
| /* end-boundary for everything */ |
| result = AddFormDataf(&form, &size, |
| "\r\n--%s--\r\n", |
| boundary); |
| if(result) { |
| Curl_formclean(&firstform); |
| free(boundary); |
| return result; |
| } |
| |
| *sizep = size; |
| |
| free(boundary); |
| |
| *finalform=firstform; |
| |
| return result; |
| } |
| |
| /* |
| * Curl_FormInit() inits the struct 'form' points to with the 'formdata' |
| * and resets the 'sent' counter. |
| */ |
| int Curl_FormInit(struct Form *form, struct FormData *formdata ) |
| { |
| if(!formdata) |
| return 1; /* error */ |
| |
| form->data = formdata; |
| form->sent = 0; |
| form->fp = NULL; |
| form->fread_func = ZERO_NULL; |
| |
| return 0; |
| } |
| |
| static size_t readfromfile(struct Form *form, char *buffer, |
| size_t size) |
| { |
| size_t nread; |
| bool callback = (bool)(form->data->type == FORM_CALLBACK); |
| |
| if(callback) |
| nread = form->fread_func(buffer, 1, size, form->data->line); |
| else { |
| if(!form->fp) { |
| /* this file hasn't yet been opened */ |
| form->fp = fopen(form->data->line, "rb"); /* b is for binary */ |
| if(!form->fp) |
| return (size_t)-1; /* failure */ |
| } |
| nread = fread(buffer, 1, size, form->fp); |
| } |
| if(!nread || nread > size) { |
| /* this is the last chunk from the file, move on */ |
| if(!callback) { |
| fclose(form->fp); |
| form->fp = NULL; |
| } |
| form->data = form->data->next; |
| } |
| |
| return nread; |
| } |
| |
| /* |
| * Curl_FormReader() is the fread() emulation function that will be used to |
| * deliver the formdata to the transfer loop and then sent away to the peer. |
| */ |
| size_t Curl_FormReader(char *buffer, |
| size_t size, |
| size_t nitems, |
| FILE *mydata) |
| { |
| struct Form *form; |
| size_t wantedsize; |
| size_t gotsize = 0; |
| |
| form=(struct Form *)mydata; |
| |
| wantedsize = size * nitems; |
| |
| if(!form->data) |
| return 0; /* nothing, error, empty */ |
| |
| if((form->data->type == FORM_FILE) || |
| (form->data->type == FORM_CALLBACK)) { |
| gotsize = readfromfile(form, buffer, wantedsize); |
| |
| if(gotsize) |
| /* If positive or -1, return. If zero, continue! */ |
| return gotsize; |
| } |
| do { |
| |
| if( (form->data->length - form->sent ) > wantedsize - gotsize) { |
| |
| memcpy(buffer + gotsize , form->data->line + form->sent, |
| wantedsize - gotsize); |
| |
| form->sent += wantedsize-gotsize; |
| |
| return wantedsize; |
| } |
| |
| memcpy(buffer+gotsize, |
| form->data->line + form->sent, |
| (form->data->length - form->sent) ); |
| gotsize += form->data->length - form->sent; |
| |
| form->sent = 0; |
| |
| form->data = form->data->next; /* advance */ |
| |
| } while(form->data && (form->data->type < FORM_CALLBACK)); |
| /* If we got an empty line and we have more data, we proceed to the next |
| line immediately to avoid returning zero before we've reached the end. */ |
| |
| return gotsize; |
| } |
| |
| /* |
| * Curl_formpostheader() returns the first line of the formpost, the |
| * request-header part (which is not part of the request-body like the rest of |
| * the post). |
| */ |
| char *Curl_formpostheader(void *formp, size_t *len) |
| { |
| char *header; |
| struct Form *form=(struct Form *)formp; |
| |
| if(!form->data) |
| return 0; /* nothing, ERROR! */ |
| |
| header = form->data->line; |
| *len = form->data->length; |
| |
| form->data = form->data->next; /* advance */ |
| |
| return header; |
| } |
| |
| |
| #ifdef _FORM_DEBUG |
| int FormAddTest(const char * errormsg, |
| struct curl_httppost **httppost, |
| struct curl_httppost **last_post, |
| ...) |
| { |
| int result; |
| va_list arg; |
| va_start(arg, last_post); |
| if((result = FormAdd(httppost, last_post, arg))) |
| fprintf (stderr, "ERROR doing FormAdd ret: %d action: %s\n", result, |
| errormsg); |
| va_end(arg); |
| return result; |
| } |
| |
| |
| int main(int argc, argv_item_t argv[]) |
| { |
| char name1[] = "simple_COPYCONTENTS"; |
| char name2[] = "COPYCONTENTS_+_CONTENTTYPE"; |
| char name3[] = "PTRNAME_+_NAMELENGTH_+_COPYNAME_+_CONTENTSLENGTH"; |
| char name4[] = "simple_PTRCONTENTS"; |
| char name5[] = "PTRCONTENTS_+_CONTENTSLENGTH"; |
| char name6[] = "PTRCONTENTS_+_CONTENTSLENGTH_+_CONTENTTYPE"; |
| char name7[] = "FILE1_+_CONTENTTYPE"; |
| char name8[] = "FILE1_+_FILE2"; |
| char name9[] = "FILE1_+_FILE2_+_FILE3"; |
| char name10[] = "ARRAY: FILE1_+_FILE2_+_FILE3"; |
| char name11[] = "FILECONTENT"; |
| char value1[] = "value for simple COPYCONTENTS"; |
| char value2[] = "value for COPYCONTENTS + CONTENTTYPE"; |
| char value3[] = "value for PTRNAME + NAMELENGTH + COPYNAME + CONTENTSLENGTH"; |
| char value4[] = "value for simple PTRCONTENTS"; |
| char value5[] = "value for PTRCONTENTS + CONTENTSLENGTH"; |
| char value6[] = "value for PTRCONTENTS + CONTENTSLENGTH + CONTENTTYPE"; |
| char value7[] = "formdata.h"; |
| char value8[] = "Makefile.b32"; |
| char type2[] = "image/gif"; |
| char type6[] = "text/plain"; |
| char type7[] = "text/html"; |
| int name3length = strlen(name3); |
| int value3length = strlen(value3); |
| int value5length = strlen(value5); |
| int value6length = strlen(value6); |
| int errors = 0; |
| CURLcode rc; |
| curl_off_t size; |
| size_t nread; |
| char buffer[4096]; |
| struct curl_httppost *httppost=NULL; |
| struct curl_httppost *last_post=NULL; |
| struct curl_forms forms[4]; |
| |
| struct FormData *form; |
| struct Form formread; |
| |
| (void) argc; |
| (void) argv; |
| |
| Curl_srand(); /* Because we do not call curl_global_init() here. */ |
| |
| if(FormAddTest("simple COPYCONTENTS test", &httppost, &last_post, |
| CURLFORM_COPYNAME, name1, CURLFORM_COPYCONTENTS, value1, |
| CURLFORM_END)) |
| ++errors; |
| if(FormAddTest("COPYCONTENTS + CONTENTTYPE test", &httppost, &last_post, |
| CURLFORM_COPYNAME, name2, CURLFORM_COPYCONTENTS, value2, |
| CURLFORM_CONTENTTYPE, type2, CURLFORM_END)) |
| ++errors; |
| /* make null character at start to check that contentslength works |
| correctly */ |
| name3[1] = '\0'; |
| value3[1] = '\0'; |
| if(FormAddTest("PTRNAME + NAMELENGTH + COPYNAME + CONTENTSLENGTH test", |
| &httppost, &last_post, |
| CURLFORM_PTRNAME, name3, CURLFORM_COPYCONTENTS, value3, |
| CURLFORM_CONTENTSLENGTH, value3length, |
| CURLFORM_NAMELENGTH, name3length, CURLFORM_END)) |
| ++errors; |
| if(FormAddTest("simple PTRCONTENTS test", &httppost, &last_post, |
| CURLFORM_COPYNAME, name4, CURLFORM_PTRCONTENTS, value4, |
| CURLFORM_END)) |
| ++errors; |
| /* make null character at start to check that contentslength works |
| correctly */ |
| value5[1] = '\0'; |
| if(FormAddTest("PTRCONTENTS + CONTENTSLENGTH test", &httppost, &last_post, |
| CURLFORM_COPYNAME, name5, CURLFORM_PTRCONTENTS, value5, |
| CURLFORM_CONTENTSLENGTH, value5length, CURLFORM_END)) |
| ++errors; |
| /* make null character at start to check that contentslength works |
| correctly */ |
| value6[1] = '\0'; |
| if(FormAddTest("PTRCONTENTS + CONTENTSLENGTH + CONTENTTYPE test", |
| &httppost, &last_post, |
| CURLFORM_COPYNAME, name6, CURLFORM_PTRCONTENTS, value6, |
| CURLFORM_CONTENTSLENGTH, value6length, |
| CURLFORM_CONTENTTYPE, type6, CURLFORM_END)) |
| ++errors; |
| if(FormAddTest("FILE + CONTENTTYPE test", &httppost, &last_post, |
| CURLFORM_COPYNAME, name7, CURLFORM_FILE, value7, |
| CURLFORM_CONTENTTYPE, type7, CURLFORM_END)) |
| ++errors; |
| if(FormAddTest("FILE1 + FILE2 test", &httppost, &last_post, |
| CURLFORM_COPYNAME, name8, CURLFORM_FILE, value7, |
| CURLFORM_FILE, value8, CURLFORM_END)) |
| ++errors; |
| if(FormAddTest("FILE1 + FILE2 + FILE3 test", &httppost, &last_post, |
| CURLFORM_COPYNAME, name9, CURLFORM_FILE, value7, |
| CURLFORM_FILE, value8, CURLFORM_FILE, value7, CURLFORM_END)) |
| ++errors; |
| forms[0].option = CURLFORM_FILE; |
| forms[0].value = value7; |
| forms[1].option = CURLFORM_FILE; |
| forms[1].value = value8; |
| forms[2].option = CURLFORM_FILE; |
| forms[2].value = value7; |
| forms[3].option = CURLFORM_END; |
| if(FormAddTest("FILE1 + FILE2 + FILE3 ARRAY test", &httppost, &last_post, |
| CURLFORM_COPYNAME, name10, CURLFORM_ARRAY, forms, |
| CURLFORM_END)) |
| ++errors; |
| if(FormAddTest("FILECONTENT test", &httppost, &last_post, |
| CURLFORM_COPYNAME, name11, CURLFORM_FILECONTENT, value7, |
| CURLFORM_END)) |
| ++errors; |
| |
| rc = Curl_getFormData(&form, httppost, NULL, &size); |
| if(rc != CURLE_OK) { |
| if(rc != CURLE_READ_ERROR) { |
| const char *errortext = curl_easy_strerror(rc); |
| fprintf(stdout, "\n==> Curl_getFormData error: %s\n", errortext); |
| } |
| return 0; |
| } |
| |
| Curl_FormInit(&formread, form); |
| |
| do { |
| nread = Curl_FormReader(buffer, 1, sizeof(buffer), |
| (FILE *)&formread); |
| |
| if(nread < 1) |
| break; |
| fwrite(buffer, nread, 1, stdout); |
| } while(1); |
| |
| fprintf(stdout, "size: "); |
| fprintf(stdout, "%" FORMAT_OFF_T, size); |
| fprintf(stdout, "\n"); |
| if(errors) |
| fprintf(stdout, "\n==> %d Test(s) failed!\n", errors); |
| else |
| fprintf(stdout, "\nAll Tests seem to have worked (please check output)\n"); |
| |
| return 0; |
| } |
| |
| #endif /* _FORM_DEBUG */ |
| |
| #else /* CURL_DISABLE_HTTP */ |
| 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 /* CURL_DISABLE_HTTP */ |
| |
| #if !defined(CURL_DISABLE_HTTP) || defined(USE_SSLEAY) |
| |
| /* |
| * Curl_FormBoundary() creates a suitable boundary string and returns an |
| * allocated one. This is also used by SSL-code so it must be present even |
| * if HTTP is disabled! |
| */ |
| char *Curl_FormBoundary(void) |
| { |
| char *retstring; |
| size_t i; |
| |
| static const char table16[]="0123456789abcdef"; |
| |
| retstring = malloc(BOUNDARY_LENGTH+1); |
| |
| if(!retstring) |
| return NULL; /* failed */ |
| |
| strcpy(retstring, "----------------------------"); |
| |
| for(i=strlen(retstring); i<BOUNDARY_LENGTH; i++) |
| retstring[i] = table16[Curl_rand()%16]; |
| |
| /* 28 dashes and 12 hexadecimal digits makes 12^16 (184884258895036416) |
| combinations */ |
| retstring[BOUNDARY_LENGTH]=0; /* zero terminate */ |
| |
| return retstring; |
| } |
| |
| #endif /* !defined(CURL_DISABLE_HTTP) || defined(USE_SSLEAY) */ |
| |
| /* Pseudo-random number support. This is always enabled, since called from |
| curl_global_init(). */ |
| |
| unsigned int Curl_rand(void) |
| { |
| unsigned int r; |
| /* Return an unsigned 32-bit pseudo-random number. */ |
| r = randseed = randseed * 1103515245 + 12345; |
| return (r << 16) | ((r >> 16) & 0xFFFF); |
| } |
| |
| void Curl_srand(void) |
| { |
| /* Randomize pseudo-random number sequence. */ |
| |
| randseed = (unsigned int) time(NULL); |
| Curl_rand(); |
| Curl_rand(); |
| Curl_rand(); |
| } |