Annotation of embedaddon/curl/src/tool_getparam.c, revision 1.1
1.1 ! misho 1: /***************************************************************************
! 2: * _ _ ____ _
! 3: * Project ___| | | | _ \| |
! 4: * / __| | | | |_) | |
! 5: * | (__| |_| | _ <| |___
! 6: * \___|\___/|_| \_\_____|
! 7: *
! 8: * Copyright (C) 1998 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
! 9: *
! 10: * This software is licensed as described in the file COPYING, which
! 11: * you should have received as part of this distribution. The terms
! 12: * are also available at https://curl.haxx.se/docs/copyright.html.
! 13: *
! 14: * You may opt to use, copy, modify, merge, publish, distribute and/or sell
! 15: * copies of the Software, and permit persons to whom the Software is
! 16: * furnished to do so, under the terms of the COPYING file.
! 17: *
! 18: * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
! 19: * KIND, either express or implied.
! 20: *
! 21: ***************************************************************************/
! 22: #include "tool_setup.h"
! 23:
! 24: #include "strcase.h"
! 25:
! 26: #define ENABLE_CURLX_PRINTF
! 27: /* use our own printf() functions */
! 28: #include "curlx.h"
! 29:
! 30: #include "tool_binmode.h"
! 31: #include "tool_cfgable.h"
! 32: #include "tool_cb_prg.h"
! 33: #include "tool_convert.h"
! 34: #include "tool_filetime.h"
! 35: #include "tool_formparse.h"
! 36: #include "tool_getparam.h"
! 37: #include "tool_helpers.h"
! 38: #include "tool_libinfo.h"
! 39: #include "tool_metalink.h"
! 40: #include "tool_msgs.h"
! 41: #include "tool_paramhlp.h"
! 42: #include "tool_parsecfg.h"
! 43: #include "tool_main.h"
! 44:
! 45: #include "memdebug.h" /* keep this as LAST include */
! 46:
! 47: #ifdef MSDOS
! 48: # define USE_WATT32
! 49: #endif
! 50:
! 51: #define GetStr(str,val) do { \
! 52: if(*(str)) { \
! 53: free(*(str)); \
! 54: *(str) = NULL; \
! 55: } \
! 56: if((val)) { \
! 57: *(str) = strdup((val)); \
! 58: if(!(*(str))) \
! 59: return PARAM_NO_MEM; \
! 60: } \
! 61: } while(0)
! 62:
! 63: struct LongShort {
! 64: const char *letter; /* short name option */
! 65: const char *lname; /* long name option */
! 66: enum {
! 67: ARG_NONE, /* stand-alone but not a boolean */
! 68: ARG_BOOL, /* accepts a --no-[name] prefix */
! 69: ARG_STRING, /* requires an argument */
! 70: ARG_FILENAME /* requires an argument, usually a file name */
! 71: } desc;
! 72: };
! 73:
! 74: static const struct LongShort aliases[]= {
! 75: /* 'letter' strings with more than one character have *no* short option to
! 76: mention. */
! 77: {"*@", "url", ARG_STRING},
! 78: {"*4", "dns-ipv4-addr", ARG_STRING},
! 79: {"*6", "dns-ipv6-addr", ARG_STRING},
! 80: {"*a", "random-file", ARG_FILENAME},
! 81: {"*b", "egd-file", ARG_STRING},
! 82: {"*B", "oauth2-bearer", ARG_STRING},
! 83: {"*c", "connect-timeout", ARG_STRING},
! 84: {"*C", "doh-url" , ARG_STRING},
! 85: {"*d", "ciphers", ARG_STRING},
! 86: {"*D", "dns-interface", ARG_STRING},
! 87: {"*e", "disable-epsv", ARG_BOOL},
! 88: {"*f", "disallow-username-in-url", ARG_BOOL},
! 89: {"*E", "epsv", ARG_BOOL},
! 90: /* 'epsv' made like this to make --no-epsv and --epsv to work
! 91: although --disable-epsv is the documented option */
! 92: {"*F", "dns-servers", ARG_STRING},
! 93: {"*g", "trace", ARG_FILENAME},
! 94: {"*G", "npn", ARG_BOOL},
! 95: {"*h", "trace-ascii", ARG_FILENAME},
! 96: {"*H", "alpn", ARG_BOOL},
! 97: {"*i", "limit-rate", ARG_STRING},
! 98: {"*j", "compressed", ARG_BOOL},
! 99: {"*J", "tr-encoding", ARG_BOOL},
! 100: {"*k", "digest", ARG_BOOL},
! 101: {"*l", "negotiate", ARG_BOOL},
! 102: {"*m", "ntlm", ARG_BOOL},
! 103: {"*M", "ntlm-wb", ARG_BOOL},
! 104: {"*n", "basic", ARG_BOOL},
! 105: {"*o", "anyauth", ARG_BOOL},
! 106: #ifdef USE_WATT32
! 107: {"*p", "wdebug", ARG_BOOL},
! 108: #endif
! 109: {"*q", "ftp-create-dirs", ARG_BOOL},
! 110: {"*r", "create-dirs", ARG_BOOL},
! 111: {"*s", "max-redirs", ARG_STRING},
! 112: {"*t", "proxy-ntlm", ARG_BOOL},
! 113: {"*u", "crlf", ARG_BOOL},
! 114: {"*v", "stderr", ARG_FILENAME},
! 115: {"*w", "interface", ARG_STRING},
! 116: {"*x", "krb", ARG_STRING},
! 117: {"*x", "krb4", ARG_STRING},
! 118: /* 'krb4' is the previous name */
! 119: {"*X", "haproxy-protocol", ARG_BOOL},
! 120: {"*y", "max-filesize", ARG_STRING},
! 121: {"*z", "disable-eprt", ARG_BOOL},
! 122: {"*Z", "eprt", ARG_BOOL},
! 123: /* 'eprt' made like this to make --no-eprt and --eprt to work
! 124: although --disable-eprt is the documented option */
! 125: {"*~", "xattr", ARG_BOOL},
! 126: {"$a", "ftp-ssl", ARG_BOOL},
! 127: /* 'ftp-ssl' deprecated name since 7.20.0 */
! 128: {"$a", "ssl", ARG_BOOL},
! 129: /* 'ssl' new option name in 7.20.0, previously this was ftp-ssl */
! 130: {"$b", "ftp-pasv", ARG_BOOL},
! 131: {"$c", "socks5", ARG_STRING},
! 132: {"$d", "tcp-nodelay", ARG_BOOL},
! 133: {"$e", "proxy-digest", ARG_BOOL},
! 134: {"$f", "proxy-basic", ARG_BOOL},
! 135: {"$g", "retry", ARG_STRING},
! 136: {"$V", "retry-connrefused", ARG_BOOL},
! 137: {"$h", "retry-delay", ARG_STRING},
! 138: {"$i", "retry-max-time", ARG_STRING},
! 139: {"$k", "proxy-negotiate", ARG_BOOL},
! 140: {"$m", "ftp-account", ARG_STRING},
! 141: {"$n", "proxy-anyauth", ARG_BOOL},
! 142: {"$o", "trace-time", ARG_BOOL},
! 143: {"$p", "ignore-content-length", ARG_BOOL},
! 144: {"$q", "ftp-skip-pasv-ip", ARG_BOOL},
! 145: {"$r", "ftp-method", ARG_STRING},
! 146: {"$s", "local-port", ARG_STRING},
! 147: {"$t", "socks4", ARG_STRING},
! 148: {"$T", "socks4a", ARG_STRING},
! 149: {"$u", "ftp-alternative-to-user", ARG_STRING},
! 150: {"$v", "ftp-ssl-reqd", ARG_BOOL},
! 151: /* 'ftp-ssl-reqd' deprecated name since 7.20.0 */
! 152: {"$v", "ssl-reqd", ARG_BOOL},
! 153: /* 'ssl-reqd' new in 7.20.0, previously this was ftp-ssl-reqd */
! 154: {"$w", "sessionid", ARG_BOOL},
! 155: /* 'sessionid' listed as --no-sessionid in the help */
! 156: {"$x", "ftp-ssl-control", ARG_BOOL},
! 157: {"$y", "ftp-ssl-ccc", ARG_BOOL},
! 158: {"$j", "ftp-ssl-ccc-mode", ARG_STRING},
! 159: {"$z", "libcurl", ARG_STRING},
! 160: {"$#", "raw", ARG_BOOL},
! 161: {"$0", "post301", ARG_BOOL},
! 162: {"$1", "keepalive", ARG_BOOL},
! 163: /* 'keepalive' listed as --no-keepalive in the help */
! 164: {"$2", "socks5-hostname", ARG_STRING},
! 165: {"$3", "keepalive-time", ARG_STRING},
! 166: {"$4", "post302", ARG_BOOL},
! 167: {"$5", "noproxy", ARG_STRING},
! 168: {"$7", "socks5-gssapi-nec", ARG_BOOL},
! 169: {"$8", "proxy1.0", ARG_STRING},
! 170: {"$9", "tftp-blksize", ARG_STRING},
! 171: {"$A", "mail-from", ARG_STRING},
! 172: {"$B", "mail-rcpt", ARG_STRING},
! 173: {"$C", "ftp-pret", ARG_BOOL},
! 174: {"$D", "proto", ARG_STRING},
! 175: {"$E", "proto-redir", ARG_STRING},
! 176: {"$F", "resolve", ARG_STRING},
! 177: {"$G", "delegation", ARG_STRING},
! 178: {"$H", "mail-auth", ARG_STRING},
! 179: {"$I", "post303", ARG_BOOL},
! 180: {"$J", "metalink", ARG_BOOL},
! 181: {"$6", "sasl-authzid", ARG_STRING},
! 182: {"$K", "sasl-ir", ARG_BOOL },
! 183: {"$L", "test-event", ARG_BOOL},
! 184: {"$M", "unix-socket", ARG_FILENAME},
! 185: {"$N", "path-as-is", ARG_BOOL},
! 186: {"$O", "socks5-gssapi-service", ARG_STRING},
! 187: /* 'socks5-gssapi-service' merged with'proxy-service-name' and
! 188: deprecated since 7.49.0 */
! 189: {"$O", "proxy-service-name", ARG_STRING},
! 190: {"$P", "service-name", ARG_STRING},
! 191: {"$Q", "proto-default", ARG_STRING},
! 192: {"$R", "expect100-timeout", ARG_STRING},
! 193: {"$S", "tftp-no-options", ARG_BOOL},
! 194: {"$U", "connect-to", ARG_STRING},
! 195: {"$W", "abstract-unix-socket", ARG_FILENAME},
! 196: {"$X", "tls-max", ARG_STRING},
! 197: {"$Y", "suppress-connect-headers", ARG_BOOL},
! 198: {"$Z", "compressed-ssh", ARG_BOOL},
! 199: {"$~", "happy-eyeballs-timeout-ms", ARG_STRING},
! 200: {"0", "http1.0", ARG_NONE},
! 201: {"01", "http1.1", ARG_NONE},
! 202: {"02", "http2", ARG_NONE},
! 203: {"03", "http2-prior-knowledge", ARG_NONE},
! 204: {"04", "http3", ARG_NONE},
! 205: {"09", "http0.9", ARG_BOOL},
! 206: {"1", "tlsv1", ARG_NONE},
! 207: {"10", "tlsv1.0", ARG_NONE},
! 208: {"11", "tlsv1.1", ARG_NONE},
! 209: {"12", "tlsv1.2", ARG_NONE},
! 210: {"13", "tlsv1.3", ARG_NONE},
! 211: {"1A", "tls13-ciphers", ARG_STRING},
! 212: {"1B", "proxy-tls13-ciphers", ARG_STRING},
! 213: {"2", "sslv2", ARG_NONE},
! 214: {"3", "sslv3", ARG_NONE},
! 215: {"4", "ipv4", ARG_NONE},
! 216: {"6", "ipv6", ARG_NONE},
! 217: {"a", "append", ARG_BOOL},
! 218: {"A", "user-agent", ARG_STRING},
! 219: {"b", "cookie", ARG_STRING},
! 220: {"ba", "alt-svc", ARG_STRING},
! 221: {"B", "use-ascii", ARG_BOOL},
! 222: {"c", "cookie-jar", ARG_STRING},
! 223: {"C", "continue-at", ARG_STRING},
! 224: {"d", "data", ARG_STRING},
! 225: {"dr", "data-raw", ARG_STRING},
! 226: {"da", "data-ascii", ARG_STRING},
! 227: {"db", "data-binary", ARG_STRING},
! 228: {"de", "data-urlencode", ARG_STRING},
! 229: {"D", "dump-header", ARG_FILENAME},
! 230: {"e", "referer", ARG_STRING},
! 231: {"E", "cert", ARG_FILENAME},
! 232: {"Ea", "cacert", ARG_FILENAME},
! 233: {"Eb", "cert-type", ARG_STRING},
! 234: {"Ec", "key", ARG_FILENAME},
! 235: {"Ed", "key-type", ARG_STRING},
! 236: {"Ee", "pass", ARG_STRING},
! 237: {"Ef", "engine", ARG_STRING},
! 238: {"Eg", "capath", ARG_FILENAME},
! 239: {"Eh", "pubkey", ARG_STRING},
! 240: {"Ei", "hostpubmd5", ARG_STRING},
! 241: {"Ej", "crlfile", ARG_FILENAME},
! 242: {"Ek", "tlsuser", ARG_STRING},
! 243: {"El", "tlspassword", ARG_STRING},
! 244: {"Em", "tlsauthtype", ARG_STRING},
! 245: {"En", "ssl-allow-beast", ARG_BOOL},
! 246: /* Eo */
! 247: {"Ep", "pinnedpubkey", ARG_STRING},
! 248: {"EP", "proxy-pinnedpubkey", ARG_STRING},
! 249: {"Eq", "cert-status", ARG_BOOL},
! 250: {"Er", "false-start", ARG_BOOL},
! 251: {"Es", "ssl-no-revoke", ARG_BOOL},
! 252: {"ES", "ssl-revoke-best-effort", ARG_BOOL},
! 253: {"Et", "tcp-fastopen", ARG_BOOL},
! 254: {"Eu", "proxy-tlsuser", ARG_STRING},
! 255: {"Ev", "proxy-tlspassword", ARG_STRING},
! 256: {"Ew", "proxy-tlsauthtype", ARG_STRING},
! 257: {"Ex", "proxy-cert", ARG_FILENAME},
! 258: {"Ey", "proxy-cert-type", ARG_STRING},
! 259: {"Ez", "proxy-key", ARG_FILENAME},
! 260: {"E0", "proxy-key-type", ARG_STRING},
! 261: {"E1", "proxy-pass", ARG_STRING},
! 262: {"E2", "proxy-ciphers", ARG_STRING},
! 263: {"E3", "proxy-crlfile", ARG_FILENAME},
! 264: {"E4", "proxy-ssl-allow-beast", ARG_BOOL},
! 265: {"E5", "login-options", ARG_STRING},
! 266: {"E6", "proxy-cacert", ARG_FILENAME},
! 267: {"E7", "proxy-capath", ARG_FILENAME},
! 268: {"E8", "proxy-insecure", ARG_BOOL},
! 269: {"E9", "proxy-tlsv1", ARG_NONE},
! 270: {"EA", "socks5-basic", ARG_BOOL},
! 271: {"EB", "socks5-gssapi", ARG_BOOL},
! 272: {"EC", "etag-save", ARG_FILENAME},
! 273: {"ED", "etag-compare", ARG_FILENAME},
! 274: {"f", "fail", ARG_BOOL},
! 275: {"fa", "fail-early", ARG_BOOL},
! 276: {"fb", "styled-output", ARG_BOOL},
! 277: {"fc", "mail-rcpt-allowfails", ARG_BOOL},
! 278: {"F", "form", ARG_STRING},
! 279: {"Fs", "form-string", ARG_STRING},
! 280: {"g", "globoff", ARG_BOOL},
! 281: {"G", "get", ARG_NONE},
! 282: {"Ga", "request-target", ARG_STRING},
! 283: {"h", "help", ARG_BOOL},
! 284: {"H", "header", ARG_STRING},
! 285: {"Hp", "proxy-header", ARG_STRING},
! 286: {"i", "include", ARG_BOOL},
! 287: {"I", "head", ARG_BOOL},
! 288: {"j", "junk-session-cookies", ARG_BOOL},
! 289: {"J", "remote-header-name", ARG_BOOL},
! 290: {"k", "insecure", ARG_BOOL},
! 291: {"K", "config", ARG_FILENAME},
! 292: {"l", "list-only", ARG_BOOL},
! 293: {"L", "location", ARG_BOOL},
! 294: {"Lt", "location-trusted", ARG_BOOL},
! 295: {"m", "max-time", ARG_STRING},
! 296: {"M", "manual", ARG_BOOL},
! 297: {"n", "netrc", ARG_BOOL},
! 298: {"no", "netrc-optional", ARG_BOOL},
! 299: {"ne", "netrc-file", ARG_FILENAME},
! 300: {"N", "buffer", ARG_BOOL},
! 301: /* 'buffer' listed as --no-buffer in the help */
! 302: {"o", "output", ARG_FILENAME},
! 303: {"O", "remote-name", ARG_NONE},
! 304: {"Oa", "remote-name-all", ARG_BOOL},
! 305: {"p", "proxytunnel", ARG_BOOL},
! 306: {"P", "ftp-port", ARG_STRING},
! 307: {"q", "disable", ARG_BOOL},
! 308: {"Q", "quote", ARG_STRING},
! 309: {"r", "range", ARG_STRING},
! 310: {"R", "remote-time", ARG_BOOL},
! 311: {"s", "silent", ARG_BOOL},
! 312: {"S", "show-error", ARG_BOOL},
! 313: {"t", "telnet-option", ARG_STRING},
! 314: {"T", "upload-file", ARG_FILENAME},
! 315: {"u", "user", ARG_STRING},
! 316: {"U", "proxy-user", ARG_STRING},
! 317: {"v", "verbose", ARG_BOOL},
! 318: {"V", "version", ARG_BOOL},
! 319: {"w", "write-out", ARG_STRING},
! 320: {"x", "proxy", ARG_STRING},
! 321: {"xa", "preproxy", ARG_STRING},
! 322: {"X", "request", ARG_STRING},
! 323: {"Y", "speed-limit", ARG_STRING},
! 324: {"y", "speed-time", ARG_STRING},
! 325: {"z", "time-cond", ARG_STRING},
! 326: {"Z", "parallel", ARG_BOOL},
! 327: {"Zb", "parallel-max", ARG_STRING},
! 328: {"Zc", "parallel-immediate", ARG_BOOL},
! 329: {"#", "progress-bar", ARG_BOOL},
! 330: {"#m", "progress-meter", ARG_BOOL},
! 331: {":", "next", ARG_NONE},
! 332: };
! 333:
! 334: /* Split the argument of -E to 'certname' and 'passphrase' separated by colon.
! 335: * We allow ':' and '\' to be escaped by '\' so that we can use certificate
! 336: * nicknames containing ':'. See <https://sourceforge.net/p/curl/bugs/1196/>
! 337: * for details. */
! 338: #ifndef UNITTESTS
! 339: static
! 340: #endif
! 341: void parse_cert_parameter(const char *cert_parameter,
! 342: char **certname,
! 343: char **passphrase)
! 344: {
! 345: size_t param_length = strlen(cert_parameter);
! 346: size_t span;
! 347: const char *param_place = NULL;
! 348: char *certname_place = NULL;
! 349: *certname = NULL;
! 350: *passphrase = NULL;
! 351:
! 352: /* most trivial assumption: cert_parameter is empty */
! 353: if(param_length == 0)
! 354: return;
! 355:
! 356: /* next less trivial: cert_parameter starts 'pkcs11:' and thus
! 357: * looks like a RFC7512 PKCS#11 URI which can be used as-is.
! 358: * Also if cert_parameter contains no colon nor backslash, this
! 359: * means no passphrase was given and no characters escaped */
! 360: if(curl_strnequal(cert_parameter, "pkcs11:", 7) ||
! 361: !strpbrk(cert_parameter, ":\\")) {
! 362: *certname = strdup(cert_parameter);
! 363: return;
! 364: }
! 365: /* deal with escaped chars; find unescaped colon if it exists */
! 366: certname_place = malloc(param_length + 1);
! 367: if(!certname_place)
! 368: return;
! 369:
! 370: *certname = certname_place;
! 371: param_place = cert_parameter;
! 372: while(*param_place) {
! 373: span = strcspn(param_place, ":\\");
! 374: strncpy(certname_place, param_place, span);
! 375: param_place += span;
! 376: certname_place += span;
! 377: /* we just ate all the non-special chars. now we're on either a special
! 378: * char or the end of the string. */
! 379: switch(*param_place) {
! 380: case '\0':
! 381: break;
! 382: case '\\':
! 383: param_place++;
! 384: switch(*param_place) {
! 385: case '\0':
! 386: *certname_place++ = '\\';
! 387: break;
! 388: case '\\':
! 389: *certname_place++ = '\\';
! 390: param_place++;
! 391: break;
! 392: case ':':
! 393: *certname_place++ = ':';
! 394: param_place++;
! 395: break;
! 396: default:
! 397: *certname_place++ = '\\';
! 398: *certname_place++ = *param_place;
! 399: param_place++;
! 400: break;
! 401: }
! 402: break;
! 403: case ':':
! 404: /* Since we live in a world of weirdness and confusion, the win32
! 405: dudes can use : when using drive letters and thus c:\file:password
! 406: needs to work. In order not to break compatibility, we still use : as
! 407: separator, but we try to detect when it is used for a file name! On
! 408: windows. */
! 409: #ifdef WIN32
! 410: if(param_place &&
! 411: (param_place == &cert_parameter[1]) &&
! 412: (cert_parameter[2] == '\\' || cert_parameter[2] == '/') &&
! 413: (ISALPHA(cert_parameter[0])) ) {
! 414: /* colon in the second column, followed by a backslash, and the
! 415: first character is an alphabetic letter:
! 416:
! 417: this is a drive letter colon */
! 418: *certname_place++ = ':';
! 419: param_place++;
! 420: break;
! 421: }
! 422: #endif
! 423: /* escaped colons and Windows drive letter colons were handled
! 424: * above; if we're still here, this is a separating colon */
! 425: param_place++;
! 426: if(*param_place) {
! 427: *passphrase = strdup(param_place);
! 428: }
! 429: goto done;
! 430: }
! 431: }
! 432: done:
! 433: *certname_place = '\0';
! 434: }
! 435:
! 436: static void
! 437: GetFileAndPassword(char *nextarg, char **file, char **password)
! 438: {
! 439: char *certname, *passphrase;
! 440: parse_cert_parameter(nextarg, &certname, &passphrase);
! 441: Curl_safefree(*file);
! 442: *file = certname;
! 443: if(passphrase) {
! 444: Curl_safefree(*password);
! 445: *password = passphrase;
! 446: }
! 447: cleanarg(nextarg);
! 448: }
! 449:
! 450: /* Get a size parameter for '--limit-rate' or '--max-filesize'.
! 451: * We support a 'G', 'M' or 'K' suffix too.
! 452: */
! 453: static ParameterError GetSizeParameter(struct GlobalConfig *global,
! 454: const char *arg,
! 455: const char *which,
! 456: curl_off_t *value_out)
! 457: {
! 458: char *unit;
! 459: curl_off_t value;
! 460:
! 461: if(curlx_strtoofft(arg, &unit, 0, &value)) {
! 462: warnf(global, "invalid number specified for %s\n", which);
! 463: return PARAM_BAD_USE;
! 464: }
! 465:
! 466: if(!*unit)
! 467: unit = (char *)"b";
! 468: else if(strlen(unit) > 1)
! 469: unit = (char *)"w"; /* unsupported */
! 470:
! 471: switch(*unit) {
! 472: case 'G':
! 473: case 'g':
! 474: if(value > (CURL_OFF_T_MAX / (1024*1024*1024)))
! 475: return PARAM_NUMBER_TOO_LARGE;
! 476: value *= 1024*1024*1024;
! 477: break;
! 478: case 'M':
! 479: case 'm':
! 480: if(value > (CURL_OFF_T_MAX / (1024*1024)))
! 481: return PARAM_NUMBER_TOO_LARGE;
! 482: value *= 1024*1024;
! 483: break;
! 484: case 'K':
! 485: case 'k':
! 486: if(value > (CURL_OFF_T_MAX / 1024))
! 487: return PARAM_NUMBER_TOO_LARGE;
! 488: value *= 1024;
! 489: break;
! 490: case 'b':
! 491: case 'B':
! 492: /* for plain bytes, leave as-is */
! 493: break;
! 494: default:
! 495: warnf(global, "unsupported %s unit. Use G, M, K or B!\n", which);
! 496: return PARAM_BAD_USE;
! 497: }
! 498: *value_out = value;
! 499: return PARAM_OK;
! 500: }
! 501:
! 502: ParameterError getparameter(const char *flag, /* f or -long-flag */
! 503: char *nextarg, /* NULL if unset */
! 504: bool *usedarg, /* set to TRUE if the arg
! 505: has been used */
! 506: struct GlobalConfig *global,
! 507: struct OperationConfig *config)
! 508: {
! 509: char letter;
! 510: char subletter = '\0'; /* subletters can only occur on long options */
! 511: int rc;
! 512: const char *parse = NULL;
! 513: unsigned int j;
! 514: time_t now;
! 515: int hit = -1;
! 516: bool longopt = FALSE;
! 517: bool singleopt = FALSE; /* when true means '-o foo' used '-ofoo' */
! 518: ParameterError err;
! 519: bool toggle = TRUE; /* how to switch boolean options, on or off. Controlled
! 520: by using --OPTION or --no-OPTION */
! 521:
! 522: *usedarg = FALSE; /* default is that we don't use the arg */
! 523:
! 524: if(('-' != flag[0]) || ('-' == flag[1])) {
! 525: /* this should be a long name */
! 526: const char *word = ('-' == flag[0]) ? flag + 2 : flag;
! 527: size_t fnam = strlen(word);
! 528: int numhits = 0;
! 529: bool noflagged = FALSE;
! 530:
! 531: if(!strncmp(word, "no-", 3)) {
! 532: /* disable this option but ignore the "no-" part when looking for it */
! 533: word += 3;
! 534: toggle = FALSE;
! 535: noflagged = TRUE;
! 536: }
! 537:
! 538: for(j = 0; j < sizeof(aliases)/sizeof(aliases[0]); j++) {
! 539: if(curl_strnequal(aliases[j].lname, word, fnam)) {
! 540: longopt = TRUE;
! 541: numhits++;
! 542: if(curl_strequal(aliases[j].lname, word)) {
! 543: parse = aliases[j].letter;
! 544: hit = j;
! 545: numhits = 1; /* a single unique hit */
! 546: break;
! 547: }
! 548: parse = aliases[j].letter;
! 549: hit = j;
! 550: }
! 551: }
! 552: if(numhits > 1) {
! 553: /* this is at least the second match! */
! 554: return PARAM_OPTION_AMBIGUOUS;
! 555: }
! 556: if(hit < 0) {
! 557: return PARAM_OPTION_UNKNOWN;
! 558: }
! 559: if(noflagged && (aliases[hit].desc != ARG_BOOL))
! 560: /* --no- prefixed an option that isn't boolean! */
! 561: return PARAM_NO_NOT_BOOLEAN;
! 562: }
! 563: else {
! 564: flag++; /* prefixed with one dash, pass it */
! 565: hit = -1;
! 566: parse = flag;
! 567: }
! 568:
! 569: do {
! 570: /* we can loop here if we have multiple single-letters */
! 571:
! 572: if(!longopt) {
! 573: letter = (char)*parse;
! 574: subletter = '\0';
! 575: }
! 576: else {
! 577: letter = parse[0];
! 578: subletter = parse[1];
! 579: }
! 580:
! 581: if(hit < 0) {
! 582: for(j = 0; j < sizeof(aliases)/sizeof(aliases[0]); j++) {
! 583: if(letter == aliases[j].letter[0]) {
! 584: hit = j;
! 585: break;
! 586: }
! 587: }
! 588: if(hit < 0) {
! 589: return PARAM_OPTION_UNKNOWN;
! 590: }
! 591: }
! 592:
! 593: if(aliases[hit].desc >= ARG_STRING) {
! 594: /* this option requires an extra parameter */
! 595: if(!longopt && parse[1]) {
! 596: nextarg = (char *)&parse[1]; /* this is the actual extra parameter */
! 597: singleopt = TRUE; /* don't loop anymore after this */
! 598: }
! 599: else if(!nextarg)
! 600: return PARAM_REQUIRES_PARAMETER;
! 601: else
! 602: *usedarg = TRUE; /* mark it as used */
! 603:
! 604: if((aliases[hit].desc == ARG_FILENAME) &&
! 605: (nextarg[0] == '-') && nextarg[1]) {
! 606: /* if the file name looks like a command line option */
! 607: warnf(global, "The file name argument '%s' looks like a flag.\n",
! 608: nextarg);
! 609: }
! 610: }
! 611: else if((aliases[hit].desc == ARG_NONE) && !toggle)
! 612: return PARAM_NO_PREFIX;
! 613:
! 614: switch(letter) {
! 615: case '*': /* options without a short option */
! 616: switch(subletter) {
! 617: case '4': /* --dns-ipv4-addr */
! 618: /* addr in dot notation */
! 619: GetStr(&config->dns_ipv4_addr, nextarg);
! 620: break;
! 621: case '6': /* --dns-ipv6-addr */
! 622: /* addr in dot notation */
! 623: GetStr(&config->dns_ipv6_addr, nextarg);
! 624: break;
! 625: case 'a': /* random-file */
! 626: GetStr(&config->random_file, nextarg);
! 627: break;
! 628: case 'b': /* egd-file */
! 629: GetStr(&config->egd_file, nextarg);
! 630: break;
! 631: case 'B': /* OAuth 2.0 bearer token */
! 632: GetStr(&config->oauth_bearer, nextarg);
! 633: config->authtype |= CURLAUTH_BEARER;
! 634: break;
! 635: case 'c': /* connect-timeout */
! 636: err = str2udouble(&config->connecttimeout, nextarg,
! 637: LONG_MAX/1000);
! 638: if(err)
! 639: return err;
! 640: break;
! 641: case 'C': /* doh-url */
! 642: GetStr(&config->doh_url, nextarg);
! 643: break;
! 644: case 'd': /* ciphers */
! 645: GetStr(&config->cipher_list, nextarg);
! 646: break;
! 647: case 'D': /* --dns-interface */
! 648: /* interface name */
! 649: GetStr(&config->dns_interface, nextarg);
! 650: break;
! 651: case 'e': /* --disable-epsv */
! 652: config->disable_epsv = toggle;
! 653: break;
! 654: case 'f': /* --disallow-username-in-url */
! 655: config->disallow_username_in_url = toggle;
! 656: break;
! 657: case 'E': /* --epsv */
! 658: config->disable_epsv = (!toggle)?TRUE:FALSE;
! 659: break;
! 660: case 'F': /* --dns-servers */
! 661: /* IP addrs of DNS servers */
! 662: GetStr(&config->dns_servers, nextarg);
! 663: break;
! 664: case 'g': /* --trace */
! 665: GetStr(&global->trace_dump, nextarg);
! 666: if(global->tracetype && (global->tracetype != TRACE_BIN))
! 667: warnf(global, "--trace overrides an earlier trace/verbose option\n");
! 668: global->tracetype = TRACE_BIN;
! 669: break;
! 670: case 'G': /* --npn */
! 671: config->nonpn = (!toggle)?TRUE:FALSE;
! 672: break;
! 673: case 'h': /* --trace-ascii */
! 674: GetStr(&global->trace_dump, nextarg);
! 675: if(global->tracetype && (global->tracetype != TRACE_ASCII))
! 676: warnf(global,
! 677: "--trace-ascii overrides an earlier trace/verbose option\n");
! 678: global->tracetype = TRACE_ASCII;
! 679: break;
! 680: case 'H': /* --alpn */
! 681: config->noalpn = (!toggle)?TRUE:FALSE;
! 682: break;
! 683: case 'i': /* --limit-rate */
! 684: {
! 685: curl_off_t value;
! 686: ParameterError pe = GetSizeParameter(global, nextarg, "rate", &value);
! 687:
! 688: if(pe != PARAM_OK)
! 689: return pe;
! 690: config->recvpersecond = value;
! 691: config->sendpersecond = value;
! 692: }
! 693: break;
! 694:
! 695: case 'j': /* --compressed */
! 696: if(toggle &&
! 697: !(curlinfo->features & (CURL_VERSION_LIBZ | CURL_VERSION_BROTLI)))
! 698: return PARAM_LIBCURL_DOESNT_SUPPORT;
! 699: config->encoding = toggle;
! 700: break;
! 701:
! 702: case 'J': /* --tr-encoding */
! 703: config->tr_encoding = toggle;
! 704: break;
! 705:
! 706: case 'k': /* --digest */
! 707: if(toggle)
! 708: config->authtype |= CURLAUTH_DIGEST;
! 709: else
! 710: config->authtype &= ~CURLAUTH_DIGEST;
! 711: break;
! 712:
! 713: case 'l': /* --negotiate */
! 714: if(toggle) {
! 715: if(curlinfo->features & CURL_VERSION_SPNEGO)
! 716: config->authtype |= CURLAUTH_NEGOTIATE;
! 717: else
! 718: return PARAM_LIBCURL_DOESNT_SUPPORT;
! 719: }
! 720: else
! 721: config->authtype &= ~CURLAUTH_NEGOTIATE;
! 722: break;
! 723:
! 724: case 'm': /* --ntlm */
! 725: if(toggle) {
! 726: if(curlinfo->features & CURL_VERSION_NTLM)
! 727: config->authtype |= CURLAUTH_NTLM;
! 728: else
! 729: return PARAM_LIBCURL_DOESNT_SUPPORT;
! 730: }
! 731: else
! 732: config->authtype &= ~CURLAUTH_NTLM;
! 733: break;
! 734:
! 735: case 'M': /* --ntlm-wb */
! 736: if(toggle) {
! 737: if(curlinfo->features & CURL_VERSION_NTLM_WB)
! 738: config->authtype |= CURLAUTH_NTLM_WB;
! 739: else
! 740: return PARAM_LIBCURL_DOESNT_SUPPORT;
! 741: }
! 742: else
! 743: config->authtype &= ~CURLAUTH_NTLM_WB;
! 744: break;
! 745:
! 746: case 'n': /* --basic for completeness */
! 747: if(toggle)
! 748: config->authtype |= CURLAUTH_BASIC;
! 749: else
! 750: config->authtype &= ~CURLAUTH_BASIC;
! 751: break;
! 752:
! 753: case 'o': /* --anyauth, let libcurl pick it */
! 754: if(toggle)
! 755: config->authtype = CURLAUTH_ANY;
! 756: /* --no-anyauth simply doesn't touch it */
! 757: break;
! 758:
! 759: #ifdef USE_WATT32
! 760: case 'p': /* --wdebug */
! 761: dbug_init();
! 762: break;
! 763: #endif
! 764: case 'q': /* --ftp-create-dirs */
! 765: config->ftp_create_dirs = toggle;
! 766: break;
! 767:
! 768: case 'r': /* --create-dirs */
! 769: config->create_dirs = toggle;
! 770: break;
! 771:
! 772: case 's': /* --max-redirs */
! 773: /* specified max no of redirects (http(s)), this accepts -1 as a
! 774: special condition */
! 775: err = str2num(&config->maxredirs, nextarg);
! 776: if(err)
! 777: return err;
! 778: if(config->maxredirs < -1)
! 779: return PARAM_BAD_NUMERIC;
! 780: break;
! 781:
! 782: case 't': /* --proxy-ntlm */
! 783: if(curlinfo->features & CURL_VERSION_NTLM)
! 784: config->proxyntlm = toggle;
! 785: else
! 786: return PARAM_LIBCURL_DOESNT_SUPPORT;
! 787: break;
! 788:
! 789: case 'u': /* --crlf */
! 790: /* LF -> CRLF conversion? */
! 791: config->crlf = toggle;
! 792: break;
! 793:
! 794: case 'v': /* --stderr */
! 795: if(strcmp(nextarg, "-")) {
! 796: FILE *newfile = fopen(nextarg, FOPEN_WRITETEXT);
! 797: if(!newfile)
! 798: warnf(global, "Failed to open %s!\n", nextarg);
! 799: else {
! 800: if(global->errors_fopened)
! 801: fclose(global->errors);
! 802: global->errors = newfile;
! 803: global->errors_fopened = TRUE;
! 804: }
! 805: }
! 806: else
! 807: global->errors = stdout;
! 808: break;
! 809: case 'w': /* --interface */
! 810: /* interface */
! 811: GetStr(&config->iface, nextarg);
! 812: break;
! 813: case 'x': /* --krb */
! 814: /* kerberos level string */
! 815: if(curlinfo->features & CURL_VERSION_KERBEROS4)
! 816: GetStr(&config->krblevel, nextarg);
! 817: else
! 818: return PARAM_LIBCURL_DOESNT_SUPPORT;
! 819: break;
! 820: case 'X': /* --haproxy-protocol */
! 821: config->haproxy_protocol = toggle;
! 822: break;
! 823: case 'y': /* --max-filesize */
! 824: {
! 825: curl_off_t value;
! 826: ParameterError pe =
! 827: GetSizeParameter(global, nextarg, "max-filesize", &value);
! 828:
! 829: if(pe != PARAM_OK)
! 830: return pe;
! 831: config->max_filesize = value;
! 832: }
! 833: break;
! 834: case 'z': /* --disable-eprt */
! 835: config->disable_eprt = toggle;
! 836: break;
! 837: case 'Z': /* --eprt */
! 838: config->disable_eprt = (!toggle)?TRUE:FALSE;
! 839: break;
! 840: case '~': /* --xattr */
! 841: config->xattr = toggle;
! 842: break;
! 843: case '@': /* the URL! */
! 844: {
! 845: struct getout *url;
! 846:
! 847: if(!config->url_get)
! 848: config->url_get = config->url_list;
! 849:
! 850: if(config->url_get) {
! 851: /* there's a node here, if it already is filled-in continue to find
! 852: an "empty" node */
! 853: while(config->url_get && (config->url_get->flags & GETOUT_URL))
! 854: config->url_get = config->url_get->next;
! 855: }
! 856:
! 857: /* now there might or might not be an available node to fill in! */
! 858:
! 859: if(config->url_get)
! 860: /* existing node */
! 861: url = config->url_get;
! 862: else
! 863: /* there was no free node, create one! */
! 864: config->url_get = url = new_getout(config);
! 865:
! 866: if(!url)
! 867: return PARAM_NO_MEM;
! 868:
! 869: /* fill in the URL */
! 870: GetStr(&url->url, nextarg);
! 871: url->flags |= GETOUT_URL;
! 872: }
! 873: }
! 874: break;
! 875: case '$': /* more options without a short option */
! 876: switch(subletter) {
! 877: case 'a': /* --ssl */
! 878: if(toggle && !(curlinfo->features & CURL_VERSION_SSL))
! 879: return PARAM_LIBCURL_DOESNT_SUPPORT;
! 880: config->ftp_ssl = toggle;
! 881: break;
! 882: case 'b': /* --ftp-pasv */
! 883: Curl_safefree(config->ftpport);
! 884: break;
! 885: case 'c': /* --socks5 specifies a socks5 proxy to use, and resolves
! 886: the name locally and passes on the resolved address */
! 887: GetStr(&config->proxy, nextarg);
! 888: config->proxyver = CURLPROXY_SOCKS5;
! 889: break;
! 890: case 't': /* --socks4 specifies a socks4 proxy to use */
! 891: GetStr(&config->proxy, nextarg);
! 892: config->proxyver = CURLPROXY_SOCKS4;
! 893: break;
! 894: case 'T': /* --socks4a specifies a socks4a proxy to use */
! 895: GetStr(&config->proxy, nextarg);
! 896: config->proxyver = CURLPROXY_SOCKS4A;
! 897: break;
! 898: case '2': /* --socks5-hostname specifies a socks5 proxy and enables name
! 899: resolving with the proxy */
! 900: GetStr(&config->proxy, nextarg);
! 901: config->proxyver = CURLPROXY_SOCKS5_HOSTNAME;
! 902: break;
! 903: case 'd': /* --tcp-nodelay option */
! 904: config->tcp_nodelay = toggle;
! 905: break;
! 906: case 'e': /* --proxy-digest */
! 907: config->proxydigest = toggle;
! 908: break;
! 909: case 'f': /* --proxy-basic */
! 910: config->proxybasic = toggle;
! 911: break;
! 912: case 'g': /* --retry */
! 913: err = str2unum(&config->req_retry, nextarg);
! 914: if(err)
! 915: return err;
! 916: break;
! 917: case 'V': /* --retry-connrefused */
! 918: config->retry_connrefused = toggle;
! 919: break;
! 920: case 'h': /* --retry-delay */
! 921: err = str2unummax(&config->retry_delay, nextarg, LONG_MAX/1000);
! 922: if(err)
! 923: return err;
! 924: break;
! 925: case 'i': /* --retry-max-time */
! 926: err = str2unummax(&config->retry_maxtime, nextarg, LONG_MAX/1000);
! 927: if(err)
! 928: return err;
! 929: break;
! 930:
! 931: case 'k': /* --proxy-negotiate */
! 932: if(curlinfo->features & CURL_VERSION_SPNEGO)
! 933: config->proxynegotiate = toggle;
! 934: else
! 935: return PARAM_LIBCURL_DOESNT_SUPPORT;
! 936: break;
! 937:
! 938: case 'm': /* --ftp-account */
! 939: GetStr(&config->ftp_account, nextarg);
! 940: break;
! 941: case 'n': /* --proxy-anyauth */
! 942: config->proxyanyauth = toggle;
! 943: break;
! 944: case 'o': /* --trace-time */
! 945: global->tracetime = toggle;
! 946: break;
! 947: case 'p': /* --ignore-content-length */
! 948: config->ignorecl = toggle;
! 949: break;
! 950: case 'q': /* --ftp-skip-pasv-ip */
! 951: config->ftp_skip_ip = toggle;
! 952: break;
! 953: case 'r': /* --ftp-method (undocumented at this point) */
! 954: config->ftp_filemethod = ftpfilemethod(config, nextarg);
! 955: break;
! 956: case 's': { /* --local-port */
! 957: char lrange[7]; /* 16bit base 10 is 5 digits, but we allow 6 so that
! 958: this catches overflows, not just truncates */
! 959: char *p = nextarg;
! 960: while(ISDIGIT(*p))
! 961: p++;
! 962: if(*p) {
! 963: /* if there's anything more than a plain decimal number */
! 964: rc = sscanf(p, " - %6s", lrange);
! 965: *p = 0; /* zero terminate to make str2unum() work below */
! 966: }
! 967: else
! 968: rc = 0;
! 969:
! 970: err = str2unum(&config->localport, nextarg);
! 971: if(err || (config->localport > 65535))
! 972: return PARAM_BAD_USE;
! 973: if(!rc)
! 974: config->localportrange = 1; /* default number of ports to try */
! 975: else {
! 976: err = str2unum(&config->localportrange, lrange);
! 977: if(err || (config->localportrange > 65535))
! 978: return PARAM_BAD_USE;
! 979: config->localportrange -= (config->localport-1);
! 980: if(config->localportrange < 1)
! 981: return PARAM_BAD_USE;
! 982: }
! 983: break;
! 984: }
! 985: case 'u': /* --ftp-alternative-to-user */
! 986: GetStr(&config->ftp_alternative_to_user, nextarg);
! 987: break;
! 988: case 'v': /* --ssl-reqd */
! 989: if(toggle && !(curlinfo->features & CURL_VERSION_SSL))
! 990: return PARAM_LIBCURL_DOESNT_SUPPORT;
! 991: config->ftp_ssl_reqd = toggle;
! 992: break;
! 993: case 'w': /* --no-sessionid */
! 994: config->disable_sessionid = (!toggle)?TRUE:FALSE;
! 995: break;
! 996: case 'x': /* --ftp-ssl-control */
! 997: if(toggle && !(curlinfo->features & CURL_VERSION_SSL))
! 998: return PARAM_LIBCURL_DOESNT_SUPPORT;
! 999: config->ftp_ssl_control = toggle;
! 1000: break;
! 1001: case 'y': /* --ftp-ssl-ccc */
! 1002: config->ftp_ssl_ccc = toggle;
! 1003: if(!config->ftp_ssl_ccc_mode)
! 1004: config->ftp_ssl_ccc_mode = CURLFTPSSL_CCC_PASSIVE;
! 1005: break;
! 1006: case 'j': /* --ftp-ssl-ccc-mode */
! 1007: config->ftp_ssl_ccc = TRUE;
! 1008: config->ftp_ssl_ccc_mode = ftpcccmethod(config, nextarg);
! 1009: break;
! 1010: case 'z': /* --libcurl */
! 1011: #ifdef CURL_DISABLE_LIBCURL_OPTION
! 1012: warnf(global,
! 1013: "--libcurl option was disabled at build-time!\n");
! 1014: return PARAM_OPTION_UNKNOWN;
! 1015: #else
! 1016: GetStr(&global->libcurl, nextarg);
! 1017: break;
! 1018: #endif
! 1019: case '#': /* --raw */
! 1020: config->raw = toggle;
! 1021: break;
! 1022: case '0': /* --post301 */
! 1023: config->post301 = toggle;
! 1024: break;
! 1025: case '1': /* --no-keepalive */
! 1026: config->nokeepalive = (!toggle)?TRUE:FALSE;
! 1027: break;
! 1028: case '3': /* --keepalive-time */
! 1029: err = str2unum(&config->alivetime, nextarg);
! 1030: if(err)
! 1031: return err;
! 1032: break;
! 1033: case '4': /* --post302 */
! 1034: config->post302 = toggle;
! 1035: break;
! 1036: case 'I': /* --post303 */
! 1037: config->post303 = toggle;
! 1038: break;
! 1039: case '5': /* --noproxy */
! 1040: /* This specifies the noproxy list */
! 1041: GetStr(&config->noproxy, nextarg);
! 1042: break;
! 1043: case '7': /* --socks5-gssapi-nec*/
! 1044: config->socks5_gssapi_nec = toggle;
! 1045: break;
! 1046: case '8': /* --proxy1.0 */
! 1047: /* http 1.0 proxy */
! 1048: GetStr(&config->proxy, nextarg);
! 1049: config->proxyver = CURLPROXY_HTTP_1_0;
! 1050: break;
! 1051: case '9': /* --tftp-blksize */
! 1052: err = str2unum(&config->tftp_blksize, nextarg);
! 1053: if(err)
! 1054: return err;
! 1055: break;
! 1056: case 'A': /* --mail-from */
! 1057: GetStr(&config->mail_from, nextarg);
! 1058: break;
! 1059: case 'B': /* --mail-rcpt */
! 1060: /* append receiver to a list */
! 1061: err = add2list(&config->mail_rcpt, nextarg);
! 1062: if(err)
! 1063: return err;
! 1064: break;
! 1065: case 'C': /* --ftp-pret */
! 1066: config->ftp_pret = toggle;
! 1067: break;
! 1068: case 'D': /* --proto */
! 1069: config->proto_present = TRUE;
! 1070: if(proto2num(config, &config->proto, nextarg))
! 1071: return PARAM_BAD_USE;
! 1072: break;
! 1073: case 'E': /* --proto-redir */
! 1074: config->proto_redir_present = TRUE;
! 1075: if(proto2num(config, &config->proto_redir, nextarg))
! 1076: return PARAM_BAD_USE;
! 1077: break;
! 1078: case 'F': /* --resolve */
! 1079: err = add2list(&config->resolve, nextarg);
! 1080: if(err)
! 1081: return err;
! 1082: break;
! 1083: case 'G': /* --delegation LEVEL */
! 1084: config->gssapi_delegation = delegation(config, nextarg);
! 1085: break;
! 1086: case 'H': /* --mail-auth */
! 1087: GetStr(&config->mail_auth, nextarg);
! 1088: break;
! 1089: case 'J': /* --metalink */
! 1090: {
! 1091: #ifdef USE_METALINK
! 1092: int mlmaj, mlmin, mlpatch;
! 1093: metalink_get_version(&mlmaj, &mlmin, &mlpatch);
! 1094: if((mlmaj*10000)+(mlmin*100) + mlpatch < CURL_REQ_LIBMETALINK_VERS) {
! 1095: warnf(global,
! 1096: "--metalink option cannot be used because the version of "
! 1097: "the linked libmetalink library is too old. "
! 1098: "Required: %d.%d.%d, found %d.%d.%d\n",
! 1099: CURL_REQ_LIBMETALINK_MAJOR,
! 1100: CURL_REQ_LIBMETALINK_MINOR,
! 1101: CURL_REQ_LIBMETALINK_PATCH,
! 1102: mlmaj, mlmin, mlpatch);
! 1103: return PARAM_BAD_USE;
! 1104: }
! 1105: else
! 1106: config->use_metalink = toggle;
! 1107: #else
! 1108: warnf(global, "--metalink option is ignored because the binary is "
! 1109: "built without the Metalink support.\n");
! 1110: #endif
! 1111: break;
! 1112: }
! 1113: case '6': /* --sasl-authzid */
! 1114: GetStr(&config->sasl_authzid, nextarg);
! 1115: break;
! 1116: case 'K': /* --sasl-ir */
! 1117: config->sasl_ir = toggle;
! 1118: break;
! 1119: case 'L': /* --test-event */
! 1120: #ifdef CURLDEBUG
! 1121: global->test_event_based = toggle;
! 1122: #else
! 1123: warnf(global, "--test-event is ignored unless a debug build!\n");
! 1124: #endif
! 1125: break;
! 1126: case 'M': /* --unix-socket */
! 1127: config->abstract_unix_socket = FALSE;
! 1128: GetStr(&config->unix_socket_path, nextarg);
! 1129: break;
! 1130: case 'N': /* --path-as-is */
! 1131: config->path_as_is = toggle;
! 1132: break;
! 1133: case 'O': /* --proxy-service-name */
! 1134: GetStr(&config->proxy_service_name, nextarg);
! 1135: break;
! 1136: case 'P': /* --service-name */
! 1137: GetStr(&config->service_name, nextarg);
! 1138: break;
! 1139: case 'Q': /* --proto-default */
! 1140: GetStr(&config->proto_default, nextarg);
! 1141: err = check_protocol(config->proto_default);
! 1142: if(err)
! 1143: return err;
! 1144: break;
! 1145: case 'R': /* --expect100-timeout */
! 1146: err = str2udouble(&config->expect100timeout, nextarg, LONG_MAX/1000);
! 1147: if(err)
! 1148: return err;
! 1149: break;
! 1150: case 'S': /* --tftp-no-options */
! 1151: config->tftp_no_options = toggle;
! 1152: break;
! 1153: case 'U': /* --connect-to */
! 1154: err = add2list(&config->connect_to, nextarg);
! 1155: if(err)
! 1156: return err;
! 1157: break;
! 1158: case 'W': /* --abstract-unix-socket */
! 1159: config->abstract_unix_socket = TRUE;
! 1160: GetStr(&config->unix_socket_path, nextarg);
! 1161: break;
! 1162: case 'X': /* --tls-max */
! 1163: err = str2tls_max(&config->ssl_version_max, nextarg);
! 1164: if(err)
! 1165: return err;
! 1166: break;
! 1167: case 'Y': /* --suppress-connect-headers */
! 1168: config->suppress_connect_headers = toggle;
! 1169: break;
! 1170: case 'Z': /* --compressed-ssh */
! 1171: config->ssh_compression = toggle;
! 1172: break;
! 1173: case '~': /* --happy-eyeballs-timeout-ms */
! 1174: err = str2unum(&config->happy_eyeballs_timeout_ms, nextarg);
! 1175: if(err)
! 1176: return err;
! 1177: /* 0 is a valid value for this timeout */
! 1178: break;
! 1179: }
! 1180: break;
! 1181: case '#':
! 1182: switch(subletter) {
! 1183: case 'm': /* --progress-meter */
! 1184: global->noprogress = !toggle;
! 1185: break;
! 1186: default: /* --progress-bar */
! 1187: global->progressmode =
! 1188: toggle ? CURL_PROGRESS_BAR : CURL_PROGRESS_STATS;
! 1189: break;
! 1190: }
! 1191: break;
! 1192: case ':': /* --next */
! 1193: return PARAM_NEXT_OPERATION;
! 1194: case '0': /* --http* options */
! 1195: switch(subletter) {
! 1196: case '\0':
! 1197: /* HTTP version 1.0 */
! 1198: config->httpversion = CURL_HTTP_VERSION_1_0;
! 1199: break;
! 1200: case '1':
! 1201: /* HTTP version 1.1 */
! 1202: config->httpversion = CURL_HTTP_VERSION_1_1;
! 1203: break;
! 1204: case '2':
! 1205: /* HTTP version 2.0 */
! 1206: config->httpversion = CURL_HTTP_VERSION_2_0;
! 1207: break;
! 1208: case '3': /* --http2-prior-knowledge */
! 1209: /* HTTP version 2.0 over clean TCP*/
! 1210: config->httpversion = CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE;
! 1211: break;
! 1212: case '4': /* --http3 */
! 1213: /* HTTP version 3 go over QUIC - at once */
! 1214: if(curlinfo->features & CURL_VERSION_HTTP3)
! 1215: config->httpversion = CURL_HTTP_VERSION_3;
! 1216: else
! 1217: return PARAM_LIBCURL_DOESNT_SUPPORT;
! 1218: break;
! 1219: case '9':
! 1220: /* Allow HTTP/0.9 responses! */
! 1221: config->http09_allowed = toggle;
! 1222: break;
! 1223: }
! 1224: break;
! 1225: case '1': /* --tlsv1* options */
! 1226: switch(subletter) {
! 1227: case '\0':
! 1228: /* TLS version 1.x */
! 1229: config->ssl_version = CURL_SSLVERSION_TLSv1;
! 1230: break;
! 1231: case '0':
! 1232: /* TLS version 1.0 */
! 1233: config->ssl_version = CURL_SSLVERSION_TLSv1_0;
! 1234: break;
! 1235: case '1':
! 1236: /* TLS version 1.1 */
! 1237: config->ssl_version = CURL_SSLVERSION_TLSv1_1;
! 1238: break;
! 1239: case '2':
! 1240: /* TLS version 1.2 */
! 1241: config->ssl_version = CURL_SSLVERSION_TLSv1_2;
! 1242: break;
! 1243: case '3':
! 1244: /* TLS version 1.3 */
! 1245: config->ssl_version = CURL_SSLVERSION_TLSv1_3;
! 1246: break;
! 1247: case 'A': /* --tls13-ciphers */
! 1248: GetStr(&config->cipher13_list, nextarg);
! 1249: break;
! 1250: case 'B': /* --proxy-tls13-ciphers */
! 1251: GetStr(&config->proxy_cipher13_list, nextarg);
! 1252: break;
! 1253: }
! 1254: break;
! 1255: case '2':
! 1256: /* SSL version 2 */
! 1257: config->ssl_version = CURL_SSLVERSION_SSLv2;
! 1258: break;
! 1259: case '3':
! 1260: /* SSL version 3 */
! 1261: config->ssl_version = CURL_SSLVERSION_SSLv3;
! 1262: break;
! 1263: case '4':
! 1264: /* IPv4 */
! 1265: config->ip_version = 4;
! 1266: break;
! 1267: case '6':
! 1268: /* IPv6 */
! 1269: config->ip_version = 6;
! 1270: break;
! 1271: case 'a':
! 1272: /* This makes the FTP sessions use APPE instead of STOR */
! 1273: config->ftp_append = toggle;
! 1274: break;
! 1275: case 'A':
! 1276: /* This specifies the User-Agent name */
! 1277: GetStr(&config->useragent, nextarg);
! 1278: break;
! 1279: case 'b':
! 1280: switch(subletter) {
! 1281: case 'a': /* --alt-svc */
! 1282: if(curlinfo->features & CURL_VERSION_ALTSVC)
! 1283: GetStr(&config->altsvc, nextarg);
! 1284: else
! 1285: return PARAM_LIBCURL_DOESNT_SUPPORT;
! 1286: break;
! 1287: default: /* --cookie string coming up: */
! 1288: if(nextarg[0] == '@') {
! 1289: nextarg++;
! 1290: }
! 1291: else if(strchr(nextarg, '=')) {
! 1292: /* A cookie string must have a =-letter */
! 1293: GetStr(&config->cookie, nextarg);
! 1294: break;
! 1295: }
! 1296: /* We have a cookie file to read from! */
! 1297: GetStr(&config->cookiefile, nextarg);
! 1298: }
! 1299: break;
! 1300: case 'B':
! 1301: /* use ASCII/text when transferring */
! 1302: config->use_ascii = toggle;
! 1303: break;
! 1304: case 'c':
! 1305: /* get the file name to dump all cookies in */
! 1306: GetStr(&config->cookiejar, nextarg);
! 1307: break;
! 1308: case 'C':
! 1309: /* This makes us continue an ftp transfer at given position */
! 1310: if(strcmp(nextarg, "-")) {
! 1311: err = str2offset(&config->resume_from, nextarg);
! 1312: if(err)
! 1313: return err;
! 1314: config->resume_from_current = FALSE;
! 1315: }
! 1316: else {
! 1317: config->resume_from_current = TRUE;
! 1318: config->resume_from = 0;
! 1319: }
! 1320: config->use_resume = TRUE;
! 1321: break;
! 1322: case 'd':
! 1323: /* postfield data */
! 1324: {
! 1325: char *postdata = NULL;
! 1326: FILE *file;
! 1327: size_t size = 0;
! 1328: bool raw_mode = (subletter == 'r');
! 1329:
! 1330: if(subletter == 'e') { /* --data-urlencode*/
! 1331: /* [name]=[content], we encode the content part only
! 1332: * [name]@[file name]
! 1333: *
! 1334: * Case 2: we first load the file using that name and then encode
! 1335: * the content.
! 1336: */
! 1337: const char *p = strchr(nextarg, '=');
! 1338: size_t nlen;
! 1339: char is_file;
! 1340: if(!p)
! 1341: /* there was no '=' letter, check for a '@' instead */
! 1342: p = strchr(nextarg, '@');
! 1343: if(p) {
! 1344: nlen = p - nextarg; /* length of the name part */
! 1345: is_file = *p++; /* pass the separator */
! 1346: }
! 1347: else {
! 1348: /* neither @ nor =, so no name and it isn't a file */
! 1349: nlen = is_file = 0;
! 1350: p = nextarg;
! 1351: }
! 1352: if('@' == is_file) {
! 1353: /* a '@' letter, it means that a file name or - (stdin) follows */
! 1354: if(!strcmp("-", p)) {
! 1355: file = stdin;
! 1356: set_binmode(stdin);
! 1357: }
! 1358: else {
! 1359: file = fopen(p, "rb");
! 1360: if(!file)
! 1361: warnf(global,
! 1362: "Couldn't read data from file \"%s\", this makes "
! 1363: "an empty POST.\n", nextarg);
! 1364: }
! 1365:
! 1366: err = file2memory(&postdata, &size, file);
! 1367:
! 1368: if(file && (file != stdin))
! 1369: fclose(file);
! 1370: if(err)
! 1371: return err;
! 1372: }
! 1373: else {
! 1374: GetStr(&postdata, p);
! 1375: if(postdata)
! 1376: size = strlen(postdata);
! 1377: }
! 1378:
! 1379: if(!postdata) {
! 1380: /* no data from the file, point to a zero byte string to make this
! 1381: get sent as a POST anyway */
! 1382: postdata = strdup("");
! 1383: if(!postdata)
! 1384: return PARAM_NO_MEM;
! 1385: size = 0;
! 1386: }
! 1387: else {
! 1388: char *enc = curl_easy_escape(NULL, postdata, (int)size);
! 1389: Curl_safefree(postdata); /* no matter if it worked or not */
! 1390: if(enc) {
! 1391: /* now make a string with the name from above and append the
! 1392: encoded string */
! 1393: size_t outlen = nlen + strlen(enc) + 2;
! 1394: char *n = malloc(outlen);
! 1395: if(!n) {
! 1396: curl_free(enc);
! 1397: return PARAM_NO_MEM;
! 1398: }
! 1399: if(nlen > 0) { /* only append '=' if we have a name */
! 1400: msnprintf(n, outlen, "%.*s=%s", nlen, nextarg, enc);
! 1401: size = outlen-1;
! 1402: }
! 1403: else {
! 1404: strcpy(n, enc);
! 1405: size = outlen-2; /* since no '=' was inserted */
! 1406: }
! 1407: curl_free(enc);
! 1408: postdata = n;
! 1409: }
! 1410: else
! 1411: return PARAM_NO_MEM;
! 1412: }
! 1413: }
! 1414: else if('@' == *nextarg && !raw_mode) {
! 1415: /* the data begins with a '@' letter, it means that a file name
! 1416: or - (stdin) follows */
! 1417: nextarg++; /* pass the @ */
! 1418:
! 1419: if(!strcmp("-", nextarg)) {
! 1420: file = stdin;
! 1421: if(subletter == 'b') /* forced data-binary */
! 1422: set_binmode(stdin);
! 1423: }
! 1424: else {
! 1425: file = fopen(nextarg, "rb");
! 1426: if(!file)
! 1427: warnf(global, "Couldn't read data from file \"%s\", this makes "
! 1428: "an empty POST.\n", nextarg);
! 1429: }
! 1430:
! 1431: if(subletter == 'b')
! 1432: /* forced binary */
! 1433: err = file2memory(&postdata, &size, file);
! 1434: else {
! 1435: err = file2string(&postdata, file);
! 1436: if(postdata)
! 1437: size = strlen(postdata);
! 1438: }
! 1439:
! 1440: if(file && (file != stdin))
! 1441: fclose(file);
! 1442: if(err)
! 1443: return err;
! 1444:
! 1445: if(!postdata) {
! 1446: /* no data from the file, point to a zero byte string to make this
! 1447: get sent as a POST anyway */
! 1448: postdata = strdup("");
! 1449: if(!postdata)
! 1450: return PARAM_NO_MEM;
! 1451: }
! 1452: }
! 1453: else {
! 1454: GetStr(&postdata, nextarg);
! 1455: if(postdata)
! 1456: size = strlen(postdata);
! 1457: }
! 1458:
! 1459: #ifdef CURL_DOES_CONVERSIONS
! 1460: if(subletter != 'b') {
! 1461: /* NOT forced binary, convert to ASCII */
! 1462: if(convert_to_network(postdata, strlen(postdata))) {
! 1463: Curl_safefree(postdata);
! 1464: return PARAM_NO_MEM;
! 1465: }
! 1466: }
! 1467: #endif
! 1468:
! 1469: if(config->postfields) {
! 1470: /* we already have a string, we append this one with a separating
! 1471: &-letter */
! 1472: char *oldpost = config->postfields;
! 1473: curl_off_t oldlen = config->postfieldsize;
! 1474: curl_off_t newlen = oldlen + curlx_uztoso(size) + 2;
! 1475: config->postfields = malloc((size_t)newlen);
! 1476: if(!config->postfields) {
! 1477: Curl_safefree(oldpost);
! 1478: Curl_safefree(postdata);
! 1479: return PARAM_NO_MEM;
! 1480: }
! 1481: memcpy(config->postfields, oldpost, (size_t)oldlen);
! 1482: /* use byte value 0x26 for '&' to accommodate non-ASCII platforms */
! 1483: config->postfields[oldlen] = '\x26';
! 1484: memcpy(&config->postfields[oldlen + 1], postdata, size);
! 1485: config->postfields[oldlen + 1 + size] = '\0';
! 1486: Curl_safefree(oldpost);
! 1487: Curl_safefree(postdata);
! 1488: config->postfieldsize += size + 1;
! 1489: }
! 1490: else {
! 1491: config->postfields = postdata;
! 1492: config->postfieldsize = curlx_uztoso(size);
! 1493: }
! 1494: }
! 1495: /*
! 1496: We can't set the request type here, as this data might be used in
! 1497: a simple GET if -G is used. Already or soon.
! 1498:
! 1499: if(SetHTTPrequest(HTTPREQ_SIMPLEPOST, &config->httpreq)) {
! 1500: Curl_safefree(postdata);
! 1501: return PARAM_BAD_USE;
! 1502: }
! 1503: */
! 1504: break;
! 1505: case 'D':
! 1506: /* dump-header to given file name */
! 1507: GetStr(&config->headerfile, nextarg);
! 1508: break;
! 1509: case 'e':
! 1510: {
! 1511: char *ptr = strstr(nextarg, ";auto");
! 1512: if(ptr) {
! 1513: /* Automatic referer requested, this may be combined with a
! 1514: set initial one */
! 1515: config->autoreferer = TRUE;
! 1516: *ptr = 0; /* zero terminate here */
! 1517: }
! 1518: else
! 1519: config->autoreferer = FALSE;
! 1520: GetStr(&config->referer, nextarg);
! 1521: }
! 1522: break;
! 1523: case 'E':
! 1524: switch(subletter) {
! 1525: case '\0': /* certificate file */
! 1526: GetFileAndPassword(nextarg, &config->cert, &config->key_passwd);
! 1527: break;
! 1528: case 'a': /* CA info PEM file */
! 1529: GetStr(&config->cacert, nextarg);
! 1530: break;
! 1531: case 'b': /* cert file type */
! 1532: GetStr(&config->cert_type, nextarg);
! 1533: break;
! 1534: case 'c': /* private key file */
! 1535: GetStr(&config->key, nextarg);
! 1536: break;
! 1537: case 'd': /* private key file type */
! 1538: GetStr(&config->key_type, nextarg);
! 1539: break;
! 1540: case 'e': /* private key passphrase */
! 1541: GetStr(&config->key_passwd, nextarg);
! 1542: cleanarg(nextarg);
! 1543: break;
! 1544: case 'f': /* crypto engine */
! 1545: GetStr(&config->engine, nextarg);
! 1546: if(config->engine && curl_strequal(config->engine, "list"))
! 1547: return PARAM_ENGINES_REQUESTED;
! 1548: break;
! 1549: case 'g': /* CA cert directory */
! 1550: GetStr(&config->capath, nextarg);
! 1551: break;
! 1552: case 'h': /* --pubkey public key file */
! 1553: GetStr(&config->pubkey, nextarg);
! 1554: break;
! 1555: case 'i': /* --hostpubmd5 md5 of the host public key */
! 1556: GetStr(&config->hostpubmd5, nextarg);
! 1557: if(!config->hostpubmd5 || strlen(config->hostpubmd5) != 32)
! 1558: return PARAM_BAD_USE;
! 1559: break;
! 1560: case 'j': /* CRL file */
! 1561: GetStr(&config->crlfile, nextarg);
! 1562: break;
! 1563: case 'k': /* TLS username */
! 1564: if(curlinfo->features & CURL_VERSION_TLSAUTH_SRP)
! 1565: GetStr(&config->tls_username, nextarg);
! 1566: else
! 1567: return PARAM_LIBCURL_DOESNT_SUPPORT;
! 1568: break;
! 1569: case 'l': /* TLS password */
! 1570: if(curlinfo->features & CURL_VERSION_TLSAUTH_SRP)
! 1571: GetStr(&config->tls_password, nextarg);
! 1572: else
! 1573: return PARAM_LIBCURL_DOESNT_SUPPORT;
! 1574: break;
! 1575: case 'm': /* TLS authentication type */
! 1576: if(curlinfo->features & CURL_VERSION_TLSAUTH_SRP) {
! 1577: GetStr(&config->tls_authtype, nextarg);
! 1578: if(!curl_strequal(config->tls_authtype, "SRP"))
! 1579: return PARAM_LIBCURL_DOESNT_SUPPORT; /* only support TLS-SRP */
! 1580: }
! 1581: else
! 1582: return PARAM_LIBCURL_DOESNT_SUPPORT;
! 1583: break;
! 1584: case 'n': /* no empty SSL fragments, --ssl-allow-beast */
! 1585: if(curlinfo->features & CURL_VERSION_SSL)
! 1586: config->ssl_allow_beast = toggle;
! 1587: break;
! 1588:
! 1589: case 'p': /* Pinned public key DER file */
! 1590: GetStr(&config->pinnedpubkey, nextarg);
! 1591: break;
! 1592:
! 1593: case 'P': /* proxy pinned public key */
! 1594: GetStr(&config->proxy_pinnedpubkey, nextarg);
! 1595: break;
! 1596:
! 1597: case 'q': /* --cert-status */
! 1598: config->verifystatus = TRUE;
! 1599: break;
! 1600:
! 1601: case 'r': /* --false-start */
! 1602: config->falsestart = TRUE;
! 1603: break;
! 1604:
! 1605: case 's': /* --ssl-no-revoke */
! 1606: if(curlinfo->features & CURL_VERSION_SSL)
! 1607: config->ssl_no_revoke = TRUE;
! 1608: break;
! 1609:
! 1610: case 'S': /* --ssl-revoke-best-effort */
! 1611: if(curlinfo->features & CURL_VERSION_SSL)
! 1612: config->ssl_revoke_best_effort = TRUE;
! 1613: break;
! 1614:
! 1615: case 't': /* --tcp-fastopen */
! 1616: config->tcp_fastopen = TRUE;
! 1617: break;
! 1618:
! 1619: case 'u': /* TLS username for proxy */
! 1620: if(curlinfo->features & CURL_VERSION_TLSAUTH_SRP)
! 1621: GetStr(&config->proxy_tls_username, nextarg);
! 1622: else
! 1623: return PARAM_LIBCURL_DOESNT_SUPPORT;
! 1624: break;
! 1625:
! 1626: case 'v': /* TLS password for proxy */
! 1627: if(curlinfo->features & CURL_VERSION_TLSAUTH_SRP)
! 1628: GetStr(&config->proxy_tls_password, nextarg);
! 1629: else
! 1630: return PARAM_LIBCURL_DOESNT_SUPPORT;
! 1631: break;
! 1632:
! 1633: case 'w': /* TLS authentication type for proxy */
! 1634: if(curlinfo->features & CURL_VERSION_TLSAUTH_SRP) {
! 1635: GetStr(&config->proxy_tls_authtype, nextarg);
! 1636: if(!curl_strequal(config->proxy_tls_authtype, "SRP"))
! 1637: return PARAM_LIBCURL_DOESNT_SUPPORT; /* only support TLS-SRP */
! 1638: }
! 1639: else
! 1640: return PARAM_LIBCURL_DOESNT_SUPPORT;
! 1641: break;
! 1642:
! 1643: case 'x': /* certificate file for proxy */
! 1644: GetFileAndPassword(nextarg, &config->proxy_cert,
! 1645: &config->proxy_key_passwd);
! 1646: break;
! 1647:
! 1648: case 'y': /* cert file type for proxy */
! 1649: GetStr(&config->proxy_cert_type, nextarg);
! 1650: break;
! 1651:
! 1652: case 'z': /* private key file for proxy */
! 1653: GetStr(&config->proxy_key, nextarg);
! 1654: break;
! 1655:
! 1656: case '0': /* private key file type for proxy */
! 1657: GetStr(&config->proxy_key_type, nextarg);
! 1658: break;
! 1659:
! 1660: case '1': /* private key passphrase for proxy */
! 1661: GetStr(&config->proxy_key_passwd, nextarg);
! 1662: cleanarg(nextarg);
! 1663: break;
! 1664:
! 1665: case '2': /* ciphers for proxy */
! 1666: GetStr(&config->proxy_cipher_list, nextarg);
! 1667: break;
! 1668:
! 1669: case '3': /* CRL file for proxy */
! 1670: GetStr(&config->proxy_crlfile, nextarg);
! 1671: break;
! 1672:
! 1673: case '4': /* no empty SSL fragments for proxy */
! 1674: if(curlinfo->features & CURL_VERSION_SSL)
! 1675: config->proxy_ssl_allow_beast = toggle;
! 1676: break;
! 1677:
! 1678: case '5': /* --login-options */
! 1679: GetStr(&config->login_options, nextarg);
! 1680: break;
! 1681:
! 1682: case '6': /* CA info PEM file for proxy */
! 1683: GetStr(&config->proxy_cacert, nextarg);
! 1684: break;
! 1685:
! 1686: case '7': /* CA cert directory for proxy */
! 1687: GetStr(&config->proxy_capath, nextarg);
! 1688: break;
! 1689:
! 1690: case '8': /* allow insecure SSL connects for proxy */
! 1691: config->proxy_insecure_ok = toggle;
! 1692: break;
! 1693:
! 1694: case '9': /* --proxy-tlsv1 */
! 1695: /* TLS version 1 for proxy */
! 1696: config->proxy_ssl_version = CURL_SSLVERSION_TLSv1;
! 1697: break;
! 1698:
! 1699: case 'A':
! 1700: /* --socks5-basic */
! 1701: if(toggle)
! 1702: config->socks5_auth |= CURLAUTH_BASIC;
! 1703: else
! 1704: config->socks5_auth &= ~CURLAUTH_BASIC;
! 1705: break;
! 1706:
! 1707: case 'B':
! 1708: /* --socks5-gssapi */
! 1709: if(toggle)
! 1710: config->socks5_auth |= CURLAUTH_GSSAPI;
! 1711: else
! 1712: config->socks5_auth &= ~CURLAUTH_GSSAPI;
! 1713: break;
! 1714:
! 1715: case 'C':
! 1716: GetStr(&config->etag_save_file, nextarg);
! 1717: break;
! 1718:
! 1719: case 'D':
! 1720: GetStr(&config->etag_compare_file, nextarg);
! 1721: break;
! 1722:
! 1723: default: /* unknown flag */
! 1724: return PARAM_OPTION_UNKNOWN;
! 1725: }
! 1726: break;
! 1727: case 'f':
! 1728: switch(subletter) {
! 1729: case 'a': /* --fail-early */
! 1730: global->fail_early = toggle;
! 1731: break;
! 1732: case 'b': /* --styled-output */
! 1733: global->styled_output = toggle;
! 1734: break;
! 1735: case 'c': /* --mail-rcpt-allowfails */
! 1736: config->mail_rcpt_allowfails = toggle;
! 1737: break;
! 1738: default: /* --fail (hard on errors) */
! 1739: config->failonerror = toggle;
! 1740: }
! 1741: break;
! 1742: case 'F':
! 1743: /* "form data" simulation, this is a little advanced so lets do our best
! 1744: to sort this out slowly and carefully */
! 1745: if(formparse(config,
! 1746: nextarg,
! 1747: &config->mimeroot,
! 1748: &config->mimecurrent,
! 1749: (subletter == 's')?TRUE:FALSE)) /* 's' is literal string */
! 1750: return PARAM_BAD_USE;
! 1751: if(SetHTTPrequest(config, HTTPREQ_MIMEPOST, &config->httpreq))
! 1752: return PARAM_BAD_USE;
! 1753: break;
! 1754:
! 1755: case 'g': /* g disables URLglobbing */
! 1756: config->globoff = toggle;
! 1757: break;
! 1758:
! 1759: case 'G': /* HTTP GET */
! 1760: if(subletter == 'a') { /* --request-target */
! 1761: GetStr(&config->request_target, nextarg);
! 1762: }
! 1763: else
! 1764: config->use_httpget = TRUE;
! 1765: break;
! 1766:
! 1767: case 'h': /* h for help */
! 1768: if(toggle) {
! 1769: return PARAM_HELP_REQUESTED;
! 1770: }
! 1771: /* we now actually support --no-help too! */
! 1772: break;
! 1773: case 'H':
! 1774: /* A custom header to append to a list */
! 1775: if(nextarg[0] == '@') {
! 1776: /* read many headers from a file or stdin */
! 1777: char *string;
! 1778: size_t len;
! 1779: bool use_stdin = !strcmp(&nextarg[1], "-");
! 1780: FILE *file = use_stdin?stdin:fopen(&nextarg[1], FOPEN_READTEXT);
! 1781: if(!file)
! 1782: warnf(global, "Failed to open %s!\n", &nextarg[1]);
! 1783: else {
! 1784: err = file2memory(&string, &len, file);
! 1785: if(!err && string) {
! 1786: /* Allow strtok() here since this isn't used threaded */
! 1787: /* !checksrc! disable BANNEDFUNC 2 */
! 1788: char *h = strtok(string, "\r\n");
! 1789: while(h) {
! 1790: if(subletter == 'p') /* --proxy-header */
! 1791: err = add2list(&config->proxyheaders, h);
! 1792: else
! 1793: err = add2list(&config->headers, h);
! 1794: if(err)
! 1795: break;
! 1796: h = strtok(NULL, "\r\n");
! 1797: }
! 1798: free(string);
! 1799: }
! 1800: if(!use_stdin)
! 1801: fclose(file);
! 1802: if(err)
! 1803: return err;
! 1804: }
! 1805: }
! 1806: else {
! 1807: if(subletter == 'p') /* --proxy-header */
! 1808: err = add2list(&config->proxyheaders, nextarg);
! 1809: else
! 1810: err = add2list(&config->headers, nextarg);
! 1811: if(err)
! 1812: return err;
! 1813: }
! 1814: break;
! 1815: case 'i':
! 1816: config->show_headers = toggle; /* show the headers as well in the
! 1817: general output stream */
! 1818: break;
! 1819: case 'j':
! 1820: config->cookiesession = toggle;
! 1821: break;
! 1822: case 'I': /* --head */
! 1823: config->no_body = toggle;
! 1824: config->show_headers = toggle;
! 1825: if(SetHTTPrequest(config,
! 1826: (config->no_body)?HTTPREQ_HEAD:HTTPREQ_GET,
! 1827: &config->httpreq))
! 1828: return PARAM_BAD_USE;
! 1829: break;
! 1830: case 'J': /* --remote-header-name */
! 1831: if(config->show_headers) {
! 1832: warnf(global,
! 1833: "--include and --remote-header-name cannot be combined.\n");
! 1834: return PARAM_BAD_USE;
! 1835: }
! 1836: config->content_disposition = toggle;
! 1837: break;
! 1838: case 'k': /* allow insecure SSL connects */
! 1839: config->insecure_ok = toggle;
! 1840: break;
! 1841: case 'K': /* parse config file */
! 1842: if(parseconfig(nextarg, global))
! 1843: warnf(global, "error trying read config from the '%s' file\n",
! 1844: nextarg);
! 1845: break;
! 1846: case 'l':
! 1847: config->dirlistonly = toggle; /* only list the names of the FTP dir */
! 1848: break;
! 1849: case 'L':
! 1850: config->followlocation = toggle; /* Follow Location: HTTP headers */
! 1851: switch(subletter) {
! 1852: case 't':
! 1853: /* Continue to send authentication (user+password) when following
! 1854: * locations, even when hostname changed */
! 1855: config->unrestricted_auth = toggle;
! 1856: break;
! 1857: }
! 1858: break;
! 1859: case 'm':
! 1860: /* specified max time */
! 1861: err = str2udouble(&config->timeout, nextarg, LONG_MAX/1000);
! 1862: if(err)
! 1863: return err;
! 1864: break;
! 1865: case 'M': /* M for manual, huge help */
! 1866: if(toggle) { /* --no-manual shows no manual... */
! 1867: #ifdef USE_MANUAL
! 1868: return PARAM_MANUAL_REQUESTED;
! 1869: #else
! 1870: warnf(global,
! 1871: "built-in manual was disabled at build-time!\n");
! 1872: return PARAM_OPTION_UNKNOWN;
! 1873: #endif
! 1874: }
! 1875: break;
! 1876: case 'n':
! 1877: switch(subletter) {
! 1878: case 'o': /* use .netrc or URL */
! 1879: config->netrc_opt = toggle;
! 1880: break;
! 1881: case 'e': /* netrc-file */
! 1882: GetStr(&config->netrc_file, nextarg);
! 1883: break;
! 1884: default:
! 1885: /* pick info from .netrc, if this is used for http, curl will
! 1886: automatically enfore user+password with the request */
! 1887: config->netrc = toggle;
! 1888: break;
! 1889: }
! 1890: break;
! 1891: case 'N':
! 1892: /* disable the output I/O buffering. note that the option is called
! 1893: --buffer but is mostly used in the negative form: --no-buffer */
! 1894: if(longopt)
! 1895: config->nobuffer = (!toggle)?TRUE:FALSE;
! 1896: else
! 1897: config->nobuffer = toggle;
! 1898: break;
! 1899: case 'O': /* --remote-name */
! 1900: if(subletter == 'a') { /* --remote-name-all */
! 1901: config->default_node_flags = toggle?GETOUT_USEREMOTE:0;
! 1902: break;
! 1903: }
! 1904: /* FALLTHROUGH */
! 1905: case 'o': /* --output */
! 1906: /* output file */
! 1907: {
! 1908: struct getout *url;
! 1909: if(!config->url_out)
! 1910: config->url_out = config->url_list;
! 1911: if(config->url_out) {
! 1912: /* there's a node here, if it already is filled-in continue to find
! 1913: an "empty" node */
! 1914: while(config->url_out && (config->url_out->flags & GETOUT_OUTFILE))
! 1915: config->url_out = config->url_out->next;
! 1916: }
! 1917:
! 1918: /* now there might or might not be an available node to fill in! */
! 1919:
! 1920: if(config->url_out)
! 1921: /* existing node */
! 1922: url = config->url_out;
! 1923: else
! 1924: /* there was no free node, create one! */
! 1925: config->url_out = url = new_getout(config);
! 1926:
! 1927: if(!url)
! 1928: return PARAM_NO_MEM;
! 1929:
! 1930: /* fill in the outfile */
! 1931: if('o' == letter) {
! 1932: GetStr(&url->outfile, nextarg);
! 1933: url->flags &= ~GETOUT_USEREMOTE; /* switch off */
! 1934: }
! 1935: else {
! 1936: url->outfile = NULL; /* leave it */
! 1937: if(toggle)
! 1938: url->flags |= GETOUT_USEREMOTE; /* switch on */
! 1939: else
! 1940: url->flags &= ~GETOUT_USEREMOTE; /* switch off */
! 1941: }
! 1942: url->flags |= GETOUT_OUTFILE;
! 1943: }
! 1944: break;
! 1945: case 'P':
! 1946: /* This makes the FTP sessions use PORT instead of PASV */
! 1947: /* use <eth0> or <192.168.10.10> style addresses. Anything except
! 1948: this will make us try to get the "default" address.
! 1949: NOTE: this is a changed behaviour since the released 4.1!
! 1950: */
! 1951: GetStr(&config->ftpport, nextarg);
! 1952: break;
! 1953: case 'p':
! 1954: /* proxy tunnel for non-http protocols */
! 1955: config->proxytunnel = toggle;
! 1956: break;
! 1957:
! 1958: case 'q': /* if used first, already taken care of, we do it like
! 1959: this so we don't cause an error! */
! 1960: break;
! 1961: case 'Q':
! 1962: /* QUOTE command to send to FTP server */
! 1963: switch(nextarg[0]) {
! 1964: case '-':
! 1965: /* prefixed with a dash makes it a POST TRANSFER one */
! 1966: nextarg++;
! 1967: err = add2list(&config->postquote, nextarg);
! 1968: break;
! 1969: case '+':
! 1970: /* prefixed with a plus makes it a just-before-transfer one */
! 1971: nextarg++;
! 1972: err = add2list(&config->prequote, nextarg);
! 1973: break;
! 1974: default:
! 1975: err = add2list(&config->quote, nextarg);
! 1976: break;
! 1977: }
! 1978: if(err)
! 1979: return err;
! 1980: break;
! 1981: case 'r':
! 1982: /* Specifying a range WITHOUT A DASH will create an illegal HTTP range
! 1983: (and won't actually be range by definition). The man page previously
! 1984: claimed that to be a good way, why this code is added to work-around
! 1985: it. */
! 1986: if(ISDIGIT(*nextarg) && !strchr(nextarg, '-')) {
! 1987: char buffer[32];
! 1988: curl_off_t off;
! 1989: if(curlx_strtoofft(nextarg, NULL, 10, &off)) {
! 1990: warnf(global, "unsupported range point\n");
! 1991: return PARAM_BAD_USE;
! 1992: }
! 1993: warnf(global,
! 1994: "A specified range MUST include at least one dash (-). "
! 1995: "Appending one for you!\n");
! 1996: msnprintf(buffer, sizeof(buffer), "%" CURL_FORMAT_CURL_OFF_T "-", off);
! 1997: Curl_safefree(config->range);
! 1998: config->range = strdup(buffer);
! 1999: if(!config->range)
! 2000: return PARAM_NO_MEM;
! 2001: }
! 2002: {
! 2003: /* byte range requested */
! 2004: const char *tmp_range = nextarg;
! 2005: while(*tmp_range != '\0') {
! 2006: if(!ISDIGIT(*tmp_range) && *tmp_range != '-' && *tmp_range != ',') {
! 2007: warnf(global, "Invalid character is found in given range. "
! 2008: "A specified range MUST have only digits in "
! 2009: "\'start\'-\'stop\'. The server's response to this "
! 2010: "request is uncertain.\n");
! 2011: break;
! 2012: }
! 2013: tmp_range++;
! 2014: }
! 2015: /* byte range requested */
! 2016: GetStr(&config->range, nextarg);
! 2017: }
! 2018: break;
! 2019: case 'R':
! 2020: /* use remote file's time */
! 2021: config->remote_time = toggle;
! 2022: break;
! 2023: case 's':
! 2024: /* don't show progress meter, don't show errors : */
! 2025: if(toggle)
! 2026: global->mute = global->noprogress = TRUE;
! 2027: else
! 2028: global->mute = global->noprogress = FALSE;
! 2029: if(global->showerror < 0)
! 2030: /* if still on the default value, set showerror to the reverse of
! 2031: toggle. This is to allow -S and -s to be used in an independent
! 2032: order but still have the same effect. */
! 2033: global->showerror = (!toggle)?TRUE:FALSE; /* toggle off */
! 2034: break;
! 2035: case 'S':
! 2036: /* show errors */
! 2037: global->showerror = toggle?1:0; /* toggle on if used with -s */
! 2038: break;
! 2039: case 't':
! 2040: /* Telnet options */
! 2041: err = add2list(&config->telnet_options, nextarg);
! 2042: if(err)
! 2043: return err;
! 2044: break;
! 2045: case 'T':
! 2046: /* we are uploading */
! 2047: {
! 2048: struct getout *url;
! 2049: if(!config->url_ul)
! 2050: config->url_ul = config->url_list;
! 2051: if(config->url_ul) {
! 2052: /* there's a node here, if it already is filled-in continue to find
! 2053: an "empty" node */
! 2054: while(config->url_ul && (config->url_ul->flags & GETOUT_UPLOAD))
! 2055: config->url_ul = config->url_ul->next;
! 2056: }
! 2057:
! 2058: /* now there might or might not be an available node to fill in! */
! 2059:
! 2060: if(config->url_ul)
! 2061: /* existing node */
! 2062: url = config->url_ul;
! 2063: else
! 2064: /* there was no free node, create one! */
! 2065: config->url_ul = url = new_getout(config);
! 2066:
! 2067: if(!url)
! 2068: return PARAM_NO_MEM;
! 2069:
! 2070: url->flags |= GETOUT_UPLOAD; /* mark -T used */
! 2071: if(!*nextarg)
! 2072: url->flags |= GETOUT_NOUPLOAD;
! 2073: else {
! 2074: /* "-" equals stdin, but keep the string around for now */
! 2075: GetStr(&url->infile, nextarg);
! 2076: }
! 2077: }
! 2078: break;
! 2079: case 'u':
! 2080: /* user:password */
! 2081: GetStr(&config->userpwd, nextarg);
! 2082: cleanarg(nextarg);
! 2083: break;
! 2084: case 'U':
! 2085: /* Proxy user:password */
! 2086: GetStr(&config->proxyuserpwd, nextarg);
! 2087: cleanarg(nextarg);
! 2088: break;
! 2089: case 'v':
! 2090: if(toggle) {
! 2091: /* the '%' thing here will cause the trace get sent to stderr */
! 2092: Curl_safefree(global->trace_dump);
! 2093: global->trace_dump = strdup("%");
! 2094: if(!global->trace_dump)
! 2095: return PARAM_NO_MEM;
! 2096: if(global->tracetype && (global->tracetype != TRACE_PLAIN))
! 2097: warnf(global,
! 2098: "-v, --verbose overrides an earlier trace/verbose option\n");
! 2099: global->tracetype = TRACE_PLAIN;
! 2100: }
! 2101: else
! 2102: /* verbose is disabled here */
! 2103: global->tracetype = TRACE_NONE;
! 2104: break;
! 2105: case 'V':
! 2106: if(toggle) /* --no-version yields no output! */
! 2107: return PARAM_VERSION_INFO_REQUESTED;
! 2108: break;
! 2109:
! 2110: case 'w':
! 2111: /* get the output string */
! 2112: if('@' == *nextarg) {
! 2113: /* the data begins with a '@' letter, it means that a file name
! 2114: or - (stdin) follows */
! 2115: FILE *file;
! 2116: const char *fname;
! 2117: nextarg++; /* pass the @ */
! 2118: if(!strcmp("-", nextarg)) {
! 2119: fname = "<stdin>";
! 2120: file = stdin;
! 2121: }
! 2122: else {
! 2123: fname = nextarg;
! 2124: file = fopen(nextarg, FOPEN_READTEXT);
! 2125: }
! 2126: Curl_safefree(config->writeout);
! 2127: err = file2string(&config->writeout, file);
! 2128: if(file && (file != stdin))
! 2129: fclose(file);
! 2130: if(err)
! 2131: return err;
! 2132: if(!config->writeout)
! 2133: warnf(global, "Failed to read %s", fname);
! 2134: }
! 2135: else
! 2136: GetStr(&config->writeout, nextarg);
! 2137: break;
! 2138: case 'x':
! 2139: switch(subletter) {
! 2140: case 'a': /* --preproxy */
! 2141: GetStr(&config->preproxy, nextarg);
! 2142: break;
! 2143: default:
! 2144: /* --proxy */
! 2145: GetStr(&config->proxy, nextarg);
! 2146: config->proxyver = CURLPROXY_HTTP;
! 2147: break;
! 2148: }
! 2149: break;
! 2150: case 'X':
! 2151: /* set custom request */
! 2152: GetStr(&config->customrequest, nextarg);
! 2153: break;
! 2154: case 'y':
! 2155: /* low speed time */
! 2156: err = str2unum(&config->low_speed_time, nextarg);
! 2157: if(err)
! 2158: return err;
! 2159: if(!config->low_speed_limit)
! 2160: config->low_speed_limit = 1;
! 2161: break;
! 2162: case 'Y':
! 2163: /* low speed limit */
! 2164: err = str2unum(&config->low_speed_limit, nextarg);
! 2165: if(err)
! 2166: return err;
! 2167: if(!config->low_speed_time)
! 2168: config->low_speed_time = 30;
! 2169: break;
! 2170: case 'Z':
! 2171: switch(subletter) {
! 2172: case '\0': /* --parallel */
! 2173: global->parallel = toggle;
! 2174: break;
! 2175: case 'b': /* --parallel-max */
! 2176: err = str2unum(&global->parallel_max, nextarg);
! 2177: if(err)
! 2178: return err;
! 2179: if((global->parallel_max > MAX_PARALLEL) ||
! 2180: (global->parallel_max < 1))
! 2181: global->parallel_max = PARALLEL_DEFAULT;
! 2182: break;
! 2183: case 'c': /* --parallel-connect */
! 2184: global->parallel_connect = toggle;
! 2185: break;
! 2186: }
! 2187: break;
! 2188: case 'z': /* time condition coming up */
! 2189: switch(*nextarg) {
! 2190: case '+':
! 2191: nextarg++;
! 2192: /* FALLTHROUGH */
! 2193: default:
! 2194: /* If-Modified-Since: (section 14.28 in RFC2068) */
! 2195: config->timecond = CURL_TIMECOND_IFMODSINCE;
! 2196: break;
! 2197: case '-':
! 2198: /* If-Unmodified-Since: (section 14.24 in RFC2068) */
! 2199: config->timecond = CURL_TIMECOND_IFUNMODSINCE;
! 2200: nextarg++;
! 2201: break;
! 2202: case '=':
! 2203: /* Last-Modified: (section 14.29 in RFC2068) */
! 2204: config->timecond = CURL_TIMECOND_LASTMOD;
! 2205: nextarg++;
! 2206: break;
! 2207: }
! 2208: now = time(NULL);
! 2209: config->condtime = (curl_off_t)curl_getdate(nextarg, &now);
! 2210: if(-1 == config->condtime) {
! 2211: /* now let's see if it is a file name to get the time from instead! */
! 2212: curl_off_t filetime = getfiletime(nextarg, config->global->errors);
! 2213: if(filetime >= 0) {
! 2214: /* pull the time out from the file */
! 2215: config->condtime = filetime;
! 2216: }
! 2217: else {
! 2218: /* failed, remove time condition */
! 2219: config->timecond = CURL_TIMECOND_NONE;
! 2220: warnf(global,
! 2221: "Illegal date format for -z, --time-cond (and not "
! 2222: "a file name). Disabling time condition. "
! 2223: "See curl_getdate(3) for valid date syntax.\n");
! 2224: }
! 2225: }
! 2226: break;
! 2227: default: /* unknown flag */
! 2228: return PARAM_OPTION_UNKNOWN;
! 2229: }
! 2230: hit = -1;
! 2231:
! 2232: } while(!longopt && !singleopt && *++parse && !*usedarg);
! 2233:
! 2234: return PARAM_OK;
! 2235: }
! 2236:
! 2237: ParameterError parse_args(struct GlobalConfig *global, int argc,
! 2238: argv_item_t argv[])
! 2239: {
! 2240: int i;
! 2241: bool stillflags;
! 2242: char *orig_opt = NULL;
! 2243: ParameterError result = PARAM_OK;
! 2244: struct OperationConfig *config = global->first;
! 2245:
! 2246: for(i = 1, stillflags = TRUE; i < argc && !result; i++) {
! 2247: orig_opt = argv[i];
! 2248:
! 2249: if(stillflags && ('-' == argv[i][0])) {
! 2250: bool passarg;
! 2251: char *flag = argv[i];
! 2252:
! 2253: if(!strcmp("--", argv[i]))
! 2254: /* This indicates the end of the flags and thus enables the
! 2255: following (URL) argument to start with -. */
! 2256: stillflags = FALSE;
! 2257: else {
! 2258: char *nextarg = (i < (argc - 1)) ? argv[i + 1] : NULL;
! 2259:
! 2260: result = getparameter(flag, nextarg, &passarg, global, config);
! 2261: config = global->last;
! 2262: if(result == PARAM_NEXT_OPERATION) {
! 2263: /* Reset result as PARAM_NEXT_OPERATION is only used here and not
! 2264: returned from this function */
! 2265: result = PARAM_OK;
! 2266:
! 2267: if(config->url_list && config->url_list->url) {
! 2268: /* Allocate the next config */
! 2269: config->next = malloc(sizeof(struct OperationConfig));
! 2270: if(config->next) {
! 2271: /* Initialise the newly created config */
! 2272: config_init(config->next);
! 2273:
! 2274: /* Set the global config pointer */
! 2275: config->next->global = global;
! 2276:
! 2277: /* Update the last config pointer */
! 2278: global->last = config->next;
! 2279:
! 2280: /* Move onto the new config */
! 2281: config->next->prev = config;
! 2282: config = config->next;
! 2283: }
! 2284: else
! 2285: result = PARAM_NO_MEM;
! 2286: }
! 2287: }
! 2288: else if(!result && passarg)
! 2289: i++; /* we're supposed to skip this */
! 2290: }
! 2291: }
! 2292: else {
! 2293: bool used;
! 2294:
! 2295: /* Just add the URL please */
! 2296: result = getparameter((char *)"--url", argv[i], &used, global,
! 2297: config);
! 2298: }
! 2299: }
! 2300:
! 2301: if(result && result != PARAM_HELP_REQUESTED &&
! 2302: result != PARAM_MANUAL_REQUESTED &&
! 2303: result != PARAM_VERSION_INFO_REQUESTED &&
! 2304: result != PARAM_ENGINES_REQUESTED) {
! 2305: const char *reason = param2text(result);
! 2306:
! 2307: if(orig_opt && strcmp(":", orig_opt))
! 2308: helpf(global->errors, "option %s: %s\n", orig_opt, reason);
! 2309: else
! 2310: helpf(global->errors, "%s\n", reason);
! 2311: }
! 2312:
! 2313: return result;
! 2314: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to tool_getparam.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / src