1999-12-29 09:20:26 -05:00
|
|
|
/*****************************************************************************
|
|
|
|
* _ _ ____ _
|
|
|
|
* Project ___| | | | _ \| |
|
|
|
|
* / __| | | | |_) | |
|
|
|
|
* | (__| |_| | _ <| |___
|
|
|
|
* \___|\___/|_| \_\_____|
|
|
|
|
*
|
2001-08-28 04:54:33 -04:00
|
|
|
* Copyright (C) 2001, Daniel Stenberg, <daniel@haxx.se>, et al.
|
1999-12-29 09:20:26 -05:00
|
|
|
*
|
2001-01-03 04:29:33 -05:00
|
|
|
* In order to be useful for every potential user, curl and libcurl are
|
|
|
|
* dual-licensed under the MPL and the MIT/X-derivate licenses.
|
1999-12-29 09:20:26 -05:00
|
|
|
*
|
2001-01-03 04:29:33 -05:00
|
|
|
* 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 MPL or the MIT/X-derivate
|
|
|
|
* licenses. You may pick one of these licenses.
|
1999-12-29 09:20:26 -05:00
|
|
|
*
|
2001-01-03 04:29:33 -05:00
|
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
|
|
* KIND, either express or implied.
|
1999-12-29 09:20:26 -05:00
|
|
|
*
|
2001-01-03 04:29:33 -05:00
|
|
|
* $Id$
|
|
|
|
*****************************************************************************/
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
/*
|
|
|
|
Debug the form generator stand-alone by compiling this source file with:
|
|
|
|
|
2001-08-21 09:18:07 -04:00
|
|
|
gcc -DHAVE_CONFIG_H -I../ -g -D_FORM_DEBUG -o formdata -I../include formdata.c strequal.c
|
|
|
|
|
|
|
|
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
|
|
|
|
|
2001-08-28 04:54:33 -04:00
|
|
|
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)
|
|
|
|
|
2001-08-21 09:18:07 -04:00
|
|
|
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: text/plain
|
|
|
|
vlue for PTRCOTNENTS + CONTENTSLENGTH + CONTENTTYPE
|
2001-08-28 04:54:33 -04:00
|
|
|
(or you might see v^@lue at the start)
|
2001-08-21 09:18:07 -04:00
|
|
|
|
|
|
|
Content-Disposition: form-data; name="FILE1_+_CONTENTTYPE"; filename="inet_ntoa_r.h"
|
|
|
|
Content-Type: text/html
|
|
|
|
...
|
|
|
|
|
|
|
|
Content-Disposition: form-data; name="FILE1_+_FILE2"
|
|
|
|
Content-Type: multipart/mixed, boundary=curlz1s0dkticx49MV1KGcYP5cvfSsz
|
2001-08-28 04:54:33 -04:00
|
|
|
...
|
2001-08-21 09:18:07 -04:00
|
|
|
Content-Disposition: attachment; filename="inet_ntoa_r.h"
|
|
|
|
Content-Type: text/plain
|
|
|
|
...
|
|
|
|
Content-Disposition: attachment; filename="Makefile.b32.resp"
|
|
|
|
Content-Type: text/plain
|
2001-08-28 04:54:33 -04:00
|
|
|
...
|
|
|
|
|
|
|
|
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
|
2001-08-21 09:18:07 -04:00
|
|
|
...
|
|
|
|
|
|
|
|
For the old FormParse used by curl_formparse use:
|
|
|
|
|
|
|
|
gcc -DHAVE_CONFIG_H -I../ -g -D_OLD_FORM_DEBUG -o formdata -I../include formdata.c strequal.c
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
run the 'formdata' executable and make sure the output is ok!
|
|
|
|
|
|
|
|
try './formdata "name=Daniel" "poo=noo" "foo=bar"' and similarly
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
2000-08-24 10:26:33 -04:00
|
|
|
#include "setup.h"
|
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdarg.h>
|
|
|
|
|
|
|
|
#include <time.h>
|
|
|
|
|
|
|
|
#include <curl/curl.h>
|
|
|
|
#include "formdata.h"
|
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
#include "strequal.h"
|
|
|
|
|
2000-10-09 07:12:34 -04:00
|
|
|
/* The last #include file should be: */
|
|
|
|
#ifdef MALLOCDEBUG
|
|
|
|
#include "memdebug.h"
|
|
|
|
#endif
|
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
/* Length of the random boundary string. The risk of this being used
|
|
|
|
in binary data is very close to zero, 64^32 makes
|
|
|
|
6277101735386680763835789423207666416102355444464034512896
|
|
|
|
combinations... */
|
|
|
|
#define BOUNDARY_LENGTH 32
|
|
|
|
|
|
|
|
/* What kind of Content-Type to use on un-specified files with unrecognized
|
|
|
|
extensions. */
|
|
|
|
#define HTTPPOST_CONTENTTYPE_DEFAULT "text/plain"
|
|
|
|
|
|
|
|
/* This is a silly duplicate of the function in main.c to enable this source
|
|
|
|
to compile stand-alone for better debugging */
|
|
|
|
static void GetStr(char **string,
|
2001-08-21 09:18:07 -04:00
|
|
|
const char *value)
|
1999-12-29 09:20:26 -05:00
|
|
|
{
|
|
|
|
if(*string)
|
|
|
|
free(*string);
|
|
|
|
*string = strdup(value);
|
|
|
|
}
|
|
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
*
|
|
|
|
* FormParse()
|
|
|
|
*
|
|
|
|
* Reads a 'name=value' paramter and builds the appropriate linked list.
|
|
|
|
*
|
|
|
|
* Specify files to upload with 'name=@filename'. Supports specified
|
|
|
|
* given Content-Type of the files. Such as ';type=<content-type>'.
|
|
|
|
*
|
|
|
|
* You may specify more than one file for a single name (field). Specify
|
|
|
|
* multiple files by writing it like:
|
|
|
|
*
|
|
|
|
* 'name=@filename,filename2,filename3'
|
|
|
|
*
|
|
|
|
* If you want content-types specified for each too, write them like:
|
|
|
|
*
|
|
|
|
* 'name=@filename;type=image/gif,filename2,filename3'
|
|
|
|
*
|
|
|
|
***************************************************************************/
|
|
|
|
|
|
|
|
#define FORM_FILE_SEPARATOR ','
|
|
|
|
#define FORM_TYPE_SEPARATOR ';'
|
|
|
|
|
2001-01-05 05:11:41 -05:00
|
|
|
static
|
1999-12-29 09:20:26 -05:00
|
|
|
int FormParse(char *input,
|
|
|
|
struct HttpPost **httppost,
|
|
|
|
struct HttpPost **last_post)
|
|
|
|
{
|
|
|
|
/* nextarg MUST be a string in the format 'name=contents' and we'll
|
|
|
|
build a linked list with the info */
|
|
|
|
char name[256];
|
2001-08-13 02:33:26 -04:00
|
|
|
char *contents;
|
1999-12-29 09:20:26 -05:00
|
|
|
char major[128];
|
|
|
|
char minor[128];
|
|
|
|
long flags = 0;
|
|
|
|
char *contp;
|
2001-08-14 04:23:20 -04:00
|
|
|
const char *type = NULL;
|
1999-12-29 09:20:26 -05:00
|
|
|
char *prevtype = NULL;
|
|
|
|
char *sep;
|
|
|
|
char *sep2;
|
|
|
|
struct HttpPost *post;
|
|
|
|
struct HttpPost *subpost; /* a sub-node */
|
|
|
|
unsigned int i;
|
|
|
|
|
2001-08-13 02:33:26 -04:00
|
|
|
/* Preallocate contents to the length of input to make sure we don't
|
|
|
|
overwrite anything. */
|
|
|
|
contents = malloc(strlen(input));
|
|
|
|
contents[0] = '\000';
|
|
|
|
|
|
|
|
if(1 <= sscanf(input, "%255[^=]=%[^\n]", name, contents)) {
|
1999-12-29 09:20:26 -05:00
|
|
|
/* the input was using the correct format */
|
|
|
|
contp = contents;
|
|
|
|
|
|
|
|
if('@' == contp[0]) {
|
|
|
|
/* we use the @-letter to indicate file name(s) */
|
|
|
|
|
|
|
|
flags = HTTPPOST_FILENAME;
|
|
|
|
contp++;
|
|
|
|
|
|
|
|
post=NULL;
|
|
|
|
|
|
|
|
do {
|
|
|
|
/* since this was a file, it may have a content-type specifier
|
|
|
|
at the end too */
|
|
|
|
|
|
|
|
sep=strchr(contp, FORM_TYPE_SEPARATOR);
|
|
|
|
sep2=strchr(contp, FORM_FILE_SEPARATOR);
|
|
|
|
|
|
|
|
/* pick the closest */
|
|
|
|
if(sep2 && (sep2 < sep)) {
|
|
|
|
sep = sep2;
|
|
|
|
|
|
|
|
/* no type was specified! */
|
|
|
|
}
|
|
|
|
if(sep) {
|
|
|
|
|
|
|
|
/* if we got here on a comma, don't do much */
|
|
|
|
if(FORM_FILE_SEPARATOR != *sep)
|
|
|
|
type = strstr(sep+1, "type=");
|
|
|
|
else
|
|
|
|
type=NULL;
|
|
|
|
|
|
|
|
*sep=0; /* terminate file name at separator */
|
|
|
|
|
|
|
|
if(type) {
|
|
|
|
type += strlen("type=");
|
|
|
|
|
|
|
|
if(2 != sscanf(type, "%127[^/]/%127[^,\n]",
|
|
|
|
major, minor)) {
|
|
|
|
fprintf(stderr, "Illegally formatted content-type field!\n");
|
2001-08-13 02:33:26 -04:00
|
|
|
free(contents);
|
1999-12-29 09:20:26 -05:00
|
|
|
return 2; /* illegal content-type syntax! */
|
|
|
|
}
|
|
|
|
/* now point beyond the content-type specifier */
|
2001-08-14 04:23:20 -04:00
|
|
|
sep = (char *)type + strlen(major)+strlen(minor)+1;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
/* find the following comma */
|
|
|
|
sep=strchr(sep, FORM_FILE_SEPARATOR);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
type=NULL;
|
|
|
|
sep=strchr(contp, FORM_FILE_SEPARATOR);
|
|
|
|
}
|
|
|
|
if(sep) {
|
|
|
|
/* the next file name starts here */
|
|
|
|
*sep =0;
|
|
|
|
sep++;
|
|
|
|
}
|
|
|
|
if(!type) {
|
|
|
|
/*
|
|
|
|
* No type was specified, we scan through a few well-known
|
|
|
|
* extensions and pick the first we match!
|
|
|
|
*/
|
|
|
|
struct ContentType {
|
2001-08-14 04:23:20 -04:00
|
|
|
const char *extension;
|
|
|
|
const char *type;
|
1999-12-29 09:20:26 -05:00
|
|
|
};
|
2001-08-14 04:23:20 -04:00
|
|
|
static struct ContentType ctts[]={
|
1999-12-29 09:20:26 -05:00
|
|
|
{".gif", "image/gif"},
|
|
|
|
{".jpg", "image/jpeg"},
|
|
|
|
{".jpeg", "image/jpeg"},
|
|
|
|
{".txt", "text/plain"},
|
|
|
|
{".html", "text/plain"}
|
|
|
|
};
|
|
|
|
|
|
|
|
if(prevtype)
|
|
|
|
/* default to the previously set/used! */
|
|
|
|
type = prevtype;
|
|
|
|
else
|
|
|
|
/* It seems RFC1867 defines no Content-Type to default to
|
|
|
|
text/plain so we don't actually need to set this: */
|
|
|
|
type = HTTPPOST_CONTENTTYPE_DEFAULT;
|
|
|
|
|
|
|
|
for(i=0; i<sizeof(ctts)/sizeof(ctts[0]); i++) {
|
|
|
|
if(strlen(contp) >= strlen(ctts[i].extension)) {
|
|
|
|
if(strequal(contp +
|
|
|
|
strlen(contp) - strlen(ctts[i].extension),
|
|
|
|
ctts[i].extension)) {
|
|
|
|
type = ctts[i].type;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* we have a type by now */
|
|
|
|
}
|
|
|
|
|
|
|
|
if(NULL == post) {
|
|
|
|
/* For the first file name, we allocate and initiate the main list
|
|
|
|
node */
|
|
|
|
|
|
|
|
post = (struct HttpPost *)malloc(sizeof(struct HttpPost));
|
|
|
|
if(post) {
|
|
|
|
memset(post, 0, sizeof(struct HttpPost));
|
|
|
|
GetStr(&post->name, name); /* get the name */
|
|
|
|
GetStr(&post->contents, contp); /* get the contents */
|
2001-08-21 09:18:07 -04:00
|
|
|
post->contentslength = 0;
|
1999-12-29 09:20:26 -05:00
|
|
|
post->flags = flags;
|
|
|
|
if(type) {
|
2001-08-14 04:23:20 -04:00
|
|
|
GetStr(&post->contenttype, (char *)type); /* get type */
|
1999-12-29 09:20:26 -05:00
|
|
|
prevtype=post->contenttype; /* point to the allocated string! */
|
|
|
|
}
|
|
|
|
/* make the previous point to this */
|
|
|
|
if(*last_post)
|
|
|
|
(*last_post)->next = post;
|
|
|
|
else
|
|
|
|
(*httppost) = post;
|
|
|
|
|
|
|
|
(*last_post) = post;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* we add a file name to the previously allocated node, known as
|
|
|
|
'post' now */
|
|
|
|
subpost =(struct HttpPost *)malloc(sizeof(struct HttpPost));
|
|
|
|
if(subpost) {
|
|
|
|
memset(subpost, 0, sizeof(struct HttpPost));
|
|
|
|
GetStr(&subpost->name, name); /* get the name */
|
|
|
|
GetStr(&subpost->contents, contp); /* get the contents */
|
2001-08-21 09:18:07 -04:00
|
|
|
subpost->contentslength = 0;
|
1999-12-29 09:20:26 -05:00
|
|
|
subpost->flags = flags;
|
|
|
|
if(type) {
|
2001-08-14 04:23:20 -04:00
|
|
|
GetStr(&subpost->contenttype, (char *)type); /* get type */
|
|
|
|
prevtype=subpost->contenttype; /* point to allocated string! */
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
/* now, point our 'more' to the original 'more' */
|
|
|
|
subpost->more = post->more;
|
|
|
|
|
|
|
|
/* then move the original 'more' to point to ourselves */
|
|
|
|
post->more = subpost;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
contp = sep; /* move the contents pointer to after the separator */
|
|
|
|
} while(sep && *sep); /* loop if there's another file name */
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
post = (struct HttpPost *)malloc(sizeof(struct HttpPost));
|
|
|
|
if(post) {
|
|
|
|
memset(post, 0, sizeof(struct HttpPost));
|
|
|
|
GetStr(&post->name, name); /* get the name */
|
2000-07-25 08:21:22 -04:00
|
|
|
if( contp[0]=='<' ) {
|
|
|
|
GetStr(&post->contents, contp+1); /* get the contents */
|
2001-08-21 09:18:07 -04:00
|
|
|
post->contentslength = 0;
|
2000-07-25 08:21:22 -04:00
|
|
|
post->flags = HTTPPOST_READFILE;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
GetStr(&post->contents, contp); /* get the contents */
|
2001-08-21 09:18:07 -04:00
|
|
|
post->contentslength = 0;
|
2000-07-25 08:21:22 -04:00
|
|
|
post->flags = 0;
|
|
|
|
}
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
/* make the previous point to this */
|
|
|
|
if(*last_post)
|
|
|
|
(*last_post)->next = post;
|
|
|
|
else
|
|
|
|
(*httppost) = post;
|
|
|
|
|
|
|
|
(*last_post) = post;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
fprintf(stderr, "Illegally formatted input field!\n");
|
2001-08-13 02:33:26 -04:00
|
|
|
free(contents);
|
1999-12-29 09:20:26 -05:00
|
|
|
return 1;
|
|
|
|
}
|
2001-08-13 02:33:26 -04:00
|
|
|
free(contents);
|
1999-12-29 09:20:26 -05:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2001-01-05 05:11:41 -05:00
|
|
|
int curl_formparse(char *input,
|
|
|
|
struct HttpPost **httppost,
|
|
|
|
struct HttpPost **last_post)
|
|
|
|
{
|
|
|
|
return FormParse(input, httppost, last_post);
|
|
|
|
}
|
|
|
|
|
2001-08-21 09:18:07 -04:00
|
|
|
/***************************************************************************
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
2001-08-28 04:54:33 -04:00
|
|
|
* Returns newly allocated HttpPost on success and NULL if malloc failed.
|
2001-08-21 09:18:07 -04:00
|
|
|
*
|
|
|
|
***************************************************************************/
|
|
|
|
static struct HttpPost * AddHttpPost (char * name,
|
2001-08-28 04:54:33 -04:00
|
|
|
long namelength,
|
2001-08-21 09:18:07 -04:00
|
|
|
char * value,
|
|
|
|
long contentslength,
|
2001-08-28 04:54:33 -04:00
|
|
|
char *contenttype,
|
2001-08-21 09:18:07 -04:00
|
|
|
long flags,
|
|
|
|
struct HttpPost *parent_post,
|
|
|
|
struct HttpPost **httppost,
|
|
|
|
struct HttpPost **last_post)
|
|
|
|
{
|
|
|
|
struct HttpPost *post;
|
|
|
|
post = (struct HttpPost *)malloc(sizeof(struct HttpPost));
|
|
|
|
if(post) {
|
|
|
|
memset(post, 0, sizeof(struct HttpPost));
|
|
|
|
post->name = name;
|
2001-08-28 04:54:33 -04:00
|
|
|
post->namelength = namelength;
|
2001-08-21 09:18:07 -04:00
|
|
|
post->contents = value;
|
|
|
|
post->contentslength = contentslength;
|
2001-08-28 04:54:33 -04:00
|
|
|
post->contenttype = contenttype;
|
2001-08-21 09:18:07 -04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2001-08-28 04:54:33 -04:00
|
|
|
/***************************************************************************
|
|
|
|
*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2001-08-21 09:18:07 -04:00
|
|
|
/***************************************************************************
|
|
|
|
*
|
|
|
|
* FormAdd()
|
|
|
|
*
|
|
|
|
* Stores a 'name=value' 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");
|
|
|
|
*
|
|
|
|
* name/value pair where only the content pointer is remembered:
|
|
|
|
* curl_formadd (&post, &last, CURLFORM_COPYNAME, "name",
|
|
|
|
* CURLFORM_PTRCONTENTS, ptr, CURLFORM_CONTENTSLENGTH, 10);
|
|
|
|
* (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);
|
|
|
|
*
|
2001-08-28 04:54:33 -04:00
|
|
|
* Returns 0 on success, 1 if the FormInfo allocation fails, 2 if one
|
|
|
|
* 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.
|
2001-08-21 09:18:07 -04:00
|
|
|
*
|
|
|
|
***************************************************************************/
|
|
|
|
|
|
|
|
static
|
|
|
|
int FormAdd(struct HttpPost **httppost,
|
|
|
|
struct HttpPost **last_post,
|
|
|
|
va_list params)
|
|
|
|
{
|
2001-08-28 04:54:33 -04:00
|
|
|
FormInfo *first_form_info, *current_form_info, *form_info;
|
|
|
|
int return_value = 0;
|
2001-08-21 09:18:07 -04:00
|
|
|
const char *prevtype = NULL;
|
|
|
|
struct HttpPost *post = NULL;
|
|
|
|
CURLformoption next_option;
|
|
|
|
|
2001-08-28 04:54:33 -04:00
|
|
|
first_form_info = (FormInfo *)malloc(sizeof(struct FormInfo));
|
|
|
|
if(first_form_info) {
|
|
|
|
memset(first_form_info, 0, sizeof(FormInfo));
|
|
|
|
current_form_info = first_form_info;
|
|
|
|
}
|
|
|
|
else
|
2001-08-21 09:18:07 -04:00
|
|
|
return 1;
|
|
|
|
|
2001-08-28 04:54:33 -04:00
|
|
|
/** TODO: first check whether char * is not NULL
|
|
|
|
TODO: transfer.c
|
|
|
|
*/
|
|
|
|
while ( ((next_option = va_arg(params, CURLformoption)) != CURLFORM_END) &&
|
|
|
|
(return_value == 0) )
|
2001-08-21 09:18:07 -04:00
|
|
|
{
|
|
|
|
switch (next_option)
|
|
|
|
{
|
2001-08-28 04:54:33 -04:00
|
|
|
case CURLFORM_PTRNAME:
|
|
|
|
current_form_info->flags |= HTTPPOST_PTRNAME; /* fall through */
|
|
|
|
case CURLFORM_COPYNAME:
|
|
|
|
if (current_form_info->name)
|
|
|
|
return_value = 2;
|
|
|
|
else {
|
|
|
|
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
|
|
|
|
return_value = 3;
|
|
|
|
}
|
2001-08-21 09:18:07 -04:00
|
|
|
}
|
|
|
|
break;
|
2001-08-28 04:54:33 -04:00
|
|
|
case CURLFORM_NAMELENGTH:
|
|
|
|
if (current_form_info->namelength)
|
|
|
|
return_value = 2;
|
|
|
|
else
|
|
|
|
current_form_info->namelength = va_arg(params, long);
|
|
|
|
break;
|
2001-08-21 09:18:07 -04:00
|
|
|
case CURLFORM_PTRCONTENTS:
|
2001-08-28 04:54:33 -04:00
|
|
|
current_form_info->flags |= HTTPPOST_PTRCONTENTS; /* fall through */
|
|
|
|
case CURLFORM_COPYCONTENTS:
|
|
|
|
if (current_form_info->value)
|
|
|
|
return_value = 2;
|
|
|
|
else {
|
|
|
|
if (next_option == CURLFORM_PTRCONTENTS)
|
|
|
|
current_form_info->value = va_arg(params, char *);
|
|
|
|
else {
|
|
|
|
char *value = va_arg(params, char *);
|
|
|
|
if (value)
|
|
|
|
current_form_info->value = value; /* store for the moment */
|
|
|
|
else
|
|
|
|
return_value = 3;
|
|
|
|
}
|
2001-08-21 09:18:07 -04:00
|
|
|
}
|
|
|
|
break;
|
2001-08-28 04:54:33 -04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return_value = 3;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return_value = 2;
|
2001-08-21 09:18:07 -04:00
|
|
|
}
|
|
|
|
else {
|
2001-08-28 04:54:33 -04:00
|
|
|
if (filename)
|
|
|
|
current_form_info->value = strdup(filename);
|
2001-08-21 09:18:07 -04:00
|
|
|
else
|
2001-08-28 04:54:33 -04:00
|
|
|
return_value = 3;
|
|
|
|
current_form_info->flags |= HTTPPOST_FILENAME;
|
2001-08-21 09:18:07 -04:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2001-08-28 04:54:33 -04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return_value = 2;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (contenttype)
|
|
|
|
current_form_info->contenttype = strdup(contenttype);
|
|
|
|
else
|
|
|
|
return_value = 3;
|
|
|
|
}
|
2001-08-21 09:18:07 -04:00
|
|
|
break;
|
2001-08-28 04:54:33 -04:00
|
|
|
}
|
2001-08-21 09:18:07 -04:00
|
|
|
default:
|
2001-08-28 04:54:33 -04:00
|
|
|
fprintf (stderr, "got unknown CURLFORM_OPTION: %d\n", next_option);
|
|
|
|
return_value = 5;
|
2001-08-21 09:18:07 -04:00
|
|
|
};
|
2001-08-28 04:54:33 -04:00
|
|
|
};
|
2001-08-21 09:18:07 -04:00
|
|
|
|
2001-08-28 04:54:33 -04:00
|
|
|
/* 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;
|
|
|
|
};
|
2001-08-21 09:18:07 -04:00
|
|
|
|
2001-08-28 04:54:33 -04:00
|
|
|
/* 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;
|
2001-08-21 09:18:07 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
int curl_formadd(struct HttpPost **httppost,
|
|
|
|
struct HttpPost **last_post,
|
|
|
|
...)
|
|
|
|
{
|
|
|
|
va_list arg;
|
|
|
|
int result;
|
|
|
|
va_start(arg, last_post);
|
|
|
|
result = FormAdd(httppost, last_post, arg);
|
|
|
|
va_end(arg);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
static int AddFormData(struct FormData **formp,
|
2001-08-14 04:23:20 -04:00
|
|
|
const void *line,
|
|
|
|
long length)
|
1999-12-29 09:20:26 -05:00
|
|
|
{
|
|
|
|
struct FormData *newform = (struct FormData *)
|
|
|
|
malloc(sizeof(struct FormData));
|
|
|
|
newform->next = NULL;
|
|
|
|
|
|
|
|
/* we make it easier for plain strings: */
|
|
|
|
if(!length)
|
|
|
|
length = strlen((char *)line);
|
|
|
|
|
|
|
|
newform->line = (char *)malloc(length+1);
|
|
|
|
memcpy(newform->line, line, length+1);
|
|
|
|
newform->length = length;
|
2000-06-15 10:33:17 -04:00
|
|
|
newform->line[length]=0; /* zero terminate for easier debugging */
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
if(*formp) {
|
|
|
|
(*formp)->next = newform;
|
|
|
|
*formp = newform;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
*formp = newform;
|
|
|
|
|
|
|
|
return length;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int AddFormDataf(struct FormData **formp,
|
2001-08-14 04:23:20 -04:00
|
|
|
const char *fmt, ...)
|
1999-12-29 09:20:26 -05:00
|
|
|
{
|
2000-07-25 08:21:22 -04:00
|
|
|
char s[4096];
|
1999-12-29 09:20:26 -05:00
|
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
|
|
vsprintf(s, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
|
|
|
|
return AddFormData(formp, s, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-01-05 05:11:41 -05:00
|
|
|
char *Curl_FormBoundary(void)
|
1999-12-29 09:20:26 -05:00
|
|
|
{
|
|
|
|
char *retstring;
|
|
|
|
static int randomizer=0; /* this is just so that two boundaries within
|
|
|
|
the same form won't be identical */
|
|
|
|
int i;
|
|
|
|
|
|
|
|
static char table64[]=
|
|
|
|
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
|
|
|
|
|
|
retstring = (char *)malloc(BOUNDARY_LENGTH);
|
|
|
|
|
|
|
|
if(!retstring)
|
|
|
|
return NULL; /* failed */
|
|
|
|
|
|
|
|
srand(time(NULL)+randomizer++); /* seed */
|
|
|
|
|
|
|
|
strcpy(retstring, "curl"); /* bonus commercials 8*) */
|
|
|
|
|
|
|
|
for(i=4; i<(BOUNDARY_LENGTH-1); i++) {
|
|
|
|
retstring[i] = table64[rand()%64];
|
|
|
|
}
|
|
|
|
retstring[BOUNDARY_LENGTH-1]=0; /* zero terminate */
|
|
|
|
|
|
|
|
return retstring;
|
|
|
|
}
|
|
|
|
|
2001-08-06 08:36:18 -04:00
|
|
|
/* Used from http.c, this cleans a built FormData linked list */
|
|
|
|
void Curl_formclean(struct FormData *form)
|
1999-12-29 09:20:26 -05:00
|
|
|
{
|
|
|
|
struct FormData *next;
|
2001-04-06 01:52:23 -04:00
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
do {
|
|
|
|
next=form->next; /* the following form line */
|
|
|
|
free(form->line); /* free the line */
|
|
|
|
free(form); /* free the struct */
|
2000-11-17 09:06:24 -05:00
|
|
|
|
|
|
|
} while((form=next)); /* continue */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* external function to free up a whole form post chain */
|
|
|
|
void curl_formfree(struct HttpPost *form)
|
|
|
|
{
|
|
|
|
struct HttpPost *next;
|
2001-04-06 01:52:23 -04:00
|
|
|
|
|
|
|
if(!form)
|
|
|
|
/* no form to free, just get out of this */
|
|
|
|
return;
|
|
|
|
|
2000-11-17 09:06:24 -05:00
|
|
|
do {
|
|
|
|
next=form->next; /* the following form line */
|
|
|
|
|
|
|
|
/* recurse to sub-contents */
|
|
|
|
if(form->more)
|
|
|
|
curl_formfree(form->more);
|
|
|
|
|
2001-08-28 04:54:33 -04:00
|
|
|
if( !(form->flags & HTTPPOST_PTRNAME) && form->name)
|
2000-11-17 09:06:24 -05:00
|
|
|
free(form->name); /* free the name */
|
2001-08-21 09:18:07 -04:00
|
|
|
if( !(form->flags & HTTPPOST_PTRCONTENTS) && form->contents)
|
2000-11-17 09:06:24 -05:00
|
|
|
free(form->contents); /* free the contents */
|
|
|
|
if(form->contenttype)
|
|
|
|
free(form->contenttype); /* free the content type */
|
|
|
|
free(form); /* free the struct */
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
} while((form=next)); /* continue */
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
|
2001-01-05 05:11:41 -05:00
|
|
|
struct FormData *Curl_getFormData(struct HttpPost *post,
|
|
|
|
int *sizep)
|
1999-12-29 09:20:26 -05:00
|
|
|
{
|
|
|
|
struct FormData *form = NULL;
|
|
|
|
struct FormData *firstform;
|
|
|
|
|
|
|
|
struct HttpPost *file;
|
|
|
|
|
|
|
|
int size =0;
|
|
|
|
char *boundary;
|
|
|
|
char *fileboundary=NULL;
|
|
|
|
|
|
|
|
if(!post)
|
|
|
|
return NULL; /* no input => no output! */
|
|
|
|
|
2001-01-05 05:11:41 -05:00
|
|
|
boundary = Curl_FormBoundary();
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
/* Make the first line of the output */
|
|
|
|
AddFormDataf(&form,
|
|
|
|
"Content-Type: multipart/form-data;"
|
|
|
|
" boundary=%s\r\n",
|
|
|
|
boundary);
|
|
|
|
/* we DO NOT count that line since that'll be part of the header! */
|
|
|
|
|
|
|
|
firstform = form;
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
|
|
|
/* boundary */
|
|
|
|
size += AddFormDataf(&form, "\r\n--%s\r\n", boundary);
|
|
|
|
|
2001-08-28 04:54:33 -04:00
|
|
|
size += AddFormData(&form,
|
|
|
|
"Content-Disposition: form-data; name=\"", 0);
|
|
|
|
|
|
|
|
size += AddFormData(&form, post->name, post->namelength);
|
|
|
|
|
|
|
|
size += AddFormData(&form, "\"", 0);
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
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 */
|
|
|
|
|
2001-01-05 05:11:41 -05:00
|
|
|
fileboundary = Curl_FormBoundary();
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
size += AddFormDataf(&form,
|
|
|
|
"\r\nContent-Type: multipart/mixed,"
|
|
|
|
" boundary=%s\r\n",
|
|
|
|
fileboundary);
|
|
|
|
}
|
|
|
|
|
|
|
|
file = post;
|
|
|
|
|
|
|
|
do {
|
|
|
|
if(post->more) {
|
|
|
|
/* if multiple-file */
|
|
|
|
size += AddFormDataf(&form,
|
|
|
|
"\r\n--%s\r\nContent-Disposition: attachment; filename=\"%s\"",
|
|
|
|
fileboundary, file->contents);
|
|
|
|
}
|
|
|
|
else if(post->flags & HTTPPOST_FILENAME) {
|
|
|
|
size += AddFormDataf(&form,
|
|
|
|
"; filename=\"%s\"",
|
|
|
|
post->contents);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(file->contenttype) {
|
|
|
|
/* we have a specified type */
|
|
|
|
size += AddFormDataf(&form,
|
|
|
|
"\r\nContent-Type: %s",
|
|
|
|
file->contenttype);
|
|
|
|
}
|
2000-10-09 18:29:35 -04:00
|
|
|
|
|
|
|
#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.
|
|
|
|
*/
|
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
if(file->contenttype &&
|
|
|
|
!strnequal("text/", file->contenttype, 5)) {
|
|
|
|
/* this is not a text content, mention our binary encoding */
|
2000-07-25 08:21:22 -04:00
|
|
|
size += AddFormData(&form, "\r\nContent-Transfer-Encoding: binary", 0);
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2000-10-09 18:29:35 -04:00
|
|
|
#endif
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2000-07-25 08:21:22 -04:00
|
|
|
size += AddFormData(&form, "\r\n\r\n", 0);
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2000-07-25 08:21:22 -04:00
|
|
|
if((post->flags & HTTPPOST_FILENAME) ||
|
|
|
|
(post->flags & HTTPPOST_READFILE)) {
|
1999-12-29 09:20:26 -05:00
|
|
|
/* we should include the contents from the specified file */
|
|
|
|
FILE *fileread;
|
|
|
|
char buffer[1024];
|
|
|
|
int nread;
|
|
|
|
|
|
|
|
fileread = strequal("-", file->contents)?stdin:
|
|
|
|
/* binary read for win32 crap */
|
2001-08-06 08:36:18 -04:00
|
|
|
/*VMS??*/ fopen(file->contents, "rb"); /* ONLY ALLOWS FOR STREAM FILES ON VMS */
|
|
|
|
/*VMS?? Stream files are OK, as are FIXED & VAR files WITHOUT implied CC */
|
|
|
|
/*VMS?? For implied CC, every record needs to have a \n appended & 1 added to SIZE */
|
1999-12-29 09:20:26 -05:00
|
|
|
if(fileread) {
|
|
|
|
while((nread = fread(buffer, 1, 1024, fileread))) {
|
|
|
|
size += AddFormData(&form,
|
|
|
|
buffer,
|
|
|
|
nread);
|
|
|
|
}
|
|
|
|
if(fileread != stdin)
|
|
|
|
fclose(fileread);
|
2000-07-25 08:21:22 -04:00
|
|
|
} else {
|
|
|
|
size += AddFormData(&form, "[File wasn't found by client]", 0);
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2000-07-25 08:21:22 -04:00
|
|
|
} else {
|
1999-12-29 09:20:26 -05:00
|
|
|
/* include the contents we got */
|
2001-08-21 09:18:07 -04:00
|
|
|
size += AddFormData(&form, post->contents, post->contentslength);
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
} while((file = file->more)); /* for each specified file for this field */
|
|
|
|
|
|
|
|
if(post->more) {
|
|
|
|
/* this was a multiple-file inclusion, make a termination file
|
|
|
|
boundary: */
|
|
|
|
size += AddFormDataf(&form,
|
|
|
|
"\r\n--%s--",
|
|
|
|
fileboundary);
|
|
|
|
free(fileboundary);
|
|
|
|
}
|
|
|
|
|
|
|
|
} while((post=post->next)); /* for each field */
|
|
|
|
|
|
|
|
/* end-boundary for everything */
|
|
|
|
size += AddFormDataf(&form,
|
|
|
|
"\r\n--%s--\r\n",
|
|
|
|
boundary);
|
|
|
|
|
|
|
|
*sizep = size;
|
|
|
|
|
|
|
|
free(boundary);
|
|
|
|
|
|
|
|
return firstform;
|
|
|
|
}
|
|
|
|
|
2001-01-05 05:11:41 -05:00
|
|
|
int Curl_FormInit(struct Form *form, struct FormData *formdata )
|
1999-12-29 09:20:26 -05:00
|
|
|
{
|
|
|
|
if(!formdata)
|
|
|
|
return 1; /* error */
|
2000-06-15 10:33:17 -04:00
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
form->data = formdata;
|
|
|
|
form->sent = 0;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* fread() emulation */
|
2001-01-05 05:11:41 -05:00
|
|
|
int Curl_FormReader(char *buffer,
|
|
|
|
size_t size,
|
|
|
|
size_t nitems,
|
|
|
|
FILE *mydata)
|
2001-08-21 09:18:07 -04:00
|
|
|
{
|
|
|
|
struct Form *form;
|
|
|
|
int wantedsize;
|
|
|
|
int gotsize = 0;
|
|
|
|
|
|
|
|
form=(struct Form *)mydata;
|
|
|
|
|
|
|
|
wantedsize = size * nitems;
|
|
|
|
|
|
|
|
if(!form->data)
|
|
|
|
return -1; /* nothing, error, empty */
|
|
|
|
|
|
|
|
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);
|
|
|
|
/* 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.
|
|
|
|
This is the bug reported November 22 1999 on curl 6.3. (Daniel) */
|
|
|
|
|
|
|
|
return gotsize;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* possible (old) fread() emulation that copies at most one line */
|
|
|
|
int Curl_FormReadOneLine(char *buffer,
|
|
|
|
size_t size,
|
|
|
|
size_t nitems,
|
|
|
|
FILE *mydata)
|
1999-12-29 09:20:26 -05:00
|
|
|
{
|
|
|
|
struct Form *form;
|
|
|
|
int wantedsize;
|
|
|
|
int gotsize;
|
|
|
|
|
|
|
|
form=(struct Form *)mydata;
|
|
|
|
|
|
|
|
wantedsize = size * nitems;
|
|
|
|
|
|
|
|
if(!form->data)
|
2000-06-15 10:33:17 -04:00
|
|
|
return -1; /* nothing, error, empty */
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
do {
|
|
|
|
|
|
|
|
if( (form->data->length - form->sent ) > wantedsize ) {
|
|
|
|
|
|
|
|
memcpy(buffer, form->data->line + form->sent, wantedsize);
|
|
|
|
|
|
|
|
form->sent += wantedsize;
|
|
|
|
|
|
|
|
return wantedsize;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(buffer,
|
|
|
|
form->data->line + form->sent,
|
|
|
|
gotsize = (form->data->length - form->sent) );
|
|
|
|
|
|
|
|
form->sent = 0;
|
|
|
|
|
|
|
|
form->data = form->data->next; /* advance */
|
|
|
|
|
|
|
|
} while(!gotsize && form->data);
|
|
|
|
/* 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.
|
|
|
|
This is the bug reported November 22 1999 on curl 6.3. (Daniel) */
|
|
|
|
|
|
|
|
return gotsize;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef _FORM_DEBUG
|
2001-08-21 09:18:07 -04:00
|
|
|
int FormAddTest(const char * errormsg,
|
|
|
|
struct HttpPost **httppost,
|
|
|
|
struct 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()
|
|
|
|
{
|
|
|
|
char name1[] = "simple_COPYCONTENTS";
|
|
|
|
char name2[] = "COPYCONTENTS_+_CONTENTTYPE";
|
2001-08-28 04:54:33 -04:00
|
|
|
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";
|
2001-08-21 09:18:07 -04:00
|
|
|
char value1[] = "value for simple COPYCONTENTS";
|
|
|
|
char value2[] = "value for COPYCONTENTS + CONTENTTYPE";
|
2001-08-28 04:54:33 -04:00
|
|
|
char value3[] = "value for PTRNAME + NAMELENGTH + COPYNAME + CONTENTSLENGTH";
|
|
|
|
char value4[] = "value for simple PTRCONTENTS";
|
|
|
|
char value5[] = "value for PTRCONTENTS + CONTENTSLENGTH";
|
|
|
|
char value6[] = "value for PTRCOTNENTS + CONTENTSLENGTH + CONTENTTYPE";
|
|
|
|
char value7[] = "inet_ntoa_r.h";
|
|
|
|
char value8[] = "Makefile.b32.resp";
|
2001-08-21 09:18:07 -04:00
|
|
|
char type2[] = "image/gif";
|
2001-08-28 04:54:33 -04:00
|
|
|
char type6[] = "text/plain";
|
|
|
|
char type7[] = "text/html";
|
|
|
|
int name3length = strlen(name3);
|
|
|
|
int value3length = strlen(value3);
|
|
|
|
int value5length = strlen(value4);
|
|
|
|
int value6length = strlen(value5);
|
2001-08-21 09:18:07 -04:00
|
|
|
int errors = 0;
|
|
|
|
int size;
|
|
|
|
int nread;
|
|
|
|
char buffer[4096];
|
|
|
|
struct HttpPost *httppost=NULL;
|
|
|
|
struct HttpPost *last_post=NULL;
|
|
|
|
|
|
|
|
struct FormData *form;
|
|
|
|
struct Form formread;
|
|
|
|
|
|
|
|
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;
|
2001-08-28 04:54:33 -04:00
|
|
|
/* 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;
|
2001-08-21 09:18:07 -04:00
|
|
|
if (FormAddTest("simple PTRCONTENTS test", &httppost, &last_post,
|
2001-08-28 04:54:33 -04:00
|
|
|
CURLFORM_COPYNAME, name4, CURLFORM_PTRCONTENTS, value4,
|
2001-08-21 09:18:07 -04:00
|
|
|
CURLFORM_END))
|
|
|
|
++errors;
|
|
|
|
/* make null character at start to check that contentslength works
|
|
|
|
correctly */
|
2001-08-28 04:54:33 -04:00
|
|
|
value5[1] = '\0';
|
2001-08-21 09:18:07 -04:00
|
|
|
if (FormAddTest("PTRCONTENTS + CONTENTSLENGTH test", &httppost, &last_post,
|
2001-08-28 04:54:33 -04:00
|
|
|
CURLFORM_COPYNAME, name5, CURLFORM_PTRCONTENTS, value5,
|
|
|
|
CURLFORM_CONTENTSLENGTH, value5length, CURLFORM_END))
|
2001-08-21 09:18:07 -04:00
|
|
|
++errors;
|
|
|
|
/* make null character at start to check that contentslength works
|
|
|
|
correctly */
|
2001-08-28 04:54:33 -04:00
|
|
|
value6[1] = '\0';
|
2001-08-21 09:18:07 -04:00
|
|
|
if (FormAddTest("PTRCONTENTS + CONTENTSLENGTH + CONTENTTYPE test",
|
|
|
|
&httppost, &last_post,
|
2001-08-28 04:54:33 -04:00
|
|
|
CURLFORM_COPYNAME, name6, CURLFORM_PTRCONTENTS, value6,
|
|
|
|
CURLFORM_CONTENTSLENGTH, value6length,
|
|
|
|
CURLFORM_CONTENTTYPE, type6, CURLFORM_END))
|
2001-08-21 09:18:07 -04:00
|
|
|
++errors;
|
|
|
|
if (FormAddTest("FILE + CONTENTTYPE test", &httppost, &last_post,
|
2001-08-28 04:54:33 -04:00
|
|
|
CURLFORM_COPYNAME, name7, CURLFORM_FILE, value7,
|
|
|
|
CURLFORM_CONTENTTYPE, type7, CURLFORM_END))
|
2001-08-21 09:18:07 -04:00
|
|
|
++errors;
|
|
|
|
if (FormAddTest("FILE1 + FILE2 test", &httppost, &last_post,
|
2001-08-28 04:54:33 -04:00
|
|
|
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))
|
2001-08-21 09:18:07 -04:00
|
|
|
++errors;
|
|
|
|
|
|
|
|
form=Curl_getFormData(httppost, &size);
|
|
|
|
|
|
|
|
Curl_FormInit(&formread, form);
|
|
|
|
|
|
|
|
do {
|
|
|
|
nread = Curl_FormReader(buffer, 1, sizeof(buffer),
|
|
|
|
(FILE *)&formread);
|
|
|
|
|
|
|
|
if(-1 == nread)
|
|
|
|
break;
|
|
|
|
fwrite(buffer, nread, 1, stderr);
|
|
|
|
} while(1);
|
|
|
|
|
|
|
|
fprintf(stderr, "size: %d\n", size);
|
|
|
|
if (errors)
|
|
|
|
fprintf(stderr, "\n==> %d Test(s) failed!\n", errors);
|
|
|
|
else
|
|
|
|
fprintf(stdout, "\nAll Tests seem to have worked (please check output)\n");
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef _OLD_FORM_DEBUG
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
|
|
|
#if 0
|
|
|
|
char *testargs[]={
|
|
|
|
"name1 = data in number one",
|
|
|
|
"name2 = number two data",
|
|
|
|
"test = @upload"
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
int i;
|
|
|
|
char *nextarg;
|
|
|
|
struct HttpPost *httppost=NULL;
|
|
|
|
struct HttpPost *last_post=NULL;
|
|
|
|
struct HttpPost *post;
|
|
|
|
int size;
|
|
|
|
int nread;
|
|
|
|
char buffer[4096];
|
|
|
|
|
|
|
|
struct FormData *form;
|
|
|
|
struct Form formread;
|
|
|
|
|
|
|
|
for(i=1; i<argc; i++) {
|
|
|
|
|
|
|
|
if( FormParse( argv[i],
|
|
|
|
&httppost,
|
|
|
|
&last_post)) {
|
|
|
|
fprintf(stderr, "Illegally formatted input field: '%s'!\n",
|
|
|
|
argv[i]);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-01-05 05:11:41 -05:00
|
|
|
form=Curl_getFormData(httppost, &size);
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-06-05 07:27:40 -04:00
|
|
|
Curl_FormInit(&formread, form);
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-06-05 07:27:40 -04:00
|
|
|
do {
|
|
|
|
nread = Curl_FormReader(buffer, 1, sizeof(buffer),
|
|
|
|
(FILE *)&formread);
|
|
|
|
|
|
|
|
if(-1 == nread)
|
|
|
|
break;
|
1999-12-29 09:20:26 -05:00
|
|
|
fwrite(buffer, nread, 1, stderr);
|
2001-06-05 07:27:40 -04:00
|
|
|
} while(1);
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
fprintf(stderr, "size: %d\n", size);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
2001-09-07 00:01:32 -04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* local variables:
|
|
|
|
* eval: (load-file "../curl-mode.el")
|
|
|
|
* end:
|
|
|
|
* vim600: et sw=2 ts=2 sts=2 tw=78 fdm=marker
|
|
|
|
* vim<600: et sw=2 ts=2 sts=2 tw=78
|
|
|
|
*/
|