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