lib/formdata.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2017, Daniel Stenberg, <daniel@haxx.se>, et al.
   9  *
  10  * This software is licensed as described in the file COPYING, which
  11  * you should have received as part of this distribution. The terms
  12  * are also available at https://curl.haxx.se/docs/copyright.html.
  13  *
  14  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15  * copies of the Software, and permit persons to whom the Software is
  16  * furnished to do so, under the terms of the COPYING file.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ***************************************************************************/
  22
  23 #include "curl_setup.h"
  24
  25 #include <curl/curl.h>
  26
  27 #ifndef CURL_DISABLE_HTTP
  28
  29 #if defined(HAVE_LIBGEN_H) && defined(HAVE_BASENAME)
  30 #include <libgen.h>
  31 #endif
  32
  33 #include "urldata.h" /* for struct Curl_easy */
  34 #include "formdata.h"
  35 #include "vtls/vtls.h"
  36 #include "strcase.h"
  37 #include "sendf.h"
  38 #include "strdup.h"
  39 #include "rand.h"
  40 /* The last 3 #include files should be in this order */
  41 #include "curl_printf.h"
  42 #include "curl_memory.h"
  43 #include "memdebug.h"
  44
  45 #ifndef HAVE_BASENAME
  46 static char *Curl_basename(char *path);
  47 #define basename(x)  Curl_basename((x))
  48 #endif
  49
  50 static size_t readfromfile(struct Form *form, char *buffer, size_t size);
  51 static char *formboundary(struct Curl_easy *data);
  52
  53 /* What kind of Content-Type to use on un-specified files with unrecognized
  54    extensions. */
  55 #define HTTPPOST_CONTENTTYPE_DEFAULT "application/octet-stream"
  56
  57 #define FORM_FILE_SEPARATOR ','
  58 #define FORM_TYPE_SEPARATOR ';'
  59
  60 #define HTTPPOST_PTRNAME CURL_HTTPPOST_PTRNAME
  61 #define HTTPPOST_FILENAME CURL_HTTPPOST_FILENAME
  62 #define HTTPPOST_PTRCONTENTS CURL_HTTPPOST_PTRCONTENTS
  63 #define HTTPPOST_READFILE CURL_HTTPPOST_READFILE
  64 #define HTTPPOST_PTRBUFFER CURL_HTTPPOST_PTRBUFFER
  65 #define HTTPPOST_CALLBACK CURL_HTTPPOST_CALLBACK
  66 #define HTTPPOST_BUFFER CURL_HTTPPOST_BUFFER
  67
  68 /***************************************************************************
  69  *
  70  * AddHttpPost()
  71  *
  72  * Adds a HttpPost structure to the list, if parent_post is given becomes
  73  * a subpost of parent_post instead of a direct list element.
  74  *
  75  * Returns newly allocated HttpPost on success and NULL if malloc failed.
  76  *
  77  ***************************************************************************/
  78 static struct curl_httppost *
  79 AddHttpPost(char *name, size_t namelength,
  80             char *value, curl_off_t contentslength,
  81             char *buffer, size_t bufferlength,
  82             char *contenttype,
  83             long flags,
  84             struct curl_slist *contentHeader,
  85             char *showfilename, char *userp,
  86             struct curl_httppost *parent_post,
  87             struct curl_httppost **httppost,
  88             struct curl_httppost **last_post)
  89 {
  90   struct curl_httppost *post;
  91   post = calloc(1, sizeof(struct curl_httppost));
  92   if(post) {
  93     post->name = name;
  94     post->namelength = (long)(name?(namelength?namelength:strlen(name)):0);
  95     post->contents = value;
  96     post->contentlen = contentslength;
  97     post->buffer = buffer;
  98     post->bufferlength = (long)bufferlength;
  99     post->contenttype = contenttype;
 100     post->contentheader = contentHeader;
 101     post->showfilename = showfilename;
 102     post->userp = userp,
 103     post->flags = flags | CURL_HTTPPOST_LARGE;
 104   }
 105   else
 106     return NULL;
 107
 108   if(parent_post) {
 109     /* now, point our 'more' to the original 'more' */
 110     post->more = parent_post->more;
 111
 112     /* then move the original 'more' to point to ourselves */
 113     parent_post->more = post;
 114   }
 115   else {
 116     /* make the previous point to this */
 117     if(*last_post)
 118       (*last_post)->next = post;
 119     else
 120       (*httppost) = post;
 121
 122     (*last_post) = post;
 123   }
 124   return post;
 125 }
 126
 127 /***************************************************************************
 128  *
 129  * AddFormInfo()
 130  *
 131  * Adds a FormInfo structure to the list presented by parent_form_info.
 132  *
 133  * Returns newly allocated FormInfo on success and NULL if malloc failed/
 134  * parent_form_info is NULL.
 135  *
 136  ***************************************************************************/
 137 static FormInfo * AddFormInfo(char *value,
 138                               char *contenttype,
 139                               FormInfo *parent_form_info)
 140 {
 141   FormInfo *form_info;
 142   form_info = calloc(1, sizeof(struct FormInfo));
 143   if(form_info) {
 144     if(value)
 145       form_info->value = value;
 146     if(contenttype)
 147       form_info->contenttype = contenttype;
 148     form_info->flags = HTTPPOST_FILENAME;
 149   }
 150   else
 151     return NULL;
 152
 153   if(parent_form_info) {
 154     /* now, point our 'more' to the original 'more' */
 155     form_info->more = parent_form_info->more;
 156
 157     /* then move the original 'more' to point to ourselves */
 158     parent_form_info->more = form_info;
 159   }
 160
 161   return form_info;
 162 }
 163
 164 /***************************************************************************
 165  *
 166  * ContentTypeForFilename()
 167  *
 168  * Provides content type for filename if one of the known types (else
 169  * (either the prevtype or the default is returned).
 170  *
 171  * Returns some valid contenttype for filename.
 172  *
 173  ***************************************************************************/
 174 static const char *ContentTypeForFilename(const char *filename,
 175                                           const char *prevtype)
 176 {
 177   const char *contenttype = NULL;
 178   unsigned int i;
 179   /*
 180    * No type was specified, we scan through a few well-known
 181    * extensions and pick the first we match!
 182    */
 183   struct ContentType {
 184     const char *extension;
 185     const char *type;
 186   };
 187   static const struct ContentType ctts[]={
 188     {".gif",  "image/gif"},
 189     {".jpg",  "image/jpeg"},
 190     {".jpeg", "image/jpeg"},
 191     {".txt",  "text/plain"},
 192     {".html", "text/html"},
 193     {".xml", "application/xml"}
 194   };
 195
 196   if(prevtype)
 197     /* default to the previously set/used! */
 198     contenttype = prevtype;
 199   else
 200     contenttype = HTTPPOST_CONTENTTYPE_DEFAULT;
 201
 202   if(filename) { /* in case a NULL was passed in */
 203     for(i=0; i<sizeof(ctts)/sizeof(ctts[0]); i++) {
 204       if(strlen(filename) >= strlen(ctts[i].extension)) {
 205         if(strcasecompare(filename +
 206                           strlen(filename) - strlen(ctts[i].extension),
 207                           ctts[i].extension)) {
 208           contenttype = ctts[i].type;
 209           break;
 210         }
 211       }
 212     }
 213   }
 214   /* we have a contenttype by now */
 215   return contenttype;
 216 }
 217
 218 /***************************************************************************
 219  *
 220  * FormAdd()
 221  *
 222  * Stores a formpost parameter and builds the appropriate linked list.
 223  *
 224  * Has two principal functionalities: using files and byte arrays as
 225  * post parts. Byte arrays are either copied or just the pointer is stored
 226  * (as the user requests) while for files only the filename and not the
 227  * content is stored.
 228  *
 229  * While you may have only one byte array for each name, multiple filenames
 230  * are allowed (and because of this feature CURLFORM_END is needed after
 231  * using CURLFORM_FILE).
 232  *
 233  * Examples:
 234  *
 235  * Simple name/value pair with copied contents:
 236  * curl_formadd (&post, &last, CURLFORM_COPYNAME, "name",
 237  * CURLFORM_COPYCONTENTS, "value", CURLFORM_END);
 238  *
 239  * name/value pair where only the content pointer is remembered:
 240  * curl_formadd (&post, &last, CURLFORM_COPYNAME, "name",
 241  * CURLFORM_PTRCONTENTS, ptr, CURLFORM_CONTENTSLENGTH, 10, CURLFORM_END);
 242  * (if CURLFORM_CONTENTSLENGTH is missing strlen () is used)
 243  *
 244  * storing a filename (CONTENTTYPE is optional!):
 245  * curl_formadd (&post, &last, CURLFORM_COPYNAME, "name",
 246  * CURLFORM_FILE, "filename1", CURLFORM_CONTENTTYPE, "plain/text",
 247  * CURLFORM_END);
 248  *
 249  * storing multiple filenames:
 250  * curl_formadd (&post, &last, CURLFORM_COPYNAME, "name",
 251  * CURLFORM_FILE, "filename1", CURLFORM_FILE, "filename2", CURLFORM_END);
 252  *
 253  * Returns:
 254  * CURL_FORMADD_OK             on success
 255  * CURL_FORMADD_MEMORY         if the FormInfo allocation fails
 256  * CURL_FORMADD_OPTION_TWICE   if one option is given twice for one Form
 257  * CURL_FORMADD_NULL           if a null pointer was given for a char
 258  * CURL_FORMADD_MEMORY         if the allocation of a FormInfo struct failed
 259  * CURL_FORMADD_UNKNOWN_OPTION if an unknown option was used
 260  * CURL_FORMADD_INCOMPLETE     if the some FormInfo is not complete (or error)
 261  * CURL_FORMADD_MEMORY         if a HttpPost struct cannot be allocated
 262  * CURL_FORMADD_MEMORY         if some allocation for string copying failed.
 263  * CURL_FORMADD_ILLEGAL_ARRAY  if an illegal option is used in an array
 264  *
 265  ***************************************************************************/
 266
 267 static
 268 CURLFORMcode FormAdd(struct curl_httppost **httppost,
 269                      struct curl_httppost **last_post,
 270                      va_list params)
 271 {
 272   FormInfo *first_form, *current_form, *form = NULL;
 273   CURLFORMcode return_value = CURL_FORMADD_OK;
 274   const char *prevtype = NULL;
 275   struct curl_httppost *post = NULL;
 276   CURLformoption option;
 277   struct curl_forms *forms = NULL;
 278   char *array_value=NULL; /* value read from an array */
 279
 280   /* This is a state variable, that if TRUE means that we're parsing an
 281      array that we got passed to us. If FALSE we're parsing the input
 282      va_list arguments. */
 283   bool array_state = FALSE;
 284
 285   /*
 286    * We need to allocate the first struct to fill in.
 287    */
 288   first_form = calloc(1, sizeof(struct FormInfo));
 289   if(!first_form)
 290     return CURL_FORMADD_MEMORY;
 291
 292   current_form = first_form;
 293
 294   /*
 295    * Loop through all the options set. Break if we have an error to report.
 296    */
 297   while(return_value == CURL_FORMADD_OK) {
 298
 299     /* first see if we have more parts of the array param */
 300     if(array_state && forms) {
 301       /* get the upcoming option from the given array */
 302       option = forms->option;
 303       array_value = (char *)forms->value;
 304
 305       forms++; /* advance this to next entry */
 306       if(CURLFORM_END == option) {
 307         /* end of array state */
 308         array_state = FALSE;
 309         continue;
 310       }
 311     }
 312     else {
 313       /* This is not array-state, get next option */
 314       option = va_arg(params, CURLformoption);
 315       if(CURLFORM_END == option)
 316         break;
 317     }
 318
 319     switch(option) {
 320     case CURLFORM_ARRAY:
 321       if(array_state)
 322         /* we don't support an array from within an array */
 323         return_value = CURL_FORMADD_ILLEGAL_ARRAY;
 324       else {
 325         forms = va_arg(params, struct curl_forms *);
 326         if(forms)
 327           array_state = TRUE;
 328         else
 329           return_value = CURL_FORMADD_NULL;
 330       }
 331       break;
 332
 333       /*
 334        * Set the Name property.
 335        */
 336     case CURLFORM_PTRNAME:
 337 #ifdef CURL_DOES_CONVERSIONS
 338       /* Treat CURLFORM_PTR like CURLFORM_COPYNAME so that libcurl will copy
 339        * the data in all cases so that we'll have safe memory for the eventual
 340        * conversion.
 341        */
 342 #else
 343       current_form->flags |= HTTPPOST_PTRNAME; /* fall through */
 344 #endif
 345     case CURLFORM_COPYNAME:
 346       if(current_form->name)
 347         return_value = CURL_FORMADD_OPTION_TWICE;
 348       else {
 349         char *name = array_state?
 350           array_value:va_arg(params, char *);
 351         if(name)
 352           current_form->name = name; /* store for the moment */
 353         else
 354           return_value = CURL_FORMADD_NULL;
 355       }
 356       break;
 357     case CURLFORM_NAMELENGTH:
 358       if(current_form->namelength)
 359         return_value = CURL_FORMADD_OPTION_TWICE;
 360       else
 361         current_form->namelength =
 362           array_state?(size_t)array_value:(size_t)va_arg(params, long);
 363       break;
 364
 365       /*
 366        * Set the contents property.
 367        */
 368     case CURLFORM_PTRCONTENTS:
 369       current_form->flags |= HTTPPOST_PTRCONTENTS; /* fall through */
 370     case CURLFORM_COPYCONTENTS:
 371       if(current_form->value)
 372         return_value = CURL_FORMADD_OPTION_TWICE;
 373       else {
 374         char *value =
 375           array_state?array_value:va_arg(params, char *);
 376         if(value)
 377           current_form->value = value; /* store for the moment */
 378         else
 379           return_value = CURL_FORMADD_NULL;
 380       }
 381       break;
 382     case CURLFORM_CONTENTSLENGTH:
 383       current_form->contentslength =
 384         array_state?(size_t)array_value:(size_t)va_arg(params, long);
 385       break;
 386
 387     case CURLFORM_CONTENTLEN:
 388       current_form->flags |= CURL_HTTPPOST_LARGE;
 389       current_form->contentslength =
 390         array_state?(curl_off_t)(size_t)array_value:va_arg(params, curl_off_t);
 391       break;
 392
 393       /* Get contents from a given file name */
 394     case CURLFORM_FILECONTENT:
 395       if(current_form->flags & (HTTPPOST_PTRCONTENTS|HTTPPOST_READFILE))
 396         return_value = CURL_FORMADD_OPTION_TWICE;
 397       else {
 398         const char *filename = array_state?
 399           array_value:va_arg(params, char *);
 400         if(filename) {
 401           current_form->value = strdup(filename);
 402           if(!current_form->value)
 403             return_value = CURL_FORMADD_MEMORY;
 404           else {
 405             current_form->flags |= HTTPPOST_READFILE;
 406             current_form->value_alloc = TRUE;
 407           }
 408         }
 409         else
 410           return_value = CURL_FORMADD_NULL;
 411       }
 412       break;
 413
 414       /* We upload a file */
 415     case CURLFORM_FILE:
 416       {
 417         const char *filename = array_state?array_value:
 418           va_arg(params, char *);
 419
 420         if(current_form->value) {
 421           if(current_form->flags & HTTPPOST_FILENAME) {
 422             if(filename) {
 423               char *fname = strdup(filename);
 424               if(!fname)
 425                 return_value = CURL_FORMADD_MEMORY;
 426               else {
 427                 form = AddFormInfo(fname, NULL, current_form);
 428                 if(!form) {
 429                   free(fname);
 430                   return_value = CURL_FORMADD_MEMORY;
 431                 }
 432                 else {
 433                   form->value_alloc = TRUE;
 434                   current_form = form;
 435                   form = NULL;
 436                 }
 437               }
 438             }
 439             else
 440               return_value = CURL_FORMADD_NULL;
 441           }
 442           else
 443             return_value = CURL_FORMADD_OPTION_TWICE;
 444         }
 445         else {
 446           if(filename) {
 447             current_form->value = strdup(filename);
 448             if(!current_form->value)
 449               return_value = CURL_FORMADD_MEMORY;
 450             else {
 451               current_form->flags |= HTTPPOST_FILENAME;
 452               current_form->value_alloc = TRUE;
 453             }
 454           }
 455           else
 456             return_value = CURL_FORMADD_NULL;
 457         }
 458         break;
 459       }
 460
 461     case CURLFORM_BUFFERPTR:
 462       current_form->flags |= HTTPPOST_PTRBUFFER|HTTPPOST_BUFFER;
 463       if(current_form->buffer)
 464         return_value = CURL_FORMADD_OPTION_TWICE;
 465       else {
 466         char *buffer =
 467           array_state?array_value:va_arg(params, char *);
 468         if(buffer) {
 469           current_form->buffer = buffer; /* store for the moment */
 470           current_form->value = buffer; /* make it non-NULL to be accepted
 471                                            as fine */
 472         }
 473         else
 474           return_value = CURL_FORMADD_NULL;
 475       }
 476       break;
 477
 478     case CURLFORM_BUFFERLENGTH:
 479       if(current_form->bufferlength)
 480         return_value = CURL_FORMADD_OPTION_TWICE;
 481       else
 482         current_form->bufferlength =
 483           array_state?(size_t)array_value:(size_t)va_arg(params, long);
 484       break;
 485
 486     case CURLFORM_STREAM:
 487       current_form->flags |= HTTPPOST_CALLBACK;
 488       if(current_form->userp)
 489         return_value = CURL_FORMADD_OPTION_TWICE;
 490       else {
 491         char *userp =
 492           array_state?array_value:va_arg(params, char *);
 493         if(userp) {
 494           current_form->userp = userp;
 495           current_form->value = userp; /* this isn't strictly true but we
 496                                           derive a value from this later on
 497                                           and we need this non-NULL to be
 498                                           accepted as a fine form part */
 499         }
 500         else
 501           return_value = CURL_FORMADD_NULL;
 502       }
 503       break;
 504
 505     case CURLFORM_CONTENTTYPE:
 506       {
 507         const char *contenttype =
 508           array_state?array_value:va_arg(params, char *);
 509         if(current_form->contenttype) {
 510           if(current_form->flags & HTTPPOST_FILENAME) {
 511             if(contenttype) {
 512               char *type = strdup(contenttype);
 513               if(!type)
 514                 return_value = CURL_FORMADD_MEMORY;
 515               else {
 516                 form = AddFormInfo(NULL, type, current_form);
 517                 if(!form) {
 518                   free(type);
 519                   return_value = CURL_FORMADD_MEMORY;
 520                 }
 521                 else {
 522                   form->contenttype_alloc = TRUE;
 523                   current_form = form;
 524                   form = NULL;
 525                 }
 526               }
 527             }
 528             else
 529               return_value = CURL_FORMADD_NULL;
 530           }
 531           else
 532             return_value = CURL_FORMADD_OPTION_TWICE;
 533         }
 534         else {
 535           if(contenttype) {
 536             current_form->contenttype = strdup(contenttype);
 537             if(!current_form->contenttype)
 538               return_value = CURL_FORMADD_MEMORY;
 539             else
 540               current_form->contenttype_alloc = TRUE;
 541           }
 542           else
 543             return_value = CURL_FORMADD_NULL;
 544         }
 545         break;
 546       }
 547     case CURLFORM_CONTENTHEADER:
 548       {
 549         /* this "cast increases required alignment of target type" but
 550            we consider it OK anyway */
 551         struct curl_slist *list = array_state?
 552           (struct curl_slist *)(void *)array_value:
 553           va_arg(params, struct curl_slist *);
 554
 555         if(current_form->contentheader)
 556           return_value = CURL_FORMADD_OPTION_TWICE;
 557         else
 558           current_form->contentheader = list;
 559
 560         break;
 561       }
 562     case CURLFORM_FILENAME:
 563     case CURLFORM_BUFFER:
 564       {
 565         const char *filename = array_state?array_value:
 566           va_arg(params, char *);
 567         if(current_form->showfilename)
 568           return_value = CURL_FORMADD_OPTION_TWICE;
 569         else {
 570           current_form->showfilename = strdup(filename);
 571           if(!current_form->showfilename)
 572             return_value = CURL_FORMADD_MEMORY;
 573           else
 574             current_form->showfilename_alloc = TRUE;
 575         }
 576         break;
 577       }
 578     default:
 579       return_value = CURL_FORMADD_UNKNOWN_OPTION;
 580       break;
 581     }
 582   }
 583
 584   if(CURL_FORMADD_OK != return_value) {
 585     /* On error, free allocated fields for all nodes of the FormInfo linked
 586        list without deallocating nodes. List nodes are deallocated later on */
 587     FormInfo *ptr;
 588     for(ptr = first_form; ptr != NULL; ptr = ptr->more) {
 589       if(ptr->name_alloc) {
 590         Curl_safefree(ptr->name);
 591         ptr->name_alloc = FALSE;
 592       }
 593       if(ptr->value_alloc) {
 594         Curl_safefree(ptr->value);
 595         ptr->value_alloc = FALSE;
 596       }
 597       if(ptr->contenttype_alloc) {
 598         Curl_safefree(ptr->contenttype);
 599         ptr->contenttype_alloc = FALSE;
 600       }
 601       if(ptr->showfilename_alloc) {
 602         Curl_safefree(ptr->showfilename);
 603         ptr->showfilename_alloc = FALSE;
 604       }
 605     }
 606   }
 607
 608   if(CURL_FORMADD_OK == return_value) {
 609     /* go through the list, check for completeness and if everything is
 610      * alright add the HttpPost item otherwise set return_value accordingly */
 611
 612     post = NULL;
 613     for(form = first_form;
 614         form != NULL;
 615         form = form->more) {
 616       if(((!form->name || !form->value) && !post) ||
 617          ( (form->contentslength) &&
 618            (form->flags & HTTPPOST_FILENAME) ) ||
 619          ( (form->flags & HTTPPOST_FILENAME) &&
 620            (form->flags & HTTPPOST_PTRCONTENTS) ) ||
 621
 622          ( (!form->buffer) &&
 623            (form->flags & HTTPPOST_BUFFER) &&
 624            (form->flags & HTTPPOST_PTRBUFFER) ) ||
 625
 626          ( (form->flags & HTTPPOST_READFILE) &&
 627            (form->flags & HTTPPOST_PTRCONTENTS) )
 628         ) {
 629         return_value = CURL_FORMADD_INCOMPLETE;
 630         break;
 631       }
 632       else {
 633         if(((form->flags & HTTPPOST_FILENAME) ||
 634             (form->flags & HTTPPOST_BUFFER)) &&
 635            !form->contenttype) {
 636           char *f = form->flags & HTTPPOST_BUFFER?
 637             form->showfilename : form->value;
 638
 639           /* our contenttype is missing */
 640           form->contenttype = strdup(ContentTypeForFilename(f, prevtype));
 641           if(!form->contenttype) {
 642             return_value = CURL_FORMADD_MEMORY;
 643             break;
 644           }
 645           form->contenttype_alloc = TRUE;
 646         }
 647         if(!(form->flags & HTTPPOST_PTRNAME) &&
 648            (form == first_form) ) {
 649           /* Note that there's small risk that form->name is NULL here if the
 650              app passed in a bad combo, so we better check for that first. */
 651           if(form->name) {
 652             /* copy name (without strdup; possibly contains null characters) */
 653             form->name = Curl_memdup(form->name, form->namelength?
 654                                      form->namelength:
 655                                      strlen(form->name)+1);
 656           }
 657           if(!form->name) {
 658             return_value = CURL_FORMADD_MEMORY;
 659             break;
 660           }
 661           form->name_alloc = TRUE;
 662         }
 663         if(!(form->flags & (HTTPPOST_FILENAME | HTTPPOST_READFILE |
 664                             HTTPPOST_PTRCONTENTS | HTTPPOST_PTRBUFFER |
 665                             HTTPPOST_CALLBACK)) && form->value) {
 666           /* copy value (without strdup; possibly contains null characters) */
 667           size_t clen  = (size_t) form->contentslength;
 668           if(!clen)
 669             clen = strlen(form->value)+1;
 670
 671           form->value = Curl_memdup(form->value, clen);
 672
 673           if(!form->value) {
 674             return_value = CURL_FORMADD_MEMORY;
 675             break;
 676           }
 677           form->value_alloc = TRUE;
 678         }
 679         post = AddHttpPost(form->name, form->namelength,
 680                            form->value, form->contentslength,
 681                            form->buffer, form->bufferlength,
 682                            form->contenttype, form->flags,
 683                            form->contentheader, form->showfilename,
 684                            form->userp,
 685                            post, httppost,
 686                            last_post);
 687
 688         if(!post) {
 689           return_value = CURL_FORMADD_MEMORY;
 690           break;
 691         }
 692
 693         if(form->contenttype)
 694           prevtype = form->contenttype;
 695       }
 696     }
 697     if(CURL_FORMADD_OK != return_value) {
 698       /* On error, free allocated fields for nodes of the FormInfo linked
 699          list which are not already owned by the httppost linked list
 700          without deallocating nodes. List nodes are deallocated later on */
 701       FormInfo *ptr;
 702       for(ptr = form; ptr != NULL; ptr = ptr->more) {
 703         if(ptr->name_alloc) {
 704           Curl_safefree(ptr->name);
 705           ptr->name_alloc = FALSE;
 706         }
 707         if(ptr->value_alloc) {
 708           Curl_safefree(ptr->value);
 709           ptr->value_alloc = FALSE;
 710         }
 711         if(ptr->contenttype_alloc) {
 712           Curl_safefree(ptr->contenttype);
 713           ptr->contenttype_alloc = FALSE;
 714         }
 715         if(ptr->showfilename_alloc) {
 716           Curl_safefree(ptr->showfilename);
 717           ptr->showfilename_alloc = FALSE;
 718         }
 719       }
 720     }
 721   }
 722
 723   /* Always deallocate FormInfo linked list nodes without touching node
 724      fields given that these have either been deallocated or are owned
 725      now by the httppost linked list */
 726   while(first_form) {
 727     FormInfo *ptr = first_form->more;
 728     free(first_form);
 729     first_form = ptr;
 730   }
 731
 732   return return_value;
 733 }
 734
 735 /*
 736  * curl_formadd() is a public API to add a section to the multipart formpost.
 737  *
 738  * @unittest: 1308
 739  */
 740
 741 CURLFORMcode curl_formadd(struct curl_httppost **httppost,
 742                           struct curl_httppost **last_post,
 743                           ...)
 744 {
 745   va_list arg;
 746   CURLFORMcode result;
 747   va_start(arg, last_post);
 748   result = FormAdd(httppost, last_post, arg);
 749   va_end(arg);
 750   return result;
 751 }
 752
 753 #ifdef __VMS
 754 #include <fabdef.h>
 755 /*
 756  * get_vms_file_size does what it takes to get the real size of the file
 757  *
 758  * For fixed files, find out the size of the EOF block and adjust.
 759  *
 760  * For all others, have to read the entire file in, discarding the contents.
 761  * Most posted text files will be small, and binary files like zlib archives
 762  * and CD/DVD images should be either a STREAM_LF format or a fixed format.
 763  *
 764  */
 765 curl_off_t VmsRealFileSize(const char *name,
 766                            const struct_stat *stat_buf)
 767 {
 768   char buffer[8192];
 769   curl_off_t count;
 770   int ret_stat;
 771   FILE * file;
 772
 773   file = fopen(name, FOPEN_READTEXT); /* VMS */
 774   if(file == NULL)
 775     return 0;
 776
 777   count = 0;
 778   ret_stat = 1;
 779   while(ret_stat > 0) {
 780     ret_stat = fread(buffer, 1, sizeof(buffer), file);
 781     if(ret_stat != 0)
 782       count += ret_stat;
 783   }
 784   fclose(file);
 785
 786   return count;
 787 }
 788
 789 /*
 790  *
 791  *  VmsSpecialSize checks to see if the stat st_size can be trusted and
 792  *  if not to call a routine to get the correct size.
 793  *
 794  */
 795 static curl_off_t VmsSpecialSize(const char *name,
 796                                  const struct_stat *stat_buf)
 797 {
 798   switch(stat_buf->st_fab_rfm) {
 799   case FAB$C_VAR:
 800   case FAB$C_VFC:
 801     return VmsRealFileSize(name, stat_buf);
 802     break;
 803   default:
 804     return stat_buf->st_size;
 805   }
 806 }
 807
 808 #endif
 809
 810 #ifndef __VMS
 811 #define filesize(name, stat_data) (stat_data.st_size)
 812 #else
 813     /* Getting the expected file size needs help on VMS */
 814 #define filesize(name, stat_data) VmsSpecialSize(name, &stat_data)
 815 #endif
 816
 817 /*
 818  * AddFormData() adds a chunk of data to the FormData linked list.
 819  *
 820  * size is incremented by the chunk length, unless it is NULL
 821  */
 822 static CURLcode AddFormData(struct FormData **formp,
 823                             enum formtype type,
 824                             const void *line,
 825                             curl_off_t length,
 826                             curl_off_t *size)
 827 {
 828   struct FormData *newform;
 829   char *alloc2 = NULL;
 830   CURLcode result = CURLE_OK;
 831   if(length < 0 || (size && *size < 0))
 832     return CURLE_BAD_FUNCTION_ARGUMENT;
 833
 834   newform = malloc(sizeof(struct FormData));
 835   if(!newform)
 836     return CURLE_OUT_OF_MEMORY;
 837   newform->next = NULL;
 838
 839   if(type <= FORM_CONTENT) {
 840     /* we make it easier for plain strings: */
 841     if(!length)
 842       length = strlen((char *)line);
 843 #if (SIZEOF_SIZE_T < CURL_SIZEOF_CURL_OFF_T)
 844     else if(length >= (curl_off_t)(size_t)-1) {
 845       result = CURLE_BAD_FUNCTION_ARGUMENT;
 846       goto error;
 847     }
 848 #endif
 849     if(type != FORM_DATAMEM) {
 850       newform->line = malloc((size_t)length+1);
 851       if(!newform->line) {
 852         result = CURLE_OUT_OF_MEMORY;
 853         goto error;
 854       }
 855       alloc2 = newform->line;
 856       memcpy(newform->line, line, (size_t)length);
 857
 858       /* zero terminate for easier debugging */
 859       newform->line[(size_t)length]=0;
 860     }
 861     else {
 862       newform->line = (char *)line;
 863       type = FORM_DATA; /* in all other aspects this is just FORM_DATA */
 864     }
 865     newform->length = (size_t)length;
 866   }
 867   else
 868     /* For callbacks and files we don't have any actual data so we just keep a
 869        pointer to whatever this points to */
 870     newform->line = (char *)line;
 871
 872   newform->type = type;
 873
 874   if(size) {
 875     if(type != FORM_FILE)
 876       /* for static content as well as callback data we add the size given
 877          as input argument */
 878       *size += length;
 879     else {
 880       /* Since this is a file to be uploaded here, add the size of the actual
 881          file */
 882       if(strcmp("-", newform->line)) {
 883         struct_stat file;
 884         if(!stat(newform->line, &file) && !S_ISDIR(file.st_mode))
 885           *size += filesize(newform->line, file);
 886         else {
 887           result = CURLE_BAD_FUNCTION_ARGUMENT;
 888           goto error;
 889         }
 890       }
 891     }
 892   }
 893
 894   if(*formp) {
 895     (*formp)->next = newform;
 896     *formp = newform;
 897   }
 898   else
 899     *formp = newform;
 900
 901   return CURLE_OK;
 902   error:
 903   if(newform)
 904     free(newform);
 905   if(alloc2)
 906     free(alloc2);
 907   return result;
 908 }
 909
 910 /*
 911  * AddFormDataf() adds printf()-style formatted data to the formdata chain.
 912  */
 913
 914 static CURLcode AddFormDataf(struct FormData **formp,
 915                              curl_off_t *size,
 916                              const char *fmt, ...)
 917 {
 918   char *s;
 919   CURLcode result;
 920   va_list ap;
 921   va_start(ap, fmt);
 922   s = curl_mvaprintf(fmt, ap);
 923   va_end(ap);
 924
 925   if(!s)
 926     return CURLE_OUT_OF_MEMORY;
 927
 928   result = AddFormData(formp, FORM_DATAMEM, s, 0, size);
 929   if(result)
 930     free(s);
 931
 932   return result;
 933 }
 934
 935 /*
 936  * Curl_formclean() is used from http.c, this cleans a built FormData linked
 937  * list
 938  */
 939 void Curl_formclean(struct FormData **form_ptr)
 940 {
 941   struct FormData *next, *form;
 942
 943   form = *form_ptr;
 944   if(!form)
 945     return;
 946
 947   do {
 948     next=form->next;  /* the following form line */
 949     if(form->type <= FORM_CONTENT)
 950       free(form->line); /* free the line */
 951     free(form);       /* free the struct */
 952     form = next;
 953   } while(form); /* continue */
 954
 955   *form_ptr = NULL;
 956 }
 957
 958 /*
 959  * curl_formget()
 960  * Serialize a curl_httppost struct.
 961  * Returns 0 on success.
 962  *
 963  * @unittest: 1308
 964  */
 965 int curl_formget(struct curl_httppost *form, void *arg,
 966                  curl_formget_callback append)
 967 {
 968   CURLcode result;
 969   curl_off_t size;
 970   struct FormData *data, *ptr;
 971
 972   result = Curl_getformdata(NULL, &data, form, NULL, &size);
 973   if(result)
 974     return (int)result;
 975
 976   for(ptr = data; ptr; ptr = ptr->next) {
 977     if((ptr->type == FORM_FILE) || (ptr->type == FORM_CALLBACK)) {
 978       char buffer[8192];
 979       size_t nread;
 980       struct Form temp;
 981
 982       Curl_FormInit(&temp, ptr);
 983
 984       do {
 985         nread = readfromfile(&temp, buffer, sizeof(buffer));
 986         if((nread == (size_t) -1) ||
 987            (nread > sizeof(buffer)) ||
 988            (nread != append(arg, buffer, nread))) {
 989           if(temp.fp)
 990             fclose(temp.fp);
 991           Curl_formclean(&data);
 992           return -1;
 993         }
 994       } while(nread);
 995     }
 996     else {
 997       if(ptr->length != append(arg, ptr->line, ptr->length)) {
 998         Curl_formclean(&data);
 999         return -1;
1000       }
1001     }
1002   }
1003   Curl_formclean(&data);
1004   return 0;
1005 }
1006
1007 /*
1008  * curl_formfree() is an external function to free up a whole form post
1009  * chain
1010  */
1011 void curl_formfree(struct curl_httppost *form)
1012 {
1013   struct curl_httppost *next;
1014
1015   if(!form)
1016     /* no form to free, just get out of this */
1017     return;
1018
1019   do {
1020     next=form->next;  /* the following form line */
1021
1022     /* recurse to sub-contents */
1023     curl_formfree(form->more);
1024
1025     if(!(form->flags & HTTPPOST_PTRNAME))
1026       free(form->name); /* free the name */
1027     if(!(form->flags &
1028          (HTTPPOST_PTRCONTENTS|HTTPPOST_BUFFER|HTTPPOST_CALLBACK))
1029       )
1030       free(form->contents); /* free the contents */
1031     free(form->contenttype); /* free the content type */
1032     free(form->showfilename); /* free the faked file name */
1033     free(form);       /* free the struct */
1034     form = next;
1035   } while(form); /* continue */
1036 }
1037
1038 #ifndef HAVE_BASENAME
1039 /*
1040   (Quote from The Open Group Base Specifications Issue 6 IEEE Std 1003.1, 2004
1041   Edition)
1042
1043   The basename() function shall take the pathname pointed to by path and
1044   return a pointer to the final component of the pathname, deleting any
1045   trailing '/' characters.
1046
1047   If the string pointed to by path consists entirely of the '/' character,
1048   basename() shall return a pointer to the string "/". If the string pointed
1049   to by path is exactly "//", it is implementation-defined whether '/' or "//"
1050   is returned.
1051
1052   If path is a null pointer or points to an empty string, basename() shall
1053   return a pointer to the string ".".
1054
1055   The basename() function may modify the string pointed to by path, and may
1056   return a pointer to static storage that may then be overwritten by a
1057   subsequent call to basename().
1058
1059   The basename() function need not be reentrant. A function that is not
1060   required to be reentrant is not required to be thread-safe.
1061
1062 */
1063 static char *Curl_basename(char *path)
1064 {
1065   /* Ignore all the details above for now and make a quick and simple
1066      implementaion here */
1067   char *s1;
1068   char *s2;
1069
1070   s1=strrchr(path, '/');
1071   s2=strrchr(path, '\\');
1072
1073   if(s1 && s2) {
1074     path = (s1 > s2? s1 : s2)+1;
1075   }
1076   else if(s1)
1077     path = s1 + 1;
1078   else if(s2)
1079     path = s2 + 1;
1080
1081   return path;
1082 }
1083 #endif
1084
1085 static char *strippath(const char *fullfile)
1086 {
1087   char *filename;
1088   char *base;
1089   filename = strdup(fullfile); /* duplicate since basename() may ruin the
1090                                   buffer it works on */
1091   if(!filename)
1092     return NULL;
1093   base = strdup(basename(filename));
1094
1095   free(filename); /* free temporary buffer */
1096
1097   return base; /* returns an allocated string or NULL ! */
1098 }
1099
1100 static CURLcode formdata_add_filename(const struct curl_httppost *file,
1101                                       struct FormData **form,
1102                                       curl_off_t *size)
1103 {
1104   CURLcode result = CURLE_OK;
1105   char *filename = file->showfilename;
1106   char *filebasename = NULL;
1107   char *filename_escaped = NULL;
1108
1109   if(!filename) {
1110     filebasename = strippath(file->contents);
1111     if(!filebasename)
1112       return CURLE_OUT_OF_MEMORY;
1113     filename = filebasename;
1114   }
1115
1116   if(strchr(filename, '\\') || strchr(filename, '"')) {
1117     char *p0, *p1;
1118
1119     /* filename need be escaped */
1120     filename_escaped = malloc(strlen(filename)*2+1);
1121     if(!filename_escaped) {
1122       free(filebasename);
1123       return CURLE_OUT_OF_MEMORY;
1124     }
1125     p0 = filename_escaped;
1126     p1 = filename;
1127     while(*p1) {
1128       if(*p1 == '\\' || *p1 == '"')
1129         *p0++ = '\\';
1130       *p0++ = *p1++;
1131     }
1132     *p0 = '\0';
1133     filename = filename_escaped;
1134   }
1135   result = AddFormDataf(form, size,
1136                         "; filename=\"%s\"",
1137                         filename);
1138   free(filename_escaped);
1139   free(filebasename);
1140   return result;
1141 }
1142
1143 /*
1144  * Curl_getformdata() converts a linked list of "meta data" into a complete
1145  * (possibly huge) multipart formdata. The input list is in 'post', while the
1146  * output resulting linked lists gets stored in '*finalform'. *sizep will get
1147  * the total size of the whole POST.
1148  * A multipart/form_data content-type is built, unless a custom content-type
1149  * is passed in 'custom_content_type'.
1150  *
1151  * This function will not do a failf() for the potential memory failures but
1152  * should for all other errors it spots. Just note that this function MAY get
1153  * a NULL pointer in the 'data' argument.
1154  */
1155
1156 CURLcode Curl_getformdata(struct Curl_easy *data,
1157                           struct FormData **finalform,
1158                           struct curl_httppost *post,
1159                           const char *custom_content_type,
1160                           curl_off_t *sizep)
1161 {
1162   struct FormData *form = NULL;
1163   struct FormData *firstform;
1164   struct curl_httppost *file;
1165   CURLcode result = CURLE_OK;
1166
1167   curl_off_t size = 0; /* support potentially ENORMOUS formposts */
1168   char *boundary;
1169   char *fileboundary = NULL;
1170   struct curl_slist *curList;
1171
1172   *finalform = NULL; /* default form is empty */
1173
1174   if(!post)
1175     return result; /* no input => no output! */
1176
1177   boundary = formboundary(data);
1178   if(!boundary)
1179     return CURLE_OUT_OF_MEMORY;
1180
1181   /* Make the first line of the output */
1182   result = AddFormDataf(&form, NULL,
1183                         "%s; boundary=%s\r\n",
1184                         custom_content_type?custom_content_type:
1185                         "Content-Type: multipart/form-data",
1186                         boundary);
1187
1188   if(result) {
1189     free(boundary);
1190     return result;
1191   }
1192   /* we DO NOT include that line in the total size of the POST, since it'll be
1193      part of the header! */
1194
1195   firstform = form;
1196
1197   do {
1198
1199     if(size) {
1200       result = AddFormDataf(&form, &size, "\r\n");
1201       if(result)
1202         break;
1203     }
1204
1205     /* boundary */
1206     result = AddFormDataf(&form, &size, "--%s\r\n", boundary);
1207     if(result)
1208       break;
1209
1210     /* Maybe later this should be disabled when a custom_content_type is
1211        passed, since Content-Disposition is not meaningful for all multipart
1212        types.
1213     */
1214     result = AddFormDataf(&form, &size,
1215                           "Content-Disposition: form-data; name=\"");
1216     if(result)
1217       break;
1218
1219     result = AddFormData(&form, FORM_DATA, post->name, post->namelength,
1220                          &size);
1221     if(result)
1222       break;
1223
1224     result = AddFormDataf(&form, &size, "\"");
1225     if(result)
1226       break;
1227
1228     if(post->more) {
1229       /* If used, this is a link to more file names, we must then do
1230          the magic to include several files with the same field name */
1231
1232       free(fileboundary);
1233       fileboundary = formboundary(data);
1234       if(!fileboundary) {
1235         result = CURLE_OUT_OF_MEMORY;
1236         break;
1237       }
1238
1239       result = AddFormDataf(&form, &size,
1240                             "\r\nContent-Type: multipart/mixed;"
1241                             " boundary=%s\r\n",
1242                             fileboundary);
1243       if(result)
1244         break;
1245     }
1246
1247     file = post;
1248
1249     do {
1250
1251       /* If 'showfilename' is set, that is a faked name passed on to us
1252          to use to in the formpost. If that is not set, the actually used
1253          local file name should be added. */
1254
1255       if(post->more) {
1256         /* if multiple-file */
1257         result = AddFormDataf(&form, &size,
1258                               "\r\n--%s\r\nContent-Disposition: "
1259                               "attachment",
1260                               fileboundary);
1261         if(result)
1262           break;
1263         result = formdata_add_filename(file, &form, &size);
1264         if(result)
1265           break;
1266       }
1267       else if(post->flags & (HTTPPOST_FILENAME|HTTPPOST_BUFFER|
1268                              HTTPPOST_CALLBACK)) {
1269         /* it should be noted that for the HTTPPOST_FILENAME and
1270            HTTPPOST_CALLBACK cases the ->showfilename struct member is always
1271            assigned at this point */
1272         if(post->showfilename || (post->flags & HTTPPOST_FILENAME)) {
1273           result = formdata_add_filename(post, &form, &size);
1274         }
1275
1276         if(result)
1277           break;
1278       }
1279
1280       if(file->contenttype) {
1281         /* we have a specified type */
1282         result = AddFormDataf(&form, &size,
1283                               "\r\nContent-Type: %s",
1284                               file->contenttype);
1285         if(result)
1286           break;
1287       }
1288
1289       curList = file->contentheader;
1290       while(curList) {
1291         /* Process the additional headers specified for this form */
1292         result = AddFormDataf(&form, &size, "\r\n%s", curList->data);
1293         if(result)
1294           break;
1295         curList = curList->next;
1296       }
1297       if(result)
1298         break;
1299
1300       result = AddFormDataf(&form, &size, "\r\n\r\n");
1301       if(result)
1302         break;
1303
1304       if((post->flags & HTTPPOST_FILENAME) ||
1305          (post->flags & HTTPPOST_READFILE)) {
1306         /* we should include the contents from the specified file */
1307         FILE *fileread;
1308
1309         fileread = !strcmp("-", file->contents)?
1310           stdin:fopen(file->contents, "rb"); /* binary read for win32  */
1311
1312         /*
1313          * VMS: This only allows for stream files on VMS.  Stream files are
1314          * OK, as are FIXED & VAR files WITHOUT implied CC For implied CC,
1315          * every record needs to have a \n appended & 1 added to SIZE
1316          */
1317
1318         if(fileread) {
1319           if(fileread != stdin) {
1320             /* close the file */
1321             fclose(fileread);
1322             /* add the file name only - for later reading from this */
1323             result = AddFormData(&form, FORM_FILE, file->contents, 0, &size);
1324           }
1325           else {
1326             /* When uploading from stdin, we can't know the size of the file,
1327              * thus must read the full file as before. We *could* use chunked
1328              * transfer-encoding, but that only works for HTTP 1.1 and we
1329              * can't be sure we work with such a server.
1330              */
1331             size_t nread;
1332             char buffer[512];
1333             while((nread = fread(buffer, 1, sizeof(buffer), fileread)) != 0) {
1334               result = AddFormData(&form, FORM_CONTENT, buffer, nread, &size);
1335               if(result || feof(fileread) || ferror(fileread))
1336                 break;
1337             }
1338           }
1339         }
1340         else {
1341           if(data)
1342             failf(data, "couldn't open file \"%s\"", file->contents);
1343           *finalform = NULL;
1344           result = CURLE_READ_ERROR;
1345         }
1346       }
1347       else if(post->flags & HTTPPOST_BUFFER)
1348         /* include contents of buffer */
1349         result = AddFormData(&form, FORM_CONTENT, post->buffer,
1350                              post->bufferlength, &size);
1351       else if(post->flags & HTTPPOST_CALLBACK)
1352         /* the contents should be read with the callback and the size is set
1353            with the contentslength */
1354         result = AddFormData(&form, FORM_CALLBACK, post->userp,
1355                              post->flags&CURL_HTTPPOST_LARGE?
1356                              post->contentlen:post->contentslength, &size);
1357       else
1358         /* include the contents we got */
1359         result = AddFormData(&form, FORM_CONTENT, post->contents,
1360                              post->flags&CURL_HTTPPOST_LARGE?
1361                              post->contentlen:post->contentslength, &size);
1362       file = file->more;
1363     } while(file && !result); /* for each specified file for this field */
1364
1365     if(result)
1366       break;
1367
1368     if(post->more) {
1369       /* this was a multiple-file inclusion, make a termination file
1370          boundary: */
1371       result = AddFormDataf(&form, &size,
1372                            "\r\n--%s--",
1373                            fileboundary);
1374       if(result)
1375         break;
1376     }
1377     post = post->next;
1378   } while(post); /* for each field */
1379
1380   /* end-boundary for everything */
1381   if(!result)
1382     result = AddFormDataf(&form, &size, "\r\n--%s--\r\n", boundary);
1383
1384   if(result) {
1385     Curl_formclean(&firstform);
1386     free(fileboundary);
1387     free(boundary);
1388     return result;
1389   }
1390
1391   *sizep = size;
1392
1393   free(fileboundary);
1394   free(boundary);
1395
1396   *finalform = firstform;
1397
1398   return result;
1399 }
1400
1401 /*
1402  * Curl_FormInit() inits the struct 'form' points to with the 'formdata'
1403  * and resets the 'sent' counter.
1404  */
1405 int Curl_FormInit(struct Form *form, struct FormData *formdata)
1406 {
1407   if(!formdata)
1408     return 1; /* error */
1409
1410   form->data = formdata;
1411   form->sent = 0;
1412   form->fp = NULL;
1413   form->fread_func = ZERO_NULL;
1414
1415   return 0;
1416 }
1417
1418 #ifndef __VMS
1419 # define fopen_read fopen
1420 #else
1421   /*
1422    * vmsfopenread
1423    *
1424    * For upload to work as expected on VMS, different optional
1425    * parameters must be added to the fopen command based on
1426    * record format of the file.
1427    *
1428    */
1429 # define fopen_read vmsfopenread
1430 static FILE * vmsfopenread(const char *file, const char *mode)
1431 {
1432   struct_stat statbuf;
1433   int result;
1434
1435   result = stat(file, &statbuf);
1436
1437   switch(statbuf.st_fab_rfm) {
1438   case FAB$C_VAR:
1439   case FAB$C_VFC:
1440   case FAB$C_STMCR:
1441     return fopen(file, FOPEN_READTEXT); /* VMS */
1442     break;
1443   default:
1444     return fopen(file, FOPEN_READTEXT, "rfm=stmlf", "ctx=stm");
1445   }
1446 }
1447 #endif
1448
1449 /*
1450  * readfromfile()
1451  *
1452  * The read callback that this function may use can return a value larger than
1453  * 'size' (which then this function returns) that indicates a problem and it
1454  * must be properly dealt with
1455  */
1456 static size_t readfromfile(struct Form *form, char *buffer,
1457                            size_t size)
1458 {
1459   size_t nread;
1460   bool callback = (form->data->type == FORM_CALLBACK)?TRUE:FALSE;
1461
1462   if(callback) {
1463     if(form->fread_func == ZERO_NULL)
1464       return 0;
1465     else
1466       nread = form->fread_func(buffer, 1, size, form->data->line);
1467   }
1468   else {
1469     if(!form->fp) {
1470       /* this file hasn't yet been opened */
1471       form->fp = fopen_read(form->data->line, "rb"); /* b is for binary */
1472       if(!form->fp)
1473         return (size_t)-1; /* failure */
1474     }
1475     nread = fread(buffer, 1, size, form->fp);
1476   }
1477   if(!nread) {
1478     /* this is the last chunk from the file, move on */
1479     if(form->fp) {
1480       fclose(form->fp);
1481       form->fp = NULL;
1482     }
1483     form->data = form->data->next;
1484   }
1485
1486   return nread;
1487 }
1488
1489 /*
1490  * Curl_FormReader() is the fread() emulation function that will be used to
1491  * deliver the formdata to the transfer loop and then sent away to the peer.
1492  */
1493 size_t Curl_FormReader(char *buffer,
1494                        size_t size,
1495                        size_t nitems,
1496                        FILE *mydata)
1497 {
1498   struct Form *form;
1499   size_t wantedsize;
1500   size_t gotsize = 0;
1501
1502   form=(struct Form *)mydata;
1503
1504   wantedsize = size * nitems;
1505
1506   if(!form->data)
1507     return 0; /* nothing, error, empty */
1508
1509   if((form->data->type == FORM_FILE) ||
1510      (form->data->type == FORM_CALLBACK)) {
1511     gotsize = readfromfile(form, buffer, wantedsize);
1512
1513     if(gotsize)
1514       /* If positive or -1, return. If zero, continue! */
1515       return gotsize;
1516   }
1517   do {
1518
1519     if((form->data->length - form->sent) > wantedsize - gotsize) {
1520
1521       memcpy(buffer + gotsize, form->data->line + form->sent,
1522              wantedsize - gotsize);
1523
1524       form->sent += wantedsize-gotsize;
1525
1526       return wantedsize;
1527     }
1528
1529     memcpy(buffer+gotsize,
1530            form->data->line + form->sent,
1531            (form->data->length - form->sent) );
1532     gotsize += form->data->length - form->sent;
1533
1534     form->sent = 0;
1535
1536     form->data = form->data->next; /* advance */
1537
1538   } while(form->data && (form->data->type < FORM_CALLBACK));
1539   /* If we got an empty line and we have more data, we proceed to the next
1540      line immediately to avoid returning zero before we've reached the end. */
1541
1542   return gotsize;
1543 }
1544
1545 /*
1546  * Curl_formpostheader() returns the first line of the formpost, the
1547  * request-header part (which is not part of the request-body like the rest of
1548  * the post).
1549  */
1550 char *Curl_formpostheader(void *formp, size_t *len)
1551 {
1552   char *header;
1553   struct Form *form=(struct Form *)formp;
1554
1555   if(!form->data)
1556     return NULL; /* nothing, ERROR! */
1557
1558   header = form->data->line;
1559   *len = form->data->length;
1560
1561   form->data = form->data->next; /* advance */
1562
1563   return header;
1564 }
1565
1566 /*
1567  * formboundary() creates a suitable boundary string and returns an allocated
1568  * one.
1569  */
1570 static char *formboundary(struct Curl_easy *data)
1571 {
1572   /* 24 dashes and 16 hexadecimal digits makes 64 bit (18446744073709551615)
1573      combinations */
1574   unsigned int rnd[2];
1575   CURLcode result = Curl_rand(data, &rnd[0], 2);
1576   if(result)
1577     return NULL;
1578
1579   return aprintf("------------------------%08x%08x", rnd[0], rnd[1]);
1580 }
1581
1582 #else  /* CURL_DISABLE_HTTP */
1583 CURLFORMcode curl_formadd(struct curl_httppost **httppost,
1584                           struct curl_httppost **last_post,
1585                           ...)
1586 {
1587   (void)httppost;
1588   (void)last_post;
1589   return CURL_FORMADD_DISABLED;
1590 }
1591
1592 int curl_formget(struct curl_httppost *form, void *arg,
1593                  curl_formget_callback append)
1594 {
1595   (void) form;
1596   (void) arg;
1597   (void) append;
1598   return CURL_FORMADD_DISABLED;
1599 }
1600
1601 void curl_formfree(struct curl_httppost *form)
1602 {
1603   (void)form;
1604   /* does nothing HTTP is disabled */
1605 }
1606
1607
1608 #endif  /* !defined(CURL_DISABLE_HTTP) */