Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 1 | /*************************************************************************** |
| 2 | * _ _ ____ _ |
| 3 | * Project ___| | | | _ \| | |
| 4 | * / __| | | | |_) | | |
| 5 | * | (__| |_| | _ <| |___ |
| 6 | * \___|\___/|_| \_\_____| |
| 7 | * |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 8 | * Copyright (C) 1998 - 2017, Daniel Stenberg, <daniel@haxx.se>, et al. |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 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 |
Alex Deymo | 8f1a214 | 2016-06-28 14:49:26 -0700 | [diff] [blame] | 12 | * are also available at https://curl.haxx.se/docs/copyright.html. |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 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 | #include "tool_setup.h" |
| 23 | |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 24 | #include "mime.h" |
Elliott Hughes | cee0338 | 2017-06-23 12:17:18 -0700 | [diff] [blame] | 25 | #include "strcase.h" |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 26 | |
| 27 | #define ENABLE_CURLX_PRINTF |
| 28 | /* use our own printf() functions */ |
| 29 | #include "curlx.h" |
| 30 | |
| 31 | #include "tool_cfgable.h" |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 32 | #include "tool_convert.h" |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 33 | #include "tool_msgs.h" |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 34 | #include "tool_binmode.h" |
| 35 | #include "tool_getparam.h" |
| 36 | #include "tool_paramhlp.h" |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 37 | #include "tool_formparse.h" |
| 38 | |
| 39 | #include "memdebug.h" /* keep this as LAST include */ |
| 40 | |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 41 | /* Stdin parameters. */ |
| 42 | typedef struct { |
| 43 | char *data; /* Memory data. */ |
| 44 | curl_off_t origin; /* File read origin offset. */ |
| 45 | curl_off_t size; /* Data size. */ |
| 46 | curl_off_t curpos; /* Current read position. */ |
| 47 | } standard_input; |
| 48 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 49 | |
| 50 | /* |
| 51 | * helper function to get a word from form param |
| 52 | * after call get_parm_word, str either point to string end |
| 53 | * or point to any of end chars. |
| 54 | */ |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 55 | static char *get_param_word(char **str, char **end_pos, char endchar) |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 56 | { |
| 57 | char *ptr = *str; |
| 58 | char *word_begin = NULL; |
| 59 | char *ptr2; |
| 60 | char *escape = NULL; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 61 | |
| 62 | /* the first non-space char is here */ |
| 63 | word_begin = ptr; |
| 64 | if(*ptr == '"') { |
| 65 | ++ptr; |
| 66 | while(*ptr) { |
| 67 | if(*ptr == '\\') { |
| 68 | if(ptr[1] == '\\' || ptr[1] == '"') { |
| 69 | /* remember the first escape position */ |
| 70 | if(!escape) |
| 71 | escape = ptr; |
| 72 | /* skip escape of back-slash or double-quote */ |
| 73 | ptr += 2; |
| 74 | continue; |
| 75 | } |
| 76 | } |
| 77 | if(*ptr == '"') { |
| 78 | *end_pos = ptr; |
| 79 | if(escape) { |
| 80 | /* has escape, we restore the unescaped string here */ |
| 81 | ptr = ptr2 = escape; |
| 82 | do { |
| 83 | if(*ptr == '\\' && (ptr[1] == '\\' || ptr[1] == '"')) |
| 84 | ++ptr; |
| 85 | *ptr2++ = *ptr++; |
| 86 | } |
| 87 | while(ptr < *end_pos); |
| 88 | *end_pos = ptr2; |
| 89 | } |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 90 | while(*ptr && *ptr != ';' && *ptr != endchar) |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 91 | ++ptr; |
| 92 | *str = ptr; |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 93 | return word_begin + 1; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 94 | } |
| 95 | ++ptr; |
| 96 | } |
| 97 | /* end quote is missing, treat it as non-quoted. */ |
| 98 | ptr = word_begin; |
| 99 | } |
| 100 | |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 101 | while(*ptr && *ptr != ';' && *ptr != endchar) |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 102 | ++ptr; |
| 103 | *str = *end_pos = ptr; |
| 104 | return word_begin; |
| 105 | } |
| 106 | |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 107 | /* Append slist item and return -1 if failed. */ |
| 108 | static int slist_append(struct curl_slist **plist, const char *data) |
| 109 | { |
| 110 | struct curl_slist *s = curl_slist_append(*plist, data); |
| 111 | |
| 112 | if(!s) |
| 113 | return -1; |
| 114 | |
| 115 | *plist = s; |
| 116 | return 0; |
| 117 | } |
| 118 | |
| 119 | /* Read headers from a file and append to list. */ |
| 120 | static int read_field_headers(struct OperationConfig *config, |
| 121 | const char *filename, FILE *fp, |
| 122 | struct curl_slist **pheaders) |
| 123 | { |
| 124 | size_t hdrlen = 0; |
| 125 | size_t pos = 0; |
| 126 | int c; |
| 127 | bool incomment = FALSE; |
| 128 | int lineno = 1; |
| 129 | char hdrbuf[999]; /* Max. header length + 1. */ |
| 130 | |
| 131 | for(;;) { |
| 132 | c = getc(fp); |
| 133 | if(c == EOF || (!pos && !ISSPACE(c))) { |
| 134 | /* Strip and flush the current header. */ |
| 135 | while(hdrlen && ISSPACE(hdrbuf[hdrlen - 1])) |
| 136 | hdrlen--; |
| 137 | if(hdrlen) { |
| 138 | hdrbuf[hdrlen] = '\0'; |
| 139 | if(slist_append(pheaders, hdrbuf)) { |
| 140 | fprintf(config->global->errors, |
| 141 | "Out of memory for field headers!\n"); |
| 142 | return -1; |
| 143 | } |
| 144 | hdrlen = 0; |
| 145 | } |
| 146 | } |
| 147 | |
| 148 | switch(c) { |
| 149 | case EOF: |
| 150 | if(ferror(fp)) { |
| 151 | fprintf(config->global->errors, |
| 152 | "Header file %s read error: %s\n", filename, strerror(errno)); |
| 153 | return -1; |
| 154 | } |
| 155 | return 0; /* Done. */ |
| 156 | case '\r': |
| 157 | continue; /* Ignore. */ |
| 158 | case '\n': |
| 159 | pos = 0; |
| 160 | incomment = FALSE; |
| 161 | lineno++; |
| 162 | continue; |
| 163 | case '#': |
| 164 | if(!pos) |
| 165 | incomment = TRUE; |
| 166 | break; |
| 167 | } |
| 168 | |
| 169 | pos++; |
| 170 | if(!incomment) { |
| 171 | if(hdrlen == sizeof hdrbuf - 1) { |
| 172 | warnf(config->global, "File %s line %d: header too long (truncated)\n", |
| 173 | filename, lineno); |
| 174 | c = ' '; |
| 175 | } |
| 176 | if(hdrlen <= sizeof hdrbuf - 1) |
| 177 | hdrbuf[hdrlen++] = (char) c; |
| 178 | } |
| 179 | } |
| 180 | /* NOTREACHED */ |
| 181 | } |
| 182 | |
| 183 | static int get_param_part(struct OperationConfig *config, char endchar, |
| 184 | char **str, char **pdata, char **ptype, |
| 185 | char **pfilename, char **pencoder, |
| 186 | struct curl_slist **pheaders) |
| 187 | { |
| 188 | char *p = *str; |
| 189 | char *type = NULL; |
| 190 | char *filename = NULL; |
| 191 | char *encoder = NULL; |
| 192 | char *endpos; |
| 193 | char *tp; |
| 194 | char sep; |
| 195 | char type_major[128] = ""; |
| 196 | char type_minor[128] = ""; |
| 197 | char *endct = NULL; |
| 198 | struct curl_slist *headers = NULL; |
| 199 | |
| 200 | if(ptype) |
| 201 | *ptype = NULL; |
| 202 | if(pfilename) |
| 203 | *pfilename = NULL; |
| 204 | if(pheaders) |
| 205 | *pheaders = NULL; |
| 206 | if(pencoder) |
| 207 | *pencoder = NULL; |
| 208 | while(ISSPACE(*p)) |
| 209 | p++; |
| 210 | tp = p; |
| 211 | *pdata = get_param_word(&p, &endpos, endchar); |
| 212 | /* If not quoted, strip trailing spaces. */ |
| 213 | if(*pdata == tp) |
| 214 | while(endpos > *pdata && ISSPACE(endpos[-1])) |
| 215 | endpos--; |
| 216 | sep = *p; |
| 217 | *endpos = '\0'; |
| 218 | while(sep == ';') { |
| 219 | while(ISSPACE(*++p)) |
| 220 | ; |
| 221 | |
| 222 | if(!endct && checkprefix("type=", p)) { |
| 223 | for(p += 5; ISSPACE(*p); p++) |
| 224 | ; |
| 225 | /* set type pointer */ |
| 226 | type = p; |
| 227 | |
| 228 | /* verify that this is a fine type specifier */ |
| 229 | if(2 != sscanf(type, "%127[^/ ]/%127[^;, \n]", type_major, type_minor)) { |
| 230 | warnf(config->global, "Illegally formatted content-type field!\n"); |
| 231 | curl_slist_free_all(headers); |
| 232 | return -1; /* illegal content-type syntax! */ |
| 233 | } |
| 234 | |
| 235 | /* now point beyond the content-type specifier */ |
| 236 | p = type + strlen(type_major) + strlen(type_minor) + 1; |
| 237 | for(endct = p; *p && *p != ';' && *p != endchar; p++) |
| 238 | if(!ISSPACE(*p)) |
| 239 | endct = p + 1; |
| 240 | sep = *p; |
| 241 | } |
| 242 | else if(checkprefix("filename=", p)) { |
| 243 | if(endct) { |
| 244 | *endct = '\0'; |
| 245 | endct = NULL; |
| 246 | } |
| 247 | for(p += 9; ISSPACE(*p); p++) |
| 248 | ; |
| 249 | tp = p; |
| 250 | filename = get_param_word(&p, &endpos, endchar); |
| 251 | /* If not quoted, strip trailing spaces. */ |
| 252 | if(filename == tp) |
| 253 | while(endpos > filename && ISSPACE(endpos[-1])) |
| 254 | endpos--; |
| 255 | sep = *p; |
| 256 | *endpos = '\0'; |
| 257 | } |
| 258 | else if(checkprefix("headers=", p)) { |
| 259 | if(endct) { |
| 260 | *endct = '\0'; |
| 261 | endct = NULL; |
| 262 | } |
| 263 | p += 8; |
| 264 | if(*p == '@' || *p == '<') { |
| 265 | char *hdrfile; |
| 266 | FILE *fp; |
| 267 | /* Read headers from a file. */ |
| 268 | |
| 269 | do { |
| 270 | p++; |
| 271 | } while(ISSPACE(*p)); |
| 272 | tp = p; |
| 273 | hdrfile = get_param_word(&p, &endpos, endchar); |
| 274 | /* If not quoted, strip trailing spaces. */ |
| 275 | if(hdrfile == tp) |
| 276 | while(endpos > hdrfile && ISSPACE(endpos[-1])) |
| 277 | endpos--; |
| 278 | sep = *p; |
| 279 | *endpos = '\0'; |
| 280 | /* TODO: maybe special fopen for VMS? */ |
| 281 | fp = fopen(hdrfile, FOPEN_READTEXT); |
| 282 | if(!fp) |
| 283 | warnf(config->global, "Cannot read from %s: %s\n", hdrfile, |
| 284 | strerror(errno)); |
| 285 | else { |
| 286 | int i = read_field_headers(config, hdrfile, fp, &headers); |
| 287 | |
| 288 | fclose(fp); |
| 289 | if(i) { |
| 290 | curl_slist_free_all(headers); |
| 291 | return -1; |
| 292 | } |
| 293 | } |
| 294 | } |
| 295 | else { |
| 296 | char *hdr; |
| 297 | |
| 298 | while(ISSPACE(*p)) |
| 299 | p++; |
| 300 | tp = p; |
| 301 | hdr = get_param_word(&p, &endpos, endchar); |
| 302 | /* If not quoted, strip trailing spaces. */ |
| 303 | if(hdr == tp) |
| 304 | while(endpos > hdr && ISSPACE(endpos[-1])) |
| 305 | endpos--; |
| 306 | sep = *p; |
| 307 | *endpos = '\0'; |
| 308 | if(slist_append(&headers, hdr)) { |
| 309 | fprintf(config->global->errors, "Out of memory for field header!\n"); |
| 310 | curl_slist_free_all(headers); |
| 311 | return -1; |
| 312 | } |
| 313 | } |
| 314 | } |
| 315 | else if(checkprefix("encoder=", p)) { |
| 316 | if(endct) { |
| 317 | *endct = '\0'; |
| 318 | endct = NULL; |
| 319 | } |
| 320 | for(p += 8; ISSPACE(*p); p++) |
| 321 | ; |
| 322 | tp = p; |
| 323 | encoder = get_param_word(&p, &endpos, endchar); |
| 324 | /* If not quoted, strip trailing spaces. */ |
| 325 | if(encoder == tp) |
| 326 | while(endpos > encoder && ISSPACE(endpos[-1])) |
| 327 | endpos--; |
| 328 | sep = *p; |
| 329 | *endpos = '\0'; |
| 330 | } |
| 331 | else if(endct) { |
| 332 | /* This is part of content type. */ |
| 333 | for(endct = p; *p && *p != ';' && *p != endchar; p++) |
| 334 | if(!ISSPACE(*p)) |
| 335 | endct = p + 1; |
| 336 | sep = *p; |
| 337 | } |
| 338 | else { |
| 339 | /* unknown prefix, skip to next block */ |
| 340 | char *unknown = get_param_word(&p, &endpos, endchar); |
| 341 | |
| 342 | sep = *p; |
| 343 | *endpos = '\0'; |
| 344 | if(*unknown) |
| 345 | warnf(config->global, "skip unknown form field: %s\n", unknown); |
| 346 | } |
| 347 | } |
| 348 | |
| 349 | /* Terminate content type. */ |
| 350 | if(endct) |
| 351 | *endct = '\0'; |
| 352 | |
| 353 | if(ptype) |
| 354 | *ptype = type; |
| 355 | else if(type) |
| 356 | warnf(config->global, "Field content type not allowed here: %s\n", type); |
| 357 | |
| 358 | if(pfilename) |
| 359 | *pfilename = filename; |
| 360 | else if(filename) |
| 361 | warnf(config->global, |
| 362 | "Field file name not allowed here: %s\n", filename); |
| 363 | |
| 364 | if(pencoder) |
| 365 | *pencoder = encoder; |
| 366 | else if(encoder) |
| 367 | warnf(config->global, |
| 368 | "Field encoder not allowed here: %s\n", encoder); |
| 369 | |
| 370 | if(pheaders) |
| 371 | *pheaders = headers; |
| 372 | else if(headers) { |
| 373 | warnf(config->global, |
| 374 | "Field headers not allowed here: %s\n", headers->data); |
| 375 | curl_slist_free_all(headers); |
| 376 | } |
| 377 | |
| 378 | *str = p; |
| 379 | return sep & 0xFF; |
| 380 | } |
| 381 | |
| 382 | |
| 383 | /* Mime part callbacks for stdin. */ |
| 384 | static size_t stdin_read(char *buffer, size_t size, size_t nitems, void *arg) |
| 385 | { |
| 386 | standard_input *sip = (standard_input *) arg; |
| 387 | curl_off_t bytesleft; |
| 388 | (void) size; /* Always 1: ignored. */ |
| 389 | |
| 390 | if(sip->curpos >= sip->size) |
| 391 | return 0; /* At eof. */ |
| 392 | bytesleft = sip->size - sip->curpos; |
| 393 | if((curl_off_t) nitems > bytesleft) |
| 394 | nitems = (size_t) bytesleft; |
| 395 | if(sip->data) { |
| 396 | /* Return data from memory. */ |
| 397 | memcpy(buffer, sip->data + (size_t) sip->curpos, nitems); |
| 398 | } |
| 399 | else { |
| 400 | /* Read from stdin. */ |
| 401 | nitems = fread(buffer, 1, nitems, stdin); |
| 402 | } |
| 403 | sip->curpos += nitems; |
| 404 | return nitems; |
| 405 | } |
| 406 | |
| 407 | static int stdin_seek(void *instream, curl_off_t offset, int whence) |
| 408 | { |
| 409 | standard_input *sip = (standard_input *) instream; |
| 410 | |
| 411 | switch(whence) { |
| 412 | case SEEK_CUR: |
| 413 | offset += sip->curpos; |
| 414 | break; |
| 415 | case SEEK_END: |
| 416 | offset += sip->size; |
| 417 | break; |
| 418 | } |
| 419 | if(offset < 0) |
| 420 | return CURL_SEEKFUNC_CANTSEEK; |
| 421 | if(!sip->data) { |
| 422 | if(fseek(stdin, (long) (offset + sip->origin), SEEK_SET)) |
| 423 | return CURL_SEEKFUNC_CANTSEEK; |
| 424 | } |
| 425 | sip->curpos = offset; |
| 426 | return CURL_SEEKFUNC_OK; |
| 427 | } |
| 428 | |
| 429 | static void stdin_free(void *ptr) |
| 430 | { |
| 431 | standard_input *sip = (standard_input *) ptr; |
| 432 | |
| 433 | Curl_safefree(sip->data); |
| 434 | free(sip); |
| 435 | } |
| 436 | |
| 437 | /* Set a part's data from a file, taking care about the pseudo filename "-" as |
| 438 | * a shortcut to read stdin: if so, use a callback to read OUR stdin (to |
| 439 | * workaround Windows DLL file handle caveat). |
| 440 | * If stdin is a regular file opened in binary mode, save current offset as |
| 441 | * origin for rewind and do not buffer data. Else read to EOF and keep in |
| 442 | * memory. In all cases, compute the stdin data size. |
| 443 | */ |
| 444 | static CURLcode file_or_stdin(curl_mimepart *part, const char *file) |
| 445 | { |
| 446 | standard_input *sip = NULL; |
| 447 | int fd = -1; |
| 448 | CURLcode result = CURLE_OK; |
| 449 | struct_stat sbuf; |
| 450 | |
| 451 | if(strcmp(file, "-")) |
| 452 | return curl_mime_filedata(part, file); |
| 453 | |
| 454 | sip = (standard_input *) malloc(sizeof *sip); |
| 455 | if(!sip) |
| 456 | return CURLE_OUT_OF_MEMORY; |
| 457 | |
| 458 | memset((char *) sip, 0, sizeof *sip); |
| 459 | set_binmode(stdin); |
| 460 | |
| 461 | /* If stdin is a regular file, do not buffer data but read it when needed. */ |
| 462 | fd = fileno(stdin); |
| 463 | sip->origin = ftell(stdin); |
| 464 | if(fd >= 0 && sip->origin >= 0 && !fstat(fd, &sbuf) && |
| 465 | #ifdef __VMS |
| 466 | sbuf.st_fab_rfm != FAB$C_VAR && sbuf.st_fab_rfm != FAB$C_VFC && |
| 467 | #endif |
| 468 | S_ISREG(sbuf.st_mode)) { |
| 469 | sip->size = sbuf.st_size - sip->origin; |
| 470 | if(sip->size < 0) |
| 471 | sip->size = 0; |
| 472 | } |
| 473 | else { /* Not suitable for direct use, buffer stdin data. */ |
| 474 | size_t stdinsize = 0; |
| 475 | |
| 476 | sip->origin = 0; |
| 477 | if(file2memory(&sip->data, &stdinsize, stdin) != PARAM_OK) |
| 478 | result = CURLE_OUT_OF_MEMORY; |
| 479 | else { |
| 480 | if(!stdinsize) |
| 481 | sip->data = NULL; /* Has been freed if no data. */ |
| 482 | sip->size = stdinsize; |
| 483 | if(ferror(stdin)) |
| 484 | result = CURLE_READ_ERROR; |
| 485 | } |
| 486 | } |
| 487 | |
| 488 | /* Set remote file name. */ |
| 489 | if(!result) |
| 490 | result = curl_mime_filename(part, file); |
| 491 | |
| 492 | /* Set part's data from callback. */ |
| 493 | if(!result) |
| 494 | result = curl_mime_data_cb(part, sip->size, |
| 495 | stdin_read, stdin_seek, stdin_free, sip); |
| 496 | if(result) |
| 497 | stdin_free(sip); |
| 498 | return result; |
| 499 | } |
| 500 | |
| 501 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 502 | /*************************************************************************** |
| 503 | * |
| 504 | * formparse() |
| 505 | * |
| 506 | * Reads a 'name=value' parameter and builds the appropriate linked list. |
| 507 | * |
| 508 | * Specify files to upload with 'name=@filename', or 'name=@"filename"' |
| 509 | * in case the filename contain ',' or ';'. Supports specified |
| 510 | * given Content-Type of the files. Such as ';type=<content-type>'. |
| 511 | * |
| 512 | * If literal_value is set, any initial '@' or '<' in the value string |
| 513 | * loses its special meaning, as does any embedded ';type='. |
| 514 | * |
| 515 | * You may specify more than one file for a single name (field). Specify |
| 516 | * multiple files by writing it like: |
| 517 | * |
| 518 | * 'name=@filename,filename2,filename3' |
| 519 | * |
| 520 | * or use double-quotes quote the filename: |
| 521 | * |
| 522 | * 'name=@"filename","filename2","filename3"' |
| 523 | * |
| 524 | * If you want content-types specified for each too, write them like: |
| 525 | * |
| 526 | * 'name=@filename;type=image/gif,filename2,filename3' |
| 527 | * |
| 528 | * If you want custom headers added for a single part, write them in a separate |
| 529 | * file and do like this: |
| 530 | * |
| 531 | * 'name=foo;headers=@headerfile' or why not |
| 532 | * 'name=@filemame;headers=@headerfile' |
| 533 | * |
| 534 | * To upload a file, but to fake the file name that will be included in the |
| 535 | * formpost, do like this: |
| 536 | * |
| 537 | * 'name=@filename;filename=/dev/null' or quote the faked filename like: |
| 538 | * 'name=@filename;filename="play, play, and play.txt"' |
| 539 | * |
| 540 | * If filename/path contains ',' or ';', it must be quoted by double-quotes, |
| 541 | * else curl will fail to figure out the correct filename. if the filename |
| 542 | * tobe quoted contains '"' or '\', '"' and '\' must be escaped by backslash. |
| 543 | * |
| 544 | * This function uses curl_formadd to fulfill it's job. Is heavily based on |
| 545 | * the old curl_formparse code. |
| 546 | * |
| 547 | ***************************************************************************/ |
| 548 | |
| 549 | int formparse(struct OperationConfig *config, |
| 550 | const char *input, |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 551 | curl_mime **mimepost, |
| 552 | curl_mime **mimecurrent, |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 553 | bool literal_value) |
| 554 | { |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 555 | /* input MUST be a string in the format 'name=contents' and we'll |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 556 | build a linked list with the info */ |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 557 | char *name = NULL; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 558 | char *contents = NULL; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 559 | char *contp; |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 560 | char *data; |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 561 | char *type = NULL; |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 562 | char *filename = NULL; |
| 563 | char *encoder = NULL; |
| 564 | struct curl_slist *headers = NULL; |
| 565 | curl_mimepart *part = NULL; |
| 566 | CURLcode res; |
| 567 | int sep = '\0'; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 568 | |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 569 | /* Allocate the main mime structure if needed. */ |
| 570 | if(!*mimepost) { |
| 571 | *mimepost = curl_mime_init(config->easy); |
| 572 | if(!*mimepost) { |
| 573 | warnf(config->global, "curl_mime_init failed!\n"); |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 574 | return 1; |
| 575 | } |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 576 | *mimecurrent = *mimepost; |
| 577 | } |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 578 | |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 579 | /* Make a copy we can overwrite. */ |
| 580 | contents = strdup(input); |
| 581 | if(!contents) { |
| 582 | fprintf(config->global->errors, "out of memory\n"); |
| 583 | return 2; |
| 584 | } |
| 585 | |
| 586 | /* Scan for the end of the name. */ |
| 587 | contp = strchr(contents, '='); |
| 588 | if(contp) { |
| 589 | if(contp > contents) |
| 590 | name = contents; |
| 591 | *contp++ = '\0'; |
| 592 | |
| 593 | if(*contp == '(' && !literal_value) { |
| 594 | curl_mime *subparts; |
| 595 | |
| 596 | /* Starting a multipart. */ |
| 597 | sep = get_param_part(config, '\0', |
| 598 | &contp, &data, &type, NULL, NULL, &headers); |
| 599 | if(sep < 0) { |
| 600 | Curl_safefree(contents); |
| 601 | return 3; |
| 602 | } |
| 603 | subparts = curl_mime_init(config->easy); |
| 604 | if(!subparts) { |
| 605 | warnf(config->global, "curl_mime_init failed!\n"); |
| 606 | curl_slist_free_all(headers); |
| 607 | Curl_safefree(contents); |
| 608 | return 4; |
| 609 | } |
| 610 | part = curl_mime_addpart(*mimecurrent); |
| 611 | if(!part) { |
| 612 | warnf(config->global, "curl_mime_addpart failed!\n"); |
| 613 | curl_mime_free(subparts); |
| 614 | curl_slist_free_all(headers); |
| 615 | Curl_safefree(contents); |
| 616 | return 5; |
| 617 | } |
| 618 | if(curl_mime_subparts(part, subparts)) { |
| 619 | warnf(config->global, "curl_mime_subparts failed!\n"); |
| 620 | curl_mime_free(subparts); |
| 621 | curl_slist_free_all(headers); |
| 622 | Curl_safefree(contents); |
| 623 | return 6; |
| 624 | } |
| 625 | *mimecurrent = subparts; |
| 626 | if(curl_mime_headers(part, headers, 1)) { |
| 627 | warnf(config->global, "curl_mime_headers failed!\n"); |
| 628 | curl_slist_free_all(headers); |
| 629 | Curl_safefree(contents); |
| 630 | return 7; |
| 631 | } |
| 632 | if(curl_mime_type(part, type)) { |
| 633 | warnf(config->global, "curl_mime_type failed!\n"); |
| 634 | Curl_safefree(contents); |
| 635 | return 8; |
| 636 | } |
| 637 | } |
| 638 | else if(!name && !strcmp(contp, ")") && !literal_value) { |
| 639 | /* Ending a mutipart. */ |
| 640 | if(*mimecurrent == *mimepost) { |
| 641 | warnf(config->global, "no multipart to terminate!\n"); |
| 642 | Curl_safefree(contents); |
| 643 | return 9; |
| 644 | } |
| 645 | *mimecurrent = (*mimecurrent)->parent->parent; |
| 646 | } |
| 647 | else if('@' == contp[0] && !literal_value) { |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 648 | |
| 649 | /* we use the @-letter to indicate file name(s) */ |
| 650 | |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 651 | curl_mime *subparts = NULL; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 652 | |
| 653 | do { |
| 654 | /* since this was a file, it may have a content-type specifier |
| 655 | at the end too, or a filename. Or both. */ |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 656 | ++contp; |
| 657 | sep = get_param_part(config, ',', &contp, |
| 658 | &data, &type, &filename, &encoder, &headers); |
| 659 | if(sep < 0) { |
| 660 | if(subparts != *mimecurrent) |
| 661 | curl_mime_free(subparts); |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 662 | Curl_safefree(contents); |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 663 | return 10; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 664 | } |
| 665 | |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 666 | /* now contp point to comma or string end. |
| 667 | If more files to come, make sure we have multiparts. */ |
| 668 | if(!subparts) { |
| 669 | if(sep != ',') /* If there is a single file. */ |
| 670 | subparts = *mimecurrent; |
| 671 | else { |
| 672 | subparts = curl_mime_init(config->easy); |
| 673 | if(!subparts) { |
| 674 | warnf(config->global, "curl_mime_init failed!\n"); |
| 675 | curl_slist_free_all(headers); |
| 676 | Curl_safefree(contents); |
| 677 | return 11; |
| 678 | } |
| 679 | } |
| 680 | } |
| 681 | |
| 682 | /* Allocate a part for that file. */ |
| 683 | part = curl_mime_addpart(subparts); |
| 684 | if(!part) { |
| 685 | warnf(config->global, "curl_mime_addpart failed!\n"); |
| 686 | if(subparts != *mimecurrent) |
| 687 | curl_mime_free(subparts); |
| 688 | curl_slist_free_all(headers); |
| 689 | Curl_safefree(contents); |
| 690 | return 12; |
| 691 | } |
| 692 | |
| 693 | /* Set part headers. */ |
| 694 | if(curl_mime_headers(part, headers, 1)) { |
| 695 | warnf(config->global, "curl_mime_headers failed!\n"); |
| 696 | if(subparts != *mimecurrent) |
| 697 | curl_mime_free(subparts); |
| 698 | curl_slist_free_all(headers); |
| 699 | Curl_safefree(contents); |
| 700 | return 13; |
| 701 | } |
| 702 | |
| 703 | /* Setup file in part. */ |
| 704 | res = file_or_stdin(part, data); |
| 705 | if(res) { |
| 706 | warnf(config->global, "setting file %s failed!\n", data); |
| 707 | if(res != CURLE_READ_ERROR) { |
| 708 | if(subparts != *mimecurrent) |
| 709 | curl_mime_free(subparts); |
| 710 | Curl_safefree(contents); |
| 711 | return 14; |
| 712 | } |
| 713 | } |
| 714 | if(filename && curl_mime_filename(part, filename)) { |
| 715 | warnf(config->global, "curl_mime_filename failed!\n"); |
| 716 | if(subparts != *mimecurrent) |
| 717 | curl_mime_free(subparts); |
| 718 | Curl_safefree(contents); |
| 719 | return 15; |
| 720 | } |
| 721 | if(curl_mime_type(part, type)) { |
| 722 | warnf(config->global, "curl_mime_type failed!\n"); |
| 723 | if(subparts != *mimecurrent) |
| 724 | curl_mime_free(subparts); |
| 725 | Curl_safefree(contents); |
| 726 | return 16; |
| 727 | } |
| 728 | if(curl_mime_encoder(part, encoder)) { |
| 729 | warnf(config->global, "curl_mime_encoder failed!\n"); |
| 730 | if(subparts != *mimecurrent) |
| 731 | curl_mime_free(subparts); |
| 732 | Curl_safefree(contents); |
| 733 | return 17; |
| 734 | } |
| 735 | |
| 736 | /* *contp could be '\0', so we just check with the delimiter */ |
| 737 | } while(sep); /* loop if there's another file name */ |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 738 | |
| 739 | /* now we add the multiple files section */ |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 740 | if(subparts != *mimecurrent) { |
| 741 | part = curl_mime_addpart(*mimecurrent); |
| 742 | if(!part) { |
| 743 | warnf(config->global, "curl_mime_addpart failed!\n"); |
| 744 | curl_mime_free(subparts); |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 745 | Curl_safefree(contents); |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 746 | return 18; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 747 | } |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 748 | if(curl_mime_subparts(part, subparts)) { |
| 749 | warnf(config->global, "curl_mime_subparts failed!\n"); |
| 750 | curl_mime_free(subparts); |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 751 | Curl_safefree(contents); |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 752 | return 19; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 753 | } |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 754 | } |
| 755 | } |
| 756 | else { |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 757 | /* Allocate a mime part. */ |
| 758 | part = curl_mime_addpart(*mimecurrent); |
| 759 | if(!part) { |
| 760 | warnf(config->global, "curl_mime_addpart failed!\n"); |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 761 | Curl_safefree(contents); |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 762 | return 20; |
| 763 | } |
| 764 | |
| 765 | if(*contp == '<' && !literal_value) { |
| 766 | ++contp; |
| 767 | sep = get_param_part(config, '\0', &contp, |
| 768 | &data, &type, NULL, &encoder, &headers); |
| 769 | if(sep < 0) { |
| 770 | Curl_safefree(contents); |
| 771 | return 21; |
| 772 | } |
| 773 | |
| 774 | /* Set part headers. */ |
| 775 | if(curl_mime_headers(part, headers, 1)) { |
| 776 | warnf(config->global, "curl_mime_headers failed!\n"); |
| 777 | curl_slist_free_all(headers); |
| 778 | Curl_safefree(contents); |
| 779 | return 22; |
| 780 | } |
| 781 | |
| 782 | /* Setup file in part. */ |
| 783 | res = file_or_stdin(part, data); |
| 784 | if(res) { |
| 785 | warnf(config->global, "setting file %s failed!\n", data); |
| 786 | if(res != CURLE_READ_ERROR) { |
| 787 | Curl_safefree(contents); |
| 788 | return 23; |
| 789 | } |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 790 | } |
| 791 | } |
| 792 | else { |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 793 | if(literal_value) |
| 794 | data = contp; |
| 795 | else { |
| 796 | sep = get_param_part(config, '\0', &contp, |
| 797 | &data, &type, &filename, &encoder, &headers); |
| 798 | if(sep < 0) { |
| 799 | Curl_safefree(contents); |
| 800 | return 24; |
| 801 | } |
| 802 | } |
| 803 | |
| 804 | /* Set part headers. */ |
| 805 | if(curl_mime_headers(part, headers, 1)) { |
| 806 | warnf(config->global, "curl_mime_headers failed!\n"); |
| 807 | curl_slist_free_all(headers); |
| 808 | Curl_safefree(contents); |
| 809 | return 25; |
| 810 | } |
| 811 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 812 | #ifdef CURL_DOES_CONVERSIONS |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 813 | if(convert_to_network(data, strlen(data))) { |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 814 | warnf(config->global, "curl_formadd failed!\n"); |
| 815 | Curl_safefree(contents); |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 816 | return 26; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 817 | } |
| 818 | #endif |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 819 | |
| 820 | if(curl_mime_data(part, data, CURL_ZERO_TERMINATED)) { |
| 821 | warnf(config->global, "curl_mime_data failed!\n"); |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 822 | Curl_safefree(contents); |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 823 | return 27; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 824 | } |
| 825 | } |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 826 | |
| 827 | if(curl_mime_filename(part, filename)) { |
| 828 | warnf(config->global, "curl_mime_filename failed!\n"); |
| 829 | Curl_safefree(contents); |
| 830 | return 28; |
| 831 | } |
| 832 | if(curl_mime_type(part, type)) { |
| 833 | warnf(config->global, "curl_mime_type failed!\n"); |
| 834 | Curl_safefree(contents); |
| 835 | return 29; |
| 836 | } |
| 837 | if(curl_mime_encoder(part, encoder)) { |
| 838 | warnf(config->global, "curl_mime_encoder failed!\n"); |
| 839 | Curl_safefree(contents); |
| 840 | return 30; |
| 841 | } |
| 842 | |
| 843 | if(sep) { |
| 844 | *contp = (char) sep; |
| 845 | warnf(config->global, |
| 846 | "garbage at end of field specification: %s\n", contp); |
| 847 | } |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 848 | } |
| 849 | |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 850 | /* Set part name. */ |
| 851 | if(name && curl_mime_name(part, name)) { |
| 852 | warnf(config->global, "curl_mime_name failed!\n"); |
| 853 | Curl_safefree(contents); |
| 854 | return 31; |
| 855 | } |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 856 | } |
| 857 | else { |
| 858 | warnf(config->global, "Illegally formatted input field!\n"); |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 859 | Curl_safefree(contents); |
| 860 | return 32; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 861 | } |
| 862 | Curl_safefree(contents); |
| 863 | return 0; |
| 864 | } |