[352] | 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 | #include "tool_setup.h"
|
---|
| 23 |
|
---|
| 24 | #include "mime.h"
|
---|
| 25 | #include "strcase.h"
|
---|
| 26 |
|
---|
| 27 | #define ENABLE_CURLX_PRINTF
|
---|
| 28 | /* use our own printf() functions */
|
---|
| 29 | #include "curlx.h"
|
---|
| 30 |
|
---|
| 31 | #include "tool_cfgable.h"
|
---|
| 32 | #include "tool_convert.h"
|
---|
| 33 | #include "tool_msgs.h"
|
---|
| 34 | #include "tool_binmode.h"
|
---|
| 35 | #include "tool_getparam.h"
|
---|
| 36 | #include "tool_paramhlp.h"
|
---|
| 37 | #include "tool_formparse.h"
|
---|
| 38 |
|
---|
| 39 | #include "memdebug.h" /* keep this as LAST include */
|
---|
| 40 |
|
---|
| 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 |
|
---|
| 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 | */
|
---|
| 55 | static char *get_param_word(char **str, char **end_pos, char endchar)
|
---|
| 56 | {
|
---|
| 57 | char *ptr = *str;
|
---|
| 58 | char *word_begin = NULL;
|
---|
| 59 | char *ptr2;
|
---|
| 60 | char *escape = NULL;
|
---|
| 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 | }
|
---|
| 90 | while(*ptr && *ptr != ';' && *ptr != endchar)
|
---|
| 91 | ++ptr;
|
---|
| 92 | *str = ptr;
|
---|
| 93 | return word_begin + 1;
|
---|
| 94 | }
|
---|
| 95 | ++ptr;
|
---|
| 96 | }
|
---|
| 97 | /* end quote is missing, treat it as non-quoted. */
|
---|
| 98 | ptr = word_begin;
|
---|
| 99 | }
|
---|
| 100 |
|
---|
| 101 | while(*ptr && *ptr != ';' && *ptr != endchar)
|
---|
| 102 | ++ptr;
|
---|
| 103 | *str = *end_pos = ptr;
|
---|
| 104 | return word_begin;
|
---|
| 105 | }
|
---|
| 106 |
|
---|
| 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 |
|
---|
| 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,
|
---|
| 551 | curl_mime **mimepost,
|
---|
| 552 | curl_mime **mimecurrent,
|
---|
| 553 | bool literal_value)
|
---|
| 554 | {
|
---|
| 555 | /* input MUST be a string in the format 'name=contents' and we'll
|
---|
| 556 | build a linked list with the info */
|
---|
| 557 | char *name = NULL;
|
---|
| 558 | char *contents = NULL;
|
---|
| 559 | char *contp;
|
---|
| 560 | char *data;
|
---|
| 561 | char *type = NULL;
|
---|
| 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';
|
---|
| 568 |
|
---|
| 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");
|
---|
| 574 | return 1;
|
---|
| 575 | }
|
---|
| 576 | *mimecurrent = *mimepost;
|
---|
| 577 | }
|
---|
| 578 |
|
---|
| 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) {
|
---|
| 648 |
|
---|
| 649 | /* we use the @-letter to indicate file name(s) */
|
---|
| 650 |
|
---|
| 651 | curl_mime *subparts = NULL;
|
---|
| 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. */
|
---|
| 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);
|
---|
| 662 | Curl_safefree(contents);
|
---|
| 663 | return 10;
|
---|
| 664 | }
|
---|
| 665 |
|
---|
| 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 */
|
---|
| 738 |
|
---|
| 739 | /* now we add the multiple files section */
|
---|
| 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);
|
---|
| 745 | Curl_safefree(contents);
|
---|
| 746 | return 18;
|
---|
| 747 | }
|
---|
| 748 | if(curl_mime_subparts(part, subparts)) {
|
---|
| 749 | warnf(config->global, "curl_mime_subparts failed!\n");
|
---|
| 750 | curl_mime_free(subparts);
|
---|
| 751 | Curl_safefree(contents);
|
---|
| 752 | return 19;
|
---|
| 753 | }
|
---|
| 754 | }
|
---|
| 755 | }
|
---|
| 756 | else {
|
---|
| 757 | /* Allocate a mime part. */
|
---|
| 758 | part = curl_mime_addpart(*mimecurrent);
|
---|
| 759 | if(!part) {
|
---|
| 760 | warnf(config->global, "curl_mime_addpart failed!\n");
|
---|
| 761 | Curl_safefree(contents);
|
---|
| 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 | }
|
---|
| 790 | }
|
---|
| 791 | }
|
---|
| 792 | else {
|
---|
| 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 |
|
---|
| 812 | #ifdef CURL_DOES_CONVERSIONS
|
---|
| 813 | if(convert_to_network(data, strlen(data))) {
|
---|
| 814 | warnf(config->global, "curl_formadd failed!\n");
|
---|
| 815 | Curl_safefree(contents);
|
---|
| 816 | return 26;
|
---|
| 817 | }
|
---|
| 818 | #endif
|
---|
| 819 |
|
---|
| 820 | if(curl_mime_data(part, data, CURL_ZERO_TERMINATED)) {
|
---|
| 821 | warnf(config->global, "curl_mime_data failed!\n");
|
---|
| 822 | Curl_safefree(contents);
|
---|
| 823 | return 27;
|
---|
| 824 | }
|
---|
| 825 | }
|
---|
| 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 | }
|
---|
| 848 | }
|
---|
| 849 |
|
---|
| 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 | }
|
---|
| 856 | }
|
---|
| 857 | else {
|
---|
| 858 | warnf(config->global, "Illegally formatted input field!\n");
|
---|
| 859 | Curl_safefree(contents);
|
---|
| 860 | return 32;
|
---|
| 861 | }
|
---|
| 862 | Curl_safefree(contents);
|
---|
| 863 | return 0;
|
---|
| 864 | }
|
---|