moparisthebest/curl
1
0
Fork 0
mirror of https://github.com/moparisthebest/curl synced 2024-12-22 08:08:50 -05:00
Code Issues Releases Wiki Activity

Georg Huettenegger's fixes and improvements to curl_formadd()

Browse Source
This commit is contained in:
Daniel Stenberg 2001-08-28 08:54:33 +00:00
parent 9835629801
commit 725bd1dddf
2 changed files with 375 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

512
lib/formdata.c
View File

@ -5,7 +5,7 @@
* | (__| |_| | _ <| |___ * | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____| * \___|\___/|_| \_\_____|
* *
* Copyright (C) 2000, Daniel Stenberg, <daniel@haxx.se>, et al. * Copyright (C) 2001, Daniel Stenberg, <daniel@haxx.se>, et al.
* *
* In order to be useful for every potential user, curl and libcurl are * In order to be useful for every potential user, curl and libcurl are
* dual-licensed under the MPL and the MIT/X-derivate licenses. * dual-licensed under the MPL and the MIT/X-derivate licenses.
@ -37,6 +37,10 @@ Content-Disposition: form-data; name="COPYCONTENTS_+_CONTENTTYPE"
Content-Type: image/gif Content-Type: image/gif
value for COPYCONTENTS + CONTENTTYPE 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" Content-Disposition: form-data; name="simple_PTRCONTENTS"
value for simple PTRCONTENTS value for simple PTRCONTENTS
@ -47,6 +51,7 @@ vlue for PTRCONTENTS + CONTENTSLENGTH
Content-Disposition: form-data; name="PTRCONTENTS_+_CONTENTSLENGTH_+_CONTENTTYPE" Content-Disposition: form-data; name="PTRCONTENTS_+_CONTENTSLENGTH_+_CONTENTTYPE"
Content-Type: text/plain Content-Type: text/plain
vlue for PTRCOTNENTS + CONTENTSLENGTH + CONTENTTYPE vlue for PTRCOTNENTS + CONTENTSLENGTH + CONTENTTYPE
(or you might see v^@lue at the start)
Content-Disposition: form-data; name="FILE1_+_CONTENTTYPE"; filename="inet_ntoa_r.h" Content-Disposition: form-data; name="FILE1_+_CONTENTTYPE"; filename="inet_ntoa_r.h"
Content-Type: text/html Content-Type: text/html
@ -54,11 +59,25 @@ Content-Type: text/html
Content-Disposition: form-data; name="FILE1_+_FILE2" Content-Disposition: form-data; name="FILE1_+_FILE2"
Content-Type: multipart/mixed, boundary=curlz1s0dkticx49MV1KGcYP5cvfSsz Content-Type: multipart/mixed, boundary=curlz1s0dkticx49MV1KGcYP5cvfSsz
...
Content-Disposition: attachment; filename="inet_ntoa_r.h" Content-Disposition: attachment; filename="inet_ntoa_r.h"
Content-Type: text/plain Content-Type: text/plain
... ...
Content-Disposition: attachment; filename="Makefile.b32.resp" Content-Disposition: attachment; filename="Makefile.b32.resp"
Content-Type: text/plain Content-Type: text/plain
...
Content-Disposition: form-data; name="FILE1_+_FILE2_+_FILE3"
Content-Type: multipart/mixed, boundary=curlirkYPmPwu6FrJ1vJ1u1BmtIufh1
...
Content-Disposition: attachment; filename="inet_ntoa_r.h"
Content-Type: text/plain
...
Content-Disposition: attachment; filename="Makefile.b32.resp"
Content-Type: text/plain
...
Content-Disposition: attachment; filename="inet_ntoa_r.h"
Content-Type: text/plain
... ...
For the old FormParse used by curl_formparse use: For the old FormParse used by curl_formparse use:
@ -357,12 +376,14 @@ int curl_formparse(char *input,
* Adds a HttpPost structure to the list, if parent_post is given becomes * Adds a HttpPost structure to the list, if parent_post is given becomes
* a subpost of parent_post instead of a direct list element. * a subpost of parent_post instead of a direct list element.
* *
* Returns 0 on success and 1 if malloc failed. * Returns newly allocated HttpPost on success and NULL if malloc failed.
* *
***************************************************************************/ ***************************************************************************/
static struct HttpPost * AddHttpPost (char * name, static struct HttpPost * AddHttpPost (char * name,
long namelength,
char * value, char * value,
long contentslength, long contentslength,
char *contenttype,
long flags, long flags,
struct HttpPost *parent_post, struct HttpPost *parent_post,
struct HttpPost **httppost, struct HttpPost **httppost,
@ -373,8 +394,10 @@ static struct HttpPost * AddHttpPost (char * name,
if(post) { if(post) {
memset(post, 0, sizeof(struct HttpPost)); memset(post, 0, sizeof(struct HttpPost));
post->name = name; post->name = name;
post->namelength = namelength;
post->contents = value; post->contents = value;
post->contentslength = contentslength; post->contentslength = contentslength;
post->contenttype = contenttype;
post->flags = flags; post->flags = flags;
} }
else else
@ -399,6 +422,125 @@ static struct HttpPost * AddHttpPost (char * name,
return 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 = (FormInfo *)malloc(sizeof(FormInfo));
if(form_info) {
memset(form_info, 0, sizeof(FormInfo));
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 (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 {
const char *extension;
const char *type;
};
static struct ContentType ctts[]={
{".gif", "image/gif"},
{".jpg", "image/jpeg"},
{".jpeg", "image/jpeg"},
{".txt", "text/plain"},
{".html", "text/plain"}
};
if(prevtype)
/* default to the previously set/used! */
contenttype = prevtype;
else
/* It seems RFC1867 defines no Content-Type to default to
text/plain so we don't actually need to set this: */
contenttype = HTTPPOST_CONTENTTYPE_DEFAULT;
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;
}
/***************************************************************************
*
* AllocAndCopy()
*
* Copies the data currently available under *buffer using newly allocated
* buffer (that becomes *buffer). Uses buffer_length if not null, else
* uses strlen to determine the length of the buffer to be copied
*
* Returns 0 on success and 1 if the malloc failed.
*
***************************************************************************/
static int AllocAndCopy (char **buffer, int buffer_length)
{
char *src = *buffer;
int length;
if (buffer_length)
length = buffer_length;
else
length = strlen(*buffer);
*buffer = (char*)malloc(length);
if (!*buffer)
return 1;
memcpy(*buffer, src, length);
return 0;
}
/*************************************************************************** /***************************************************************************
* *
* FormAdd() * FormAdd()
@ -435,8 +577,12 @@ static struct HttpPost * AddHttpPost (char * name,
* curl_formadd (&post, &last, CURLFORM_COPYNAME, "name", * curl_formadd (&post, &last, CURLFORM_COPYNAME, "name",
* CURLFORM_FILE, "filename1", CURLFORM_FILE, "filename2", CURLFORM_END); * CURLFORM_FILE, "filename1", CURLFORM_FILE, "filename2", CURLFORM_END);
* *
* Returns 0 on success, 1 if the first option is not CURLFORM_COPYNAME, * Returns 0 on success, 1 if the FormInfo allocation fails, 2 if one
* 2 if AddHttpPost failes, and 3 if an unknown option is encountered * option is given twice for one Form, 3 if a null pointer was given for
* a char *, 4 if the allocation of a FormInfo struct failed, 5 if an
* unknown option was used, 6 if the some FormInfo is not complete (or
* has an error), 7 if a HttpPost struct cannot be allocated, and 8
* if some allocation for string copying failed.
* *
***************************************************************************/ ***************************************************************************/
@ -445,155 +591,192 @@ int FormAdd(struct HttpPost **httppost,
struct HttpPost **last_post, struct HttpPost **last_post,
va_list params) va_list params)
{ {
int go_on = TRUE; FormInfo *first_form_info, *current_form_info, *form_info;
int read_argument = TRUE; int return_value = 0;
unsigned int i;
char *name;
char *value;
const char *prevtype = NULL; const char *prevtype = NULL;
struct HttpPost *post = NULL; struct HttpPost *post = NULL;
CURLformoption next_option; CURLformoption next_option;
/* We always expect CURLFORM_COPYNAME first for the moment. */ first_form_info = (FormInfo *)malloc(sizeof(struct FormInfo));
next_option = va_arg(params, CURLformoption); if(first_form_info) {
if (next_option != CURLFORM_COPYNAME) memset(first_form_info, 0, sizeof(FormInfo));
current_form_info = first_form_info;
}
else
return 1; return 1;
name = va_arg(params, char *); /** TODO: first check whether char * is not NULL
do TODO: transfer.c
*/
while ( ((next_option = va_arg(params, CURLformoption)) != CURLFORM_END) &&
(return_value == 0) )
{ {
/* if not already read read next argument */
if (read_argument)
next_option = va_arg(params, CURLformoption);
else
read_argument = TRUE;
switch (next_option) switch (next_option)
{ {
case CURLFORM_COPYCONTENTS: case CURLFORM_PTRNAME:
{ /* simple name/value storage of duplicated data */ current_form_info->flags |= HTTPPOST_PTRNAME; /* fall through */
const char * contenttype = NULL; case CURLFORM_COPYNAME:
value = va_arg(params, char *); if (current_form_info->name)
next_option = va_arg(params, CURLformoption); return_value = 2;
if (next_option == CURLFORM_CONTENTTYPE) else {
contenttype = va_arg(params, char *); if (next_option == CURLFORM_PTRNAME)
current_form_info->name = va_arg(params, char *);
else {
char *name = va_arg(params, char *);
if (name)
current_form_info->name = name; /* store for the moment */
else else
read_argument = FALSE; return_value = 3;
if ((post = AddHttpPost(strdup(name), strdup(value), 0, 0, NULL, }
httppost, last_post)) == NULL) {
return 2;
} }
if (contenttype)
post->contenttype = strdup(contenttype);
/* at the moment no more options are allowd in this case */
go_on = FALSE;
break; break;
} case CURLFORM_NAMELENGTH:
if (current_form_info->namelength)
return_value = 2;
else
current_form_info->namelength = va_arg(params, long);
break;
case CURLFORM_PTRCONTENTS: case CURLFORM_PTRCONTENTS:
{ /* name/value storage with value stored as a pointer */ current_form_info->flags |= HTTPPOST_PTRCONTENTS; /* fall through */
const char * contenttype = NULL; case CURLFORM_COPYCONTENTS:
void * ptr_contents = va_arg(params, void *); if (current_form_info->value)
long contentslength; return_value = 2;
int got_contentslength = FALSE; else {
/* either use provided length or use strlen () to get it */ if (next_option == CURLFORM_PTRCONTENTS)
next_option = va_arg(params, CURLformoption); current_form_info->value = va_arg(params, char *);
while ( (next_option == CURLFORM_CONTENTSLENGTH) || else {
(next_option == CURLFORM_CONTENTTYPE) ) { char *value = va_arg(params, char *);
if (next_option == CURLFORM_CONTENTSLENGTH) { if (value)
contentslength = va_arg(params, long); current_form_info->value = value; /* store for the moment */
got_contentslength = TRUE; else
return_value = 3;
} }
else { /* CURLFORM_CONTENTTYPE */
contenttype = va_arg(params, char *);
} }
next_option = va_arg(params, CURLformoption);
};
/* we already read the next CURLformoption */
read_argument = FALSE;
if (!got_contentslength)
/* no length given, use strlen to find out */
contentslength = strlen (ptr_contents);
if ((post = AddHttpPost(strdup(name), ptr_contents, contentslength,
HTTPPOST_PTRCONTENTS, NULL, httppost,
last_post))
== NULL) {
return 2;
}
if (contenttype)
post->contenttype = strdup(contenttype);
/* at the moment no more options are allowd in this case */
go_on = FALSE;
break; break;
case CURLFORM_CONTENTSLENGTH:
if (current_form_info->contentslength)
return_value = 2;
else
current_form_info->contentslength = va_arg(params, long);
break;
case CURLFORM_FILE: {
char *filename = va_arg(params, char *);
if (current_form_info->value) {
if (current_form_info->flags & HTTPPOST_FILENAME) {
if (filename) {
if (!(current_form_info = AddFormInfo (strdup(filename),
NULL, current_form_info)))
return_value = 4;
} }
case CURLFORM_FILE: else
{ return_value = 3;
const char * contenttype = NULL; }
value = va_arg(params, char *); else
next_option = va_arg(params, CURLformoption); return_value = 2;
/* if contenttype was provided retrieve it */
if (next_option == CURLFORM_CONTENTTYPE) {
contenttype = va_arg(params, char *);
} }
else { else {
/* if (filename)
* No type was specified, we scan through a few well-known current_form_info->value = strdup(filename);
* extensions and pick the first we match!
*/
struct ContentType {
const char *extension;
const char *type;
};
static struct ContentType ctts[]={
{".gif", "image/gif"},
{".jpg", "image/jpeg"},
{".jpeg", "image/jpeg"},
{".txt", "text/plain"},
{".html", "text/plain"}
};
if(prevtype)
/* default to the previously set/used! */
contenttype = prevtype;
else else
/* It seems RFC1867 defines no Content-Type to default to return_value = 3;
text/plain so we don't actually need to set this: */ current_form_info->flags |= HTTPPOST_FILENAME;
contenttype = HTTPPOST_CONTENTTYPE_DEFAULT; }
for(i=0; i<sizeof(ctts)/sizeof(ctts[0]); i++) {
if(strlen(value) >= strlen(ctts[i].extension)) {
if(strequal(value +
strlen(value) - strlen(ctts[i].extension),
ctts[i].extension)) {
contenttype = ctts[i].type;
break; break;
} }
case CURLFORM_CONTENTTYPE: {
char *contenttype = va_arg(params, char *);
if (current_form_info->contenttype) {
if (current_form_info->flags & HTTPPOST_FILENAME) {
if (contenttype) {
if (!(current_form_info = AddFormInfo (NULL,
strdup(contenttype),
current_form_info)))
return_value = 4;
} }
else
return_value = 3;
} }
/* we have a contenttype by now */ else
/* do not try to read the next option we already did that */ return_value = 2;
read_argument = FALSE;
} }
if ( (post = AddHttpPost (strdup(name), strdup(value), 0, else {
HTTPPOST_FILENAME, post, httppost, if (contenttype)
last_post)) == NULL) { current_form_info->contenttype = strdup(contenttype);
return 2; else
return_value = 3;
} }
post->contenttype = strdup (contenttype);
prevtype = post->contenttype;
/* we do not set go_on to false as multiple files are allowed */
break; break;
} }
case CURLFORM_END:
/* this ends our loop */
break;
default: default:
fprintf (stderr, "got: %d\n", next_option); fprintf (stderr, "got unknown CURLFORM_OPTION: %d\n", next_option);
return 3; return_value = 5;
};
}; };
} while (go_on && next_option != CURLFORM_END); /* go through the list, check for copleteness and if everything is
* alright add the HttpPost item otherwise set return_value accordingly */
form_info = first_form_info;
while (form_info != NULL)
{
if ( (!first_form_info->name) ||
(!form_info->value) ||
( (!form_info->namelength) &&
(form_info->flags & HTTPPOST_PTRNAME) ) ||
( (form_info->contentslength) &&
(form_info->flags & HTTPPOST_FILENAME) ) ||
( (form_info->flags & HTTPPOST_FILENAME) &&
(form_info->flags & HTTPPOST_PTRCONTENTS) )
) {
return_value = 6;
break;
}
else {
if ( (form_info->flags & HTTPPOST_FILENAME) &&
(!form_info->contenttype) ) {
/* our contenttype is missing */
form_info->contenttype
= strdup(ContentTypeForFilename(form_info->value, prevtype));
}
if ( !(form_info->flags & HTTPPOST_PTRNAME) &&
(form_info == first_form_info) ) {
/* copy name (without strdup; possibly contains null characters) */
if (AllocAndCopy(&form_info->name, form_info->namelength)) {
return_value = 8;
break;
}
}
if ( !(form_info->flags & HTTPPOST_FILENAME) &&
!(form_info->flags & HTTPPOST_PTRCONTENTS) ) {
/* copy value (without strdup; possibly contains null characters) */
if (AllocAndCopy(&form_info->value, form_info->contentslength)) {
return_value = 8;
break;
}
}
if ( (post = AddHttpPost (form_info->name, form_info->namelength,
form_info->value, form_info->contentslength,
form_info->contenttype, form_info->flags,
post, httppost,
last_post)) == NULL) {
return_value = 7;
}
if (form_info->contenttype)
prevtype = form_info->contenttype;
}
form_info = form_info->more;
};
return 0; /* and finally delete the allocated memory */
form_info = first_form_info;
while (form_info != NULL) {
FormInfo *delete_form_info;
delete_form_info = form_info;
form_info = form_info->more;
free (delete_form_info);
};
return return_value;
} }
int curl_formadd(struct HttpPost **httppost, int curl_formadd(struct HttpPost **httppost,
@ -705,7 +888,7 @@ void curl_formfree(struct HttpPost *form)
if(form->more) if(form->more)
curl_formfree(form->more); curl_formfree(form->more);
if(form->name) if( !(form->flags & HTTPPOST_PTRNAME) && form->name)
free(form->name); /* free the name */ free(form->name); /* free the name */
if( !(form->flags & HTTPPOST_PTRCONTENTS) && form->contents) if( !(form->flags & HTTPPOST_PTRCONTENTS) && form->contents)
free(form->contents); /* free the contents */ free(form->contents); /* free the contents */
@ -747,9 +930,12 @@ struct FormData *Curl_getFormData(struct HttpPost *post,
/* boundary */ /* boundary */
size += AddFormDataf(&form, "\r\n--%s\r\n", boundary); size += AddFormDataf(&form, "\r\n--%s\r\n", boundary);
size += AddFormDataf(&form, size += AddFormData(&form,
"Content-Disposition: form-data; name=\"%s\"", "Content-Disposition: form-data; name=\"", 0);
post->name);
size += AddFormData(&form, post->name, post->namelength);
size += AddFormData(&form, "\"", 0);
if(post->more) { if(post->more) {
/* If used, this is a link to more file names, we must then do /* If used, this is a link to more file names, we must then do
@ -963,8 +1149,6 @@ int FormAddTest(const char * errormsg,
{ {
int result; int result;
va_list arg; va_list arg;
CURLformoption next_option;
char * value;
va_start(arg, last_post); va_start(arg, last_post);
if ((result = FormAdd(httppost, last_post, arg))) if ((result = FormAdd(httppost, last_post, arg)))
fprintf (stderr, "ERROR doing FormAdd ret: %d action: %s\n", result, fprintf (stderr, "ERROR doing FormAdd ret: %d action: %s\n", result,
@ -978,30 +1162,34 @@ int main()
{ {
char name1[] = "simple_COPYCONTENTS"; char name1[] = "simple_COPYCONTENTS";
char name2[] = "COPYCONTENTS_+_CONTENTTYPE"; char name2[] = "COPYCONTENTS_+_CONTENTTYPE";
char name3[] = "simple_PTRCONTENTS"; char name3[] = "PTRNAME_+_NAMELENGTH_+_COPYNAME_+_CONTENTSLENGTH";
char name4[] = "PTRCONTENTS_+_CONTENTSLENGTH"; char name4[] = "simple_PTRCONTENTS";
char name5[] = "PTRCONTENTS_+_CONTENTSLENGTH_+_CONTENTTYPE"; char name5[] = "PTRCONTENTS_+_CONTENTSLENGTH";
char name6[] = "FILE1_+_CONTENTTYPE"; char name6[] = "PTRCONTENTS_+_CONTENTSLENGTH_+_CONTENTTYPE";
char name7[] = "FILE1_+_FILE2"; char name7[] = "FILE1_+_CONTENTTYPE";
char name8[] = "FILE1_+_FILE2";
char name9[] = "FILE1_+_FILE2_+_FILE3";
char value1[] = "value for simple COPYCONTENTS"; char value1[] = "value for simple COPYCONTENTS";
char value2[] = "value for COPYCONTENTS + CONTENTTYPE"; char value2[] = "value for COPYCONTENTS + CONTENTTYPE";
char value3[] = "value for simple PTRCONTENTS"; char value3[] = "value for PTRNAME + NAMELENGTH + COPYNAME + CONTENTSLENGTH";
char value4[] = "value for PTRCONTENTS + CONTENTSLENGTH"; char value4[] = "value for simple PTRCONTENTS";
char value5[] = "value for PTRCOTNENTS + CONTENTSLENGTH + CONTENTTYPE"; char value5[] = "value for PTRCONTENTS + CONTENTSLENGTH";
char value6[] = "inet_ntoa_r.h"; char value6[] = "value for PTRCOTNENTS + CONTENTSLENGTH + CONTENTTYPE";
char value7[] = "Makefile.b32.resp"; char value7[] = "inet_ntoa_r.h";
char value8[] = "Makefile.b32.resp";
char type2[] = "image/gif"; char type2[] = "image/gif";
char type5[] = "text/plain"; char type6[] = "text/plain";
char type6[] = "text/html"; char type7[] = "text/html";
int value4length = strlen(value4); int name3length = strlen(name3);
int value5length = strlen(value5); int value3length = strlen(value3);
int value5length = strlen(value4);
int value6length = strlen(value5);
int errors = 0; int errors = 0;
int size; int size;
int nread; int nread;
char buffer[4096]; char buffer[4096];
struct HttpPost *httppost=NULL; struct HttpPost *httppost=NULL;
struct HttpPost *last_post=NULL; struct HttpPost *last_post=NULL;
struct HttpPost *post;
struct FormData *form; struct FormData *form;
struct Form formread; struct Form formread;
@ -1014,33 +1202,47 @@ int main()
CURLFORM_COPYNAME, name2, CURLFORM_COPYCONTENTS, value2, CURLFORM_COPYNAME, name2, CURLFORM_COPYCONTENTS, value2,
CURLFORM_CONTENTTYPE, type2, CURLFORM_END)) CURLFORM_CONTENTTYPE, type2, CURLFORM_END))
++errors; ++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, if (FormAddTest("simple PTRCONTENTS test", &httppost, &last_post,
CURLFORM_COPYNAME, name3, CURLFORM_PTRCONTENTS, value3, CURLFORM_COPYNAME, name4, CURLFORM_PTRCONTENTS, value4,
CURLFORM_END)) CURLFORM_END))
++errors; ++errors;
/* make null character at start to check that contentslength works /* make null character at start to check that contentslength works
correctly */ correctly */
value4[1] = '\0'; value5[1] = '\0';
if (FormAddTest("PTRCONTENTS + CONTENTSLENGTH test", &httppost, &last_post, if (FormAddTest("PTRCONTENTS + CONTENTSLENGTH test", &httppost, &last_post,
CURLFORM_COPYNAME, name4, CURLFORM_PTRCONTENTS, value4, CURLFORM_COPYNAME, name5, CURLFORM_PTRCONTENTS, value5,
CURLFORM_CONTENTSLENGTH, value4length, CURLFORM_END)) CURLFORM_CONTENTSLENGTH, value5length, CURLFORM_END))
++errors; ++errors;
/* make null character at start to check that contentslength works /* make null character at start to check that contentslength works
correctly */ correctly */
value5[1] = '\0'; value6[1] = '\0';
if (FormAddTest("PTRCONTENTS + CONTENTSLENGTH + CONTENTTYPE test", if (FormAddTest("PTRCONTENTS + CONTENTSLENGTH + CONTENTTYPE test",
&httppost, &last_post, &httppost, &last_post,
CURLFORM_COPYNAME, name5, CURLFORM_PTRCONTENTS, value5, CURLFORM_COPYNAME, name6, CURLFORM_PTRCONTENTS, value6,
CURLFORM_CONTENTSLENGTH, value5length, CURLFORM_CONTENTSLENGTH, value6length,
CURLFORM_CONTENTTYPE, type5, CURLFORM_END))
++errors;
if (FormAddTest("FILE + CONTENTTYPE test", &httppost, &last_post,
CURLFORM_COPYNAME, name6, CURLFORM_FILE, value6,
CURLFORM_CONTENTTYPE, type6, CURLFORM_END)) CURLFORM_CONTENTTYPE, type6, CURLFORM_END))
++errors; ++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, if (FormAddTest("FILE1 + FILE2 test", &httppost, &last_post,
CURLFORM_COPYNAME, name7, CURLFORM_FILE, value6, CURLFORM_COPYNAME, name8, CURLFORM_FILE, value7,
CURLFORM_FILE, value7, CURLFORM_END)) 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; ++errors;
form=Curl_getFormData(httppost, &size); form=Curl_getFormData(httppost, &size);

11
lib/formdata.h
View File

@ -36,6 +36,17 @@ struct Form {
been sent in a previous invoke */ been sent in a previous invoke */
}; };
/* used by FormAdd for temporary storage */
typedef struct FormInfo {
char *name;
long namelength;
char *value;
long contentslength;
char *contenttype;
long flags;
struct FormInfo *more;
} FormInfo;
int Curl_FormInit(struct Form *form, struct FormData *formdata ); int Curl_FormInit(struct Form *form, struct FormData *formdata );
struct FormData *Curl_getFormData(struct HttpPost *post, struct FormData *Curl_getFormData(struct HttpPost *post,