Annotation of embedaddon/curl/lib/setopt.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:
! 23: #include "curl_setup.h"
! 24:
! 25: #include <limits.h>
! 26:
! 27: #ifdef HAVE_NETINET_IN_H
! 28: #include <netinet/in.h>
! 29: #endif
! 30:
! 31: #ifdef HAVE_LINUX_TCP_H
! 32: #include <linux/tcp.h>
! 33: #endif
! 34:
! 35: #include "urldata.h"
! 36: #include "url.h"
! 37: #include "progress.h"
! 38: #include "content_encoding.h"
! 39: #include "strcase.h"
! 40: #include "share.h"
! 41: #include "vtls/vtls.h"
! 42: #include "warnless.h"
! 43: #include "sendf.h"
! 44: #include "http2.h"
! 45: #include "setopt.h"
! 46: #include "multiif.h"
! 47: #include "altsvc.h"
! 48:
! 49: /* The last 3 #include files should be in this order */
! 50: #include "curl_printf.h"
! 51: #include "curl_memory.h"
! 52: #include "memdebug.h"
! 53:
! 54: CURLcode Curl_setstropt(char **charp, const char *s)
! 55: {
! 56: /* Release the previous storage at `charp' and replace by a dynamic storage
! 57: copy of `s'. Return CURLE_OK or CURLE_OUT_OF_MEMORY. */
! 58:
! 59: Curl_safefree(*charp);
! 60:
! 61: if(s) {
! 62: char *str = strdup(s);
! 63:
! 64: if(str) {
! 65: size_t len = strlen(str);
! 66: if(len > CURL_MAX_INPUT_LENGTH) {
! 67: free(str);
! 68: return CURLE_BAD_FUNCTION_ARGUMENT;
! 69: }
! 70: }
! 71: if(!str)
! 72: return CURLE_OUT_OF_MEMORY;
! 73:
! 74: *charp = str;
! 75: }
! 76:
! 77: return CURLE_OK;
! 78: }
! 79:
! 80: static CURLcode setstropt_userpwd(char *option, char **userp, char **passwdp)
! 81: {
! 82: CURLcode result = CURLE_OK;
! 83: char *user = NULL;
! 84: char *passwd = NULL;
! 85:
! 86: /* Parse the login details if specified. It not then we treat NULL as a hint
! 87: to clear the existing data */
! 88: if(option) {
! 89: result = Curl_parse_login_details(option, strlen(option),
! 90: (userp ? &user : NULL),
! 91: (passwdp ? &passwd : NULL),
! 92: NULL);
! 93: }
! 94:
! 95: if(!result) {
! 96: /* Store the username part of option if required */
! 97: if(userp) {
! 98: if(!user && option && option[0] == ':') {
! 99: /* Allocate an empty string instead of returning NULL as user name */
! 100: user = strdup("");
! 101: if(!user)
! 102: result = CURLE_OUT_OF_MEMORY;
! 103: }
! 104:
! 105: Curl_safefree(*userp);
! 106: *userp = user;
! 107: }
! 108:
! 109: /* Store the password part of option if required */
! 110: if(passwdp) {
! 111: Curl_safefree(*passwdp);
! 112: *passwdp = passwd;
! 113: }
! 114: }
! 115:
! 116: return result;
! 117: }
! 118:
! 119: #define C_SSLVERSION_VALUE(x) (x & 0xffff)
! 120: #define C_SSLVERSION_MAX_VALUE(x) (x & 0xffff0000)
! 121:
! 122: /*
! 123: * Do not make Curl_vsetopt() static: it is called from
! 124: * packages/OS400/ccsidcurl.c.
! 125: */
! 126: CURLcode Curl_vsetopt(struct Curl_easy *data, CURLoption option, va_list param)
! 127: {
! 128: char *argptr;
! 129: CURLcode result = CURLE_OK;
! 130: long arg;
! 131: unsigned long uarg;
! 132: curl_off_t bigsize;
! 133:
! 134: switch(option) {
! 135: case CURLOPT_DNS_CACHE_TIMEOUT:
! 136: arg = va_arg(param, long);
! 137: if(arg < -1)
! 138: return CURLE_BAD_FUNCTION_ARGUMENT;
! 139: data->set.dns_cache_timeout = arg;
! 140: break;
! 141: case CURLOPT_DNS_USE_GLOBAL_CACHE:
! 142: /* deprecated */
! 143: break;
! 144: case CURLOPT_SSL_CIPHER_LIST:
! 145: /* set a list of cipher we want to use in the SSL connection */
! 146: result = Curl_setstropt(&data->set.str[STRING_SSL_CIPHER_LIST_ORIG],
! 147: va_arg(param, char *));
! 148: break;
! 149: #ifndef CURL_DISABLE_PROXY
! 150: case CURLOPT_PROXY_SSL_CIPHER_LIST:
! 151: /* set a list of cipher we want to use in the SSL connection for proxy */
! 152: result = Curl_setstropt(&data->set.str[STRING_SSL_CIPHER_LIST_PROXY],
! 153: va_arg(param, char *));
! 154: break;
! 155: #endif
! 156: case CURLOPT_TLS13_CIPHERS:
! 157: if(Curl_ssl_tls13_ciphersuites()) {
! 158: /* set preferred list of TLS 1.3 cipher suites */
! 159: result = Curl_setstropt(&data->set.str[STRING_SSL_CIPHER13_LIST_ORIG],
! 160: va_arg(param, char *));
! 161: }
! 162: else
! 163: return CURLE_NOT_BUILT_IN;
! 164: break;
! 165: #ifndef CURL_DISABLE_PROXY
! 166: case CURLOPT_PROXY_TLS13_CIPHERS:
! 167: if(Curl_ssl_tls13_ciphersuites()) {
! 168: /* set preferred list of TLS 1.3 cipher suites for proxy */
! 169: result = Curl_setstropt(&data->set.str[STRING_SSL_CIPHER13_LIST_PROXY],
! 170: va_arg(param, char *));
! 171: }
! 172: else
! 173: return CURLE_NOT_BUILT_IN;
! 174: break;
! 175: #endif
! 176: case CURLOPT_RANDOM_FILE:
! 177: /*
! 178: * This is the path name to a file that contains random data to seed
! 179: * the random SSL stuff with. The file is only used for reading.
! 180: */
! 181: result = Curl_setstropt(&data->set.str[STRING_SSL_RANDOM_FILE],
! 182: va_arg(param, char *));
! 183: break;
! 184: case CURLOPT_EGDSOCKET:
! 185: /*
! 186: * The Entropy Gathering Daemon socket pathname
! 187: */
! 188: result = Curl_setstropt(&data->set.str[STRING_SSL_EGDSOCKET],
! 189: va_arg(param, char *));
! 190: break;
! 191: case CURLOPT_MAXCONNECTS:
! 192: /*
! 193: * Set the absolute number of maximum simultaneous alive connection that
! 194: * libcurl is allowed to have.
! 195: */
! 196: arg = va_arg(param, long);
! 197: if(arg < 0)
! 198: return CURLE_BAD_FUNCTION_ARGUMENT;
! 199: data->set.maxconnects = arg;
! 200: break;
! 201: case CURLOPT_FORBID_REUSE:
! 202: /*
! 203: * When this transfer is done, it must not be left to be reused by a
! 204: * subsequent transfer but shall be closed immediately.
! 205: */
! 206: data->set.reuse_forbid = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 207: break;
! 208: case CURLOPT_FRESH_CONNECT:
! 209: /*
! 210: * This transfer shall not use a previously cached connection but
! 211: * should be made with a fresh new connect!
! 212: */
! 213: data->set.reuse_fresh = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 214: break;
! 215: case CURLOPT_VERBOSE:
! 216: /*
! 217: * Verbose means infof() calls that give a lot of information about
! 218: * the connection and transfer procedures as well as internal choices.
! 219: */
! 220: data->set.verbose = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 221: break;
! 222: case CURLOPT_HEADER:
! 223: /*
! 224: * Set to include the header in the general data output stream.
! 225: */
! 226: data->set.include_header = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 227: break;
! 228: case CURLOPT_NOPROGRESS:
! 229: /*
! 230: * Shut off the internal supported progress meter
! 231: */
! 232: data->set.hide_progress = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 233: if(data->set.hide_progress)
! 234: data->progress.flags |= PGRS_HIDE;
! 235: else
! 236: data->progress.flags &= ~PGRS_HIDE;
! 237: break;
! 238: case CURLOPT_NOBODY:
! 239: /*
! 240: * Do not include the body part in the output data stream.
! 241: */
! 242: data->set.opt_no_body = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 243: break;
! 244: case CURLOPT_FAILONERROR:
! 245: /*
! 246: * Don't output the >=400 error code HTML-page, but instead only
! 247: * return error.
! 248: */
! 249: data->set.http_fail_on_error = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 250: break;
! 251: case CURLOPT_KEEP_SENDING_ON_ERROR:
! 252: data->set.http_keep_sending_on_error = (0 != va_arg(param, long)) ?
! 253: TRUE : FALSE;
! 254: break;
! 255: case CURLOPT_UPLOAD:
! 256: case CURLOPT_PUT:
! 257: /*
! 258: * We want to sent data to the remote host. If this is HTTP, that equals
! 259: * using the PUT request.
! 260: */
! 261: data->set.upload = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 262: if(data->set.upload) {
! 263: /* If this is HTTP, PUT is what's needed to "upload" */
! 264: data->set.httpreq = HTTPREQ_PUT;
! 265: data->set.opt_no_body = FALSE; /* this is implied */
! 266: }
! 267: else
! 268: /* In HTTP, the opposite of upload is GET (unless NOBODY is true as
! 269: then this can be changed to HEAD later on) */
! 270: data->set.httpreq = HTTPREQ_GET;
! 271: break;
! 272: case CURLOPT_REQUEST_TARGET:
! 273: result = Curl_setstropt(&data->set.str[STRING_TARGET],
! 274: va_arg(param, char *));
! 275: break;
! 276: case CURLOPT_FILETIME:
! 277: /*
! 278: * Try to get the file time of the remote document. The time will
! 279: * later (possibly) become available using curl_easy_getinfo().
! 280: */
! 281: data->set.get_filetime = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 282: break;
! 283: case CURLOPT_SERVER_RESPONSE_TIMEOUT:
! 284: /*
! 285: * Option that specifies how quickly an server response must be obtained
! 286: * before it is considered failure. For pingpong protocols.
! 287: */
! 288: arg = va_arg(param, long);
! 289: if((arg >= 0) && (arg <= (INT_MAX/1000)))
! 290: data->set.server_response_timeout = arg * 1000;
! 291: else
! 292: return CURLE_BAD_FUNCTION_ARGUMENT;
! 293: break;
! 294: #ifndef CURL_DISABLE_TFTP
! 295: case CURLOPT_TFTP_NO_OPTIONS:
! 296: /*
! 297: * Option that prevents libcurl from sending TFTP option requests to the
! 298: * server.
! 299: */
! 300: data->set.tftp_no_options = va_arg(param, long) != 0;
! 301: break;
! 302: case CURLOPT_TFTP_BLKSIZE:
! 303: /*
! 304: * TFTP option that specifies the block size to use for data transmission.
! 305: */
! 306: arg = va_arg(param, long);
! 307: if(arg < 0)
! 308: return CURLE_BAD_FUNCTION_ARGUMENT;
! 309: data->set.tftp_blksize = arg;
! 310: break;
! 311: #endif
! 312: #ifndef CURL_DISABLE_NETRC
! 313: case CURLOPT_NETRC:
! 314: /*
! 315: * Parse the $HOME/.netrc file
! 316: */
! 317: arg = va_arg(param, long);
! 318: if((arg < CURL_NETRC_IGNORED) || (arg >= CURL_NETRC_LAST))
! 319: return CURLE_BAD_FUNCTION_ARGUMENT;
! 320: data->set.use_netrc = (enum CURL_NETRC_OPTION)arg;
! 321: break;
! 322: case CURLOPT_NETRC_FILE:
! 323: /*
! 324: * Use this file instead of the $HOME/.netrc file
! 325: */
! 326: result = Curl_setstropt(&data->set.str[STRING_NETRC_FILE],
! 327: va_arg(param, char *));
! 328: break;
! 329: #endif
! 330: case CURLOPT_TRANSFERTEXT:
! 331: /*
! 332: * This option was previously named 'FTPASCII'. Renamed to work with
! 333: * more protocols than merely FTP.
! 334: *
! 335: * Transfer using ASCII (instead of BINARY).
! 336: */
! 337: data->set.prefer_ascii = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 338: break;
! 339: case CURLOPT_TIMECONDITION:
! 340: /*
! 341: * Set HTTP time condition. This must be one of the defines in the
! 342: * curl/curl.h header file.
! 343: */
! 344: arg = va_arg(param, long);
! 345: if((arg < CURL_TIMECOND_NONE) || (arg >= CURL_TIMECOND_LAST))
! 346: return CURLE_BAD_FUNCTION_ARGUMENT;
! 347: data->set.timecondition = (curl_TimeCond)arg;
! 348: break;
! 349: case CURLOPT_TIMEVALUE:
! 350: /*
! 351: * This is the value to compare with the remote document with the
! 352: * method set with CURLOPT_TIMECONDITION
! 353: */
! 354: data->set.timevalue = (time_t)va_arg(param, long);
! 355: break;
! 356:
! 357: case CURLOPT_TIMEVALUE_LARGE:
! 358: /*
! 359: * This is the value to compare with the remote document with the
! 360: * method set with CURLOPT_TIMECONDITION
! 361: */
! 362: data->set.timevalue = (time_t)va_arg(param, curl_off_t);
! 363: break;
! 364:
! 365: case CURLOPT_SSLVERSION:
! 366: case CURLOPT_PROXY_SSLVERSION:
! 367: /*
! 368: * Set explicit SSL version to try to connect with, as some SSL
! 369: * implementations are lame.
! 370: */
! 371: #ifdef USE_SSL
! 372: {
! 373: long version, version_max;
! 374: struct ssl_primary_config *primary = (option == CURLOPT_SSLVERSION ?
! 375: &data->set.ssl.primary :
! 376: &data->set.proxy_ssl.primary);
! 377:
! 378: arg = va_arg(param, long);
! 379:
! 380: version = C_SSLVERSION_VALUE(arg);
! 381: version_max = C_SSLVERSION_MAX_VALUE(arg);
! 382:
! 383: if(version < CURL_SSLVERSION_DEFAULT ||
! 384: version >= CURL_SSLVERSION_LAST ||
! 385: version_max < CURL_SSLVERSION_MAX_NONE ||
! 386: version_max >= CURL_SSLVERSION_MAX_LAST)
! 387: return CURLE_BAD_FUNCTION_ARGUMENT;
! 388:
! 389: primary->version = version;
! 390: primary->version_max = version_max;
! 391: }
! 392: #else
! 393: result = CURLE_UNKNOWN_OPTION;
! 394: #endif
! 395: break;
! 396:
! 397: #ifndef CURL_DISABLE_HTTP
! 398: case CURLOPT_AUTOREFERER:
! 399: /*
! 400: * Switch on automatic referer that gets set if curl follows locations.
! 401: */
! 402: data->set.http_auto_referer = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 403: break;
! 404:
! 405: case CURLOPT_ACCEPT_ENCODING:
! 406: /*
! 407: * String to use at the value of Accept-Encoding header.
! 408: *
! 409: * If the encoding is set to "" we use an Accept-Encoding header that
! 410: * encompasses all the encodings we support.
! 411: * If the encoding is set to NULL we don't send an Accept-Encoding header
! 412: * and ignore an received Content-Encoding header.
! 413: *
! 414: */
! 415: argptr = va_arg(param, char *);
! 416: if(argptr && !*argptr) {
! 417: argptr = Curl_all_content_encodings();
! 418: if(!argptr)
! 419: result = CURLE_OUT_OF_MEMORY;
! 420: else {
! 421: result = Curl_setstropt(&data->set.str[STRING_ENCODING], argptr);
! 422: free(argptr);
! 423: }
! 424: }
! 425: else
! 426: result = Curl_setstropt(&data->set.str[STRING_ENCODING], argptr);
! 427: break;
! 428:
! 429: case CURLOPT_TRANSFER_ENCODING:
! 430: data->set.http_transfer_encoding = (0 != va_arg(param, long)) ?
! 431: TRUE : FALSE;
! 432: break;
! 433:
! 434: case CURLOPT_FOLLOWLOCATION:
! 435: /*
! 436: * Follow Location: header hints on a HTTP-server.
! 437: */
! 438: data->set.http_follow_location = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 439: break;
! 440:
! 441: case CURLOPT_UNRESTRICTED_AUTH:
! 442: /*
! 443: * Send authentication (user+password) when following locations, even when
! 444: * hostname changed.
! 445: */
! 446: data->set.allow_auth_to_other_hosts =
! 447: (0 != va_arg(param, long)) ? TRUE : FALSE;
! 448: break;
! 449:
! 450: case CURLOPT_MAXREDIRS:
! 451: /*
! 452: * The maximum amount of hops you allow curl to follow Location:
! 453: * headers. This should mostly be used to detect never-ending loops.
! 454: */
! 455: arg = va_arg(param, long);
! 456: if(arg < -1)
! 457: return CURLE_BAD_FUNCTION_ARGUMENT;
! 458: data->set.maxredirs = arg;
! 459: break;
! 460:
! 461: case CURLOPT_POSTREDIR:
! 462: /*
! 463: * Set the behaviour of POST when redirecting
! 464: * CURL_REDIR_GET_ALL - POST is changed to GET after 301 and 302
! 465: * CURL_REDIR_POST_301 - POST is kept as POST after 301
! 466: * CURL_REDIR_POST_302 - POST is kept as POST after 302
! 467: * CURL_REDIR_POST_303 - POST is kept as POST after 303
! 468: * CURL_REDIR_POST_ALL - POST is kept as POST after 301, 302 and 303
! 469: * other - POST is kept as POST after 301 and 302
! 470: */
! 471: arg = va_arg(param, long);
! 472: if(arg < CURL_REDIR_GET_ALL)
! 473: /* no return error on too high numbers since the bitmask could be
! 474: extended in a future */
! 475: return CURLE_BAD_FUNCTION_ARGUMENT;
! 476: data->set.keep_post = arg & CURL_REDIR_POST_ALL;
! 477: break;
! 478:
! 479: case CURLOPT_POST:
! 480: /* Does this option serve a purpose anymore? Yes it does, when
! 481: CURLOPT_POSTFIELDS isn't used and the POST data is read off the
! 482: callback! */
! 483: if(va_arg(param, long)) {
! 484: data->set.httpreq = HTTPREQ_POST;
! 485: data->set.opt_no_body = FALSE; /* this is implied */
! 486: }
! 487: else
! 488: data->set.httpreq = HTTPREQ_GET;
! 489: break;
! 490:
! 491: case CURLOPT_COPYPOSTFIELDS:
! 492: /*
! 493: * A string with POST data. Makes curl HTTP POST. Even if it is NULL.
! 494: * If needed, CURLOPT_POSTFIELDSIZE must have been set prior to
! 495: * CURLOPT_COPYPOSTFIELDS and not altered later.
! 496: */
! 497: argptr = va_arg(param, char *);
! 498:
! 499: if(!argptr || data->set.postfieldsize == -1)
! 500: result = Curl_setstropt(&data->set.str[STRING_COPYPOSTFIELDS], argptr);
! 501: else {
! 502: /*
! 503: * Check that requested length does not overflow the size_t type.
! 504: */
! 505:
! 506: if((data->set.postfieldsize < 0) ||
! 507: ((sizeof(curl_off_t) != sizeof(size_t)) &&
! 508: (data->set.postfieldsize > (curl_off_t)((size_t)-1))))
! 509: result = CURLE_OUT_OF_MEMORY;
! 510: else {
! 511: char *p;
! 512:
! 513: (void) Curl_setstropt(&data->set.str[STRING_COPYPOSTFIELDS], NULL);
! 514:
! 515: /* Allocate even when size == 0. This satisfies the need of possible
! 516: later address compare to detect the COPYPOSTFIELDS mode, and
! 517: to mark that postfields is used rather than read function or
! 518: form data.
! 519: */
! 520: p = malloc((size_t)(data->set.postfieldsize?
! 521: data->set.postfieldsize:1));
! 522:
! 523: if(!p)
! 524: result = CURLE_OUT_OF_MEMORY;
! 525: else {
! 526: if(data->set.postfieldsize)
! 527: memcpy(p, argptr, (size_t)data->set.postfieldsize);
! 528:
! 529: data->set.str[STRING_COPYPOSTFIELDS] = p;
! 530: }
! 531: }
! 532: }
! 533:
! 534: data->set.postfields = data->set.str[STRING_COPYPOSTFIELDS];
! 535: data->set.httpreq = HTTPREQ_POST;
! 536: break;
! 537:
! 538: case CURLOPT_POSTFIELDS:
! 539: /*
! 540: * Like above, but use static data instead of copying it.
! 541: */
! 542: data->set.postfields = va_arg(param, void *);
! 543: /* Release old copied data. */
! 544: (void) Curl_setstropt(&data->set.str[STRING_COPYPOSTFIELDS], NULL);
! 545: data->set.httpreq = HTTPREQ_POST;
! 546: break;
! 547:
! 548: case CURLOPT_POSTFIELDSIZE:
! 549: /*
! 550: * The size of the POSTFIELD data to prevent libcurl to do strlen() to
! 551: * figure it out. Enables binary posts.
! 552: */
! 553: bigsize = va_arg(param, long);
! 554: if(bigsize < -1)
! 555: return CURLE_BAD_FUNCTION_ARGUMENT;
! 556:
! 557: if(data->set.postfieldsize < bigsize &&
! 558: data->set.postfields == data->set.str[STRING_COPYPOSTFIELDS]) {
! 559: /* Previous CURLOPT_COPYPOSTFIELDS is no longer valid. */
! 560: (void) Curl_setstropt(&data->set.str[STRING_COPYPOSTFIELDS], NULL);
! 561: data->set.postfields = NULL;
! 562: }
! 563:
! 564: data->set.postfieldsize = bigsize;
! 565: break;
! 566:
! 567: case CURLOPT_POSTFIELDSIZE_LARGE:
! 568: /*
! 569: * The size of the POSTFIELD data to prevent libcurl to do strlen() to
! 570: * figure it out. Enables binary posts.
! 571: */
! 572: bigsize = va_arg(param, curl_off_t);
! 573: if(bigsize < -1)
! 574: return CURLE_BAD_FUNCTION_ARGUMENT;
! 575:
! 576: if(data->set.postfieldsize < bigsize &&
! 577: data->set.postfields == data->set.str[STRING_COPYPOSTFIELDS]) {
! 578: /* Previous CURLOPT_COPYPOSTFIELDS is no longer valid. */
! 579: (void) Curl_setstropt(&data->set.str[STRING_COPYPOSTFIELDS], NULL);
! 580: data->set.postfields = NULL;
! 581: }
! 582:
! 583: data->set.postfieldsize = bigsize;
! 584: break;
! 585:
! 586: case CURLOPT_HTTPPOST:
! 587: /*
! 588: * Set to make us do HTTP POST
! 589: */
! 590: data->set.httppost = va_arg(param, struct curl_httppost *);
! 591: data->set.httpreq = HTTPREQ_POST_FORM;
! 592: data->set.opt_no_body = FALSE; /* this is implied */
! 593: break;
! 594: #endif /* CURL_DISABLE_HTTP */
! 595:
! 596: case CURLOPT_MIMEPOST:
! 597: /*
! 598: * Set to make us do MIME/form POST
! 599: */
! 600: result = Curl_mime_set_subparts(&data->set.mimepost,
! 601: va_arg(param, curl_mime *), FALSE);
! 602: if(!result) {
! 603: data->set.httpreq = HTTPREQ_POST_MIME;
! 604: data->set.opt_no_body = FALSE; /* this is implied */
! 605: }
! 606: break;
! 607:
! 608: case CURLOPT_REFERER:
! 609: /*
! 610: * String to set in the HTTP Referer: field.
! 611: */
! 612: if(data->change.referer_alloc) {
! 613: Curl_safefree(data->change.referer);
! 614: data->change.referer_alloc = FALSE;
! 615: }
! 616: result = Curl_setstropt(&data->set.str[STRING_SET_REFERER],
! 617: va_arg(param, char *));
! 618: data->change.referer = data->set.str[STRING_SET_REFERER];
! 619: break;
! 620:
! 621: case CURLOPT_USERAGENT:
! 622: /*
! 623: * String to use in the HTTP User-Agent field
! 624: */
! 625: result = Curl_setstropt(&data->set.str[STRING_USERAGENT],
! 626: va_arg(param, char *));
! 627: break;
! 628:
! 629: case CURLOPT_HTTPHEADER:
! 630: /*
! 631: * Set a list with HTTP headers to use (or replace internals with)
! 632: */
! 633: data->set.headers = va_arg(param, struct curl_slist *);
! 634: break;
! 635:
! 636: #ifndef CURL_DISABLE_HTTP
! 637: #ifndef CURL_DISABLE_PROXY
! 638: case CURLOPT_PROXYHEADER:
! 639: /*
! 640: * Set a list with proxy headers to use (or replace internals with)
! 641: *
! 642: * Since CURLOPT_HTTPHEADER was the only way to set HTTP headers for a
! 643: * long time we remain doing it this way until CURLOPT_PROXYHEADER is
! 644: * used. As soon as this option has been used, if set to anything but
! 645: * NULL, custom headers for proxies are only picked from this list.
! 646: *
! 647: * Set this option to NULL to restore the previous behavior.
! 648: */
! 649: data->set.proxyheaders = va_arg(param, struct curl_slist *);
! 650: break;
! 651: #endif
! 652: case CURLOPT_HEADEROPT:
! 653: /*
! 654: * Set header option.
! 655: */
! 656: arg = va_arg(param, long);
! 657: data->set.sep_headers = (bool)((arg & CURLHEADER_SEPARATE)? TRUE: FALSE);
! 658: break;
! 659:
! 660: case CURLOPT_HTTP200ALIASES:
! 661: /*
! 662: * Set a list of aliases for HTTP 200 in response header
! 663: */
! 664: data->set.http200aliases = va_arg(param, struct curl_slist *);
! 665: break;
! 666:
! 667: #if !defined(CURL_DISABLE_COOKIES)
! 668: case CURLOPT_COOKIE:
! 669: /*
! 670: * Cookie string to send to the remote server in the request.
! 671: */
! 672: result = Curl_setstropt(&data->set.str[STRING_COOKIE],
! 673: va_arg(param, char *));
! 674: break;
! 675:
! 676: case CURLOPT_COOKIEFILE:
! 677: /*
! 678: * Set cookie file to read and parse. Can be used multiple times.
! 679: */
! 680: argptr = (char *)va_arg(param, void *);
! 681: if(argptr) {
! 682: struct curl_slist *cl;
! 683: /* append the cookie file name to the list of file names, and deal with
! 684: them later */
! 685: cl = curl_slist_append(data->change.cookielist, argptr);
! 686: if(!cl) {
! 687: curl_slist_free_all(data->change.cookielist);
! 688: data->change.cookielist = NULL;
! 689: return CURLE_OUT_OF_MEMORY;
! 690: }
! 691: data->change.cookielist = cl; /* store the list for later use */
! 692: }
! 693: break;
! 694:
! 695: case CURLOPT_COOKIEJAR:
! 696: /*
! 697: * Set cookie file name to dump all cookies to when we're done.
! 698: */
! 699: {
! 700: struct CookieInfo *newcookies;
! 701: result = Curl_setstropt(&data->set.str[STRING_COOKIEJAR],
! 702: va_arg(param, char *));
! 703:
! 704: /*
! 705: * Activate the cookie parser. This may or may not already
! 706: * have been made.
! 707: */
! 708: newcookies = Curl_cookie_init(data, NULL, data->cookies,
! 709: data->set.cookiesession);
! 710: if(!newcookies)
! 711: result = CURLE_OUT_OF_MEMORY;
! 712: data->cookies = newcookies;
! 713: }
! 714: break;
! 715:
! 716: case CURLOPT_COOKIESESSION:
! 717: /*
! 718: * Set this option to TRUE to start a new "cookie session". It will
! 719: * prevent the forthcoming read-cookies-from-file actions to accept
! 720: * cookies that are marked as being session cookies, as they belong to a
! 721: * previous session.
! 722: *
! 723: * In the original Netscape cookie spec, "session cookies" are cookies
! 724: * with no expire date set. RFC2109 describes the same action if no
! 725: * 'Max-Age' is set and RFC2965 includes the RFC2109 description and adds
! 726: * a 'Discard' action that can enforce the discard even for cookies that
! 727: * have a Max-Age.
! 728: *
! 729: * We run mostly with the original cookie spec, as hardly anyone implements
! 730: * anything else.
! 731: */
! 732: data->set.cookiesession = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 733: break;
! 734:
! 735: case CURLOPT_COOKIELIST:
! 736: argptr = va_arg(param, char *);
! 737:
! 738: if(argptr == NULL)
! 739: break;
! 740:
! 741: if(strcasecompare(argptr, "ALL")) {
! 742: /* clear all cookies */
! 743: Curl_share_lock(data, CURL_LOCK_DATA_COOKIE, CURL_LOCK_ACCESS_SINGLE);
! 744: Curl_cookie_clearall(data->cookies);
! 745: Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE);
! 746: }
! 747: else if(strcasecompare(argptr, "SESS")) {
! 748: /* clear session cookies */
! 749: Curl_share_lock(data, CURL_LOCK_DATA_COOKIE, CURL_LOCK_ACCESS_SINGLE);
! 750: Curl_cookie_clearsess(data->cookies);
! 751: Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE);
! 752: }
! 753: else if(strcasecompare(argptr, "FLUSH")) {
! 754: /* flush cookies to file, takes care of the locking */
! 755: Curl_flush_cookies(data, FALSE);
! 756: }
! 757: else if(strcasecompare(argptr, "RELOAD")) {
! 758: /* reload cookies from file */
! 759: Curl_cookie_loadfiles(data);
! 760: break;
! 761: }
! 762: else {
! 763: if(!data->cookies)
! 764: /* if cookie engine was not running, activate it */
! 765: data->cookies = Curl_cookie_init(data, NULL, NULL, TRUE);
! 766:
! 767: argptr = strdup(argptr);
! 768: if(!argptr || !data->cookies) {
! 769: result = CURLE_OUT_OF_MEMORY;
! 770: free(argptr);
! 771: }
! 772: else {
! 773: Curl_share_lock(data, CURL_LOCK_DATA_COOKIE, CURL_LOCK_ACCESS_SINGLE);
! 774:
! 775: if(checkprefix("Set-Cookie:", argptr))
! 776: /* HTTP Header format line */
! 777: Curl_cookie_add(data, data->cookies, TRUE, FALSE, argptr + 11, NULL,
! 778: NULL, TRUE);
! 779:
! 780: else
! 781: /* Netscape format line */
! 782: Curl_cookie_add(data, data->cookies, FALSE, FALSE, argptr, NULL,
! 783: NULL, TRUE);
! 784:
! 785: Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE);
! 786: free(argptr);
! 787: }
! 788: }
! 789:
! 790: break;
! 791: #endif /* !CURL_DISABLE_COOKIES */
! 792:
! 793: case CURLOPT_HTTPGET:
! 794: /*
! 795: * Set to force us do HTTP GET
! 796: */
! 797: if(va_arg(param, long)) {
! 798: data->set.httpreq = HTTPREQ_GET;
! 799: data->set.upload = FALSE; /* switch off upload */
! 800: data->set.opt_no_body = FALSE; /* this is implied */
! 801: }
! 802: break;
! 803:
! 804: case CURLOPT_HTTP_VERSION:
! 805: /*
! 806: * This sets a requested HTTP version to be used. The value is one of
! 807: * the listed enums in curl/curl.h.
! 808: */
! 809: arg = va_arg(param, long);
! 810: if(arg < CURL_HTTP_VERSION_NONE)
! 811: return CURLE_BAD_FUNCTION_ARGUMENT;
! 812: #ifdef ENABLE_QUIC
! 813: if(arg == CURL_HTTP_VERSION_3)
! 814: ;
! 815: else
! 816: #endif
! 817: #ifndef USE_NGHTTP2
! 818: if(arg >= CURL_HTTP_VERSION_2)
! 819: return CURLE_UNSUPPORTED_PROTOCOL;
! 820: #else
! 821: if(arg >= CURL_HTTP_VERSION_LAST)
! 822: return CURLE_UNSUPPORTED_PROTOCOL;
! 823: if(arg == CURL_HTTP_VERSION_NONE)
! 824: arg = CURL_HTTP_VERSION_2TLS;
! 825: #endif
! 826: data->set.httpversion = arg;
! 827: break;
! 828:
! 829: case CURLOPT_EXPECT_100_TIMEOUT_MS:
! 830: /*
! 831: * Time to wait for a response to a HTTP request containing an
! 832: * Expect: 100-continue header before sending the data anyway.
! 833: */
! 834: arg = va_arg(param, long);
! 835: if(arg < 0)
! 836: return CURLE_BAD_FUNCTION_ARGUMENT;
! 837: data->set.expect_100_timeout = arg;
! 838: break;
! 839:
! 840: case CURLOPT_HTTP09_ALLOWED:
! 841: arg = va_arg(param, unsigned long);
! 842: if(arg > 1L)
! 843: return CURLE_BAD_FUNCTION_ARGUMENT;
! 844: data->set.http09_allowed = arg ? TRUE : FALSE;
! 845: break;
! 846: #endif /* CURL_DISABLE_HTTP */
! 847:
! 848: case CURLOPT_HTTPAUTH:
! 849: /*
! 850: * Set HTTP Authentication type BITMASK.
! 851: */
! 852: {
! 853: int bitcheck;
! 854: bool authbits;
! 855: unsigned long auth = va_arg(param, unsigned long);
! 856:
! 857: if(auth == CURLAUTH_NONE) {
! 858: data->set.httpauth = auth;
! 859: break;
! 860: }
! 861:
! 862: /* the DIGEST_IE bit is only used to set a special marker, for all the
! 863: rest we need to handle it as normal DIGEST */
! 864: data->state.authhost.iestyle =
! 865: (bool)((auth & CURLAUTH_DIGEST_IE) ? TRUE : FALSE);
! 866:
! 867: if(auth & CURLAUTH_DIGEST_IE) {
! 868: auth |= CURLAUTH_DIGEST; /* set standard digest bit */
! 869: auth &= ~CURLAUTH_DIGEST_IE; /* unset ie digest bit */
! 870: }
! 871:
! 872: /* switch off bits we can't support */
! 873: #ifndef USE_NTLM
! 874: auth &= ~CURLAUTH_NTLM; /* no NTLM support */
! 875: auth &= ~CURLAUTH_NTLM_WB; /* no NTLM_WB support */
! 876: #elif !defined(NTLM_WB_ENABLED)
! 877: auth &= ~CURLAUTH_NTLM_WB; /* no NTLM_WB support */
! 878: #endif
! 879: #ifndef USE_SPNEGO
! 880: auth &= ~CURLAUTH_NEGOTIATE; /* no Negotiate (SPNEGO) auth without
! 881: GSS-API or SSPI */
! 882: #endif
! 883:
! 884: /* check if any auth bit lower than CURLAUTH_ONLY is still set */
! 885: bitcheck = 0;
! 886: authbits = FALSE;
! 887: while(bitcheck < 31) {
! 888: if(auth & (1UL << bitcheck++)) {
! 889: authbits = TRUE;
! 890: break;
! 891: }
! 892: }
! 893: if(!authbits)
! 894: return CURLE_NOT_BUILT_IN; /* no supported types left! */
! 895:
! 896: data->set.httpauth = auth;
! 897: }
! 898: break;
! 899:
! 900: case CURLOPT_CUSTOMREQUEST:
! 901: /*
! 902: * Set a custom string to use as request
! 903: */
! 904: result = Curl_setstropt(&data->set.str[STRING_CUSTOMREQUEST],
! 905: va_arg(param, char *));
! 906:
! 907: /* we don't set
! 908: data->set.httpreq = HTTPREQ_CUSTOM;
! 909: here, we continue as if we were using the already set type
! 910: and this just changes the actual request keyword */
! 911: break;
! 912:
! 913: #ifndef CURL_DISABLE_PROXY
! 914: case CURLOPT_HTTPPROXYTUNNEL:
! 915: /*
! 916: * Tunnel operations through the proxy instead of normal proxy use
! 917: */
! 918: data->set.tunnel_thru_httpproxy = (0 != va_arg(param, long)) ?
! 919: TRUE : FALSE;
! 920: break;
! 921:
! 922: case CURLOPT_PROXYPORT:
! 923: /*
! 924: * Explicitly set HTTP proxy port number.
! 925: */
! 926: arg = va_arg(param, long);
! 927: if((arg < 0) || (arg > 65535))
! 928: return CURLE_BAD_FUNCTION_ARGUMENT;
! 929: data->set.proxyport = arg;
! 930: break;
! 931:
! 932: case CURLOPT_PROXYAUTH:
! 933: /*
! 934: * Set HTTP Authentication type BITMASK.
! 935: */
! 936: {
! 937: int bitcheck;
! 938: bool authbits;
! 939: unsigned long auth = va_arg(param, unsigned long);
! 940:
! 941: if(auth == CURLAUTH_NONE) {
! 942: data->set.proxyauth = auth;
! 943: break;
! 944: }
! 945:
! 946: /* the DIGEST_IE bit is only used to set a special marker, for all the
! 947: rest we need to handle it as normal DIGEST */
! 948: data->state.authproxy.iestyle =
! 949: (bool)((auth & CURLAUTH_DIGEST_IE) ? TRUE : FALSE);
! 950:
! 951: if(auth & CURLAUTH_DIGEST_IE) {
! 952: auth |= CURLAUTH_DIGEST; /* set standard digest bit */
! 953: auth &= ~CURLAUTH_DIGEST_IE; /* unset ie digest bit */
! 954: }
! 955: /* switch off bits we can't support */
! 956: #ifndef USE_NTLM
! 957: auth &= ~CURLAUTH_NTLM; /* no NTLM support */
! 958: auth &= ~CURLAUTH_NTLM_WB; /* no NTLM_WB support */
! 959: #elif !defined(NTLM_WB_ENABLED)
! 960: auth &= ~CURLAUTH_NTLM_WB; /* no NTLM_WB support */
! 961: #endif
! 962: #ifndef USE_SPNEGO
! 963: auth &= ~CURLAUTH_NEGOTIATE; /* no Negotiate (SPNEGO) auth without
! 964: GSS-API or SSPI */
! 965: #endif
! 966:
! 967: /* check if any auth bit lower than CURLAUTH_ONLY is still set */
! 968: bitcheck = 0;
! 969: authbits = FALSE;
! 970: while(bitcheck < 31) {
! 971: if(auth & (1UL << bitcheck++)) {
! 972: authbits = TRUE;
! 973: break;
! 974: }
! 975: }
! 976: if(!authbits)
! 977: return CURLE_NOT_BUILT_IN; /* no supported types left! */
! 978:
! 979: data->set.proxyauth = auth;
! 980: }
! 981: break;
! 982:
! 983: case CURLOPT_PROXY:
! 984: /*
! 985: * Set proxy server:port to use as proxy.
! 986: *
! 987: * If the proxy is set to "" (and CURLOPT_SOCKS_PROXY is set to "" or NULL)
! 988: * we explicitly say that we don't want to use a proxy
! 989: * (even though there might be environment variables saying so).
! 990: *
! 991: * Setting it to NULL, means no proxy but allows the environment variables
! 992: * to decide for us (if CURLOPT_SOCKS_PROXY setting it to NULL).
! 993: */
! 994: result = Curl_setstropt(&data->set.str[STRING_PROXY],
! 995: va_arg(param, char *));
! 996: break;
! 997:
! 998: case CURLOPT_PRE_PROXY:
! 999: /*
! 1000: * Set proxy server:port to use as SOCKS proxy.
! 1001: *
! 1002: * If the proxy is set to "" or NULL we explicitly say that we don't want
! 1003: * to use the socks proxy.
! 1004: */
! 1005: result = Curl_setstropt(&data->set.str[STRING_PRE_PROXY],
! 1006: va_arg(param, char *));
! 1007: break;
! 1008:
! 1009: case CURLOPT_PROXYTYPE:
! 1010: /*
! 1011: * Set proxy type. HTTP/HTTP_1_0/SOCKS4/SOCKS4a/SOCKS5/SOCKS5_HOSTNAME
! 1012: */
! 1013: arg = va_arg(param, long);
! 1014: if((arg < CURLPROXY_HTTP) || (arg > CURLPROXY_SOCKS5_HOSTNAME))
! 1015: return CURLE_BAD_FUNCTION_ARGUMENT;
! 1016: data->set.proxytype = (curl_proxytype)arg;
! 1017: break;
! 1018:
! 1019: case CURLOPT_PROXY_TRANSFER_MODE:
! 1020: /*
! 1021: * set transfer mode (;type=<a|i>) when doing FTP via an HTTP proxy
! 1022: */
! 1023: switch(va_arg(param, long)) {
! 1024: case 0:
! 1025: data->set.proxy_transfer_mode = FALSE;
! 1026: break;
! 1027: case 1:
! 1028: data->set.proxy_transfer_mode = TRUE;
! 1029: break;
! 1030: default:
! 1031: /* reserve other values for future use */
! 1032: result = CURLE_UNKNOWN_OPTION;
! 1033: break;
! 1034: }
! 1035: break;
! 1036: #endif /* CURL_DISABLE_PROXY */
! 1037:
! 1038: case CURLOPT_SOCKS5_AUTH:
! 1039: data->set.socks5auth = va_arg(param, unsigned long);
! 1040: if(data->set.socks5auth & ~(CURLAUTH_BASIC | CURLAUTH_GSSAPI))
! 1041: result = CURLE_NOT_BUILT_IN;
! 1042: break;
! 1043: #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
! 1044: case CURLOPT_SOCKS5_GSSAPI_NEC:
! 1045: /*
! 1046: * Set flag for NEC SOCK5 support
! 1047: */
! 1048: data->set.socks5_gssapi_nec = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 1049: break;
! 1050: #endif
! 1051: #ifndef CURL_DISABLE_PROXY
! 1052: case CURLOPT_SOCKS5_GSSAPI_SERVICE:
! 1053: case CURLOPT_PROXY_SERVICE_NAME:
! 1054: /*
! 1055: * Set proxy authentication service name for Kerberos 5 and SPNEGO
! 1056: */
! 1057: result = Curl_setstropt(&data->set.str[STRING_PROXY_SERVICE_NAME],
! 1058: va_arg(param, char *));
! 1059: break;
! 1060: #endif
! 1061: case CURLOPT_SERVICE_NAME:
! 1062: /*
! 1063: * Set authentication service name for DIGEST-MD5, Kerberos 5 and SPNEGO
! 1064: */
! 1065: result = Curl_setstropt(&data->set.str[STRING_SERVICE_NAME],
! 1066: va_arg(param, char *));
! 1067: break;
! 1068:
! 1069: case CURLOPT_HEADERDATA:
! 1070: /*
! 1071: * Custom pointer to pass the header write callback function
! 1072: */
! 1073: data->set.writeheader = (void *)va_arg(param, void *);
! 1074: break;
! 1075: case CURLOPT_ERRORBUFFER:
! 1076: /*
! 1077: * Error buffer provided by the caller to get the human readable
! 1078: * error string in.
! 1079: */
! 1080: data->set.errorbuffer = va_arg(param, char *);
! 1081: break;
! 1082: case CURLOPT_WRITEDATA:
! 1083: /*
! 1084: * FILE pointer to write to. Or possibly
! 1085: * used as argument to the write callback.
! 1086: */
! 1087: data->set.out = va_arg(param, void *);
! 1088: break;
! 1089:
! 1090: case CURLOPT_DIRLISTONLY:
! 1091: /*
! 1092: * An option that changes the command to one that asks for a list only, no
! 1093: * file info details. Used for FTP, POP3 and SFTP.
! 1094: */
! 1095: data->set.ftp_list_only = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 1096: break;
! 1097:
! 1098: case CURLOPT_APPEND:
! 1099: /*
! 1100: * We want to upload and append to an existing file. Used for FTP and
! 1101: * SFTP.
! 1102: */
! 1103: data->set.ftp_append = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 1104: break;
! 1105:
! 1106: #ifndef CURL_DISABLE_FTP
! 1107: case CURLOPT_FTP_FILEMETHOD:
! 1108: /*
! 1109: * How do access files over FTP.
! 1110: */
! 1111: arg = va_arg(param, long);
! 1112: if((arg < CURLFTPMETHOD_DEFAULT) || (arg >= CURLFTPMETHOD_LAST))
! 1113: return CURLE_BAD_FUNCTION_ARGUMENT;
! 1114: data->set.ftp_filemethod = (curl_ftpfile)arg;
! 1115: break;
! 1116: case CURLOPT_FTPPORT:
! 1117: /*
! 1118: * Use FTP PORT, this also specifies which IP address to use
! 1119: */
! 1120: result = Curl_setstropt(&data->set.str[STRING_FTPPORT],
! 1121: va_arg(param, char *));
! 1122: data->set.ftp_use_port = (data->set.str[STRING_FTPPORT]) ? TRUE : FALSE;
! 1123: break;
! 1124:
! 1125: case CURLOPT_FTP_USE_EPRT:
! 1126: data->set.ftp_use_eprt = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 1127: break;
! 1128:
! 1129: case CURLOPT_FTP_USE_EPSV:
! 1130: data->set.ftp_use_epsv = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 1131: break;
! 1132:
! 1133: case CURLOPT_FTP_USE_PRET:
! 1134: data->set.ftp_use_pret = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 1135: break;
! 1136:
! 1137: case CURLOPT_FTP_SSL_CCC:
! 1138: arg = va_arg(param, long);
! 1139: if((arg < CURLFTPSSL_CCC_NONE) || (arg >= CURLFTPSSL_CCC_LAST))
! 1140: return CURLE_BAD_FUNCTION_ARGUMENT;
! 1141: data->set.ftp_ccc = (curl_ftpccc)arg;
! 1142: break;
! 1143:
! 1144: case CURLOPT_FTP_SKIP_PASV_IP:
! 1145: /*
! 1146: * Enable or disable FTP_SKIP_PASV_IP, which will disable/enable the
! 1147: * bypass of the IP address in PASV responses.
! 1148: */
! 1149: data->set.ftp_skip_ip = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 1150: break;
! 1151:
! 1152: case CURLOPT_FTP_ACCOUNT:
! 1153: result = Curl_setstropt(&data->set.str[STRING_FTP_ACCOUNT],
! 1154: va_arg(param, char *));
! 1155: break;
! 1156:
! 1157: case CURLOPT_FTP_ALTERNATIVE_TO_USER:
! 1158: result = Curl_setstropt(&data->set.str[STRING_FTP_ALTERNATIVE_TO_USER],
! 1159: va_arg(param, char *));
! 1160: break;
! 1161:
! 1162: case CURLOPT_FTPSSLAUTH:
! 1163: /*
! 1164: * Set a specific auth for FTP-SSL transfers.
! 1165: */
! 1166: arg = va_arg(param, long);
! 1167: if((arg < CURLFTPAUTH_DEFAULT) || (arg >= CURLFTPAUTH_LAST))
! 1168: return CURLE_BAD_FUNCTION_ARGUMENT;
! 1169: data->set.ftpsslauth = (curl_ftpauth)arg;
! 1170: break;
! 1171: case CURLOPT_KRBLEVEL:
! 1172: /*
! 1173: * A string that defines the kerberos security level.
! 1174: */
! 1175: result = Curl_setstropt(&data->set.str[STRING_KRB_LEVEL],
! 1176: va_arg(param, char *));
! 1177: data->set.krb = (data->set.str[STRING_KRB_LEVEL]) ? TRUE : FALSE;
! 1178: break;
! 1179: #endif
! 1180: case CURLOPT_FTP_CREATE_MISSING_DIRS:
! 1181: /*
! 1182: * An FTP/SFTP option that modifies an upload to create missing
! 1183: * directories on the server.
! 1184: */
! 1185: switch(va_arg(param, long)) {
! 1186: case 0:
! 1187: data->set.ftp_create_missing_dirs = 0;
! 1188: break;
! 1189: case 1:
! 1190: data->set.ftp_create_missing_dirs = 1;
! 1191: break;
! 1192: case 2:
! 1193: data->set.ftp_create_missing_dirs = 2;
! 1194: break;
! 1195: default:
! 1196: /* reserve other values for future use */
! 1197: result = CURLE_UNKNOWN_OPTION;
! 1198: break;
! 1199: }
! 1200: break;
! 1201: case CURLOPT_READDATA:
! 1202: /*
! 1203: * FILE pointer to read the file to be uploaded from. Or possibly
! 1204: * used as argument to the read callback.
! 1205: */
! 1206: data->set.in_set = va_arg(param, void *);
! 1207: break;
! 1208: case CURLOPT_INFILESIZE:
! 1209: /*
! 1210: * If known, this should inform curl about the file size of the
! 1211: * to-be-uploaded file.
! 1212: */
! 1213: arg = va_arg(param, long);
! 1214: if(arg < -1)
! 1215: return CURLE_BAD_FUNCTION_ARGUMENT;
! 1216: data->set.filesize = arg;
! 1217: break;
! 1218: case CURLOPT_INFILESIZE_LARGE:
! 1219: /*
! 1220: * If known, this should inform curl about the file size of the
! 1221: * to-be-uploaded file.
! 1222: */
! 1223: bigsize = va_arg(param, curl_off_t);
! 1224: if(bigsize < -1)
! 1225: return CURLE_BAD_FUNCTION_ARGUMENT;
! 1226: data->set.filesize = bigsize;
! 1227: break;
! 1228: case CURLOPT_LOW_SPEED_LIMIT:
! 1229: /*
! 1230: * The low speed limit that if transfers are below this for
! 1231: * CURLOPT_LOW_SPEED_TIME, the transfer is aborted.
! 1232: */
! 1233: arg = va_arg(param, long);
! 1234: if(arg < 0)
! 1235: return CURLE_BAD_FUNCTION_ARGUMENT;
! 1236: data->set.low_speed_limit = arg;
! 1237: break;
! 1238: case CURLOPT_MAX_SEND_SPEED_LARGE:
! 1239: /*
! 1240: * When transfer uploads are faster then CURLOPT_MAX_SEND_SPEED_LARGE
! 1241: * bytes per second the transfer is throttled..
! 1242: */
! 1243: bigsize = va_arg(param, curl_off_t);
! 1244: if(bigsize < 0)
! 1245: return CURLE_BAD_FUNCTION_ARGUMENT;
! 1246: data->set.max_send_speed = bigsize;
! 1247: break;
! 1248: case CURLOPT_MAX_RECV_SPEED_LARGE:
! 1249: /*
! 1250: * When receiving data faster than CURLOPT_MAX_RECV_SPEED_LARGE bytes per
! 1251: * second the transfer is throttled..
! 1252: */
! 1253: bigsize = va_arg(param, curl_off_t);
! 1254: if(bigsize < 0)
! 1255: return CURLE_BAD_FUNCTION_ARGUMENT;
! 1256: data->set.max_recv_speed = bigsize;
! 1257: break;
! 1258: case CURLOPT_LOW_SPEED_TIME:
! 1259: /*
! 1260: * The low speed time that if transfers are below the set
! 1261: * CURLOPT_LOW_SPEED_LIMIT during this time, the transfer is aborted.
! 1262: */
! 1263: arg = va_arg(param, long);
! 1264: if(arg < 0)
! 1265: return CURLE_BAD_FUNCTION_ARGUMENT;
! 1266: data->set.low_speed_time = arg;
! 1267: break;
! 1268: case CURLOPT_CURLU:
! 1269: /*
! 1270: * pass CURLU to set URL
! 1271: */
! 1272: data->set.uh = va_arg(param, CURLU *);
! 1273: break;
! 1274: case CURLOPT_URL:
! 1275: /*
! 1276: * The URL to fetch.
! 1277: */
! 1278: if(data->change.url_alloc) {
! 1279: /* the already set URL is allocated, free it first! */
! 1280: Curl_safefree(data->change.url);
! 1281: data->change.url_alloc = FALSE;
! 1282: }
! 1283: result = Curl_setstropt(&data->set.str[STRING_SET_URL],
! 1284: va_arg(param, char *));
! 1285: data->change.url = data->set.str[STRING_SET_URL];
! 1286: break;
! 1287: case CURLOPT_PORT:
! 1288: /*
! 1289: * The port number to use when getting the URL
! 1290: */
! 1291: arg = va_arg(param, long);
! 1292: if((arg < 0) || (arg > 65535))
! 1293: return CURLE_BAD_FUNCTION_ARGUMENT;
! 1294: data->set.use_port = arg;
! 1295: break;
! 1296: case CURLOPT_TIMEOUT:
! 1297: /*
! 1298: * The maximum time you allow curl to use for a single transfer
! 1299: * operation.
! 1300: */
! 1301: arg = va_arg(param, long);
! 1302: if((arg >= 0) && (arg <= (INT_MAX/1000)))
! 1303: data->set.timeout = arg * 1000;
! 1304: else
! 1305: return CURLE_BAD_FUNCTION_ARGUMENT;
! 1306: break;
! 1307:
! 1308: case CURLOPT_TIMEOUT_MS:
! 1309: arg = va_arg(param, long);
! 1310: if(arg < 0)
! 1311: return CURLE_BAD_FUNCTION_ARGUMENT;
! 1312: data->set.timeout = arg;
! 1313: break;
! 1314:
! 1315: case CURLOPT_CONNECTTIMEOUT:
! 1316: /*
! 1317: * The maximum time you allow curl to use to connect.
! 1318: */
! 1319: arg = va_arg(param, long);
! 1320: if((arg >= 0) && (arg <= (INT_MAX/1000)))
! 1321: data->set.connecttimeout = arg * 1000;
! 1322: else
! 1323: return CURLE_BAD_FUNCTION_ARGUMENT;
! 1324: break;
! 1325:
! 1326: case CURLOPT_CONNECTTIMEOUT_MS:
! 1327: arg = va_arg(param, long);
! 1328: if(arg < 0)
! 1329: return CURLE_BAD_FUNCTION_ARGUMENT;
! 1330: data->set.connecttimeout = arg;
! 1331: break;
! 1332:
! 1333: case CURLOPT_ACCEPTTIMEOUT_MS:
! 1334: /*
! 1335: * The maximum time you allow curl to wait for server connect
! 1336: */
! 1337: arg = va_arg(param, long);
! 1338: if(arg < 0)
! 1339: return CURLE_BAD_FUNCTION_ARGUMENT;
! 1340: data->set.accepttimeout = arg;
! 1341: break;
! 1342:
! 1343: case CURLOPT_USERPWD:
! 1344: /*
! 1345: * user:password to use in the operation
! 1346: */
! 1347: result = setstropt_userpwd(va_arg(param, char *),
! 1348: &data->set.str[STRING_USERNAME],
! 1349: &data->set.str[STRING_PASSWORD]);
! 1350: break;
! 1351:
! 1352: case CURLOPT_USERNAME:
! 1353: /*
! 1354: * authentication user name to use in the operation
! 1355: */
! 1356: result = Curl_setstropt(&data->set.str[STRING_USERNAME],
! 1357: va_arg(param, char *));
! 1358: break;
! 1359:
! 1360: case CURLOPT_PASSWORD:
! 1361: /*
! 1362: * authentication password to use in the operation
! 1363: */
! 1364: result = Curl_setstropt(&data->set.str[STRING_PASSWORD],
! 1365: va_arg(param, char *));
! 1366: break;
! 1367:
! 1368: case CURLOPT_LOGIN_OPTIONS:
! 1369: /*
! 1370: * authentication options to use in the operation
! 1371: */
! 1372: result = Curl_setstropt(&data->set.str[STRING_OPTIONS],
! 1373: va_arg(param, char *));
! 1374: break;
! 1375:
! 1376: case CURLOPT_XOAUTH2_BEARER:
! 1377: /*
! 1378: * OAuth 2.0 bearer token to use in the operation
! 1379: */
! 1380: result = Curl_setstropt(&data->set.str[STRING_BEARER],
! 1381: va_arg(param, char *));
! 1382: break;
! 1383:
! 1384: case CURLOPT_POSTQUOTE:
! 1385: /*
! 1386: * List of RAW FTP commands to use after a transfer
! 1387: */
! 1388: data->set.postquote = va_arg(param, struct curl_slist *);
! 1389: break;
! 1390: case CURLOPT_PREQUOTE:
! 1391: /*
! 1392: * List of RAW FTP commands to use prior to RETR (Wesley Laxton)
! 1393: */
! 1394: data->set.prequote = va_arg(param, struct curl_slist *);
! 1395: break;
! 1396: case CURLOPT_QUOTE:
! 1397: /*
! 1398: * List of RAW FTP commands to use before a transfer
! 1399: */
! 1400: data->set.quote = va_arg(param, struct curl_slist *);
! 1401: break;
! 1402: case CURLOPT_RESOLVE:
! 1403: /*
! 1404: * List of NAME:[address] names to populate the DNS cache with
! 1405: * Prefix the NAME with dash (-) to _remove_ the name from the cache.
! 1406: *
! 1407: * Names added with this API will remain in the cache until explicitly
! 1408: * removed or the handle is cleaned up.
! 1409: *
! 1410: * This API can remove any name from the DNS cache, but only entries
! 1411: * that aren't actually in use right now will be pruned immediately.
! 1412: */
! 1413: data->set.resolve = va_arg(param, struct curl_slist *);
! 1414: data->change.resolve = data->set.resolve;
! 1415: break;
! 1416: case CURLOPT_PROGRESSFUNCTION:
! 1417: /*
! 1418: * Progress callback function
! 1419: */
! 1420: data->set.fprogress = va_arg(param, curl_progress_callback);
! 1421: if(data->set.fprogress)
! 1422: data->progress.callback = TRUE; /* no longer internal */
! 1423: else
! 1424: data->progress.callback = FALSE; /* NULL enforces internal */
! 1425: break;
! 1426:
! 1427: case CURLOPT_XFERINFOFUNCTION:
! 1428: /*
! 1429: * Transfer info callback function
! 1430: */
! 1431: data->set.fxferinfo = va_arg(param, curl_xferinfo_callback);
! 1432: if(data->set.fxferinfo)
! 1433: data->progress.callback = TRUE; /* no longer internal */
! 1434: else
! 1435: data->progress.callback = FALSE; /* NULL enforces internal */
! 1436:
! 1437: break;
! 1438:
! 1439: case CURLOPT_PROGRESSDATA:
! 1440: /*
! 1441: * Custom client data to pass to the progress callback
! 1442: */
! 1443: data->set.progress_client = va_arg(param, void *);
! 1444: break;
! 1445:
! 1446: #ifndef CURL_DISABLE_PROXY
! 1447: case CURLOPT_PROXYUSERPWD:
! 1448: /*
! 1449: * user:password needed to use the proxy
! 1450: */
! 1451: result = setstropt_userpwd(va_arg(param, char *),
! 1452: &data->set.str[STRING_PROXYUSERNAME],
! 1453: &data->set.str[STRING_PROXYPASSWORD]);
! 1454: break;
! 1455: case CURLOPT_PROXYUSERNAME:
! 1456: /*
! 1457: * authentication user name to use in the operation
! 1458: */
! 1459: result = Curl_setstropt(&data->set.str[STRING_PROXYUSERNAME],
! 1460: va_arg(param, char *));
! 1461: break;
! 1462: case CURLOPT_PROXYPASSWORD:
! 1463: /*
! 1464: * authentication password to use in the operation
! 1465: */
! 1466: result = Curl_setstropt(&data->set.str[STRING_PROXYPASSWORD],
! 1467: va_arg(param, char *));
! 1468: break;
! 1469: case CURLOPT_NOPROXY:
! 1470: /*
! 1471: * proxy exception list
! 1472: */
! 1473: result = Curl_setstropt(&data->set.str[STRING_NOPROXY],
! 1474: va_arg(param, char *));
! 1475: break;
! 1476: #endif
! 1477:
! 1478: case CURLOPT_RANGE:
! 1479: /*
! 1480: * What range of the file you want to transfer
! 1481: */
! 1482: result = Curl_setstropt(&data->set.str[STRING_SET_RANGE],
! 1483: va_arg(param, char *));
! 1484: break;
! 1485: case CURLOPT_RESUME_FROM:
! 1486: /*
! 1487: * Resume transfer at the given file position
! 1488: */
! 1489: arg = va_arg(param, long);
! 1490: if(arg < -1)
! 1491: return CURLE_BAD_FUNCTION_ARGUMENT;
! 1492: data->set.set_resume_from = arg;
! 1493: break;
! 1494: case CURLOPT_RESUME_FROM_LARGE:
! 1495: /*
! 1496: * Resume transfer at the given file position
! 1497: */
! 1498: bigsize = va_arg(param, curl_off_t);
! 1499: if(bigsize < -1)
! 1500: return CURLE_BAD_FUNCTION_ARGUMENT;
! 1501: data->set.set_resume_from = bigsize;
! 1502: break;
! 1503: case CURLOPT_DEBUGFUNCTION:
! 1504: /*
! 1505: * stderr write callback.
! 1506: */
! 1507: data->set.fdebug = va_arg(param, curl_debug_callback);
! 1508: /*
! 1509: * if the callback provided is NULL, it'll use the default callback
! 1510: */
! 1511: break;
! 1512: case CURLOPT_DEBUGDATA:
! 1513: /*
! 1514: * Set to a void * that should receive all error writes. This
! 1515: * defaults to CURLOPT_STDERR for normal operations.
! 1516: */
! 1517: data->set.debugdata = va_arg(param, void *);
! 1518: break;
! 1519: case CURLOPT_STDERR:
! 1520: /*
! 1521: * Set to a FILE * that should receive all error writes. This
! 1522: * defaults to stderr for normal operations.
! 1523: */
! 1524: data->set.err = va_arg(param, FILE *);
! 1525: if(!data->set.err)
! 1526: data->set.err = stderr;
! 1527: break;
! 1528: case CURLOPT_HEADERFUNCTION:
! 1529: /*
! 1530: * Set header write callback
! 1531: */
! 1532: data->set.fwrite_header = va_arg(param, curl_write_callback);
! 1533: break;
! 1534: case CURLOPT_WRITEFUNCTION:
! 1535: /*
! 1536: * Set data write callback
! 1537: */
! 1538: data->set.fwrite_func = va_arg(param, curl_write_callback);
! 1539: if(!data->set.fwrite_func) {
! 1540: data->set.is_fwrite_set = 0;
! 1541: /* When set to NULL, reset to our internal default function */
! 1542: data->set.fwrite_func = (curl_write_callback)fwrite;
! 1543: }
! 1544: else
! 1545: data->set.is_fwrite_set = 1;
! 1546: break;
! 1547: case CURLOPT_READFUNCTION:
! 1548: /*
! 1549: * Read data callback
! 1550: */
! 1551: data->set.fread_func_set = va_arg(param, curl_read_callback);
! 1552: if(!data->set.fread_func_set) {
! 1553: data->set.is_fread_set = 0;
! 1554: /* When set to NULL, reset to our internal default function */
! 1555: data->set.fread_func_set = (curl_read_callback)fread;
! 1556: }
! 1557: else
! 1558: data->set.is_fread_set = 1;
! 1559: break;
! 1560: case CURLOPT_SEEKFUNCTION:
! 1561: /*
! 1562: * Seek callback. Might be NULL.
! 1563: */
! 1564: data->set.seek_func = va_arg(param, curl_seek_callback);
! 1565: break;
! 1566: case CURLOPT_SEEKDATA:
! 1567: /*
! 1568: * Seek control callback. Might be NULL.
! 1569: */
! 1570: data->set.seek_client = va_arg(param, void *);
! 1571: break;
! 1572: case CURLOPT_CONV_FROM_NETWORK_FUNCTION:
! 1573: /*
! 1574: * "Convert from network encoding" callback
! 1575: */
! 1576: data->set.convfromnetwork = va_arg(param, curl_conv_callback);
! 1577: break;
! 1578: case CURLOPT_CONV_TO_NETWORK_FUNCTION:
! 1579: /*
! 1580: * "Convert to network encoding" callback
! 1581: */
! 1582: data->set.convtonetwork = va_arg(param, curl_conv_callback);
! 1583: break;
! 1584: case CURLOPT_CONV_FROM_UTF8_FUNCTION:
! 1585: /*
! 1586: * "Convert from UTF-8 encoding" callback
! 1587: */
! 1588: data->set.convfromutf8 = va_arg(param, curl_conv_callback);
! 1589: break;
! 1590: case CURLOPT_IOCTLFUNCTION:
! 1591: /*
! 1592: * I/O control callback. Might be NULL.
! 1593: */
! 1594: data->set.ioctl_func = va_arg(param, curl_ioctl_callback);
! 1595: break;
! 1596: case CURLOPT_IOCTLDATA:
! 1597: /*
! 1598: * I/O control data pointer. Might be NULL.
! 1599: */
! 1600: data->set.ioctl_client = va_arg(param, void *);
! 1601: break;
! 1602: case CURLOPT_SSLCERT:
! 1603: /*
! 1604: * String that holds file name of the SSL certificate to use
! 1605: */
! 1606: result = Curl_setstropt(&data->set.str[STRING_CERT_ORIG],
! 1607: va_arg(param, char *));
! 1608: break;
! 1609: #ifndef CURL_DISABLE_PROXY
! 1610: case CURLOPT_PROXY_SSLCERT:
! 1611: /*
! 1612: * String that holds file name of the SSL certificate to use for proxy
! 1613: */
! 1614: result = Curl_setstropt(&data->set.str[STRING_CERT_PROXY],
! 1615: va_arg(param, char *));
! 1616: break;
! 1617: #endif
! 1618: case CURLOPT_SSLCERTTYPE:
! 1619: /*
! 1620: * String that holds file type of the SSL certificate to use
! 1621: */
! 1622: result = Curl_setstropt(&data->set.str[STRING_CERT_TYPE_ORIG],
! 1623: va_arg(param, char *));
! 1624: break;
! 1625: #ifndef CURL_DISABLE_PROXY
! 1626: case CURLOPT_PROXY_SSLCERTTYPE:
! 1627: /*
! 1628: * String that holds file type of the SSL certificate to use for proxy
! 1629: */
! 1630: result = Curl_setstropt(&data->set.str[STRING_CERT_TYPE_PROXY],
! 1631: va_arg(param, char *));
! 1632: break;
! 1633: #endif
! 1634: case CURLOPT_SSLKEY:
! 1635: /*
! 1636: * String that holds file name of the SSL key to use
! 1637: */
! 1638: result = Curl_setstropt(&data->set.str[STRING_KEY_ORIG],
! 1639: va_arg(param, char *));
! 1640: break;
! 1641: #ifndef CURL_DISABLE_PROXY
! 1642: case CURLOPT_PROXY_SSLKEY:
! 1643: /*
! 1644: * String that holds file name of the SSL key to use for proxy
! 1645: */
! 1646: result = Curl_setstropt(&data->set.str[STRING_KEY_PROXY],
! 1647: va_arg(param, char *));
! 1648: break;
! 1649: #endif
! 1650: case CURLOPT_SSLKEYTYPE:
! 1651: /*
! 1652: * String that holds file type of the SSL key to use
! 1653: */
! 1654: result = Curl_setstropt(&data->set.str[STRING_KEY_TYPE_ORIG],
! 1655: va_arg(param, char *));
! 1656: break;
! 1657: #ifndef CURL_DISABLE_PROXY
! 1658: case CURLOPT_PROXY_SSLKEYTYPE:
! 1659: /*
! 1660: * String that holds file type of the SSL key to use for proxy
! 1661: */
! 1662: result = Curl_setstropt(&data->set.str[STRING_KEY_TYPE_PROXY],
! 1663: va_arg(param, char *));
! 1664: break;
! 1665: #endif
! 1666: case CURLOPT_KEYPASSWD:
! 1667: /*
! 1668: * String that holds the SSL or SSH private key password.
! 1669: */
! 1670: result = Curl_setstropt(&data->set.str[STRING_KEY_PASSWD_ORIG],
! 1671: va_arg(param, char *));
! 1672: break;
! 1673: #ifndef CURL_DISABLE_PROXY
! 1674: case CURLOPT_PROXY_KEYPASSWD:
! 1675: /*
! 1676: * String that holds the SSL private key password for proxy.
! 1677: */
! 1678: result = Curl_setstropt(&data->set.str[STRING_KEY_PASSWD_PROXY],
! 1679: va_arg(param, char *));
! 1680: break;
! 1681: #endif
! 1682: case CURLOPT_SSLENGINE:
! 1683: /*
! 1684: * String that holds the SSL crypto engine.
! 1685: */
! 1686: argptr = va_arg(param, char *);
! 1687: if(argptr && argptr[0]) {
! 1688: result = Curl_setstropt(&data->set.str[STRING_SSL_ENGINE], argptr);
! 1689: if(!result) {
! 1690: result = Curl_ssl_set_engine(data, argptr);
! 1691: }
! 1692: }
! 1693: break;
! 1694:
! 1695: case CURLOPT_SSLENGINE_DEFAULT:
! 1696: /*
! 1697: * flag to set engine as default.
! 1698: */
! 1699: Curl_setstropt(&data->set.str[STRING_SSL_ENGINE], NULL);
! 1700: result = Curl_ssl_set_engine_default(data);
! 1701: break;
! 1702: case CURLOPT_CRLF:
! 1703: /*
! 1704: * Kludgy option to enable CRLF conversions. Subject for removal.
! 1705: */
! 1706: data->set.crlf = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 1707: break;
! 1708: #ifndef CURL_DISABLE_PROXY
! 1709: case CURLOPT_HAPROXYPROTOCOL:
! 1710: /*
! 1711: * Set to send the HAProxy Proxy Protocol header
! 1712: */
! 1713: data->set.haproxyprotocol = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 1714: break;
! 1715: #endif
! 1716: case CURLOPT_INTERFACE:
! 1717: /*
! 1718: * Set what interface or address/hostname to bind the socket to when
! 1719: * performing an operation and thus what from-IP your connection will use.
! 1720: */
! 1721: result = Curl_setstropt(&data->set.str[STRING_DEVICE],
! 1722: va_arg(param, char *));
! 1723: break;
! 1724: case CURLOPT_LOCALPORT:
! 1725: /*
! 1726: * Set what local port to bind the socket to when performing an operation.
! 1727: */
! 1728: arg = va_arg(param, long);
! 1729: if((arg < 0) || (arg > 65535))
! 1730: return CURLE_BAD_FUNCTION_ARGUMENT;
! 1731: data->set.localport = curlx_sltous(arg);
! 1732: break;
! 1733: case CURLOPT_LOCALPORTRANGE:
! 1734: /*
! 1735: * Set number of local ports to try, starting with CURLOPT_LOCALPORT.
! 1736: */
! 1737: arg = va_arg(param, long);
! 1738: if((arg < 0) || (arg > 65535))
! 1739: return CURLE_BAD_FUNCTION_ARGUMENT;
! 1740: data->set.localportrange = curlx_sltosi(arg);
! 1741: break;
! 1742: case CURLOPT_GSSAPI_DELEGATION:
! 1743: /*
! 1744: * GSS-API credential delegation bitmask
! 1745: */
! 1746: arg = va_arg(param, long);
! 1747: if(arg < CURLGSSAPI_DELEGATION_NONE)
! 1748: return CURLE_BAD_FUNCTION_ARGUMENT;
! 1749: data->set.gssapi_delegation = arg;
! 1750: break;
! 1751: case CURLOPT_SSL_VERIFYPEER:
! 1752: /*
! 1753: * Enable peer SSL verifying.
! 1754: */
! 1755: data->set.ssl.primary.verifypeer = (0 != va_arg(param, long)) ?
! 1756: TRUE : FALSE;
! 1757:
! 1758: /* Update the current connection ssl_config. */
! 1759: if(data->conn) {
! 1760: data->conn->ssl_config.verifypeer =
! 1761: data->set.ssl.primary.verifypeer;
! 1762: }
! 1763: break;
! 1764: #ifndef CURL_DISABLE_PROXY
! 1765: case CURLOPT_PROXY_SSL_VERIFYPEER:
! 1766: /*
! 1767: * Enable peer SSL verifying for proxy.
! 1768: */
! 1769: data->set.proxy_ssl.primary.verifypeer =
! 1770: (0 != va_arg(param, long))?TRUE:FALSE;
! 1771:
! 1772: /* Update the current connection proxy_ssl_config. */
! 1773: if(data->conn) {
! 1774: data->conn->proxy_ssl_config.verifypeer =
! 1775: data->set.proxy_ssl.primary.verifypeer;
! 1776: }
! 1777: break;
! 1778: #endif
! 1779: case CURLOPT_SSL_VERIFYHOST:
! 1780: /*
! 1781: * Enable verification of the host name in the peer certificate
! 1782: */
! 1783: arg = va_arg(param, long);
! 1784:
! 1785: /* Obviously people are not reading documentation and too many thought
! 1786: this argument took a boolean when it wasn't and misused it.
! 1787: Treat 1 and 2 the same */
! 1788: data->set.ssl.primary.verifyhost = (bool)((arg & 3) ? TRUE : FALSE);
! 1789:
! 1790: /* Update the current connection ssl_config. */
! 1791: if(data->conn) {
! 1792: data->conn->ssl_config.verifyhost =
! 1793: data->set.ssl.primary.verifyhost;
! 1794: }
! 1795: break;
! 1796: #ifndef CURL_DISABLE_PROXY
! 1797: case CURLOPT_PROXY_SSL_VERIFYHOST:
! 1798: /*
! 1799: * Enable verification of the host name in the peer certificate for proxy
! 1800: */
! 1801: arg = va_arg(param, long);
! 1802:
! 1803: /* Treat both 1 and 2 as TRUE */
! 1804: data->set.proxy_ssl.primary.verifyhost = (bool)((arg & 3)?TRUE:FALSE);
! 1805:
! 1806: /* Update the current connection proxy_ssl_config. */
! 1807: if(data->conn) {
! 1808: data->conn->proxy_ssl_config.verifyhost =
! 1809: data->set.proxy_ssl.primary.verifyhost;
! 1810: }
! 1811: break;
! 1812: #endif
! 1813: case CURLOPT_SSL_VERIFYSTATUS:
! 1814: /*
! 1815: * Enable certificate status verifying.
! 1816: */
! 1817: if(!Curl_ssl_cert_status_request()) {
! 1818: result = CURLE_NOT_BUILT_IN;
! 1819: break;
! 1820: }
! 1821:
! 1822: data->set.ssl.primary.verifystatus = (0 != va_arg(param, long)) ?
! 1823: TRUE : FALSE;
! 1824:
! 1825: /* Update the current connection ssl_config. */
! 1826: if(data->conn) {
! 1827: data->conn->ssl_config.verifystatus =
! 1828: data->set.ssl.primary.verifystatus;
! 1829: }
! 1830: break;
! 1831: case CURLOPT_SSL_CTX_FUNCTION:
! 1832: /*
! 1833: * Set a SSL_CTX callback
! 1834: */
! 1835: #ifdef USE_SSL
! 1836: if(Curl_ssl->supports & SSLSUPP_SSL_CTX)
! 1837: data->set.ssl.fsslctx = va_arg(param, curl_ssl_ctx_callback);
! 1838: else
! 1839: #endif
! 1840: result = CURLE_NOT_BUILT_IN;
! 1841: break;
! 1842: case CURLOPT_SSL_CTX_DATA:
! 1843: /*
! 1844: * Set a SSL_CTX callback parameter pointer
! 1845: */
! 1846: #ifdef USE_SSL
! 1847: if(Curl_ssl->supports & SSLSUPP_SSL_CTX)
! 1848: data->set.ssl.fsslctxp = va_arg(param, void *);
! 1849: else
! 1850: #endif
! 1851: result = CURLE_NOT_BUILT_IN;
! 1852: break;
! 1853: case CURLOPT_SSL_FALSESTART:
! 1854: /*
! 1855: * Enable TLS false start.
! 1856: */
! 1857: if(!Curl_ssl_false_start()) {
! 1858: result = CURLE_NOT_BUILT_IN;
! 1859: break;
! 1860: }
! 1861:
! 1862: data->set.ssl.falsestart = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 1863: break;
! 1864: case CURLOPT_CERTINFO:
! 1865: #ifdef USE_SSL
! 1866: if(Curl_ssl->supports & SSLSUPP_CERTINFO)
! 1867: data->set.ssl.certinfo = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 1868: else
! 1869: #endif
! 1870: result = CURLE_NOT_BUILT_IN;
! 1871: break;
! 1872: case CURLOPT_PINNEDPUBLICKEY:
! 1873: /*
! 1874: * Set pinned public key for SSL connection.
! 1875: * Specify file name of the public key in DER format.
! 1876: */
! 1877: #ifdef USE_SSL
! 1878: if(Curl_ssl->supports & SSLSUPP_PINNEDPUBKEY)
! 1879: result = Curl_setstropt(&data->set.str[STRING_SSL_PINNEDPUBLICKEY_ORIG],
! 1880: va_arg(param, char *));
! 1881: else
! 1882: #endif
! 1883: result = CURLE_NOT_BUILT_IN;
! 1884: break;
! 1885: #ifndef CURL_DISABLE_PROXY
! 1886: case CURLOPT_PROXY_PINNEDPUBLICKEY:
! 1887: /*
! 1888: * Set pinned public key for SSL connection.
! 1889: * Specify file name of the public key in DER format.
! 1890: */
! 1891: #ifdef USE_SSL
! 1892: if(Curl_ssl->supports & SSLSUPP_PINNEDPUBKEY)
! 1893: result = Curl_setstropt(&data->set.str[STRING_SSL_PINNEDPUBLICKEY_PROXY],
! 1894: va_arg(param, char *));
! 1895: else
! 1896: #endif
! 1897: result = CURLE_NOT_BUILT_IN;
! 1898: break;
! 1899: #endif
! 1900: case CURLOPT_CAINFO:
! 1901: /*
! 1902: * Set CA info for SSL connection. Specify file name of the CA certificate
! 1903: */
! 1904: result = Curl_setstropt(&data->set.str[STRING_SSL_CAFILE_ORIG],
! 1905: va_arg(param, char *));
! 1906: break;
! 1907: #ifndef CURL_DISABLE_PROXY
! 1908: case CURLOPT_PROXY_CAINFO:
! 1909: /*
! 1910: * Set CA info SSL connection for proxy. Specify file name of the
! 1911: * CA certificate
! 1912: */
! 1913: result = Curl_setstropt(&data->set.str[STRING_SSL_CAFILE_PROXY],
! 1914: va_arg(param, char *));
! 1915: break;
! 1916: #endif
! 1917: case CURLOPT_CAPATH:
! 1918: /*
! 1919: * Set CA path info for SSL connection. Specify directory name of the CA
! 1920: * certificates which have been prepared using openssl c_rehash utility.
! 1921: */
! 1922: #ifdef USE_SSL
! 1923: if(Curl_ssl->supports & SSLSUPP_CA_PATH)
! 1924: /* This does not work on windows. */
! 1925: result = Curl_setstropt(&data->set.str[STRING_SSL_CAPATH_ORIG],
! 1926: va_arg(param, char *));
! 1927: else
! 1928: #endif
! 1929: result = CURLE_NOT_BUILT_IN;
! 1930: break;
! 1931: #ifndef CURL_DISABLE_PROXY
! 1932: case CURLOPT_PROXY_CAPATH:
! 1933: /*
! 1934: * Set CA path info for SSL connection proxy. Specify directory name of the
! 1935: * CA certificates which have been prepared using openssl c_rehash utility.
! 1936: */
! 1937: #ifdef USE_SSL
! 1938: if(Curl_ssl->supports & SSLSUPP_CA_PATH)
! 1939: /* This does not work on windows. */
! 1940: result = Curl_setstropt(&data->set.str[STRING_SSL_CAPATH_PROXY],
! 1941: va_arg(param, char *));
! 1942: else
! 1943: #endif
! 1944: result = CURLE_NOT_BUILT_IN;
! 1945: break;
! 1946: #endif
! 1947: case CURLOPT_CRLFILE:
! 1948: /*
! 1949: * Set CRL file info for SSL connection. Specify file name of the CRL
! 1950: * to check certificates revocation
! 1951: */
! 1952: result = Curl_setstropt(&data->set.str[STRING_SSL_CRLFILE_ORIG],
! 1953: va_arg(param, char *));
! 1954: break;
! 1955: #ifndef CURL_DISABLE_PROXY
! 1956: case CURLOPT_PROXY_CRLFILE:
! 1957: /*
! 1958: * Set CRL file info for SSL connection for proxy. Specify file name of the
! 1959: * CRL to check certificates revocation
! 1960: */
! 1961: result = Curl_setstropt(&data->set.str[STRING_SSL_CRLFILE_PROXY],
! 1962: va_arg(param, char *));
! 1963: break;
! 1964: #endif
! 1965: case CURLOPT_ISSUERCERT:
! 1966: /*
! 1967: * Set Issuer certificate file
! 1968: * to check certificates issuer
! 1969: */
! 1970: result = Curl_setstropt(&data->set.str[STRING_SSL_ISSUERCERT_ORIG],
! 1971: va_arg(param, char *));
! 1972: break;
! 1973: #ifndef CURL_DISABLE_TELNET
! 1974: case CURLOPT_TELNETOPTIONS:
! 1975: /*
! 1976: * Set a linked list of telnet options
! 1977: */
! 1978: data->set.telnet_options = va_arg(param, struct curl_slist *);
! 1979: break;
! 1980: #endif
! 1981: case CURLOPT_BUFFERSIZE:
! 1982: /*
! 1983: * The application kindly asks for a differently sized receive buffer.
! 1984: * If it seems reasonable, we'll use it.
! 1985: */
! 1986: arg = va_arg(param, long);
! 1987:
! 1988: if(arg > READBUFFER_MAX)
! 1989: arg = READBUFFER_MAX;
! 1990: else if(arg < 1)
! 1991: arg = READBUFFER_SIZE;
! 1992: else if(arg < READBUFFER_MIN)
! 1993: arg = READBUFFER_MIN;
! 1994:
! 1995: /* Resize if new size */
! 1996: if(arg != data->set.buffer_size) {
! 1997: char *newbuff = realloc(data->state.buffer, arg + 1);
! 1998: if(!newbuff) {
! 1999: DEBUGF(fprintf(stderr, "Error: realloc of buffer failed\n"));
! 2000: result = CURLE_OUT_OF_MEMORY;
! 2001: }
! 2002: else
! 2003: data->state.buffer = newbuff;
! 2004: }
! 2005: data->set.buffer_size = arg;
! 2006:
! 2007: break;
! 2008:
! 2009: case CURLOPT_UPLOAD_BUFFERSIZE:
! 2010: /*
! 2011: * The application kindly asks for a differently sized upload buffer.
! 2012: * Cap it to sensible.
! 2013: */
! 2014: arg = va_arg(param, long);
! 2015:
! 2016: if(arg > UPLOADBUFFER_MAX)
! 2017: arg = UPLOADBUFFER_MAX;
! 2018: else if(arg < UPLOADBUFFER_MIN)
! 2019: arg = UPLOADBUFFER_MIN;
! 2020:
! 2021: data->set.upload_buffer_size = arg;
! 2022: Curl_safefree(data->state.ulbuf); /* force a realloc next opportunity */
! 2023: break;
! 2024:
! 2025: case CURLOPT_NOSIGNAL:
! 2026: /*
! 2027: * The application asks not to set any signal() or alarm() handlers,
! 2028: * even when using a timeout.
! 2029: */
! 2030: data->set.no_signal = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 2031: break;
! 2032:
! 2033: case CURLOPT_SHARE:
! 2034: {
! 2035: struct Curl_share *set;
! 2036: set = va_arg(param, struct Curl_share *);
! 2037:
! 2038: /* disconnect from old share, if any */
! 2039: if(data->share) {
! 2040: Curl_share_lock(data, CURL_LOCK_DATA_SHARE, CURL_LOCK_ACCESS_SINGLE);
! 2041:
! 2042: if(data->dns.hostcachetype == HCACHE_SHARED) {
! 2043: data->dns.hostcache = NULL;
! 2044: data->dns.hostcachetype = HCACHE_NONE;
! 2045: }
! 2046:
! 2047: #if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_COOKIES)
! 2048: if(data->share->cookies == data->cookies)
! 2049: data->cookies = NULL;
! 2050: #endif
! 2051:
! 2052: if(data->share->sslsession == data->state.session)
! 2053: data->state.session = NULL;
! 2054:
! 2055: #ifdef USE_LIBPSL
! 2056: if(data->psl == &data->share->psl)
! 2057: data->psl = data->multi? &data->multi->psl: NULL;
! 2058: #endif
! 2059:
! 2060: data->share->dirty--;
! 2061:
! 2062: Curl_share_unlock(data, CURL_LOCK_DATA_SHARE);
! 2063: data->share = NULL;
! 2064: }
! 2065:
! 2066: /* use new share if it set */
! 2067: data->share = set;
! 2068: if(data->share) {
! 2069:
! 2070: Curl_share_lock(data, CURL_LOCK_DATA_SHARE, CURL_LOCK_ACCESS_SINGLE);
! 2071:
! 2072: data->share->dirty++;
! 2073:
! 2074: if(data->share->specifier & (1<< CURL_LOCK_DATA_DNS)) {
! 2075: /* use shared host cache */
! 2076: data->dns.hostcache = &data->share->hostcache;
! 2077: data->dns.hostcachetype = HCACHE_SHARED;
! 2078: }
! 2079: #if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_COOKIES)
! 2080: if(data->share->cookies) {
! 2081: /* use shared cookie list, first free own one if any */
! 2082: Curl_cookie_cleanup(data->cookies);
! 2083: /* enable cookies since we now use a share that uses cookies! */
! 2084: data->cookies = data->share->cookies;
! 2085: }
! 2086: #endif /* CURL_DISABLE_HTTP */
! 2087: if(data->share->sslsession) {
! 2088: data->set.general_ssl.max_ssl_sessions = data->share->max_ssl_sessions;
! 2089: data->state.session = data->share->sslsession;
! 2090: }
! 2091: #ifdef USE_LIBPSL
! 2092: if(data->share->specifier & (1 << CURL_LOCK_DATA_PSL))
! 2093: data->psl = &data->share->psl;
! 2094: #endif
! 2095:
! 2096: Curl_share_unlock(data, CURL_LOCK_DATA_SHARE);
! 2097: }
! 2098: /* check for host cache not needed,
! 2099: * it will be done by curl_easy_perform */
! 2100: }
! 2101: break;
! 2102:
! 2103: case CURLOPT_PRIVATE:
! 2104: /*
! 2105: * Set private data pointer.
! 2106: */
! 2107: data->set.private_data = va_arg(param, void *);
! 2108: break;
! 2109:
! 2110: case CURLOPT_MAXFILESIZE:
! 2111: /*
! 2112: * Set the maximum size of a file to download.
! 2113: */
! 2114: arg = va_arg(param, long);
! 2115: if(arg < 0)
! 2116: return CURLE_BAD_FUNCTION_ARGUMENT;
! 2117: data->set.max_filesize = arg;
! 2118: break;
! 2119:
! 2120: #ifdef USE_SSL
! 2121: case CURLOPT_USE_SSL:
! 2122: /*
! 2123: * Make transfers attempt to use SSL/TLS.
! 2124: */
! 2125: arg = va_arg(param, long);
! 2126: if((arg < CURLUSESSL_NONE) || (arg >= CURLUSESSL_LAST))
! 2127: return CURLE_BAD_FUNCTION_ARGUMENT;
! 2128: data->set.use_ssl = (curl_usessl)arg;
! 2129: break;
! 2130:
! 2131: case CURLOPT_SSL_OPTIONS:
! 2132: arg = va_arg(param, long);
! 2133: data->set.ssl.enable_beast =
! 2134: (bool)((arg&CURLSSLOPT_ALLOW_BEAST) ? TRUE : FALSE);
! 2135: data->set.ssl.no_revoke = !!(arg & CURLSSLOPT_NO_REVOKE);
! 2136: data->set.ssl.no_partialchain = !!(arg & CURLSSLOPT_NO_PARTIALCHAIN);
! 2137: data->set.ssl.revoke_best_effort = !!(arg & CURLSSLOPT_REVOKE_BEST_EFFORT);
! 2138: break;
! 2139:
! 2140: #ifndef CURL_DISABLE_PROXY
! 2141: case CURLOPT_PROXY_SSL_OPTIONS:
! 2142: arg = va_arg(param, long);
! 2143: data->set.proxy_ssl.enable_beast =
! 2144: (bool)((arg&CURLSSLOPT_ALLOW_BEAST) ? TRUE : FALSE);
! 2145: data->set.proxy_ssl.no_revoke = !!(arg & CURLSSLOPT_NO_REVOKE);
! 2146: data->set.proxy_ssl.no_partialchain = !!(arg & CURLSSLOPT_NO_PARTIALCHAIN);
! 2147: data->set.proxy_ssl.revoke_best_effort =
! 2148: !!(arg & CURLSSLOPT_REVOKE_BEST_EFFORT);
! 2149: break;
! 2150: #endif
! 2151:
! 2152: #endif
! 2153: case CURLOPT_IPRESOLVE:
! 2154: arg = va_arg(param, long);
! 2155: if((arg < CURL_IPRESOLVE_WHATEVER) || (arg > CURL_IPRESOLVE_V6))
! 2156: return CURLE_BAD_FUNCTION_ARGUMENT;
! 2157: data->set.ipver = arg;
! 2158: break;
! 2159:
! 2160: case CURLOPT_MAXFILESIZE_LARGE:
! 2161: /*
! 2162: * Set the maximum size of a file to download.
! 2163: */
! 2164: bigsize = va_arg(param, curl_off_t);
! 2165: if(bigsize < 0)
! 2166: return CURLE_BAD_FUNCTION_ARGUMENT;
! 2167: data->set.max_filesize = bigsize;
! 2168: break;
! 2169:
! 2170: case CURLOPT_TCP_NODELAY:
! 2171: /*
! 2172: * Enable or disable TCP_NODELAY, which will disable/enable the Nagle
! 2173: * algorithm
! 2174: */
! 2175: data->set.tcp_nodelay = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 2176: break;
! 2177:
! 2178: case CURLOPT_IGNORE_CONTENT_LENGTH:
! 2179: data->set.ignorecl = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 2180: break;
! 2181:
! 2182: case CURLOPT_CONNECT_ONLY:
! 2183: /*
! 2184: * No data transfer, set up connection and let application use the socket
! 2185: */
! 2186: data->set.connect_only = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 2187: break;
! 2188:
! 2189: case CURLOPT_SOCKOPTFUNCTION:
! 2190: /*
! 2191: * socket callback function: called after socket() but before connect()
! 2192: */
! 2193: data->set.fsockopt = va_arg(param, curl_sockopt_callback);
! 2194: break;
! 2195:
! 2196: case CURLOPT_SOCKOPTDATA:
! 2197: /*
! 2198: * socket callback data pointer. Might be NULL.
! 2199: */
! 2200: data->set.sockopt_client = va_arg(param, void *);
! 2201: break;
! 2202:
! 2203: case CURLOPT_OPENSOCKETFUNCTION:
! 2204: /*
! 2205: * open/create socket callback function: called instead of socket(),
! 2206: * before connect()
! 2207: */
! 2208: data->set.fopensocket = va_arg(param, curl_opensocket_callback);
! 2209: break;
! 2210:
! 2211: case CURLOPT_OPENSOCKETDATA:
! 2212: /*
! 2213: * socket callback data pointer. Might be NULL.
! 2214: */
! 2215: data->set.opensocket_client = va_arg(param, void *);
! 2216: break;
! 2217:
! 2218: case CURLOPT_CLOSESOCKETFUNCTION:
! 2219: /*
! 2220: * close socket callback function: called instead of close()
! 2221: * when shutting down a connection
! 2222: */
! 2223: data->set.fclosesocket = va_arg(param, curl_closesocket_callback);
! 2224: break;
! 2225:
! 2226: case CURLOPT_RESOLVER_START_FUNCTION:
! 2227: /*
! 2228: * resolver start callback function: called before a new resolver request
! 2229: * is started
! 2230: */
! 2231: data->set.resolver_start = va_arg(param, curl_resolver_start_callback);
! 2232: break;
! 2233:
! 2234: case CURLOPT_RESOLVER_START_DATA:
! 2235: /*
! 2236: * resolver start callback data pointer. Might be NULL.
! 2237: */
! 2238: data->set.resolver_start_client = va_arg(param, void *);
! 2239: break;
! 2240:
! 2241: case CURLOPT_CLOSESOCKETDATA:
! 2242: /*
! 2243: * socket callback data pointer. Might be NULL.
! 2244: */
! 2245: data->set.closesocket_client = va_arg(param, void *);
! 2246: break;
! 2247:
! 2248: case CURLOPT_SSL_SESSIONID_CACHE:
! 2249: data->set.ssl.primary.sessionid = (0 != va_arg(param, long)) ?
! 2250: TRUE : FALSE;
! 2251: data->set.proxy_ssl.primary.sessionid = data->set.ssl.primary.sessionid;
! 2252: break;
! 2253:
! 2254: #ifdef USE_SSH
! 2255: /* we only include SSH options if explicitly built to support SSH */
! 2256: case CURLOPT_SSH_AUTH_TYPES:
! 2257: data->set.ssh_auth_types = va_arg(param, long);
! 2258: break;
! 2259:
! 2260: case CURLOPT_SSH_PUBLIC_KEYFILE:
! 2261: /*
! 2262: * Use this file instead of the $HOME/.ssh/id_dsa.pub file
! 2263: */
! 2264: result = Curl_setstropt(&data->set.str[STRING_SSH_PUBLIC_KEY],
! 2265: va_arg(param, char *));
! 2266: break;
! 2267:
! 2268: case CURLOPT_SSH_PRIVATE_KEYFILE:
! 2269: /*
! 2270: * Use this file instead of the $HOME/.ssh/id_dsa file
! 2271: */
! 2272: result = Curl_setstropt(&data->set.str[STRING_SSH_PRIVATE_KEY],
! 2273: va_arg(param, char *));
! 2274: break;
! 2275: case CURLOPT_SSH_HOST_PUBLIC_KEY_MD5:
! 2276: /*
! 2277: * Option to allow for the MD5 of the host public key to be checked
! 2278: * for validation purposes.
! 2279: */
! 2280: result = Curl_setstropt(&data->set.str[STRING_SSH_HOST_PUBLIC_KEY_MD5],
! 2281: va_arg(param, char *));
! 2282: break;
! 2283:
! 2284: case CURLOPT_SSH_KNOWNHOSTS:
! 2285: /*
! 2286: * Store the file name to read known hosts from.
! 2287: */
! 2288: result = Curl_setstropt(&data->set.str[STRING_SSH_KNOWNHOSTS],
! 2289: va_arg(param, char *));
! 2290: break;
! 2291:
! 2292: case CURLOPT_SSH_KEYFUNCTION:
! 2293: /* setting to NULL is fine since the ssh.c functions themselves will
! 2294: then revert to use the internal default */
! 2295: data->set.ssh_keyfunc = va_arg(param, curl_sshkeycallback);
! 2296: break;
! 2297:
! 2298: case CURLOPT_SSH_KEYDATA:
! 2299: /*
! 2300: * Custom client data to pass to the SSH keyfunc callback
! 2301: */
! 2302: data->set.ssh_keyfunc_userp = va_arg(param, void *);
! 2303: break;
! 2304:
! 2305: case CURLOPT_SSH_COMPRESSION:
! 2306: data->set.ssh_compression = (0 != va_arg(param, long))?TRUE:FALSE;
! 2307: break;
! 2308: #endif /* USE_SSH */
! 2309:
! 2310: case CURLOPT_HTTP_TRANSFER_DECODING:
! 2311: /*
! 2312: * disable libcurl transfer encoding is used
! 2313: */
! 2314: data->set.http_te_skip = (0 == va_arg(param, long)) ? TRUE : FALSE;
! 2315: break;
! 2316:
! 2317: case CURLOPT_HTTP_CONTENT_DECODING:
! 2318: /*
! 2319: * raw data passed to the application when content encoding is used
! 2320: */
! 2321: data->set.http_ce_skip = (0 == va_arg(param, long)) ? TRUE : FALSE;
! 2322: break;
! 2323:
! 2324: #if !defined(CURL_DISABLE_FTP) || defined(USE_SSH)
! 2325: case CURLOPT_NEW_FILE_PERMS:
! 2326: /*
! 2327: * Uses these permissions instead of 0644
! 2328: */
! 2329: arg = va_arg(param, long);
! 2330: if((arg < 0) || (arg > 0777))
! 2331: return CURLE_BAD_FUNCTION_ARGUMENT;
! 2332: data->set.new_file_perms = arg;
! 2333: break;
! 2334:
! 2335: case CURLOPT_NEW_DIRECTORY_PERMS:
! 2336: /*
! 2337: * Uses these permissions instead of 0755
! 2338: */
! 2339: arg = va_arg(param, long);
! 2340: if((arg < 0) || (arg > 0777))
! 2341: return CURLE_BAD_FUNCTION_ARGUMENT;
! 2342: data->set.new_directory_perms = arg;
! 2343: break;
! 2344: #endif
! 2345:
! 2346: case CURLOPT_ADDRESS_SCOPE:
! 2347: /*
! 2348: * Use this scope id when using IPv6
! 2349: * We always get longs when passed plain numericals so we should check
! 2350: * that the value fits into an unsigned 32 bit integer.
! 2351: */
! 2352: uarg = va_arg(param, unsigned long);
! 2353: #if SIZEOF_LONG > 4
! 2354: if(uarg > UINT_MAX)
! 2355: return CURLE_BAD_FUNCTION_ARGUMENT;
! 2356: #endif
! 2357: data->set.scope_id = (unsigned int)uarg;
! 2358: break;
! 2359:
! 2360: case CURLOPT_PROTOCOLS:
! 2361: /* set the bitmask for the protocols that are allowed to be used for the
! 2362: transfer, which thus helps the app which takes URLs from users or other
! 2363: external inputs and want to restrict what protocol(s) to deal
! 2364: with. Defaults to CURLPROTO_ALL. */
! 2365: data->set.allowed_protocols = va_arg(param, long);
! 2366: break;
! 2367:
! 2368: case CURLOPT_REDIR_PROTOCOLS:
! 2369: /* set the bitmask for the protocols that libcurl is allowed to follow to,
! 2370: as a subset of the CURLOPT_PROTOCOLS ones. That means the protocol needs
! 2371: to be set in both bitmasks to be allowed to get redirected to. */
! 2372: data->set.redir_protocols = va_arg(param, long);
! 2373: break;
! 2374:
! 2375: case CURLOPT_DEFAULT_PROTOCOL:
! 2376: /* Set the protocol to use when the URL doesn't include any protocol */
! 2377: result = Curl_setstropt(&data->set.str[STRING_DEFAULT_PROTOCOL],
! 2378: va_arg(param, char *));
! 2379: break;
! 2380: #ifndef CURL_DISABLE_SMTP
! 2381: case CURLOPT_MAIL_FROM:
! 2382: /* Set the SMTP mail originator */
! 2383: result = Curl_setstropt(&data->set.str[STRING_MAIL_FROM],
! 2384: va_arg(param, char *));
! 2385: break;
! 2386:
! 2387: case CURLOPT_MAIL_AUTH:
! 2388: /* Set the SMTP auth originator */
! 2389: result = Curl_setstropt(&data->set.str[STRING_MAIL_AUTH],
! 2390: va_arg(param, char *));
! 2391: break;
! 2392:
! 2393: case CURLOPT_MAIL_RCPT:
! 2394: /* Set the list of mail recipients */
! 2395: data->set.mail_rcpt = va_arg(param, struct curl_slist *);
! 2396: break;
! 2397: case CURLOPT_MAIL_RCPT_ALLLOWFAILS:
! 2398: /* allow RCPT TO command to fail for some recipients */
! 2399: data->set.mail_rcpt_allowfails = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 2400: break;
! 2401: #endif
! 2402:
! 2403: case CURLOPT_SASL_AUTHZID:
! 2404: /* Authorisation identity (identity to act as) */
! 2405: result = Curl_setstropt(&data->set.str[STRING_SASL_AUTHZID],
! 2406: va_arg(param, char *));
! 2407: break;
! 2408:
! 2409: case CURLOPT_SASL_IR:
! 2410: /* Enable/disable SASL initial response */
! 2411: data->set.sasl_ir = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 2412: break;
! 2413: #ifndef CURL_DISABLE_RTSP
! 2414: case CURLOPT_RTSP_REQUEST:
! 2415: {
! 2416: /*
! 2417: * Set the RTSP request method (OPTIONS, SETUP, PLAY, etc...)
! 2418: * Would this be better if the RTSPREQ_* were just moved into here?
! 2419: */
! 2420: long curl_rtspreq = va_arg(param, long);
! 2421: Curl_RtspReq rtspreq = RTSPREQ_NONE;
! 2422: switch(curl_rtspreq) {
! 2423: case CURL_RTSPREQ_OPTIONS:
! 2424: rtspreq = RTSPREQ_OPTIONS;
! 2425: break;
! 2426:
! 2427: case CURL_RTSPREQ_DESCRIBE:
! 2428: rtspreq = RTSPREQ_DESCRIBE;
! 2429: break;
! 2430:
! 2431: case CURL_RTSPREQ_ANNOUNCE:
! 2432: rtspreq = RTSPREQ_ANNOUNCE;
! 2433: break;
! 2434:
! 2435: case CURL_RTSPREQ_SETUP:
! 2436: rtspreq = RTSPREQ_SETUP;
! 2437: break;
! 2438:
! 2439: case CURL_RTSPREQ_PLAY:
! 2440: rtspreq = RTSPREQ_PLAY;
! 2441: break;
! 2442:
! 2443: case CURL_RTSPREQ_PAUSE:
! 2444: rtspreq = RTSPREQ_PAUSE;
! 2445: break;
! 2446:
! 2447: case CURL_RTSPREQ_TEARDOWN:
! 2448: rtspreq = RTSPREQ_TEARDOWN;
! 2449: break;
! 2450:
! 2451: case CURL_RTSPREQ_GET_PARAMETER:
! 2452: rtspreq = RTSPREQ_GET_PARAMETER;
! 2453: break;
! 2454:
! 2455: case CURL_RTSPREQ_SET_PARAMETER:
! 2456: rtspreq = RTSPREQ_SET_PARAMETER;
! 2457: break;
! 2458:
! 2459: case CURL_RTSPREQ_RECORD:
! 2460: rtspreq = RTSPREQ_RECORD;
! 2461: break;
! 2462:
! 2463: case CURL_RTSPREQ_RECEIVE:
! 2464: rtspreq = RTSPREQ_RECEIVE;
! 2465: break;
! 2466: default:
! 2467: rtspreq = RTSPREQ_NONE;
! 2468: }
! 2469:
! 2470: data->set.rtspreq = rtspreq;
! 2471: break;
! 2472: }
! 2473:
! 2474:
! 2475: case CURLOPT_RTSP_SESSION_ID:
! 2476: /*
! 2477: * Set the RTSP Session ID manually. Useful if the application is
! 2478: * resuming a previously established RTSP session
! 2479: */
! 2480: result = Curl_setstropt(&data->set.str[STRING_RTSP_SESSION_ID],
! 2481: va_arg(param, char *));
! 2482: break;
! 2483:
! 2484: case CURLOPT_RTSP_STREAM_URI:
! 2485: /*
! 2486: * Set the Stream URI for the RTSP request. Unless the request is
! 2487: * for generic server options, the application will need to set this.
! 2488: */
! 2489: result = Curl_setstropt(&data->set.str[STRING_RTSP_STREAM_URI],
! 2490: va_arg(param, char *));
! 2491: break;
! 2492:
! 2493: case CURLOPT_RTSP_TRANSPORT:
! 2494: /*
! 2495: * The content of the Transport: header for the RTSP request
! 2496: */
! 2497: result = Curl_setstropt(&data->set.str[STRING_RTSP_TRANSPORT],
! 2498: va_arg(param, char *));
! 2499: break;
! 2500:
! 2501: case CURLOPT_RTSP_CLIENT_CSEQ:
! 2502: /*
! 2503: * Set the CSEQ number to issue for the next RTSP request. Useful if the
! 2504: * application is resuming a previously broken connection. The CSEQ
! 2505: * will increment from this new number henceforth.
! 2506: */
! 2507: data->state.rtsp_next_client_CSeq = va_arg(param, long);
! 2508: break;
! 2509:
! 2510: case CURLOPT_RTSP_SERVER_CSEQ:
! 2511: /* Same as the above, but for server-initiated requests */
! 2512: data->state.rtsp_next_server_CSeq = va_arg(param, long);
! 2513: break;
! 2514:
! 2515: case CURLOPT_INTERLEAVEDATA:
! 2516: data->set.rtp_out = va_arg(param, void *);
! 2517: break;
! 2518: case CURLOPT_INTERLEAVEFUNCTION:
! 2519: /* Set the user defined RTP write function */
! 2520: data->set.fwrite_rtp = va_arg(param, curl_write_callback);
! 2521: break;
! 2522: #endif
! 2523: #ifndef CURL_DISABLE_FTP
! 2524: case CURLOPT_WILDCARDMATCH:
! 2525: data->set.wildcard_enabled = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 2526: break;
! 2527: case CURLOPT_CHUNK_BGN_FUNCTION:
! 2528: data->set.chunk_bgn = va_arg(param, curl_chunk_bgn_callback);
! 2529: break;
! 2530: case CURLOPT_CHUNK_END_FUNCTION:
! 2531: data->set.chunk_end = va_arg(param, curl_chunk_end_callback);
! 2532: break;
! 2533: case CURLOPT_FNMATCH_FUNCTION:
! 2534: data->set.fnmatch = va_arg(param, curl_fnmatch_callback);
! 2535: break;
! 2536: case CURLOPT_CHUNK_DATA:
! 2537: data->wildcard.customptr = va_arg(param, void *);
! 2538: break;
! 2539: case CURLOPT_FNMATCH_DATA:
! 2540: data->set.fnmatch_data = va_arg(param, void *);
! 2541: break;
! 2542: #endif
! 2543: #ifdef USE_TLS_SRP
! 2544: case CURLOPT_TLSAUTH_USERNAME:
! 2545: result = Curl_setstropt(&data->set.str[STRING_TLSAUTH_USERNAME_ORIG],
! 2546: va_arg(param, char *));
! 2547: if(data->set.str[STRING_TLSAUTH_USERNAME_ORIG] && !data->set.ssl.authtype)
! 2548: data->set.ssl.authtype = CURL_TLSAUTH_SRP; /* default to SRP */
! 2549: break;
! 2550: case CURLOPT_PROXY_TLSAUTH_USERNAME:
! 2551: result = Curl_setstropt(&data->set.str[STRING_TLSAUTH_USERNAME_PROXY],
! 2552: va_arg(param, char *));
! 2553: if(data->set.str[STRING_TLSAUTH_USERNAME_PROXY] &&
! 2554: !data->set.proxy_ssl.authtype)
! 2555: data->set.proxy_ssl.authtype = CURL_TLSAUTH_SRP; /* default to SRP */
! 2556: break;
! 2557: case CURLOPT_TLSAUTH_PASSWORD:
! 2558: result = Curl_setstropt(&data->set.str[STRING_TLSAUTH_PASSWORD_ORIG],
! 2559: va_arg(param, char *));
! 2560: if(data->set.str[STRING_TLSAUTH_USERNAME_ORIG] && !data->set.ssl.authtype)
! 2561: data->set.ssl.authtype = CURL_TLSAUTH_SRP; /* default to SRP */
! 2562: break;
! 2563: case CURLOPT_PROXY_TLSAUTH_PASSWORD:
! 2564: result = Curl_setstropt(&data->set.str[STRING_TLSAUTH_PASSWORD_PROXY],
! 2565: va_arg(param, char *));
! 2566: if(data->set.str[STRING_TLSAUTH_USERNAME_PROXY] &&
! 2567: !data->set.proxy_ssl.authtype)
! 2568: data->set.proxy_ssl.authtype = CURL_TLSAUTH_SRP; /* default to SRP */
! 2569: break;
! 2570: case CURLOPT_TLSAUTH_TYPE:
! 2571: argptr = va_arg(param, char *);
! 2572: if(!argptr ||
! 2573: strncasecompare(argptr, "SRP", strlen("SRP")))
! 2574: data->set.ssl.authtype = CURL_TLSAUTH_SRP;
! 2575: else
! 2576: data->set.ssl.authtype = CURL_TLSAUTH_NONE;
! 2577: break;
! 2578: case CURLOPT_PROXY_TLSAUTH_TYPE:
! 2579: argptr = va_arg(param, char *);
! 2580: if(!argptr ||
! 2581: strncasecompare(argptr, "SRP", strlen("SRP")))
! 2582: data->set.proxy_ssl.authtype = CURL_TLSAUTH_SRP;
! 2583: else
! 2584: data->set.proxy_ssl.authtype = CURL_TLSAUTH_NONE;
! 2585: break;
! 2586: #endif
! 2587: #ifdef USE_ARES
! 2588: case CURLOPT_DNS_SERVERS:
! 2589: result = Curl_setstropt(&data->set.str[STRING_DNS_SERVERS],
! 2590: va_arg(param, char *));
! 2591: if(result)
! 2592: return result;
! 2593: result = Curl_set_dns_servers(data, data->set.str[STRING_DNS_SERVERS]);
! 2594: break;
! 2595: case CURLOPT_DNS_INTERFACE:
! 2596: result = Curl_setstropt(&data->set.str[STRING_DNS_INTERFACE],
! 2597: va_arg(param, char *));
! 2598: if(result)
! 2599: return result;
! 2600: result = Curl_set_dns_interface(data, data->set.str[STRING_DNS_INTERFACE]);
! 2601: break;
! 2602: case CURLOPT_DNS_LOCAL_IP4:
! 2603: result = Curl_setstropt(&data->set.str[STRING_DNS_LOCAL_IP4],
! 2604: va_arg(param, char *));
! 2605: if(result)
! 2606: return result;
! 2607: result = Curl_set_dns_local_ip4(data, data->set.str[STRING_DNS_LOCAL_IP4]);
! 2608: break;
! 2609: case CURLOPT_DNS_LOCAL_IP6:
! 2610: result = Curl_setstropt(&data->set.str[STRING_DNS_LOCAL_IP6],
! 2611: va_arg(param, char *));
! 2612: if(result)
! 2613: return result;
! 2614: result = Curl_set_dns_local_ip6(data, data->set.str[STRING_DNS_LOCAL_IP6]);
! 2615: break;
! 2616: #endif
! 2617: case CURLOPT_TCP_KEEPALIVE:
! 2618: data->set.tcp_keepalive = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 2619: break;
! 2620: case CURLOPT_TCP_KEEPIDLE:
! 2621: arg = va_arg(param, long);
! 2622: if(arg < 0)
! 2623: return CURLE_BAD_FUNCTION_ARGUMENT;
! 2624: data->set.tcp_keepidle = arg;
! 2625: break;
! 2626: case CURLOPT_TCP_KEEPINTVL:
! 2627: arg = va_arg(param, long);
! 2628: if(arg < 0)
! 2629: return CURLE_BAD_FUNCTION_ARGUMENT;
! 2630: data->set.tcp_keepintvl = arg;
! 2631: break;
! 2632: case CURLOPT_TCP_FASTOPEN:
! 2633: #if defined(CONNECT_DATA_IDEMPOTENT) || defined(MSG_FASTOPEN) || \
! 2634: defined(TCP_FASTOPEN_CONNECT)
! 2635: data->set.tcp_fastopen = (0 != va_arg(param, long))?TRUE:FALSE;
! 2636: #else
! 2637: result = CURLE_NOT_BUILT_IN;
! 2638: #endif
! 2639: break;
! 2640: case CURLOPT_SSL_ENABLE_NPN:
! 2641: data->set.ssl_enable_npn = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 2642: break;
! 2643: case CURLOPT_SSL_ENABLE_ALPN:
! 2644: data->set.ssl_enable_alpn = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 2645: break;
! 2646: #ifdef USE_UNIX_SOCKETS
! 2647: case CURLOPT_UNIX_SOCKET_PATH:
! 2648: data->set.abstract_unix_socket = FALSE;
! 2649: result = Curl_setstropt(&data->set.str[STRING_UNIX_SOCKET_PATH],
! 2650: va_arg(param, char *));
! 2651: break;
! 2652: case CURLOPT_ABSTRACT_UNIX_SOCKET:
! 2653: data->set.abstract_unix_socket = TRUE;
! 2654: result = Curl_setstropt(&data->set.str[STRING_UNIX_SOCKET_PATH],
! 2655: va_arg(param, char *));
! 2656: break;
! 2657: #endif
! 2658:
! 2659: case CURLOPT_PATH_AS_IS:
! 2660: data->set.path_as_is = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 2661: break;
! 2662: case CURLOPT_PIPEWAIT:
! 2663: data->set.pipewait = (0 != va_arg(param, long)) ? TRUE : FALSE;
! 2664: break;
! 2665: case CURLOPT_STREAM_WEIGHT:
! 2666: #ifndef USE_NGHTTP2
! 2667: return CURLE_NOT_BUILT_IN;
! 2668: #else
! 2669: arg = va_arg(param, long);
! 2670: if((arg >= 1) && (arg <= 256))
! 2671: data->set.stream_weight = (int)arg;
! 2672: break;
! 2673: #endif
! 2674: case CURLOPT_STREAM_DEPENDS:
! 2675: case CURLOPT_STREAM_DEPENDS_E:
! 2676: {
! 2677: #ifndef USE_NGHTTP2
! 2678: return CURLE_NOT_BUILT_IN;
! 2679: #else
! 2680: struct Curl_easy *dep = va_arg(param, struct Curl_easy *);
! 2681: if(!dep || GOOD_EASY_HANDLE(dep)) {
! 2682: if(data->set.stream_depends_on) {
! 2683: Curl_http2_remove_child(data->set.stream_depends_on, data);
! 2684: }
! 2685: Curl_http2_add_child(dep, data, (option == CURLOPT_STREAM_DEPENDS_E));
! 2686: }
! 2687: break;
! 2688: #endif
! 2689: }
! 2690: case CURLOPT_CONNECT_TO:
! 2691: data->set.connect_to = va_arg(param, struct curl_slist *);
! 2692: break;
! 2693: case CURLOPT_SUPPRESS_CONNECT_HEADERS:
! 2694: data->set.suppress_connect_headers = (0 != va_arg(param, long))?TRUE:FALSE;
! 2695: break;
! 2696: case CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS:
! 2697: arg = va_arg(param, long);
! 2698: if(arg < 0)
! 2699: return CURLE_BAD_FUNCTION_ARGUMENT;
! 2700: data->set.happy_eyeballs_timeout = arg;
! 2701: break;
! 2702: #ifndef CURL_DISABLE_SHUFFLE_DNS
! 2703: case CURLOPT_DNS_SHUFFLE_ADDRESSES:
! 2704: data->set.dns_shuffle_addresses = (0 != va_arg(param, long)) ? TRUE:FALSE;
! 2705: break;
! 2706: #endif
! 2707: case CURLOPT_DISALLOW_USERNAME_IN_URL:
! 2708: data->set.disallow_username_in_url =
! 2709: (0 != va_arg(param, long)) ? TRUE : FALSE;
! 2710: break;
! 2711: #ifndef CURL_DISABLE_DOH
! 2712: case CURLOPT_DOH_URL:
! 2713: result = Curl_setstropt(&data->set.str[STRING_DOH],
! 2714: va_arg(param, char *));
! 2715: data->set.doh = data->set.str[STRING_DOH]?TRUE:FALSE;
! 2716: break;
! 2717: #endif
! 2718: case CURLOPT_UPKEEP_INTERVAL_MS:
! 2719: arg = va_arg(param, long);
! 2720: if(arg < 0)
! 2721: return CURLE_BAD_FUNCTION_ARGUMENT;
! 2722: data->set.upkeep_interval_ms = arg;
! 2723: break;
! 2724: case CURLOPT_MAXAGE_CONN:
! 2725: arg = va_arg(param, long);
! 2726: if(arg < 0)
! 2727: return CURLE_BAD_FUNCTION_ARGUMENT;
! 2728: data->set.maxage_conn = arg;
! 2729: break;
! 2730: case CURLOPT_TRAILERFUNCTION:
! 2731: #ifndef CURL_DISABLE_HTTP
! 2732: data->set.trailer_callback = va_arg(param, curl_trailer_callback);
! 2733: #endif
! 2734: break;
! 2735: case CURLOPT_TRAILERDATA:
! 2736: #ifndef CURL_DISABLE_HTTP
! 2737: data->set.trailer_data = va_arg(param, void *);
! 2738: #endif
! 2739: break;
! 2740: #ifdef USE_ALTSVC
! 2741: case CURLOPT_ALTSVC:
! 2742: if(!data->asi) {
! 2743: data->asi = Curl_altsvc_init();
! 2744: if(!data->asi)
! 2745: return CURLE_OUT_OF_MEMORY;
! 2746: }
! 2747: argptr = va_arg(param, char *);
! 2748: result = Curl_setstropt(&data->set.str[STRING_ALTSVC], argptr);
! 2749: if(result)
! 2750: return result;
! 2751: if(argptr)
! 2752: (void)Curl_altsvc_load(data->asi, argptr);
! 2753: break;
! 2754: case CURLOPT_ALTSVC_CTRL:
! 2755: if(!data->asi) {
! 2756: data->asi = Curl_altsvc_init();
! 2757: if(!data->asi)
! 2758: return CURLE_OUT_OF_MEMORY;
! 2759: }
! 2760: arg = va_arg(param, long);
! 2761: result = Curl_altsvc_ctrl(data->asi, arg);
! 2762: if(result)
! 2763: return result;
! 2764: break;
! 2765: #endif
! 2766: default:
! 2767: /* unknown tag and its companion, just ignore: */
! 2768: result = CURLE_UNKNOWN_OPTION;
! 2769: break;
! 2770: }
! 2771:
! 2772: return result;
! 2773: }
! 2774:
! 2775: /*
! 2776: * curl_easy_setopt() is the external interface for setting options on an
! 2777: * easy handle.
! 2778: *
! 2779: * NOTE: This is one of few API functions that are allowed to be called from
! 2780: * within a callback.
! 2781: */
! 2782:
! 2783: #undef curl_easy_setopt
! 2784: CURLcode curl_easy_setopt(struct Curl_easy *data, CURLoption tag, ...)
! 2785: {
! 2786: va_list arg;
! 2787: CURLcode result;
! 2788:
! 2789: if(!data)
! 2790: return CURLE_BAD_FUNCTION_ARGUMENT;
! 2791:
! 2792: va_start(arg, tag);
! 2793:
! 2794: result = Curl_vsetopt(data, tag, arg);
! 2795:
! 2796: va_end(arg);
! 2797: return result;
! 2798: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to setopt.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 / lib