Annotation of embedaddon/curl/src/tool_operate.c, revision 1.1
1.1 ! misho 1: /***************************************************************************
! 2: * _ _ ____ _
! 3: * Project ___| | | | _ \| |
! 4: * / __| | | | |_) | |
! 5: * | (__| |_| | _ <| |___
! 6: * \___|\___/|_| \_\_____|
! 7: *
! 8: * Copyright (C) 1998 - 2020, 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: #ifdef HAVE_FCNTL_H
! 25: # include <fcntl.h>
! 26: #endif
! 27:
! 28: #ifdef HAVE_LOCALE_H
! 29: # include <locale.h>
! 30: #endif
! 31:
! 32: #ifdef HAVE_SYS_SELECT_H
! 33: # include <sys/select.h>
! 34: #elif defined(HAVE_UNISTD_H)
! 35: # include <unistd.h>
! 36: #endif
! 37:
! 38: #ifdef __VMS
! 39: # include <fabdef.h>
! 40: #endif
! 41:
! 42: #ifdef __AMIGA__
! 43: # include <proto/dos.h>
! 44: #endif
! 45:
! 46: #include "strcase.h"
! 47:
! 48: #define ENABLE_CURLX_PRINTF
! 49: /* use our own printf() functions */
! 50: #include "curlx.h"
! 51:
! 52: #include "tool_binmode.h"
! 53: #include "tool_cfgable.h"
! 54: #include "tool_cb_dbg.h"
! 55: #include "tool_cb_hdr.h"
! 56: #include "tool_cb_prg.h"
! 57: #include "tool_cb_rea.h"
! 58: #include "tool_cb_see.h"
! 59: #include "tool_cb_wrt.h"
! 60: #include "tool_dirhie.h"
! 61: #include "tool_doswin.h"
! 62: #include "tool_easysrc.h"
! 63: #include "tool_filetime.h"
! 64: #include "tool_getparam.h"
! 65: #include "tool_helpers.h"
! 66: #include "tool_homedir.h"
! 67: #include "tool_libinfo.h"
! 68: #include "tool_main.h"
! 69: #include "tool_metalink.h"
! 70: #include "tool_msgs.h"
! 71: #include "tool_operate.h"
! 72: #include "tool_operhlp.h"
! 73: #include "tool_paramhlp.h"
! 74: #include "tool_parsecfg.h"
! 75: #include "tool_setopt.h"
! 76: #include "tool_sleep.h"
! 77: #include "tool_urlglob.h"
! 78: #include "tool_util.h"
! 79: #include "tool_writeout.h"
! 80: #include "tool_xattr.h"
! 81: #include "tool_vms.h"
! 82: #include "tool_help.h"
! 83: #include "tool_hugehelp.h"
! 84: #include "tool_progress.h"
! 85:
! 86: #include "memdebug.h" /* keep this as LAST include */
! 87:
! 88: #ifdef CURLDEBUG
! 89: /* libcurl's debug builds provide an extra function */
! 90: CURLcode curl_easy_perform_ev(CURL *easy);
! 91: #endif
! 92:
! 93: #define CURLseparator "--_curl_--"
! 94:
! 95: #ifndef O_BINARY
! 96: /* since O_BINARY as used in bitmasks, setting it to zero makes it usable in
! 97: source code but yet it doesn't ruin anything */
! 98: # define O_BINARY 0
! 99: #endif
! 100:
! 101: #define CURL_CA_CERT_ERRORMSG \
! 102: "More details here: https://curl.haxx.se/docs/sslcerts.html\n\n" \
! 103: "curl failed to verify the legitimacy of the server and therefore " \
! 104: "could not\nestablish a secure connection to it. To learn more about " \
! 105: "this situation and\nhow to fix it, please visit the web page mentioned " \
! 106: "above.\n"
! 107:
! 108: static CURLcode single_transfer(struct GlobalConfig *global,
! 109: struct OperationConfig *config,
! 110: CURLSH *share,
! 111: bool capath_from_env,
! 112: bool *added);
! 113: static CURLcode create_transfer(struct GlobalConfig *global,
! 114: CURLSH *share,
! 115: bool *added);
! 116:
! 117: static bool is_fatal_error(CURLcode code)
! 118: {
! 119: switch(code) {
! 120: case CURLE_FAILED_INIT:
! 121: case CURLE_OUT_OF_MEMORY:
! 122: case CURLE_UNKNOWN_OPTION:
! 123: case CURLE_FUNCTION_NOT_FOUND:
! 124: case CURLE_BAD_FUNCTION_ARGUMENT:
! 125: /* critical error */
! 126: return TRUE;
! 127: default:
! 128: break;
! 129: }
! 130:
! 131: /* no error or not critical */
! 132: return FALSE;
! 133: }
! 134:
! 135: /*
! 136: * Check if a given string is a PKCS#11 URI
! 137: */
! 138: static bool is_pkcs11_uri(const char *string)
! 139: {
! 140: if(curl_strnequal(string, "pkcs11:", 7)) {
! 141: return TRUE;
! 142: }
! 143: else {
! 144: return FALSE;
! 145: }
! 146: }
! 147:
! 148: #ifdef __VMS
! 149: /*
! 150: * get_vms_file_size does what it takes to get the real size of the file
! 151: *
! 152: * For fixed files, find out the size of the EOF block and adjust.
! 153: *
! 154: * For all others, have to read the entire file in, discarding the contents.
! 155: * Most posted text files will be small, and binary files like zlib archives
! 156: * and CD/DVD images should be either a STREAM_LF format or a fixed format.
! 157: *
! 158: */
! 159: static curl_off_t vms_realfilesize(const char *name,
! 160: const struct_stat *stat_buf)
! 161: {
! 162: char buffer[8192];
! 163: curl_off_t count;
! 164: int ret_stat;
! 165: FILE * file;
! 166:
! 167: /* !checksrc! disable FOPENMODE 1 */
! 168: file = fopen(name, "r"); /* VMS */
! 169: if(file == NULL) {
! 170: return 0;
! 171: }
! 172: count = 0;
! 173: ret_stat = 1;
! 174: while(ret_stat > 0) {
! 175: ret_stat = fread(buffer, 1, sizeof(buffer), file);
! 176: if(ret_stat != 0)
! 177: count += ret_stat;
! 178: }
! 179: fclose(file);
! 180:
! 181: return count;
! 182: }
! 183:
! 184: /*
! 185: *
! 186: * VmsSpecialSize checks to see if the stat st_size can be trusted and
! 187: * if not to call a routine to get the correct size.
! 188: *
! 189: */
! 190: static curl_off_t VmsSpecialSize(const char *name,
! 191: const struct_stat *stat_buf)
! 192: {
! 193: switch(stat_buf->st_fab_rfm) {
! 194: case FAB$C_VAR:
! 195: case FAB$C_VFC:
! 196: return vms_realfilesize(name, stat_buf);
! 197: break;
! 198: default:
! 199: return stat_buf->st_size;
! 200: }
! 201: }
! 202: #endif /* __VMS */
! 203:
! 204: #define BUFFER_SIZE (100*1024)
! 205:
! 206: struct per_transfer *transfers; /* first node */
! 207: static struct per_transfer *transfersl; /* last node */
! 208:
! 209: /* add_per_transfer creates a new 'per_transfer' node in the linked
! 210: list of transfers */
! 211: static CURLcode add_per_transfer(struct per_transfer **per)
! 212: {
! 213: struct per_transfer *p;
! 214: p = calloc(sizeof(struct per_transfer), 1);
! 215: if(!p)
! 216: return CURLE_OUT_OF_MEMORY;
! 217: if(!transfers)
! 218: /* first entry */
! 219: transfersl = transfers = p;
! 220: else {
! 221: /* make the last node point to the new node */
! 222: transfersl->next = p;
! 223: /* make the new node point back to the formerly last node */
! 224: p->prev = transfersl;
! 225: /* move the last node pointer to the new entry */
! 226: transfersl = p;
! 227: }
! 228: *per = p;
! 229: all_xfers++; /* count total number of transfers added */
! 230: return CURLE_OK;
! 231: }
! 232:
! 233: /* Remove the specified transfer from the list (and free it), return the next
! 234: in line */
! 235: static struct per_transfer *del_per_transfer(struct per_transfer *per)
! 236: {
! 237: struct per_transfer *n;
! 238: struct per_transfer *p;
! 239: DEBUGASSERT(transfers);
! 240: DEBUGASSERT(transfersl);
! 241: DEBUGASSERT(per);
! 242:
! 243: n = per->next;
! 244: p = per->prev;
! 245:
! 246: if(p)
! 247: p->next = n;
! 248: else
! 249: transfers = n;
! 250:
! 251: if(n)
! 252: n->prev = p;
! 253: else
! 254: transfersl = p;
! 255:
! 256: free(per);
! 257:
! 258: return n;
! 259: }
! 260:
! 261: static CURLcode pre_transfer(struct GlobalConfig *global,
! 262: struct per_transfer *per)
! 263: {
! 264: curl_off_t uploadfilesize = -1;
! 265: struct_stat fileinfo;
! 266: CURLcode result = CURLE_OK;
! 267:
! 268: if(per->separator_err)
! 269: fprintf(global->errors, "%s\n", per->separator_err);
! 270: if(per->separator)
! 271: printf("%s\n", per->separator);
! 272:
! 273: if(per->uploadfile && !stdin_upload(per->uploadfile)) {
! 274: /* VMS Note:
! 275: *
! 276: * Reading binary from files can be a problem... Only FIXED, VAR
! 277: * etc WITHOUT implied CC will work Others need a \n appended to a
! 278: * line
! 279: *
! 280: * - Stat gives a size but this is UNRELIABLE in VMS As a f.e. a
! 281: * fixed file with implied CC needs to have a byte added for every
! 282: * record processed, this can by derived from Filesize & recordsize
! 283: * for VARiable record files the records need to be counted! for
! 284: * every record add 1 for linefeed and subtract 2 for the record
! 285: * header for VARIABLE header files only the bare record data needs
! 286: * to be considered with one appended if implied CC
! 287: */
! 288: #ifdef __VMS
! 289: /* Calculate the real upload size for VMS */
! 290: per->infd = -1;
! 291: if(stat(per->uploadfile, &fileinfo) == 0) {
! 292: fileinfo.st_size = VmsSpecialSize(uploadfile, &fileinfo);
! 293: switch(fileinfo.st_fab_rfm) {
! 294: case FAB$C_VAR:
! 295: case FAB$C_VFC:
! 296: case FAB$C_STMCR:
! 297: per->infd = open(per->uploadfile, O_RDONLY | O_BINARY);
! 298: break;
! 299: default:
! 300: per->infd = open(per->uploadfile, O_RDONLY | O_BINARY,
! 301: "rfm=stmlf", "ctx=stm");
! 302: }
! 303: }
! 304: if(per->infd == -1)
! 305: #else
! 306: per->infd = open(per->uploadfile, O_RDONLY | O_BINARY);
! 307: if((per->infd == -1) || fstat(per->infd, &fileinfo))
! 308: #endif
! 309: {
! 310: helpf(global->errors, "Can't open '%s'!\n", per->uploadfile);
! 311: if(per->infd != -1) {
! 312: close(per->infd);
! 313: per->infd = STDIN_FILENO;
! 314: }
! 315: return CURLE_READ_ERROR;
! 316: }
! 317: per->infdopen = TRUE;
! 318:
! 319: /* we ignore file size for char/block devices, sockets, etc. */
! 320: if(S_ISREG(fileinfo.st_mode))
! 321: uploadfilesize = fileinfo.st_size;
! 322:
! 323: if(uploadfilesize != -1)
! 324: my_setopt(per->curl, CURLOPT_INFILESIZE_LARGE, uploadfilesize);
! 325: per->input.fd = per->infd;
! 326: }
! 327: return result;
! 328: }
! 329:
! 330: /*
! 331: * Call this after a transfer has completed.
! 332: */
! 333: static CURLcode post_per_transfer(struct GlobalConfig *global,
! 334: struct per_transfer *per,
! 335: CURLcode result,
! 336: bool *retryp)
! 337: {
! 338: struct OutStruct *outs = &per->outs;
! 339: CURL *curl = per->curl;
! 340: struct OperationConfig *config = per->config;
! 341:
! 342: if(!curl || !config)
! 343: return result;
! 344:
! 345: *retryp = FALSE;
! 346:
! 347: if(per->infdopen)
! 348: close(per->infd);
! 349:
! 350: #ifdef __VMS
! 351: if(is_vms_shell()) {
! 352: /* VMS DCL shell behavior */
! 353: if(!global->showerror)
! 354: vms_show = VMSSTS_HIDE;
! 355: }
! 356: else
! 357: #endif
! 358: if(config->synthetic_error) {
! 359: ;
! 360: }
! 361: else if(result && global->showerror) {
! 362: fprintf(global->errors, "curl: (%d) %s\n", result,
! 363: (per->errorbuffer[0]) ? per->errorbuffer :
! 364: curl_easy_strerror(result));
! 365: if(result == CURLE_PEER_FAILED_VERIFICATION)
! 366: fputs(CURL_CA_CERT_ERRORMSG, global->errors);
! 367: }
! 368:
! 369: /* Set file extended attributes */
! 370: if(!result && config->xattr && outs->fopened && outs->stream) {
! 371: int rc = fwrite_xattr(curl, fileno(outs->stream));
! 372: if(rc)
! 373: warnf(config->global, "Error setting extended attributes: %s\n",
! 374: strerror(errno));
! 375: }
! 376:
! 377: if(!result && !outs->stream && !outs->bytes) {
! 378: /* we have received no data despite the transfer was successful
! 379: ==> force cration of an empty output file (if an output file
! 380: was specified) */
! 381: long cond_unmet = 0L;
! 382: /* do not create (or even overwrite) the file in case we get no
! 383: data because of unmet condition */
! 384: curl_easy_getinfo(curl, CURLINFO_CONDITION_UNMET, &cond_unmet);
! 385: if(!cond_unmet && !tool_create_output_file(outs, config))
! 386: result = CURLE_WRITE_ERROR;
! 387: }
! 388:
! 389: if(!outs->s_isreg && outs->stream) {
! 390: /* Dump standard stream buffered data */
! 391: int rc = fflush(outs->stream);
! 392: if(!result && rc) {
! 393: /* something went wrong in the writing process */
! 394: result = CURLE_WRITE_ERROR;
! 395: fprintf(global->errors, "(%d) Failed writing body\n", result);
! 396: }
! 397: }
! 398:
! 399: #ifdef USE_METALINK
! 400: if(per->metalink && !per->metalink_next_res)
! 401: fprintf(global->errors, "Metalink: fetching (%s) from (%s) OK\n",
! 402: per->mlfile->filename, per->this_url);
! 403:
! 404: if(!per->metalink && config->use_metalink && result == CURLE_OK) {
! 405: int rv = parse_metalink(config, outs, per->this_url);
! 406: if(!rv) {
! 407: fprintf(config->global->errors, "Metalink: parsing (%s) OK\n",
! 408: per->this_url);
! 409: }
! 410: else if(rv == -1)
! 411: fprintf(config->global->errors, "Metalink: parsing (%s) FAILED\n",
! 412: per->this_url);
! 413: }
! 414: else if(per->metalink && result == CURLE_OK && !per->metalink_next_res) {
! 415: int rv;
! 416: (void)fflush(outs->stream);
! 417: rv = metalink_check_hash(global, per->mlfile, outs->filename);
! 418: if(!rv)
! 419: per->metalink_next_res = 1;
! 420: }
! 421: #endif /* USE_METALINK */
! 422:
! 423: #ifdef USE_METALINK
! 424: if(outs->metalink_parser)
! 425: metalink_parser_context_delete(outs->metalink_parser);
! 426: #endif /* USE_METALINK */
! 427:
! 428: if(outs->is_cd_filename && outs->stream && !global->mute &&
! 429: outs->filename)
! 430: printf("curl: Saved to filename '%s'\n", outs->filename);
! 431:
! 432: /* if retry-max-time is non-zero, make sure we haven't exceeded the
! 433: time */
! 434: if(per->retry_numretries &&
! 435: (!config->retry_maxtime ||
! 436: (tvdiff(tvnow(), per->retrystart) <
! 437: config->retry_maxtime*1000L)) ) {
! 438: enum {
! 439: RETRY_NO,
! 440: RETRY_TIMEOUT,
! 441: RETRY_CONNREFUSED,
! 442: RETRY_HTTP,
! 443: RETRY_FTP,
! 444: RETRY_LAST /* not used */
! 445: } retry = RETRY_NO;
! 446: long response;
! 447: if((CURLE_OPERATION_TIMEDOUT == result) ||
! 448: (CURLE_COULDNT_RESOLVE_HOST == result) ||
! 449: (CURLE_COULDNT_RESOLVE_PROXY == result) ||
! 450: (CURLE_FTP_ACCEPT_TIMEOUT == result))
! 451: /* retry timeout always */
! 452: retry = RETRY_TIMEOUT;
! 453: else if(config->retry_connrefused &&
! 454: (CURLE_COULDNT_CONNECT == result)) {
! 455: long oserrno;
! 456: curl_easy_getinfo(curl, CURLINFO_OS_ERRNO, &oserrno);
! 457: if(ECONNREFUSED == oserrno)
! 458: retry = RETRY_CONNREFUSED;
! 459: }
! 460: else if((CURLE_OK == result) ||
! 461: (config->failonerror &&
! 462: (CURLE_HTTP_RETURNED_ERROR == result))) {
! 463: /* If it returned OK. _or_ failonerror was enabled and it
! 464: returned due to such an error, check for HTTP transient
! 465: errors to retry on. */
! 466: long protocol;
! 467: curl_easy_getinfo(curl, CURLINFO_PROTOCOL, &protocol);
! 468: if((protocol == CURLPROTO_HTTP) || (protocol == CURLPROTO_HTTPS)) {
! 469: /* This was HTTP(S) */
! 470: curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response);
! 471:
! 472: switch(response) {
! 473: case 429: /* Too Many Requests (RFC6585) */
! 474: case 500: /* Internal Server Error */
! 475: case 502: /* Bad Gateway */
! 476: case 503: /* Service Unavailable */
! 477: case 504: /* Gateway Timeout */
! 478: retry = RETRY_HTTP;
! 479: /*
! 480: * At this point, we have already written data to the output
! 481: * file (or terminal). If we write to a file, we must rewind
! 482: * or close/re-open the file so that the next attempt starts
! 483: * over from the beginning.
! 484: *
! 485: * TODO: similar action for the upload case. We might need
! 486: * to start over reading from a previous point if we have
! 487: * uploaded something when this was returned.
! 488: */
! 489: break;
! 490: }
! 491: }
! 492: } /* if CURLE_OK */
! 493: else if(result) {
! 494: long protocol;
! 495:
! 496: curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response);
! 497: curl_easy_getinfo(curl, CURLINFO_PROTOCOL, &protocol);
! 498:
! 499: if((protocol == CURLPROTO_FTP || protocol == CURLPROTO_FTPS) &&
! 500: response / 100 == 4)
! 501: /*
! 502: * This is typically when the FTP server only allows a certain
! 503: * amount of users and we are not one of them. All 4xx codes
! 504: * are transient.
! 505: */
! 506: retry = RETRY_FTP;
! 507: }
! 508:
! 509: if(retry) {
! 510: long sleeptime = 0;
! 511: curl_off_t retry_after = 0;
! 512: static const char * const m[]={
! 513: NULL,
! 514: "timeout",
! 515: "connection refused",
! 516: "HTTP error",
! 517: "FTP error"
! 518: };
! 519:
! 520: sleeptime = per->retry_sleep;
! 521: if(RETRY_HTTP == retry) {
! 522: curl_easy_getinfo(curl, CURLINFO_RETRY_AFTER, &retry_after);
! 523: if(retry_after) {
! 524: /* store in a 'long', make sure it doesn't overflow */
! 525: if(retry_after > LONG_MAX/1000)
! 526: sleeptime = LONG_MAX;
! 527: else
! 528: sleeptime = (long)retry_after * 1000; /* milliseconds */
! 529: }
! 530: }
! 531: warnf(config->global, "Transient problem: %s "
! 532: "Will retry in %ld seconds. "
! 533: "%ld retries left.\n",
! 534: m[retry], sleeptime/1000L, per->retry_numretries);
! 535:
! 536: per->retry_numretries--;
! 537: tool_go_sleep(sleeptime);
! 538: if(!config->retry_delay) {
! 539: per->retry_sleep *= 2;
! 540: if(per->retry_sleep > RETRY_SLEEP_MAX)
! 541: per->retry_sleep = RETRY_SLEEP_MAX;
! 542: }
! 543: if(outs->bytes && outs->filename && outs->stream) {
! 544: int rc;
! 545: /* We have written data to a output file, we truncate file
! 546: */
! 547: if(!global->mute)
! 548: fprintf(global->errors, "Throwing away %"
! 549: CURL_FORMAT_CURL_OFF_T " bytes\n",
! 550: outs->bytes);
! 551: fflush(outs->stream);
! 552: /* truncate file at the position where we started appending */
! 553: #ifdef HAVE_FTRUNCATE
! 554: if(ftruncate(fileno(outs->stream), outs->init)) {
! 555: /* when truncate fails, we can't just append as then we'll
! 556: create something strange, bail out */
! 557: if(!global->mute)
! 558: fprintf(global->errors,
! 559: "failed to truncate, exiting\n");
! 560: return CURLE_WRITE_ERROR;
! 561: }
! 562: /* now seek to the end of the file, the position where we
! 563: just truncated the file in a large file-safe way */
! 564: rc = fseek(outs->stream, 0, SEEK_END);
! 565: #else
! 566: /* ftruncate is not available, so just reposition the file
! 567: to the location we would have truncated it. This won't
! 568: work properly with large files on 32-bit systems, but
! 569: most of those will have ftruncate. */
! 570: rc = fseek(outs->stream, (long)outs->init, SEEK_SET);
! 571: #endif
! 572: if(rc) {
! 573: if(!global->mute)
! 574: fprintf(global->errors,
! 575: "failed seeking to end of file, exiting\n");
! 576: return CURLE_WRITE_ERROR;
! 577: }
! 578: outs->bytes = 0; /* clear for next round */
! 579: }
! 580: *retryp = TRUE; /* curl_easy_perform loop */
! 581: return CURLE_OK;
! 582: }
! 583: } /* if retry_numretries */
! 584: else if(per->metalink) {
! 585: /* Metalink: Decide to try the next resource or not. Try the next resource
! 586: if download was not successful. */
! 587: long response;
! 588: if(CURLE_OK == result) {
! 589: /* TODO We want to try next resource when download was
! 590: not successful. How to know that? */
! 591: char *effective_url = NULL;
! 592: curl_easy_getinfo(curl, CURLINFO_EFFECTIVE_URL, &effective_url);
! 593: if(effective_url &&
! 594: curl_strnequal(effective_url, "http", 4)) {
! 595: /* This was HTTP(S) */
! 596: curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response);
! 597: if(response != 200 && response != 206) {
! 598: per->metalink_next_res = 1;
! 599: fprintf(global->errors,
! 600: "Metalink: fetching (%s) from (%s) FAILED "
! 601: "(HTTP status code %ld)\n",
! 602: per->mlfile->filename, per->this_url, response);
! 603: }
! 604: }
! 605: }
! 606: else {
! 607: per->metalink_next_res = 1;
! 608: fprintf(global->errors,
! 609: "Metalink: fetching (%s) from (%s) FAILED (%s)\n",
! 610: per->mlfile->filename, per->this_url,
! 611: curl_easy_strerror(result));
! 612: }
! 613: }
! 614:
! 615: if((global->progressmode == CURL_PROGRESS_BAR) &&
! 616: per->progressbar.calls)
! 617: /* if the custom progress bar has been displayed, we output a
! 618: newline here */
! 619: fputs("\n", per->progressbar.out);
! 620:
! 621: if(config->writeout)
! 622: ourWriteOut(per->curl, &per->outs, config->writeout);
! 623:
! 624: /* Close the outs file */
! 625: if(outs->fopened && outs->stream) {
! 626: int rc = fclose(outs->stream);
! 627: if(!result && rc) {
! 628: /* something went wrong in the writing process */
! 629: result = CURLE_WRITE_ERROR;
! 630: fprintf(global->errors, "(%d) Failed writing body\n", result);
! 631: }
! 632: }
! 633:
! 634: /* File time can only be set _after_ the file has been closed */
! 635: if(!result && config->remote_time && outs->s_isreg && outs->filename) {
! 636: /* Ask libcurl if we got a remote file time */
! 637: curl_off_t filetime = -1;
! 638: curl_easy_getinfo(curl, CURLINFO_FILETIME_T, &filetime);
! 639: setfiletime(filetime, outs->filename, config->global->errors);
! 640: }
! 641:
! 642: /* Close function-local opened file descriptors */
! 643: if(per->heads.fopened && per->heads.stream)
! 644: fclose(per->heads.stream);
! 645:
! 646: if(per->heads.alloc_filename)
! 647: Curl_safefree(per->heads.filename);
! 648:
! 649: if(per->etag_save.fopened && per->etag_save.stream)
! 650: fclose(per->etag_save.stream);
! 651:
! 652: if(per->etag_save.alloc_filename)
! 653: Curl_safefree(per->etag_save.filename);
! 654:
! 655: curl_easy_cleanup(per->curl);
! 656: if(outs->alloc_filename)
! 657: free(outs->filename);
! 658: free(per->this_url);
! 659: free(per->separator_err);
! 660: free(per->separator);
! 661: free(per->outfile);
! 662: free(per->uploadfile);
! 663:
! 664: return CURLE_OK;
! 665: }
! 666:
! 667: static void single_transfer_cleanup(struct OperationConfig *config)
! 668: {
! 669: if(config) {
! 670: struct State *state = &config->state;
! 671: if(state->urls) {
! 672: /* Free list of remaining URLs */
! 673: glob_cleanup(state->urls);
! 674: state->urls = NULL;
! 675: }
! 676: Curl_safefree(state->outfiles);
! 677: Curl_safefree(state->httpgetfields);
! 678: Curl_safefree(state->uploadfile);
! 679: if(state->inglob) {
! 680: /* Free list of globbed upload files */
! 681: glob_cleanup(state->inglob);
! 682: state->inglob = NULL;
! 683: }
! 684: }
! 685: }
! 686:
! 687: /* create the next (singular) transfer */
! 688:
! 689: static CURLcode single_transfer(struct GlobalConfig *global,
! 690: struct OperationConfig *config,
! 691: CURLSH *share,
! 692: bool capath_from_env,
! 693: bool *added)
! 694: {
! 695: CURLcode result = CURLE_OK;
! 696: struct getout *urlnode;
! 697: metalinkfile *mlfile_last = NULL;
! 698: bool orig_noprogress = global->noprogress;
! 699: bool orig_isatty = global->isatty;
! 700: struct State *state = &config->state;
! 701: char *httpgetfields = state->httpgetfields;
! 702: *added = FALSE; /* not yet */
! 703:
! 704: if(config->postfields) {
! 705: if(config->use_httpget) {
! 706: if(!httpgetfields) {
! 707: /* Use the postfields data for a http get */
! 708: httpgetfields = state->httpgetfields = strdup(config->postfields);
! 709: Curl_safefree(config->postfields);
! 710: if(!httpgetfields) {
! 711: errorf(global, "out of memory\n");
! 712: result = CURLE_OUT_OF_MEMORY;
! 713: }
! 714: else if(SetHTTPrequest(config,
! 715: (config->no_body?HTTPREQ_HEAD:HTTPREQ_GET),
! 716: &config->httpreq)) {
! 717: result = CURLE_FAILED_INIT;
! 718: }
! 719: }
! 720: }
! 721: else {
! 722: if(SetHTTPrequest(config, HTTPREQ_SIMPLEPOST, &config->httpreq))
! 723: result = CURLE_FAILED_INIT;
! 724: }
! 725: if(result) {
! 726: single_transfer_cleanup(config);
! 727: return result;
! 728: }
! 729: }
! 730: if(!state->urlnode) {
! 731: /* first time caller, setup things */
! 732: state->urlnode = config->url_list;
! 733: state->infilenum = 1;
! 734: }
! 735:
! 736: while(config->state.urlnode) {
! 737: char *infiles; /* might be a glob pattern */
! 738: URLGlob *inglob = state->inglob;
! 739: bool metalink = FALSE; /* metalink download? */
! 740: metalinkfile *mlfile;
! 741: metalink_resource *mlres;
! 742:
! 743: urlnode = config->state.urlnode;
! 744: if(urlnode->flags & GETOUT_METALINK) {
! 745: metalink = 1;
! 746: if(mlfile_last == NULL) {
! 747: mlfile_last = config->metalinkfile_list;
! 748: }
! 749: mlfile = mlfile_last;
! 750: mlfile_last = mlfile_last->next;
! 751: mlres = mlfile->resource;
! 752: }
! 753: else {
! 754: mlfile = NULL;
! 755: mlres = NULL;
! 756: }
! 757:
! 758: /* urlnode->url is the full URL (it might be NULL) */
! 759:
! 760: if(!urlnode->url) {
! 761: /* This node has no URL. Free node data without destroying the
! 762: node itself nor modifying next pointer and continue to next */
! 763: Curl_safefree(urlnode->outfile);
! 764: Curl_safefree(urlnode->infile);
! 765: urlnode->flags = 0;
! 766: config->state.urlnode = urlnode->next;
! 767: state->up = 0;
! 768: continue; /* next URL please */
! 769: }
! 770:
! 771: /* save outfile pattern before expansion */
! 772: if(urlnode->outfile && !state->outfiles) {
! 773: state->outfiles = strdup(urlnode->outfile);
! 774: if(!state->outfiles) {
! 775: errorf(global, "out of memory\n");
! 776: result = CURLE_OUT_OF_MEMORY;
! 777: break;
! 778: }
! 779: }
! 780:
! 781: infiles = urlnode->infile;
! 782:
! 783: if(!config->globoff && infiles && !inglob) {
! 784: /* Unless explicitly shut off */
! 785: result = glob_url(&inglob, infiles, &state->infilenum,
! 786: global->showerror?global->errors:NULL);
! 787: if(result)
! 788: break;
! 789: config->state.inglob = inglob;
! 790: }
! 791:
! 792: {
! 793: int separator;
! 794: unsigned long urlnum;
! 795:
! 796: if(!state->up && !infiles)
! 797: Curl_nop_stmt;
! 798: else {
! 799: if(!state->uploadfile) {
! 800: if(inglob) {
! 801: result = glob_next_url(&state->uploadfile, inglob);
! 802: if(result == CURLE_OUT_OF_MEMORY)
! 803: errorf(global, "out of memory\n");
! 804: }
! 805: else if(!state->up) {
! 806: state->uploadfile = strdup(infiles);
! 807: if(!state->uploadfile) {
! 808: errorf(global, "out of memory\n");
! 809: result = CURLE_OUT_OF_MEMORY;
! 810: }
! 811: }
! 812: }
! 813: if(result)
! 814: break;
! 815: }
! 816:
! 817: if(!state->urlnum) {
! 818: if(metalink) {
! 819: /* For Metalink download, we don't use glob. Instead we use
! 820: the number of resources as urlnum. */
! 821: urlnum = count_next_metalink_resource(mlfile);
! 822: }
! 823: else if(!config->globoff) {
! 824: /* Unless explicitly shut off, we expand '{...}' and '[...]'
! 825: expressions and return total number of URLs in pattern set */
! 826: result = glob_url(&state->urls, urlnode->url, &state->urlnum,
! 827: global->showerror?global->errors:NULL);
! 828: if(result)
! 829: break;
! 830: urlnum = state->urlnum;
! 831: }
! 832: else
! 833: urlnum = 1; /* without globbing, this is a single URL */
! 834: }
! 835: else
! 836: urlnum = state->urlnum;
! 837:
! 838: /* if multiple files extracted to stdout, insert separators! */
! 839: separator = ((!state->outfiles ||
! 840: !strcmp(state->outfiles, "-")) && urlnum > 1);
! 841:
! 842: if(state->up < state->infilenum) {
! 843: struct per_transfer *per;
! 844: struct OutStruct *outs;
! 845: struct InStruct *input;
! 846: struct OutStruct *heads;
! 847: struct OutStruct *etag_save;
! 848: struct HdrCbData *hdrcbdata = NULL;
! 849: CURL *curl = curl_easy_init();
! 850: result = add_per_transfer(&per);
! 851: if(result || !curl) {
! 852: curl_easy_cleanup(curl);
! 853: result = CURLE_OUT_OF_MEMORY;
! 854: break;
! 855: }
! 856: if(state->uploadfile) {
! 857: per->uploadfile = strdup(state->uploadfile);
! 858: if(!per->uploadfile) {
! 859: curl_easy_cleanup(curl);
! 860: result = CURLE_OUT_OF_MEMORY;
! 861: break;
! 862: }
! 863: }
! 864: *added = TRUE;
! 865: per->config = config;
! 866: per->curl = curl;
! 867:
! 868: /* default headers output stream is stdout */
! 869: heads = &per->heads;
! 870: heads->stream = stdout;
! 871:
! 872: /* Single header file for all URLs */
! 873: if(config->headerfile) {
! 874: /* open file for output: */
! 875: if(strcmp(config->headerfile, "-")) {
! 876: FILE *newfile;
! 877: newfile = fopen(config->headerfile, per->prev == NULL?"wb":"ab");
! 878: if(!newfile) {
! 879: warnf(config->global, "Failed to open %s\n", config->headerfile);
! 880: result = CURLE_WRITE_ERROR;
! 881: break;
! 882: }
! 883: else {
! 884: heads->filename = config->headerfile;
! 885: heads->s_isreg = TRUE;
! 886: heads->fopened = TRUE;
! 887: heads->stream = newfile;
! 888: }
! 889: }
! 890: else {
! 891: /* always use binary mode for protocol header output */
! 892: set_binmode(heads->stream);
! 893: }
! 894: }
! 895:
! 896: hdrcbdata = &per->hdrcbdata;
! 897:
! 898: outs = &per->outs;
! 899: input = &per->input;
! 900:
! 901: per->outfile = NULL;
! 902: per->infdopen = FALSE;
! 903: per->infd = STDIN_FILENO;
! 904:
! 905: /* default output stream is stdout */
! 906: outs->stream = stdout;
! 907:
! 908: /* --etag-compare */
! 909: if(config->etag_compare_file) {
! 910: char *etag_from_file = NULL;
! 911: char *header = NULL;
! 912:
! 913: /* open file for reading: */
! 914: FILE *file = fopen(config->etag_compare_file, FOPEN_READTEXT);
! 915: if(!file && !config->etag_save_file) {
! 916: errorf(config->global,
! 917: "Failed to open %s\n", config->etag_compare_file);
! 918: result = CURLE_READ_ERROR;
! 919: break;
! 920: }
! 921:
! 922: if((PARAM_OK == file2string(&etag_from_file, file)) &&
! 923: etag_from_file) {
! 924: header = aprintf("If-None-Match: \"%s\"", etag_from_file);
! 925: Curl_safefree(etag_from_file);
! 926: }
! 927: else
! 928: header = aprintf("If-None-Match: \"\"");
! 929:
! 930: if(!header) {
! 931: if(file)
! 932: fclose(file);
! 933: errorf(config->global,
! 934: "Failed to allocate memory for custom etag header\n");
! 935: result = CURLE_OUT_OF_MEMORY;
! 936: break;
! 937: }
! 938:
! 939: /* add Etag from file to list of custom headers */
! 940: add2list(&config->headers, header);
! 941:
! 942: Curl_safefree(header);
! 943:
! 944: if(file) {
! 945: fclose(file);
! 946: }
! 947: }
! 948:
! 949: /* --etag-save */
! 950: etag_save = &per->etag_save;
! 951: etag_save->stream = stdout;
! 952:
! 953: if(config->etag_save_file) {
! 954: /* open file for output: */
! 955: if(strcmp(config->etag_save_file, "-")) {
! 956: FILE *newfile = fopen(config->etag_save_file, "wb");
! 957: if(!newfile) {
! 958: warnf(
! 959: config->global,
! 960: "Failed to open %s\n", config->etag_save_file);
! 961:
! 962: result = CURLE_WRITE_ERROR;
! 963: break;
! 964: }
! 965: else {
! 966: etag_save->filename = config->etag_save_file;
! 967: etag_save->s_isreg = TRUE;
! 968: etag_save->fopened = TRUE;
! 969: etag_save->stream = newfile;
! 970: }
! 971: }
! 972: else {
! 973: /* always use binary mode for protocol header output */
! 974: set_binmode(etag_save->stream);
! 975: }
! 976: }
! 977:
! 978: if(metalink) {
! 979: /* For Metalink download, use name in Metalink file as
! 980: filename. */
! 981: per->outfile = strdup(mlfile->filename);
! 982: if(!per->outfile) {
! 983: result = CURLE_OUT_OF_MEMORY;
! 984: break;
! 985: }
! 986: per->this_url = strdup(mlres->url);
! 987: if(!per->this_url) {
! 988: result = CURLE_OUT_OF_MEMORY;
! 989: break;
! 990: }
! 991: per->mlfile = mlfile;
! 992: }
! 993: else {
! 994: if(state->urls) {
! 995: result = glob_next_url(&per->this_url, state->urls);
! 996: if(result)
! 997: break;
! 998: }
! 999: else if(!state->li) {
! 1000: per->this_url = strdup(urlnode->url);
! 1001: if(!per->this_url) {
! 1002: result = CURLE_OUT_OF_MEMORY;
! 1003: break;
! 1004: }
! 1005: }
! 1006: else
! 1007: per->this_url = NULL;
! 1008: if(!per->this_url)
! 1009: break;
! 1010:
! 1011: if(state->outfiles) {
! 1012: per->outfile = strdup(state->outfiles);
! 1013: if(!per->outfile) {
! 1014: result = CURLE_OUT_OF_MEMORY;
! 1015: break;
! 1016: }
! 1017: }
! 1018: }
! 1019:
! 1020: if(((urlnode->flags&GETOUT_USEREMOTE) ||
! 1021: (per->outfile && strcmp("-", per->outfile))) &&
! 1022: (metalink || !config->use_metalink)) {
! 1023:
! 1024: /*
! 1025: * We have specified a file name to store the result in, or we have
! 1026: * decided we want to use the remote file name.
! 1027: */
! 1028:
! 1029: if(!per->outfile) {
! 1030: /* extract the file name from the URL */
! 1031: result = get_url_file_name(&per->outfile, per->this_url);
! 1032: if(result)
! 1033: break;
! 1034: if(!*per->outfile && !config->content_disposition) {
! 1035: errorf(global, "Remote file name has no length!\n");
! 1036: result = CURLE_WRITE_ERROR;
! 1037: break;
! 1038: }
! 1039: }
! 1040: else if(state->urls) {
! 1041: /* fill '#1' ... '#9' terms from URL pattern */
! 1042: char *storefile = per->outfile;
! 1043: result = glob_match_url(&per->outfile, storefile, state->urls);
! 1044: Curl_safefree(storefile);
! 1045: if(result) {
! 1046: /* bad globbing */
! 1047: warnf(config->global, "bad output glob!\n");
! 1048: break;
! 1049: }
! 1050: }
! 1051:
! 1052: /* Create the directory hierarchy, if not pre-existent to a multiple
! 1053: file output call */
! 1054:
! 1055: if(config->create_dirs || metalink) {
! 1056: result = create_dir_hierarchy(per->outfile, global->errors);
! 1057: /* create_dir_hierarchy shows error upon CURLE_WRITE_ERROR */
! 1058: if(result)
! 1059: break;
! 1060: }
! 1061:
! 1062: if((urlnode->flags & GETOUT_USEREMOTE)
! 1063: && config->content_disposition) {
! 1064: /* Our header callback MIGHT set the filename */
! 1065: DEBUGASSERT(!outs->filename);
! 1066: }
! 1067:
! 1068: if(config->resume_from || config->resume_from_current) {
! 1069: #ifdef __VMS
! 1070: /* open file for output, forcing VMS output format into stream
! 1071: mode which is needed for stat() call above to always work. */
! 1072: FILE *file = fopen(outfile, "ab",
! 1073: "ctx=stm", "rfm=stmlf", "rat=cr", "mrs=0");
! 1074: #else
! 1075: /* open file for output: */
! 1076: FILE *file = fopen(per->outfile, "ab");
! 1077: #endif
! 1078: if(!file) {
! 1079: errorf(global, "Can't open '%s'!\n", per->outfile);
! 1080: result = CURLE_WRITE_ERROR;
! 1081: break;
! 1082: }
! 1083: outs->fopened = TRUE;
! 1084: outs->stream = file;
! 1085:
! 1086: if(config->resume_from_current) {
! 1087: /* We're told to continue from where we are now. Get the size
! 1088: of the file as it is now */
! 1089: struct_stat fileinfo;
! 1090: if(0 == fstat(fileno(outs->stream), &fileinfo))
! 1091: /* set offset to current file size: */
! 1092: config->resume_from = fileinfo.st_size;
! 1093: else
! 1094: /* let offset be 0 */
! 1095: config->resume_from = 0;
! 1096: }
! 1097:
! 1098: outs->init = config->resume_from;
! 1099: }
! 1100: else {
! 1101: outs->stream = NULL; /* open when needed */
! 1102: }
! 1103: outs->filename = per->outfile;
! 1104: outs->s_isreg = TRUE;
! 1105: }
! 1106:
! 1107: if(per->uploadfile && !stdin_upload(per->uploadfile)) {
! 1108: /*
! 1109: * We have specified a file to upload and it isn't "-".
! 1110: */
! 1111: char *nurl = add_file_name_to_url(per->this_url, per->uploadfile);
! 1112: if(!nurl) {
! 1113: result = CURLE_OUT_OF_MEMORY;
! 1114: break;
! 1115: }
! 1116: per->this_url = nurl;
! 1117: }
! 1118: else if(per->uploadfile && stdin_upload(per->uploadfile)) {
! 1119: /* count to see if there are more than one auth bit set
! 1120: in the authtype field */
! 1121: int authbits = 0;
! 1122: int bitcheck = 0;
! 1123: while(bitcheck < 32) {
! 1124: if(config->authtype & (1UL << bitcheck++)) {
! 1125: authbits++;
! 1126: if(authbits > 1) {
! 1127: /* more than one, we're done! */
! 1128: break;
! 1129: }
! 1130: }
! 1131: }
! 1132:
! 1133: /*
! 1134: * If the user has also selected --anyauth or --proxy-anyauth
! 1135: * we should warn him/her.
! 1136: */
! 1137: if(config->proxyanyauth || (authbits>1)) {
! 1138: warnf(config->global,
! 1139: "Using --anyauth or --proxy-anyauth with upload from stdin"
! 1140: " involves a big risk of it not working. Use a temporary"
! 1141: " file or a fixed auth type instead!\n");
! 1142: }
! 1143:
! 1144: DEBUGASSERT(per->infdopen == FALSE);
! 1145: DEBUGASSERT(per->infd == STDIN_FILENO);
! 1146:
! 1147: set_binmode(stdin);
! 1148: if(!strcmp(per->uploadfile, ".")) {
! 1149: if(curlx_nonblock((curl_socket_t)per->infd, TRUE) < 0)
! 1150: warnf(config->global,
! 1151: "fcntl failed on fd=%d: %s\n", per->infd, strerror(errno));
! 1152: }
! 1153: }
! 1154:
! 1155: if(per->uploadfile && config->resume_from_current)
! 1156: config->resume_from = -1; /* -1 will then force get-it-yourself */
! 1157:
! 1158: if(output_expected(per->this_url, per->uploadfile) && outs->stream &&
! 1159: isatty(fileno(outs->stream)))
! 1160: /* we send the output to a tty, therefore we switch off the progress
! 1161: meter */
! 1162: per->noprogress = global->noprogress = global->isatty = TRUE;
! 1163: else {
! 1164: /* progress meter is per download, so restore config
! 1165: values */
! 1166: per->noprogress = global->noprogress = orig_noprogress;
! 1167: global->isatty = orig_isatty;
! 1168: }
! 1169:
! 1170: if(urlnum > 1 && !global->mute) {
! 1171: per->separator_err =
! 1172: aprintf("\n[%lu/%lu]: %s --> %s",
! 1173: state->li + 1, urlnum, per->this_url,
! 1174: per->outfile ? per->outfile : "<stdout>");
! 1175: if(separator)
! 1176: per->separator = aprintf("%s%s", CURLseparator, per->this_url);
! 1177: }
! 1178: if(httpgetfields) {
! 1179: char *urlbuffer;
! 1180: /* Find out whether the url contains a file name */
! 1181: const char *pc = strstr(per->this_url, "://");
! 1182: char sep = '?';
! 1183: if(pc)
! 1184: pc += 3;
! 1185: else
! 1186: pc = per->this_url;
! 1187:
! 1188: pc = strrchr(pc, '/'); /* check for a slash */
! 1189:
! 1190: if(pc) {
! 1191: /* there is a slash present in the URL */
! 1192:
! 1193: if(strchr(pc, '?'))
! 1194: /* Ouch, there's already a question mark in the URL string, we
! 1195: then append the data with an ampersand separator instead! */
! 1196: sep = '&';
! 1197: }
! 1198: /*
! 1199: * Then append ? followed by the get fields to the url.
! 1200: */
! 1201: if(pc)
! 1202: urlbuffer = aprintf("%s%c%s", per->this_url, sep, httpgetfields);
! 1203: else
! 1204: /* Append / before the ? to create a well-formed url
! 1205: if the url contains a hostname only
! 1206: */
! 1207: urlbuffer = aprintf("%s/?%s", per->this_url, httpgetfields);
! 1208:
! 1209: if(!urlbuffer) {
! 1210: result = CURLE_OUT_OF_MEMORY;
! 1211: break;
! 1212: }
! 1213:
! 1214: Curl_safefree(per->this_url); /* free previous URL */
! 1215: per->this_url = urlbuffer; /* use our new URL instead! */
! 1216: }
! 1217:
! 1218: if(!global->errors)
! 1219: global->errors = stderr;
! 1220:
! 1221: if((!per->outfile || !strcmp(per->outfile, "-")) &&
! 1222: !config->use_ascii) {
! 1223: /* We get the output to stdout and we have not got the ASCII/text
! 1224: flag, then set stdout to be binary */
! 1225: set_binmode(stdout);
! 1226: }
! 1227:
! 1228: /* explicitly passed to stdout means okaying binary gunk */
! 1229: config->terminal_binary_ok =
! 1230: (per->outfile && !strcmp(per->outfile, "-"));
! 1231:
! 1232: /* Avoid having this setopt added to the --libcurl source output. */
! 1233: result = curl_easy_setopt(curl, CURLOPT_SHARE, share);
! 1234: if(result)
! 1235: break;
! 1236:
! 1237: if(!config->tcp_nodelay)
! 1238: my_setopt(curl, CURLOPT_TCP_NODELAY, 0L);
! 1239:
! 1240: if(config->tcp_fastopen)
! 1241: my_setopt(curl, CURLOPT_TCP_FASTOPEN, 1L);
! 1242:
! 1243: /* where to store */
! 1244: my_setopt(curl, CURLOPT_WRITEDATA, per);
! 1245: my_setopt(curl, CURLOPT_INTERLEAVEDATA, per);
! 1246:
! 1247: if(metalink || !config->use_metalink)
! 1248: /* what call to write */
! 1249: my_setopt(curl, CURLOPT_WRITEFUNCTION, tool_write_cb);
! 1250: #ifdef USE_METALINK
! 1251: else
! 1252: /* Set Metalink specific write callback function to parse
! 1253: XML data progressively. */
! 1254: my_setopt(curl, CURLOPT_WRITEFUNCTION, metalink_write_cb);
! 1255: #endif /* USE_METALINK */
! 1256:
! 1257: /* for uploads */
! 1258: input->config = config;
! 1259: /* Note that if CURLOPT_READFUNCTION is fread (the default), then
! 1260: * lib/telnet.c will Curl_poll() on the input file descriptor
! 1261: * rather then calling the READFUNCTION at regular intervals.
! 1262: * The circumstances in which it is preferable to enable this
! 1263: * behaviour, by omitting to set the READFUNCTION & READDATA options,
! 1264: * have not been determined.
! 1265: */
! 1266: my_setopt(curl, CURLOPT_READDATA, input);
! 1267: /* what call to read */
! 1268: my_setopt(curl, CURLOPT_READFUNCTION, tool_read_cb);
! 1269:
! 1270: /* in 7.18.0, the CURLOPT_SEEKFUNCTION/DATA pair is taking over what
! 1271: CURLOPT_IOCTLFUNCTION/DATA pair previously provided for seeking */
! 1272: my_setopt(curl, CURLOPT_SEEKDATA, input);
! 1273: my_setopt(curl, CURLOPT_SEEKFUNCTION, tool_seek_cb);
! 1274:
! 1275: if(config->recvpersecond &&
! 1276: (config->recvpersecond < BUFFER_SIZE))
! 1277: /* use a smaller sized buffer for better sleeps */
! 1278: my_setopt(curl, CURLOPT_BUFFERSIZE, (long)config->recvpersecond);
! 1279: else
! 1280: my_setopt(curl, CURLOPT_BUFFERSIZE, (long)BUFFER_SIZE);
! 1281:
! 1282: my_setopt_str(curl, CURLOPT_URL, per->this_url);
! 1283: my_setopt(curl, CURLOPT_NOPROGRESS, global->noprogress?1L:0L);
! 1284: if(config->no_body)
! 1285: my_setopt(curl, CURLOPT_NOBODY, 1L);
! 1286:
! 1287: if(config->oauth_bearer)
! 1288: my_setopt_str(curl, CURLOPT_XOAUTH2_BEARER, config->oauth_bearer);
! 1289:
! 1290: {
! 1291: my_setopt_str(curl, CURLOPT_PROXY, config->proxy);
! 1292: /* new in libcurl 7.5 */
! 1293: if(config->proxy)
! 1294: my_setopt_enum(curl, CURLOPT_PROXYTYPE, config->proxyver);
! 1295:
! 1296: my_setopt_str(curl, CURLOPT_PROXYUSERPWD, config->proxyuserpwd);
! 1297:
! 1298: /* new in libcurl 7.3 */
! 1299: my_setopt(curl, CURLOPT_HTTPPROXYTUNNEL, config->proxytunnel?1L:0L);
! 1300:
! 1301: /* new in libcurl 7.52.0 */
! 1302: if(config->preproxy)
! 1303: my_setopt_str(curl, CURLOPT_PRE_PROXY, config->preproxy);
! 1304:
! 1305: /* new in libcurl 7.10.6 */
! 1306: if(config->proxyanyauth)
! 1307: my_setopt_bitmask(curl, CURLOPT_PROXYAUTH,
! 1308: (long)CURLAUTH_ANY);
! 1309: else if(config->proxynegotiate)
! 1310: my_setopt_bitmask(curl, CURLOPT_PROXYAUTH,
! 1311: (long)CURLAUTH_GSSNEGOTIATE);
! 1312: else if(config->proxyntlm)
! 1313: my_setopt_bitmask(curl, CURLOPT_PROXYAUTH,
! 1314: (long)CURLAUTH_NTLM);
! 1315: else if(config->proxydigest)
! 1316: my_setopt_bitmask(curl, CURLOPT_PROXYAUTH,
! 1317: (long)CURLAUTH_DIGEST);
! 1318: else if(config->proxybasic)
! 1319: my_setopt_bitmask(curl, CURLOPT_PROXYAUTH,
! 1320: (long)CURLAUTH_BASIC);
! 1321:
! 1322: /* new in libcurl 7.19.4 */
! 1323: my_setopt_str(curl, CURLOPT_NOPROXY, config->noproxy);
! 1324:
! 1325: my_setopt(curl, CURLOPT_SUPPRESS_CONNECT_HEADERS,
! 1326: config->suppress_connect_headers?1L:0L);
! 1327: }
! 1328:
! 1329: my_setopt(curl, CURLOPT_FAILONERROR, config->failonerror?1L:0L);
! 1330: my_setopt(curl, CURLOPT_REQUEST_TARGET, config->request_target);
! 1331: my_setopt(curl, CURLOPT_UPLOAD, per->uploadfile?1L:0L);
! 1332: my_setopt(curl, CURLOPT_DIRLISTONLY, config->dirlistonly?1L:0L);
! 1333: my_setopt(curl, CURLOPT_APPEND, config->ftp_append?1L:0L);
! 1334:
! 1335: if(config->netrc_opt)
! 1336: my_setopt_enum(curl, CURLOPT_NETRC, (long)CURL_NETRC_OPTIONAL);
! 1337: else if(config->netrc || config->netrc_file)
! 1338: my_setopt_enum(curl, CURLOPT_NETRC, (long)CURL_NETRC_REQUIRED);
! 1339: else
! 1340: my_setopt_enum(curl, CURLOPT_NETRC, (long)CURL_NETRC_IGNORED);
! 1341:
! 1342: if(config->netrc_file)
! 1343: my_setopt_str(curl, CURLOPT_NETRC_FILE, config->netrc_file);
! 1344:
! 1345: my_setopt(curl, CURLOPT_TRANSFERTEXT, config->use_ascii?1L:0L);
! 1346: if(config->login_options)
! 1347: my_setopt_str(curl, CURLOPT_LOGIN_OPTIONS, config->login_options);
! 1348: my_setopt_str(curl, CURLOPT_USERPWD, config->userpwd);
! 1349: my_setopt_str(curl, CURLOPT_RANGE, config->range);
! 1350: my_setopt(curl, CURLOPT_ERRORBUFFER, per->errorbuffer);
! 1351: my_setopt(curl, CURLOPT_TIMEOUT_MS, (long)(config->timeout * 1000));
! 1352:
! 1353: switch(config->httpreq) {
! 1354: case HTTPREQ_SIMPLEPOST:
! 1355: my_setopt_str(curl, CURLOPT_POSTFIELDS,
! 1356: config->postfields);
! 1357: my_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE,
! 1358: config->postfieldsize);
! 1359: break;
! 1360: case HTTPREQ_MIMEPOST:
! 1361: /* free previous remainders */
! 1362: curl_mime_free(config->mimepost);
! 1363: config->mimepost = NULL;
! 1364: result = tool2curlmime(curl, config->mimeroot, &config->mimepost);
! 1365: if(result)
! 1366: break;
! 1367: my_setopt_mimepost(curl, CURLOPT_MIMEPOST, config->mimepost);
! 1368: break;
! 1369: default:
! 1370: break;
! 1371: }
! 1372: if(result)
! 1373: break;
! 1374:
! 1375: /* new in libcurl 7.10.6 (default is Basic) */
! 1376: if(config->authtype)
! 1377: my_setopt_bitmask(curl, CURLOPT_HTTPAUTH, (long)config->authtype);
! 1378:
! 1379: my_setopt_slist(curl, CURLOPT_HTTPHEADER, config->headers);
! 1380:
! 1381: if(built_in_protos & (CURLPROTO_HTTP | CURLPROTO_RTSP)) {
! 1382: my_setopt_str(curl, CURLOPT_REFERER, config->referer);
! 1383: my_setopt_str(curl, CURLOPT_USERAGENT, config->useragent);
! 1384: }
! 1385:
! 1386: if(built_in_protos & CURLPROTO_HTTP) {
! 1387:
! 1388: long postRedir = 0;
! 1389:
! 1390: my_setopt(curl, CURLOPT_FOLLOWLOCATION,
! 1391: config->followlocation?1L:0L);
! 1392: my_setopt(curl, CURLOPT_UNRESTRICTED_AUTH,
! 1393: config->unrestricted_auth?1L:0L);
! 1394:
! 1395: my_setopt(curl, CURLOPT_AUTOREFERER, config->autoreferer?1L:0L);
! 1396:
! 1397: /* new in libcurl 7.36.0 */
! 1398: if(config->proxyheaders) {
! 1399: my_setopt_slist(curl, CURLOPT_PROXYHEADER, config->proxyheaders);
! 1400: my_setopt(curl, CURLOPT_HEADEROPT, CURLHEADER_SEPARATE);
! 1401: }
! 1402:
! 1403: /* new in libcurl 7.5 */
! 1404: my_setopt(curl, CURLOPT_MAXREDIRS, config->maxredirs);
! 1405:
! 1406: if(config->httpversion)
! 1407: my_setopt_enum(curl, CURLOPT_HTTP_VERSION, config->httpversion);
! 1408: else if(curlinfo->features & CURL_VERSION_HTTP2) {
! 1409: my_setopt_enum(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2TLS);
! 1410: }
! 1411:
! 1412: /* curl 7.19.1 (the 301 version existed in 7.18.2),
! 1413: 303 was added in 7.26.0 */
! 1414: if(config->post301)
! 1415: postRedir |= CURL_REDIR_POST_301;
! 1416: if(config->post302)
! 1417: postRedir |= CURL_REDIR_POST_302;
! 1418: if(config->post303)
! 1419: postRedir |= CURL_REDIR_POST_303;
! 1420: my_setopt(curl, CURLOPT_POSTREDIR, postRedir);
! 1421:
! 1422: /* new in libcurl 7.21.6 */
! 1423: if(config->encoding)
! 1424: my_setopt_str(curl, CURLOPT_ACCEPT_ENCODING, "");
! 1425:
! 1426: /* new in libcurl 7.21.6 */
! 1427: if(config->tr_encoding)
! 1428: my_setopt(curl, CURLOPT_TRANSFER_ENCODING, 1L);
! 1429: /* new in libcurl 7.64.0 */
! 1430: my_setopt(curl, CURLOPT_HTTP09_ALLOWED,
! 1431: config->http09_allowed ? 1L : 0L);
! 1432:
! 1433: } /* (built_in_protos & CURLPROTO_HTTP) */
! 1434:
! 1435: my_setopt_str(curl, CURLOPT_FTPPORT, config->ftpport);
! 1436: my_setopt(curl, CURLOPT_LOW_SPEED_LIMIT,
! 1437: config->low_speed_limit);
! 1438: my_setopt(curl, CURLOPT_LOW_SPEED_TIME, config->low_speed_time);
! 1439: my_setopt(curl, CURLOPT_MAX_SEND_SPEED_LARGE,
! 1440: config->sendpersecond);
! 1441: my_setopt(curl, CURLOPT_MAX_RECV_SPEED_LARGE,
! 1442: config->recvpersecond);
! 1443:
! 1444: if(config->use_resume)
! 1445: my_setopt(curl, CURLOPT_RESUME_FROM_LARGE, config->resume_from);
! 1446: else
! 1447: my_setopt(curl, CURLOPT_RESUME_FROM_LARGE, CURL_OFF_T_C(0));
! 1448:
! 1449: my_setopt_str(curl, CURLOPT_KEYPASSWD, config->key_passwd);
! 1450: my_setopt_str(curl, CURLOPT_PROXY_KEYPASSWD, config->proxy_key_passwd);
! 1451:
! 1452: if(built_in_protos & (CURLPROTO_SCP|CURLPROTO_SFTP)) {
! 1453:
! 1454: /* SSH and SSL private key uses same command-line option */
! 1455: /* new in libcurl 7.16.1 */
! 1456: my_setopt_str(curl, CURLOPT_SSH_PRIVATE_KEYFILE, config->key);
! 1457: /* new in libcurl 7.16.1 */
! 1458: my_setopt_str(curl, CURLOPT_SSH_PUBLIC_KEYFILE, config->pubkey);
! 1459:
! 1460: /* new in libcurl 7.17.1: SSH host key md5 checking allows us
! 1461: to fail if we are not talking to who we think we should */
! 1462: my_setopt_str(curl, CURLOPT_SSH_HOST_PUBLIC_KEY_MD5,
! 1463: config->hostpubmd5);
! 1464:
! 1465: /* new in libcurl 7.56.0 */
! 1466: if(config->ssh_compression)
! 1467: my_setopt(curl, CURLOPT_SSH_COMPRESSION, 1L);
! 1468: }
! 1469:
! 1470: if(config->cacert)
! 1471: my_setopt_str(curl, CURLOPT_CAINFO, config->cacert);
! 1472: if(config->proxy_cacert)
! 1473: my_setopt_str(curl, CURLOPT_PROXY_CAINFO, config->proxy_cacert);
! 1474:
! 1475: if(config->capath) {
! 1476: result = res_setopt_str(curl, CURLOPT_CAPATH, config->capath);
! 1477: if(result == CURLE_NOT_BUILT_IN) {
! 1478: warnf(config->global, "ignoring %s, not supported by libcurl\n",
! 1479: capath_from_env?
! 1480: "SSL_CERT_DIR environment variable":"--capath");
! 1481: }
! 1482: else if(result)
! 1483: break;
! 1484: }
! 1485: /* For the time being if --proxy-capath is not set then we use the
! 1486: --capath value for it, if any. See #1257 */
! 1487: if((config->proxy_capath || config->capath) &&
! 1488: !tool_setopt_skip(CURLOPT_PROXY_CAPATH)) {
! 1489: result = res_setopt_str(curl, CURLOPT_PROXY_CAPATH,
! 1490: (config->proxy_capath ?
! 1491: config->proxy_capath :
! 1492: config->capath));
! 1493: if(result == CURLE_NOT_BUILT_IN) {
! 1494: if(config->proxy_capath) {
! 1495: warnf(config->global,
! 1496: "ignoring --proxy-capath, not supported by libcurl\n");
! 1497: }
! 1498: }
! 1499: else if(result)
! 1500: break;
! 1501: }
! 1502:
! 1503: if(config->crlfile)
! 1504: my_setopt_str(curl, CURLOPT_CRLFILE, config->crlfile);
! 1505: if(config->proxy_crlfile)
! 1506: my_setopt_str(curl, CURLOPT_PROXY_CRLFILE, config->proxy_crlfile);
! 1507: else if(config->crlfile) /* CURLOPT_PROXY_CRLFILE default is crlfile */
! 1508: my_setopt_str(curl, CURLOPT_PROXY_CRLFILE, config->crlfile);
! 1509:
! 1510: if(config->pinnedpubkey)
! 1511: my_setopt_str(curl, CURLOPT_PINNEDPUBLICKEY, config->pinnedpubkey);
! 1512:
! 1513: if(curlinfo->features & CURL_VERSION_SSL) {
! 1514: /* Check if config->cert is a PKCS#11 URI and set the
! 1515: * config->cert_type if necessary */
! 1516: if(config->cert) {
! 1517: if(!config->cert_type) {
! 1518: if(is_pkcs11_uri(config->cert)) {
! 1519: config->cert_type = strdup("ENG");
! 1520: }
! 1521: }
! 1522: }
! 1523:
! 1524: /* Check if config->key is a PKCS#11 URI and set the
! 1525: * config->key_type if necessary */
! 1526: if(config->key) {
! 1527: if(!config->key_type) {
! 1528: if(is_pkcs11_uri(config->key)) {
! 1529: config->key_type = strdup("ENG");
! 1530: }
! 1531: }
! 1532: }
! 1533:
! 1534: /* Check if config->proxy_cert is a PKCS#11 URI and set the
! 1535: * config->proxy_type if necessary */
! 1536: if(config->proxy_cert) {
! 1537: if(!config->proxy_cert_type) {
! 1538: if(is_pkcs11_uri(config->proxy_cert)) {
! 1539: config->proxy_cert_type = strdup("ENG");
! 1540: }
! 1541: }
! 1542: }
! 1543:
! 1544: /* Check if config->proxy_key is a PKCS#11 URI and set the
! 1545: * config->proxy_key_type if necessary */
! 1546: if(config->proxy_key) {
! 1547: if(!config->proxy_key_type) {
! 1548: if(is_pkcs11_uri(config->proxy_key)) {
! 1549: config->proxy_key_type = strdup("ENG");
! 1550: }
! 1551: }
! 1552: }
! 1553:
! 1554: my_setopt_str(curl, CURLOPT_SSLCERT, config->cert);
! 1555: my_setopt_str(curl, CURLOPT_PROXY_SSLCERT, config->proxy_cert);
! 1556: my_setopt_str(curl, CURLOPT_SSLCERTTYPE, config->cert_type);
! 1557: my_setopt_str(curl, CURLOPT_PROXY_SSLCERTTYPE,
! 1558: config->proxy_cert_type);
! 1559: my_setopt_str(curl, CURLOPT_SSLKEY, config->key);
! 1560: my_setopt_str(curl, CURLOPT_PROXY_SSLKEY, config->proxy_key);
! 1561: my_setopt_str(curl, CURLOPT_SSLKEYTYPE, config->key_type);
! 1562: my_setopt_str(curl, CURLOPT_PROXY_SSLKEYTYPE,
! 1563: config->proxy_key_type);
! 1564:
! 1565: if(config->insecure_ok) {
! 1566: my_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
! 1567: my_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
! 1568: }
! 1569: else {
! 1570: my_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L);
! 1571: /* libcurl default is strict verifyhost -> 2L */
! 1572: /* my_setopt(curl, CURLOPT_SSL_VERIFYHOST, 2L); */
! 1573: }
! 1574: if(config->proxy_insecure_ok) {
! 1575: my_setopt(curl, CURLOPT_PROXY_SSL_VERIFYPEER, 0L);
! 1576: my_setopt(curl, CURLOPT_PROXY_SSL_VERIFYHOST, 0L);
! 1577: }
! 1578: else {
! 1579: my_setopt(curl, CURLOPT_PROXY_SSL_VERIFYPEER, 1L);
! 1580: }
! 1581:
! 1582: if(config->verifystatus)
! 1583: my_setopt(curl, CURLOPT_SSL_VERIFYSTATUS, 1L);
! 1584:
! 1585: if(config->falsestart)
! 1586: my_setopt(curl, CURLOPT_SSL_FALSESTART, 1L);
! 1587:
! 1588: my_setopt_enum(curl, CURLOPT_SSLVERSION,
! 1589: config->ssl_version | config->ssl_version_max);
! 1590: my_setopt_enum(curl, CURLOPT_PROXY_SSLVERSION,
! 1591: config->proxy_ssl_version);
! 1592: }
! 1593: if(config->path_as_is)
! 1594: my_setopt(curl, CURLOPT_PATH_AS_IS, 1L);
! 1595:
! 1596: if(built_in_protos & (CURLPROTO_SCP|CURLPROTO_SFTP)) {
! 1597: if(!config->insecure_ok) {
! 1598: char *home;
! 1599: char *file;
! 1600: result = CURLE_FAILED_INIT;
! 1601: home = homedir();
! 1602: if(home) {
! 1603: file = aprintf("%s/.ssh/known_hosts", home);
! 1604: if(file) {
! 1605: /* new in curl 7.19.6 */
! 1606: result = res_setopt_str(curl, CURLOPT_SSH_KNOWNHOSTS, file);
! 1607: curl_free(file);
! 1608: if(result == CURLE_UNKNOWN_OPTION)
! 1609: /* libssh2 version older than 1.1.1 */
! 1610: result = CURLE_OK;
! 1611: }
! 1612: Curl_safefree(home);
! 1613: }
! 1614: else {
! 1615: errorf(global, "Failed to figure out user's home dir!");
! 1616: }
! 1617: if(result)
! 1618: break;
! 1619: }
! 1620: }
! 1621:
! 1622: if(config->no_body || config->remote_time) {
! 1623: /* no body or use remote time */
! 1624: my_setopt(curl, CURLOPT_FILETIME, 1L);
! 1625: }
! 1626:
! 1627: my_setopt(curl, CURLOPT_CRLF, config->crlf?1L:0L);
! 1628: my_setopt_slist(curl, CURLOPT_QUOTE, config->quote);
! 1629: my_setopt_slist(curl, CURLOPT_POSTQUOTE, config->postquote);
! 1630: my_setopt_slist(curl, CURLOPT_PREQUOTE, config->prequote);
! 1631:
! 1632: if(config->cookie)
! 1633: my_setopt_str(curl, CURLOPT_COOKIE, config->cookie);
! 1634:
! 1635: if(config->cookiefile)
! 1636: my_setopt_str(curl, CURLOPT_COOKIEFILE, config->cookiefile);
! 1637:
! 1638: /* new in libcurl 7.9 */
! 1639: if(config->cookiejar)
! 1640: my_setopt_str(curl, CURLOPT_COOKIEJAR, config->cookiejar);
! 1641:
! 1642: /* new in libcurl 7.9.7 */
! 1643: my_setopt(curl, CURLOPT_COOKIESESSION, config->cookiesession?1L:0L);
! 1644:
! 1645: my_setopt_enum(curl, CURLOPT_TIMECONDITION, (long)config->timecond);
! 1646: my_setopt(curl, CURLOPT_TIMEVALUE_LARGE, config->condtime);
! 1647: my_setopt_str(curl, CURLOPT_CUSTOMREQUEST, config->customrequest);
! 1648: customrequest_helper(config, config->httpreq, config->customrequest);
! 1649: my_setopt(curl, CURLOPT_STDERR, global->errors);
! 1650:
! 1651: /* three new ones in libcurl 7.3: */
! 1652: my_setopt_str(curl, CURLOPT_INTERFACE, config->iface);
! 1653: my_setopt_str(curl, CURLOPT_KRBLEVEL, config->krblevel);
! 1654: progressbarinit(&per->progressbar, config);
! 1655:
! 1656: if((global->progressmode == CURL_PROGRESS_BAR) &&
! 1657: !global->noprogress && !global->mute) {
! 1658: /* we want the alternative style, then we have to implement it
! 1659: ourselves! */
! 1660: my_setopt(curl, CURLOPT_XFERINFOFUNCTION, tool_progress_cb);
! 1661: my_setopt(curl, CURLOPT_XFERINFODATA, per);
! 1662: }
! 1663: else if(per->uploadfile && !strcmp(per->uploadfile, ".")) {
! 1664: /* when reading from stdin in non-blocking mode, we use the progress
! 1665: function to unpause a busy read */
! 1666: my_setopt(curl, CURLOPT_NOPROGRESS, 0L);
! 1667: my_setopt(curl, CURLOPT_XFERINFOFUNCTION, tool_readbusy_cb);
! 1668: my_setopt(curl, CURLOPT_XFERINFODATA, per);
! 1669: }
! 1670:
! 1671: /* new in libcurl 7.24.0: */
! 1672: if(config->dns_servers)
! 1673: my_setopt_str(curl, CURLOPT_DNS_SERVERS, config->dns_servers);
! 1674:
! 1675: /* new in libcurl 7.33.0: */
! 1676: if(config->dns_interface)
! 1677: my_setopt_str(curl, CURLOPT_DNS_INTERFACE, config->dns_interface);
! 1678: if(config->dns_ipv4_addr)
! 1679: my_setopt_str(curl, CURLOPT_DNS_LOCAL_IP4, config->dns_ipv4_addr);
! 1680: if(config->dns_ipv6_addr)
! 1681: my_setopt_str(curl, CURLOPT_DNS_LOCAL_IP6, config->dns_ipv6_addr);
! 1682:
! 1683: /* new in libcurl 7.6.2: */
! 1684: my_setopt_slist(curl, CURLOPT_TELNETOPTIONS, config->telnet_options);
! 1685:
! 1686: /* new in libcurl 7.7: */
! 1687: my_setopt_str(curl, CURLOPT_RANDOM_FILE, config->random_file);
! 1688: my_setopt_str(curl, CURLOPT_EGDSOCKET, config->egd_file);
! 1689: my_setopt(curl, CURLOPT_CONNECTTIMEOUT_MS,
! 1690: (long)(config->connecttimeout * 1000));
! 1691:
! 1692: if(config->doh_url)
! 1693: my_setopt_str(curl, CURLOPT_DOH_URL, config->doh_url);
! 1694:
! 1695: if(config->cipher_list)
! 1696: my_setopt_str(curl, CURLOPT_SSL_CIPHER_LIST, config->cipher_list);
! 1697:
! 1698: if(config->proxy_cipher_list)
! 1699: my_setopt_str(curl, CURLOPT_PROXY_SSL_CIPHER_LIST,
! 1700: config->proxy_cipher_list);
! 1701:
! 1702: if(config->cipher13_list)
! 1703: my_setopt_str(curl, CURLOPT_TLS13_CIPHERS, config->cipher13_list);
! 1704:
! 1705: if(config->proxy_cipher13_list)
! 1706: my_setopt_str(curl, CURLOPT_PROXY_TLS13_CIPHERS,
! 1707: config->proxy_cipher13_list);
! 1708:
! 1709: /* new in libcurl 7.9.2: */
! 1710: if(config->disable_epsv)
! 1711: /* disable it */
! 1712: my_setopt(curl, CURLOPT_FTP_USE_EPSV, 0L);
! 1713:
! 1714: /* new in libcurl 7.10.5 */
! 1715: if(config->disable_eprt)
! 1716: /* disable it */
! 1717: my_setopt(curl, CURLOPT_FTP_USE_EPRT, 0L);
! 1718:
! 1719: if(global->tracetype != TRACE_NONE) {
! 1720: my_setopt(curl, CURLOPT_DEBUGFUNCTION, tool_debug_cb);
! 1721: my_setopt(curl, CURLOPT_DEBUGDATA, config);
! 1722: my_setopt(curl, CURLOPT_VERBOSE, 1L);
! 1723: }
! 1724:
! 1725: /* new in curl 7.9.3 */
! 1726: if(config->engine) {
! 1727: result = res_setopt_str(curl, CURLOPT_SSLENGINE, config->engine);
! 1728: if(result)
! 1729: break;
! 1730: }
! 1731:
! 1732: /* new in curl 7.10.7, extended in 7.19.4. Modified to use
! 1733: CREATE_DIR_RETRY in 7.49.0 */
! 1734: my_setopt(curl, CURLOPT_FTP_CREATE_MISSING_DIRS,
! 1735: (long)(config->ftp_create_dirs?
! 1736: CURLFTP_CREATE_DIR_RETRY:
! 1737: CURLFTP_CREATE_DIR_NONE));
! 1738:
! 1739: /* new in curl 7.10.8 */
! 1740: if(config->max_filesize)
! 1741: my_setopt(curl, CURLOPT_MAXFILESIZE_LARGE,
! 1742: config->max_filesize);
! 1743:
! 1744: if(4 == config->ip_version)
! 1745: my_setopt(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
! 1746: else if(6 == config->ip_version)
! 1747: my_setopt(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V6);
! 1748: else
! 1749: my_setopt(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_WHATEVER);
! 1750:
! 1751: /* new in curl 7.15.5 */
! 1752: if(config->ftp_ssl_reqd)
! 1753: my_setopt_enum(curl, CURLOPT_USE_SSL, (long)CURLUSESSL_ALL);
! 1754:
! 1755: /* new in curl 7.11.0 */
! 1756: else if(config->ftp_ssl)
! 1757: my_setopt_enum(curl, CURLOPT_USE_SSL, (long)CURLUSESSL_TRY);
! 1758:
! 1759: /* new in curl 7.16.0 */
! 1760: else if(config->ftp_ssl_control)
! 1761: my_setopt_enum(curl, CURLOPT_USE_SSL, (long)CURLUSESSL_CONTROL);
! 1762:
! 1763: /* new in curl 7.16.1 */
! 1764: if(config->ftp_ssl_ccc)
! 1765: my_setopt_enum(curl, CURLOPT_FTP_SSL_CCC,
! 1766: (long)config->ftp_ssl_ccc_mode);
! 1767:
! 1768: /* new in curl 7.19.4 */
! 1769: if(config->socks5_gssapi_nec)
! 1770: my_setopt_str(curl, CURLOPT_SOCKS5_GSSAPI_NEC,
! 1771: config->socks5_gssapi_nec);
! 1772:
! 1773: /* new in curl 7.55.0 */
! 1774: if(config->socks5_auth)
! 1775: my_setopt_bitmask(curl, CURLOPT_SOCKS5_AUTH,
! 1776: (long)config->socks5_auth);
! 1777:
! 1778: /* new in curl 7.43.0 */
! 1779: if(config->proxy_service_name)
! 1780: my_setopt_str(curl, CURLOPT_PROXY_SERVICE_NAME,
! 1781: config->proxy_service_name);
! 1782:
! 1783: /* new in curl 7.43.0 */
! 1784: if(config->service_name)
! 1785: my_setopt_str(curl, CURLOPT_SERVICE_NAME,
! 1786: config->service_name);
! 1787:
! 1788: /* curl 7.13.0 */
! 1789: my_setopt_str(curl, CURLOPT_FTP_ACCOUNT, config->ftp_account);
! 1790: my_setopt(curl, CURLOPT_IGNORE_CONTENT_LENGTH, config->ignorecl?1L:0L);
! 1791:
! 1792: /* curl 7.14.2 */
! 1793: my_setopt(curl, CURLOPT_FTP_SKIP_PASV_IP, config->ftp_skip_ip?1L:0L);
! 1794:
! 1795: /* curl 7.15.1 */
! 1796: my_setopt(curl, CURLOPT_FTP_FILEMETHOD, (long)config->ftp_filemethod);
! 1797:
! 1798: /* curl 7.15.2 */
! 1799: if(config->localport) {
! 1800: my_setopt(curl, CURLOPT_LOCALPORT, config->localport);
! 1801: my_setopt_str(curl, CURLOPT_LOCALPORTRANGE, config->localportrange);
! 1802: }
! 1803:
! 1804: /* curl 7.15.5 */
! 1805: my_setopt_str(curl, CURLOPT_FTP_ALTERNATIVE_TO_USER,
! 1806: config->ftp_alternative_to_user);
! 1807:
! 1808: /* curl 7.16.0 */
! 1809: if(config->disable_sessionid)
! 1810: /* disable it */
! 1811: my_setopt(curl, CURLOPT_SSL_SESSIONID_CACHE, 0L);
! 1812:
! 1813: /* curl 7.16.2 */
! 1814: if(config->raw) {
! 1815: my_setopt(curl, CURLOPT_HTTP_CONTENT_DECODING, 0L);
! 1816: my_setopt(curl, CURLOPT_HTTP_TRANSFER_DECODING, 0L);
! 1817: }
! 1818:
! 1819: /* curl 7.17.1 */
! 1820: if(!config->nokeepalive) {
! 1821: my_setopt(curl, CURLOPT_TCP_KEEPALIVE, 1L);
! 1822: if(config->alivetime != 0) {
! 1823: my_setopt(curl, CURLOPT_TCP_KEEPIDLE, config->alivetime);
! 1824: my_setopt(curl, CURLOPT_TCP_KEEPINTVL, config->alivetime);
! 1825: }
! 1826: }
! 1827: else
! 1828: my_setopt(curl, CURLOPT_TCP_KEEPALIVE, 0L);
! 1829:
! 1830: /* curl 7.20.0 */
! 1831: if(config->tftp_blksize)
! 1832: my_setopt(curl, CURLOPT_TFTP_BLKSIZE, config->tftp_blksize);
! 1833:
! 1834: if(config->mail_from)
! 1835: my_setopt_str(curl, CURLOPT_MAIL_FROM, config->mail_from);
! 1836:
! 1837: if(config->mail_rcpt)
! 1838: my_setopt_slist(curl, CURLOPT_MAIL_RCPT, config->mail_rcpt);
! 1839:
! 1840: /* curl 7.69.x */
! 1841: my_setopt(curl, CURLOPT_MAIL_RCPT_ALLLOWFAILS,
! 1842: config->mail_rcpt_allowfails ? 1L : 0L);
! 1843:
! 1844: /* curl 7.20.x */
! 1845: if(config->ftp_pret)
! 1846: my_setopt(curl, CURLOPT_FTP_USE_PRET, 1L);
! 1847:
! 1848: if(config->proto_present)
! 1849: my_setopt_flags(curl, CURLOPT_PROTOCOLS, config->proto);
! 1850: if(config->proto_redir_present)
! 1851: my_setopt_flags(curl, CURLOPT_REDIR_PROTOCOLS, config->proto_redir);
! 1852:
! 1853: if(config->content_disposition
! 1854: && (urlnode->flags & GETOUT_USEREMOTE))
! 1855: hdrcbdata->honor_cd_filename = TRUE;
! 1856: else
! 1857: hdrcbdata->honor_cd_filename = FALSE;
! 1858:
! 1859: hdrcbdata->outs = outs;
! 1860: hdrcbdata->heads = heads;
! 1861: hdrcbdata->etag_save = etag_save;
! 1862: hdrcbdata->global = global;
! 1863: hdrcbdata->config = config;
! 1864:
! 1865: my_setopt(curl, CURLOPT_HEADERFUNCTION, tool_header_cb);
! 1866: my_setopt(curl, CURLOPT_HEADERDATA, per);
! 1867:
! 1868: if(config->resolve)
! 1869: /* new in 7.21.3 */
! 1870: my_setopt_slist(curl, CURLOPT_RESOLVE, config->resolve);
! 1871:
! 1872: if(config->connect_to)
! 1873: /* new in 7.49.0 */
! 1874: my_setopt_slist(curl, CURLOPT_CONNECT_TO, config->connect_to);
! 1875:
! 1876: /* new in 7.21.4 */
! 1877: if(curlinfo->features & CURL_VERSION_TLSAUTH_SRP) {
! 1878: if(config->tls_username)
! 1879: my_setopt_str(curl, CURLOPT_TLSAUTH_USERNAME,
! 1880: config->tls_username);
! 1881: if(config->tls_password)
! 1882: my_setopt_str(curl, CURLOPT_TLSAUTH_PASSWORD,
! 1883: config->tls_password);
! 1884: if(config->tls_authtype)
! 1885: my_setopt_str(curl, CURLOPT_TLSAUTH_TYPE,
! 1886: config->tls_authtype);
! 1887: if(config->proxy_tls_username)
! 1888: my_setopt_str(curl, CURLOPT_PROXY_TLSAUTH_USERNAME,
! 1889: config->proxy_tls_username);
! 1890: if(config->proxy_tls_password)
! 1891: my_setopt_str(curl, CURLOPT_PROXY_TLSAUTH_PASSWORD,
! 1892: config->proxy_tls_password);
! 1893: if(config->proxy_tls_authtype)
! 1894: my_setopt_str(curl, CURLOPT_PROXY_TLSAUTH_TYPE,
! 1895: config->proxy_tls_authtype);
! 1896: }
! 1897:
! 1898: /* new in 7.22.0 */
! 1899: if(config->gssapi_delegation)
! 1900: my_setopt_str(curl, CURLOPT_GSSAPI_DELEGATION,
! 1901: config->gssapi_delegation);
! 1902:
! 1903: /* new in 7.25.0, 7.44.0 and 7.70.0 */
! 1904: {
! 1905: long mask = (config->ssl_allow_beast ? CURLSSLOPT_ALLOW_BEAST : 0) |
! 1906: (config->ssl_revoke_best_effort ?
! 1907: CURLSSLOPT_REVOKE_BEST_EFFORT : 0) |
! 1908: (config->ssl_no_revoke ? CURLSSLOPT_NO_REVOKE : 0);
! 1909: if(mask)
! 1910: my_setopt_bitmask(curl, CURLOPT_SSL_OPTIONS, mask);
! 1911: }
! 1912:
! 1913: if(config->proxy_ssl_allow_beast)
! 1914: my_setopt(curl, CURLOPT_PROXY_SSL_OPTIONS,
! 1915: (long)CURLSSLOPT_ALLOW_BEAST);
! 1916:
! 1917: if(config->mail_auth)
! 1918: my_setopt_str(curl, CURLOPT_MAIL_AUTH, config->mail_auth);
! 1919:
! 1920: /* new in 7.66.0 */
! 1921: if(config->sasl_authzid)
! 1922: my_setopt_str(curl, CURLOPT_SASL_AUTHZID, config->sasl_authzid);
! 1923:
! 1924: /* new in 7.31.0 */
! 1925: if(config->sasl_ir)
! 1926: my_setopt(curl, CURLOPT_SASL_IR, 1L);
! 1927:
! 1928: if(config->nonpn) {
! 1929: my_setopt(curl, CURLOPT_SSL_ENABLE_NPN, 0L);
! 1930: }
! 1931:
! 1932: if(config->noalpn) {
! 1933: my_setopt(curl, CURLOPT_SSL_ENABLE_ALPN, 0L);
! 1934: }
! 1935:
! 1936: /* new in 7.40.0, abstract support added in 7.53.0 */
! 1937: if(config->unix_socket_path) {
! 1938: if(config->abstract_unix_socket) {
! 1939: my_setopt_str(curl, CURLOPT_ABSTRACT_UNIX_SOCKET,
! 1940: config->unix_socket_path);
! 1941: }
! 1942: else {
! 1943: my_setopt_str(curl, CURLOPT_UNIX_SOCKET_PATH,
! 1944: config->unix_socket_path);
! 1945: }
! 1946: }
! 1947:
! 1948: /* new in 7.45.0 */
! 1949: if(config->proto_default)
! 1950: my_setopt_str(curl, CURLOPT_DEFAULT_PROTOCOL, config->proto_default);
! 1951:
! 1952: /* new in 7.47.0 */
! 1953: if(config->expect100timeout > 0)
! 1954: my_setopt_str(curl, CURLOPT_EXPECT_100_TIMEOUT_MS,
! 1955: (long)(config->expect100timeout*1000));
! 1956:
! 1957: /* new in 7.48.0 */
! 1958: if(config->tftp_no_options)
! 1959: my_setopt(curl, CURLOPT_TFTP_NO_OPTIONS, 1L);
! 1960:
! 1961: /* new in 7.59.0 */
! 1962: if(config->happy_eyeballs_timeout_ms != CURL_HET_DEFAULT)
! 1963: my_setopt(curl, CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS,
! 1964: config->happy_eyeballs_timeout_ms);
! 1965:
! 1966: /* new in 7.60.0 */
! 1967: if(config->haproxy_protocol)
! 1968: my_setopt(curl, CURLOPT_HAPROXYPROTOCOL, 1L);
! 1969:
! 1970: if(config->disallow_username_in_url)
! 1971: my_setopt(curl, CURLOPT_DISALLOW_USERNAME_IN_URL, 1L);
! 1972:
! 1973: if(config->altsvc)
! 1974: my_setopt_str(curl, CURLOPT_ALTSVC, config->altsvc);
! 1975:
! 1976: #ifdef USE_METALINK
! 1977: if(!metalink && config->use_metalink) {
! 1978: outs->metalink_parser = metalink_parser_context_new();
! 1979: if(outs->metalink_parser == NULL) {
! 1980: result = CURLE_OUT_OF_MEMORY;
! 1981: break;
! 1982: }
! 1983: fprintf(config->global->errors,
! 1984: "Metalink: parsing (%s) metalink/XML...\n", per->this_url);
! 1985: }
! 1986: else if(metalink)
! 1987: fprintf(config->global->errors,
! 1988: "Metalink: fetching (%s) from (%s)...\n",
! 1989: mlfile->filename, per->this_url);
! 1990: #endif /* USE_METALINK */
! 1991:
! 1992: per->metalink = metalink;
! 1993: /* initialize retry vars for loop below */
! 1994: per->retry_sleep_default = (config->retry_delay) ?
! 1995: config->retry_delay*1000L : RETRY_SLEEP_DEFAULT; /* ms */
! 1996: per->retry_numretries = config->req_retry;
! 1997: per->retry_sleep = per->retry_sleep_default; /* ms */
! 1998: per->retrystart = tvnow();
! 1999:
! 2000: state->li++;
! 2001: /* Here's looping around each globbed URL */
! 2002: if(state->li >= urlnum) {
! 2003: state->li = 0;
! 2004: state->urlnum = 0; /* forced reglob of URLs */
! 2005: glob_cleanup(state->urls);
! 2006: state->urls = NULL;
! 2007: state->up++;
! 2008: Curl_safefree(state->uploadfile); /* clear it to get the next */
! 2009: }
! 2010: }
! 2011: else {
! 2012: /* Free this URL node data without destroying the
! 2013: the node itself nor modifying next pointer. */
! 2014: Curl_safefree(urlnode->outfile);
! 2015: Curl_safefree(urlnode->infile);
! 2016: urlnode->flags = 0;
! 2017: glob_cleanup(state->urls);
! 2018: state->urls = NULL;
! 2019: state->urlnum = 0;
! 2020:
! 2021: Curl_safefree(state->outfiles);
! 2022: Curl_safefree(state->uploadfile);
! 2023: if(state->inglob) {
! 2024: /* Free list of globbed upload files */
! 2025: glob_cleanup(state->inglob);
! 2026: state->inglob = NULL;
! 2027: }
! 2028: config->state.urlnode = urlnode->next;
! 2029: state->up = 0;
! 2030: continue;
! 2031: }
! 2032: }
! 2033: break;
! 2034: }
! 2035:
! 2036: if(!*added || result) {
! 2037: *added = FALSE;
! 2038: single_transfer_cleanup(config);
! 2039: }
! 2040: return result;
! 2041: }
! 2042:
! 2043: static long all_added; /* number of easy handles currently added */
! 2044:
! 2045: /*
! 2046: * add_parallel_transfers() sets 'morep' to TRUE if there are more transfers
! 2047: * to add even after this call returns. sets 'addedp' to TRUE if one or more
! 2048: * transfers were added.
! 2049: */
! 2050: static CURLcode add_parallel_transfers(struct GlobalConfig *global,
! 2051: CURLM *multi,
! 2052: CURLSH *share,
! 2053: bool *morep,
! 2054: bool *addedp)
! 2055: {
! 2056: struct per_transfer *per;
! 2057: CURLcode result = CURLE_OK;
! 2058: CURLMcode mcode;
! 2059: *addedp = FALSE;
! 2060: *morep = FALSE;
! 2061: result = create_transfer(global, share, addedp);
! 2062: if(result)
! 2063: return result;
! 2064: for(per = transfers; per && (all_added < global->parallel_max);
! 2065: per = per->next) {
! 2066: bool getadded = FALSE;
! 2067: if(per->added)
! 2068: /* already added */
! 2069: continue;
! 2070:
! 2071: result = pre_transfer(global, per);
! 2072: if(result)
! 2073: break;
! 2074:
! 2075: /* parallel connect means that we don't set PIPEWAIT since pipewait
! 2076: will make libcurl prefer multiplexing */
! 2077: (void)curl_easy_setopt(per->curl, CURLOPT_PIPEWAIT,
! 2078: global->parallel_connect ? 0L : 1L);
! 2079: (void)curl_easy_setopt(per->curl, CURLOPT_PRIVATE, per);
! 2080: (void)curl_easy_setopt(per->curl, CURLOPT_XFERINFOFUNCTION, xferinfo_cb);
! 2081: (void)curl_easy_setopt(per->curl, CURLOPT_XFERINFODATA, per);
! 2082:
! 2083: mcode = curl_multi_add_handle(multi, per->curl);
! 2084: if(mcode)
! 2085: return CURLE_OUT_OF_MEMORY;
! 2086:
! 2087: result = create_transfer(global, share, &getadded);
! 2088: if(result)
! 2089: return result;
! 2090: per->added = TRUE;
! 2091: all_added++;
! 2092: *addedp = TRUE;
! 2093: }
! 2094: *morep = per ? TRUE : FALSE;
! 2095: return CURLE_OK;
! 2096: }
! 2097:
! 2098: static CURLcode parallel_transfers(struct GlobalConfig *global,
! 2099: CURLSH *share)
! 2100: {
! 2101: CURLM *multi;
! 2102: CURLMcode mcode = CURLM_OK;
! 2103: CURLcode result = CURLE_OK;
! 2104: int still_running = 1;
! 2105: struct timeval start = tvnow();
! 2106: bool more_transfers;
! 2107: bool added_transfers;
! 2108:
! 2109: multi = curl_multi_init();
! 2110: if(!multi)
! 2111: return CURLE_OUT_OF_MEMORY;
! 2112:
! 2113: result = add_parallel_transfers(global, multi, share,
! 2114: &more_transfers, &added_transfers);
! 2115: if(result) {
! 2116: curl_multi_cleanup(multi);
! 2117: return result;
! 2118: }
! 2119:
! 2120: while(!mcode && (still_running || more_transfers)) {
! 2121: mcode = curl_multi_poll(multi, NULL, 0, 1000, NULL);
! 2122: if(!mcode)
! 2123: mcode = curl_multi_perform(multi, &still_running);
! 2124:
! 2125: progress_meter(global, &start, FALSE);
! 2126:
! 2127: if(!mcode) {
! 2128: int rc;
! 2129: CURLMsg *msg;
! 2130: bool removed = FALSE;
! 2131: do {
! 2132: msg = curl_multi_info_read(multi, &rc);
! 2133: if(msg) {
! 2134: bool retry;
! 2135: struct per_transfer *ended;
! 2136: CURL *easy = msg->easy_handle;
! 2137: result = msg->data.result;
! 2138: curl_easy_getinfo(easy, CURLINFO_PRIVATE, (void *)&ended);
! 2139: curl_multi_remove_handle(multi, easy);
! 2140:
! 2141: result = post_per_transfer(global, ended, result, &retry);
! 2142: if(retry)
! 2143: continue;
! 2144: progress_finalize(ended); /* before it goes away */
! 2145: all_added--; /* one fewer added */
! 2146: removed = TRUE;
! 2147: (void)del_per_transfer(ended);
! 2148: }
! 2149: } while(msg);
! 2150: if(removed) {
! 2151: /* one or more transfers completed, add more! */
! 2152: (void)add_parallel_transfers(global, multi, share,
! 2153: &more_transfers,
! 2154: &added_transfers);
! 2155: if(added_transfers)
! 2156: /* we added new ones, make sure the loop doesn't exit yet */
! 2157: still_running = 1;
! 2158: }
! 2159: }
! 2160: }
! 2161:
! 2162: (void)progress_meter(global, &start, TRUE);
! 2163:
! 2164: /* Make sure to return some kind of error if there was a multi problem */
! 2165: if(mcode) {
! 2166: result = (mcode == CURLM_OUT_OF_MEMORY) ? CURLE_OUT_OF_MEMORY :
! 2167: /* The other multi errors should never happen, so return
! 2168: something suitably generic */
! 2169: CURLE_BAD_FUNCTION_ARGUMENT;
! 2170: }
! 2171:
! 2172: curl_multi_cleanup(multi);
! 2173:
! 2174: return result;
! 2175: }
! 2176:
! 2177: static CURLcode serial_transfers(struct GlobalConfig *global,
! 2178: CURLSH *share)
! 2179: {
! 2180: CURLcode returncode = CURLE_OK;
! 2181: CURLcode result = CURLE_OK;
! 2182: struct per_transfer *per;
! 2183: bool added = FALSE;
! 2184:
! 2185: result = create_transfer(global, share, &added);
! 2186: if(result || !added)
! 2187: return result;
! 2188: for(per = transfers; per;) {
! 2189: bool retry;
! 2190: bool bailout = FALSE;
! 2191: result = pre_transfer(global, per);
! 2192: if(result)
! 2193: break;
! 2194:
! 2195: #ifndef CURL_DISABLE_LIBCURL_OPTION
! 2196: if(global->libcurl) {
! 2197: result = easysrc_perform();
! 2198: if(result)
! 2199: break;
! 2200: }
! 2201: #endif
! 2202: #ifdef CURLDEBUG
! 2203: if(global->test_event_based)
! 2204: result = curl_easy_perform_ev(per->curl);
! 2205: else
! 2206: #endif
! 2207: result = curl_easy_perform(per->curl);
! 2208:
! 2209: /* store the result of the actual transfer */
! 2210: returncode = result;
! 2211:
! 2212: result = post_per_transfer(global, per, result, &retry);
! 2213: if(retry)
! 2214: continue;
! 2215:
! 2216: /* Bail out upon critical errors or --fail-early */
! 2217: if(result || is_fatal_error(returncode) ||
! 2218: (returncode && global->fail_early))
! 2219: bailout = TRUE;
! 2220: else {
! 2221: /* setup the next one just before we delete this */
! 2222: result = create_transfer(global, share, &added);
! 2223: if(result)
! 2224: bailout = TRUE;
! 2225: }
! 2226:
! 2227: /* Release metalink related resources here */
! 2228: delete_metalinkfile(per->mlfile);
! 2229:
! 2230: per = del_per_transfer(per);
! 2231:
! 2232: if(bailout)
! 2233: break;
! 2234: }
! 2235: if(returncode)
! 2236: /* returncode errors have priority */
! 2237: result = returncode;
! 2238:
! 2239: if(result)
! 2240: single_transfer_cleanup(global->current);
! 2241:
! 2242: return result;
! 2243: }
! 2244:
! 2245: /* setup a transfer for the given config */
! 2246: static CURLcode transfer_per_config(struct GlobalConfig *global,
! 2247: struct OperationConfig *config,
! 2248: CURLSH *share,
! 2249: bool *added)
! 2250: {
! 2251: CURLcode result = CURLE_OK;
! 2252: bool capath_from_env;
! 2253: *added = FALSE;
! 2254:
! 2255: /* Check we have a url */
! 2256: if(!config->url_list || !config->url_list->url) {
! 2257: helpf(global->errors, "no URL specified!\n");
! 2258: return CURLE_FAILED_INIT;
! 2259: }
! 2260:
! 2261: /* On WIN32 we can't set the path to curl-ca-bundle.crt
! 2262: * at compile time. So we look here for the file in two ways:
! 2263: * 1: look at the environment variable CURL_CA_BUNDLE for a path
! 2264: * 2: if #1 isn't found, use the windows API function SearchPath()
! 2265: * to find it along the app's path (includes app's dir and CWD)
! 2266: *
! 2267: * We support the environment variable thing for non-Windows platforms
! 2268: * too. Just for the sake of it.
! 2269: */
! 2270: capath_from_env = false;
! 2271: if(!config->cacert &&
! 2272: !config->capath &&
! 2273: !config->insecure_ok) {
! 2274: CURL *curltls = curl_easy_init();
! 2275: struct curl_tlssessioninfo *tls_backend_info = NULL;
! 2276:
! 2277: /* With the addition of CAINFO support for Schannel, this search could find
! 2278: * a certificate bundle that was previously ignored. To maintain backward
! 2279: * compatibility, only perform this search if not using Schannel.
! 2280: */
! 2281: result = curl_easy_getinfo(curltls, CURLINFO_TLS_SSL_PTR,
! 2282: &tls_backend_info);
! 2283: if(result)
! 2284: return result;
! 2285:
! 2286: /* Set the CA cert locations specified in the environment. For Windows if
! 2287: * no environment-specified filename is found then check for CA bundle
! 2288: * default filename curl-ca-bundle.crt in the user's PATH.
! 2289: *
! 2290: * If Schannel is the selected SSL backend then these locations are
! 2291: * ignored. We allow setting CA location for schannel only when explicitly
! 2292: * specified by the user via CURLOPT_CAINFO / --cacert.
! 2293: */
! 2294: if(tls_backend_info->backend != CURLSSLBACKEND_SCHANNEL) {
! 2295: char *env;
! 2296: env = curlx_getenv("CURL_CA_BUNDLE");
! 2297: if(env) {
! 2298: config->cacert = strdup(env);
! 2299: if(!config->cacert) {
! 2300: curl_free(env);
! 2301: errorf(global, "out of memory\n");
! 2302: return CURLE_OUT_OF_MEMORY;
! 2303: }
! 2304: }
! 2305: else {
! 2306: env = curlx_getenv("SSL_CERT_DIR");
! 2307: if(env) {
! 2308: config->capath = strdup(env);
! 2309: if(!config->capath) {
! 2310: curl_free(env);
! 2311: helpf(global->errors, "out of memory\n");
! 2312: return CURLE_OUT_OF_MEMORY;
! 2313: }
! 2314: capath_from_env = true;
! 2315: }
! 2316: else {
! 2317: env = curlx_getenv("SSL_CERT_FILE");
! 2318: if(env) {
! 2319: config->cacert = strdup(env);
! 2320: if(!config->cacert) {
! 2321: curl_free(env);
! 2322: errorf(global, "out of memory\n");
! 2323: return CURLE_OUT_OF_MEMORY;
! 2324: }
! 2325: }
! 2326: }
! 2327: }
! 2328:
! 2329: if(env)
! 2330: curl_free(env);
! 2331: #ifdef WIN32
! 2332: else {
! 2333: result = FindWin32CACert(config, tls_backend_info->backend,
! 2334: "curl-ca-bundle.crt");
! 2335: }
! 2336: #endif
! 2337: }
! 2338: curl_easy_cleanup(curltls);
! 2339: }
! 2340:
! 2341: if(!result)
! 2342: result = single_transfer(global, config, share, capath_from_env, added);
! 2343:
! 2344: return result;
! 2345: }
! 2346:
! 2347: /*
! 2348: * 'create_transfer' gets the details and sets up a new transfer if 'added'
! 2349: * returns TRUE.
! 2350: */
! 2351: static CURLcode create_transfer(struct GlobalConfig *global,
! 2352: CURLSH *share,
! 2353: bool *added)
! 2354: {
! 2355: CURLcode result = CURLE_OK;
! 2356: *added = FALSE;
! 2357: while(global->current) {
! 2358: result = transfer_per_config(global, global->current, share, added);
! 2359: if(!result && !*added) {
! 2360: /* when one set is drained, continue to next */
! 2361: global->current = global->current->next;
! 2362: continue;
! 2363: }
! 2364: break;
! 2365: }
! 2366: return result;
! 2367: }
! 2368:
! 2369: static CURLcode run_all_transfers(struct GlobalConfig *global,
! 2370: CURLSH *share,
! 2371: CURLcode result)
! 2372: {
! 2373: /* Save the values of noprogress and isatty to restore them later on */
! 2374: bool orig_noprogress = global->noprogress;
! 2375: bool orig_isatty = global->isatty;
! 2376: struct per_transfer *per;
! 2377:
! 2378: /* Time to actually do the transfers */
! 2379: if(!result) {
! 2380: if(global->parallel)
! 2381: result = parallel_transfers(global, share);
! 2382: else
! 2383: result = serial_transfers(global, share);
! 2384: }
! 2385:
! 2386: /* cleanup if there are any left */
! 2387: for(per = transfers; per;) {
! 2388: bool retry;
! 2389: CURLcode result2 = post_per_transfer(global, per, result, &retry);
! 2390: if(!result)
! 2391: /* don't overwrite the original error */
! 2392: result = result2;
! 2393:
! 2394: /* Free list of given URLs */
! 2395: clean_getout(per->config);
! 2396:
! 2397: /* Release metalink related resources here */
! 2398: clean_metalink(per->config);
! 2399: per = del_per_transfer(per);
! 2400: }
! 2401:
! 2402: /* Reset the global config variables */
! 2403: global->noprogress = orig_noprogress;
! 2404: global->isatty = orig_isatty;
! 2405:
! 2406:
! 2407: return result;
! 2408: }
! 2409:
! 2410: CURLcode operate(struct GlobalConfig *global, int argc, argv_item_t argv[])
! 2411: {
! 2412: CURLcode result = CURLE_OK;
! 2413:
! 2414: /* Setup proper locale from environment */
! 2415: #ifdef HAVE_SETLOCALE
! 2416: setlocale(LC_ALL, "");
! 2417: #endif
! 2418:
! 2419: /* Parse .curlrc if necessary */
! 2420: if((argc == 1) ||
! 2421: (!curl_strequal(argv[1], "-q") &&
! 2422: !curl_strequal(argv[1], "--disable"))) {
! 2423: parseconfig(NULL, global); /* ignore possible failure */
! 2424:
! 2425: /* If we had no arguments then make sure a url was specified in .curlrc */
! 2426: if((argc < 2) && (!global->first->url_list)) {
! 2427: helpf(global->errors, NULL);
! 2428: result = CURLE_FAILED_INIT;
! 2429: }
! 2430: }
! 2431:
! 2432: if(!result) {
! 2433: /* Parse the command line arguments */
! 2434: ParameterError res = parse_args(global, argc, argv);
! 2435: if(res) {
! 2436: result = CURLE_OK;
! 2437:
! 2438: /* Check if we were asked for the help */
! 2439: if(res == PARAM_HELP_REQUESTED)
! 2440: tool_help();
! 2441: /* Check if we were asked for the manual */
! 2442: else if(res == PARAM_MANUAL_REQUESTED)
! 2443: hugehelp();
! 2444: /* Check if we were asked for the version information */
! 2445: else if(res == PARAM_VERSION_INFO_REQUESTED)
! 2446: tool_version_info();
! 2447: /* Check if we were asked to list the SSL engines */
! 2448: else if(res == PARAM_ENGINES_REQUESTED)
! 2449: tool_list_engines();
! 2450: else if(res == PARAM_LIBCURL_UNSUPPORTED_PROTOCOL)
! 2451: result = CURLE_UNSUPPORTED_PROTOCOL;
! 2452: else
! 2453: result = CURLE_FAILED_INIT;
! 2454: }
! 2455: else {
! 2456: #ifndef CURL_DISABLE_LIBCURL_OPTION
! 2457: if(global->libcurl) {
! 2458: /* Initialise the libcurl source output */
! 2459: result = easysrc_init();
! 2460: }
! 2461: #endif
! 2462:
! 2463: /* Perform the main operations */
! 2464: if(!result) {
! 2465: size_t count = 0;
! 2466: struct OperationConfig *operation = global->first;
! 2467: CURLSH *share = curl_share_init();
! 2468: if(!share) {
! 2469: #ifndef CURL_DISABLE_LIBCURL_OPTION
! 2470: if(global->libcurl) {
! 2471: /* Cleanup the libcurl source output */
! 2472: easysrc_cleanup();
! 2473: }
! 2474: #endif
! 2475: return CURLE_OUT_OF_MEMORY;
! 2476: }
! 2477:
! 2478: curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
! 2479: curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
! 2480: curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_SSL_SESSION);
! 2481: curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_CONNECT);
! 2482: curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_PSL);
! 2483:
! 2484: /* Get the required arguments for each operation */
! 2485: do {
! 2486: result = get_args(operation, count++);
! 2487:
! 2488: operation = operation->next;
! 2489: } while(!result && operation);
! 2490:
! 2491: /* Set the current operation pointer */
! 2492: global->current = global->first;
! 2493:
! 2494: /* now run! */
! 2495: result = run_all_transfers(global, share, result);
! 2496:
! 2497: curl_share_cleanup(share);
! 2498: #ifndef CURL_DISABLE_LIBCURL_OPTION
! 2499: if(global->libcurl) {
! 2500: /* Cleanup the libcurl source output */
! 2501: easysrc_cleanup();
! 2502:
! 2503: /* Dump the libcurl code if previously enabled */
! 2504: dumpeasysrc(global);
! 2505: }
! 2506: #endif
! 2507: }
! 2508: else
! 2509: errorf(global, "out of memory\n");
! 2510: }
! 2511: }
! 2512:
! 2513: return result;
! 2514: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to tool_operate.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / src