src/tool_getparam.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2014, 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 http://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 "rawstr.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_formparse.h"
  34 #include "tool_getparam.h"
  35 #include "tool_helpers.h"
  36 #include "tool_libinfo.h"
  37 #include "tool_metalink.h"
  38 #include "tool_msgs.h"
  39 #include "tool_paramhlp.h"
  40 #include "tool_parsecfg.h"
  41
  42 #include "memdebug.h" /* keep this as LAST include */
  43
  44 #ifdef MSDOS
  45 #  define USE_WATT32
  46 #endif
  47
  48 #define GetStr(str,val) do { \
  49   if(*(str)) { \
  50     free(*(str)); \
  51     *(str) = NULL; \
  52   } \
  53   if((val)) {              \
  54     *(str) = strdup((val)); \
  55     if(!(*(str)))          \
  56       return PARAM_NO_MEM; \
  57   } \
  58 } WHILE_FALSE
  59
  60 struct LongShort {
  61   const char *letter; /* short name option */
  62   const char *lname;  /* long name option */
  63   bool extraparam;    /* whether it takes an additional argument */
  64 };
  65
  66 static const struct LongShort aliases[]= {
  67   /* all these ones, starting with "*" or "$" as a short-option have *no*
  68      short option to mention. */
  69   {"*",  "url",                      TRUE},
  70   {"*4", "dns-ipv4-addr",            TRUE},
  71   {"*6", "dns-ipv6-addr",            TRUE},
  72   {"*a", "random-file",              TRUE},
  73   {"*b", "egd-file",                 TRUE},
  74   {"*B", "oauth2-bearer",             TRUE},
  75   {"*c", "connect-timeout",          TRUE},
  76   {"*d", "ciphers",                  TRUE},
  77   {"*D", "dns-interface",            TRUE},
  78   {"*e", "disable-epsv",             FALSE},
  79   {"*E", "epsv",                     FALSE},
  80          /* 'epsv' made like this to make --no-epsv and --epsv to work
  81              although --disable-epsv is the documented option */
  82 #ifdef USE_ENVIRONMENT
  83   {"*f", "environment",              FALSE},
  84 #endif
  85   {"*F", "dns-servers",              TRUE},
  86   {"*g", "trace",                    TRUE},
  87   {"*G", "npn",                      FALSE},
  88   {"*h", "trace-ascii",              TRUE},
  89   {"*H", "alpn",                     FALSE},
  90   {"*i", "limit-rate",               TRUE},
  91   {"*j", "compressed",               FALSE},
  92   {"*J", "tr-encoding",              FALSE},
  93   {"*k", "digest",                   FALSE},
  94   {"*l", "negotiate",                FALSE},
  95   {"*m", "ntlm",                     FALSE},
  96   {"*M", "ntlm-wb",                  FALSE},
  97   {"*n", "basic",                    FALSE},
  98   {"*o", "anyauth",                  FALSE},
  99 #ifdef USE_WATT32
 100   {"*p", "wdebug",                   FALSE},
 101 #endif
 102   {"*q", "ftp-create-dirs",          FALSE},
 103   {"*r", "create-dirs",              FALSE},
 104   {"*s", "max-redirs",               TRUE},
 105   {"*t", "proxy-ntlm",               FALSE},
 106   {"*u", "crlf",                     FALSE},
 107   {"*v", "stderr",                   TRUE},
 108   {"*w", "interface",                TRUE},
 109   {"*x", "krb" ,                     TRUE},
 110   {"*x", "krb4" ,                    TRUE},
 111          /* 'krb4' is the previous name */
 112   {"*y", "max-filesize",             TRUE},
 113   {"*z", "disable-eprt",             FALSE},
 114   {"*Z", "eprt",                     FALSE},
 115          /* 'eprt' made like this to make --no-eprt and --eprt to work
 116              although --disable-eprt is the documented option */
 117   {"$a", "ftp-ssl",                  FALSE},
 118          /* 'ftp-ssl' deprecated name since 7.20.0 */
 119   {"$a", "ssl",                      FALSE},
 120          /* 'ssl' new option name in 7.20.0, previously this was ftp-ssl */
 121   {"$b", "ftp-pasv",                 FALSE},
 122   {"$c", "socks5",                   TRUE},
 123   {"$c", "socks",                    TRUE},
 124          /* 'socks' is how the option once was documented but we prefer
 125             the --socks5 version for explicit version */
 126   {"$d", "tcp-nodelay",              FALSE},
 127   {"$e", "proxy-digest",             FALSE},
 128   {"$f", "proxy-basic",              FALSE},
 129   {"$g", "retry",                    TRUE},
 130   {"$h", "retry-delay",              TRUE},
 131   {"$i", "retry-max-time",           TRUE},
 132   {"$k", "proxy-negotiate",          FALSE},
 133   {"$m", "ftp-account",              TRUE},
 134   {"$n", "proxy-anyauth",            FALSE},
 135   {"$o", "trace-time",               FALSE},
 136   {"$p", "ignore-content-length",    FALSE},
 137   {"$q", "ftp-skip-pasv-ip",         FALSE},
 138   {"$r", "ftp-method",               TRUE},
 139   {"$s", "local-port",               TRUE},
 140   {"$t", "socks4",                   TRUE},
 141   {"$T", "socks4a",                  TRUE},
 142   {"$u", "ftp-alternative-to-user",  TRUE},
 143   {"$v", "ftp-ssl-reqd",             FALSE},
 144          /* 'ftp-ssl-reqd' deprecated name since 7.20.0 */
 145   {"$v", "ssl-reqd",                 FALSE},
 146          /* 'ssl-reqd' new in 7.20.0, previously this was ftp-ssl-reqd */
 147   {"$w", "sessionid",                FALSE},
 148          /* ¡sessionid' listed as --no-sessionid in the help */
 149   {"$x", "ftp-ssl-control",          FALSE},
 150   {"$y", "ftp-ssl-ccc",              FALSE},
 151   {"$j", "ftp-ssl-ccc-mode",         TRUE},
 152   {"$z", "libcurl",                  TRUE},
 153   {"$#", "raw",                      FALSE},
 154   {"$0", "post301",                  FALSE},
 155   {"$1", "keepalive",                FALSE},
 156          /* 'keepalive' listed as --no-keepalive in the help */
 157   {"$2", "socks5-hostname",          TRUE},
 158   {"$3", "keepalive-time",           TRUE},
 159   {"$4", "post302",                  FALSE},
 160   {"$5", "noproxy",                  TRUE},
 161 #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
 162   {"$6", "socks5-gssapi-service",    TRUE},
 163   {"$7", "socks5-gssapi-nec",        FALSE},
 164 #endif
 165   {"$8", "proxy1.0",                 TRUE},
 166   {"$9", "tftp-blksize",             TRUE},
 167   {"$A", "mail-from",                TRUE},
 168   {"$B", "mail-rcpt",                TRUE},
 169   {"$C", "ftp-pret",                 FALSE},
 170   {"$D", "proto",                    TRUE},
 171   {"$E", "proto-redir",              TRUE},
 172   {"$F", "resolve",                  TRUE},
 173   {"$G", "delegation",               TRUE},
 174   {"$H", "mail-auth",                TRUE},
 175   {"$I", "post303",                  FALSE},
 176   {"$J", "metalink",                 FALSE},
 177   {"$K", "sasl-ir",                  FALSE},
 178   {"$L", "test-event",               FALSE},
 179   {"$M", "unix-socket",              TRUE},
 180   {"0",   "http1.0",                 FALSE},
 181   {"01",  "http1.1",                 FALSE},
 182   {"02",  "http2",                   FALSE},
 183   {"1",  "tlsv1",                    FALSE},
 184   {"10",  "tlsv1.0",                 FALSE},
 185   {"11",  "tlsv1.1",                 FALSE},
 186   {"12",  "tlsv1.2",                 FALSE},
 187   {"2",  "sslv2",                    FALSE},
 188   {"3",  "sslv3",                    FALSE},
 189   {"4",  "ipv4",                     FALSE},
 190   {"6",  "ipv6",                     FALSE},
 191   {"a",  "append",                   FALSE},
 192   {"A",  "user-agent",               TRUE},
 193   {"b",  "cookie",                   TRUE},
 194   {"B",  "use-ascii",                FALSE},
 195   {"c",  "cookie-jar",               TRUE},
 196   {"C",  "continue-at",              TRUE},
 197   {"d",  "data",                     TRUE},
 198   {"da", "data-ascii",               TRUE},
 199   {"db", "data-binary",              TRUE},
 200   {"de", "data-urlencode",           TRUE},
 201   {"D",  "dump-header",              TRUE},
 202   {"e",  "referer",                  TRUE},
 203   {"E",  "cert",                     TRUE},
 204   {"Ea", "cacert",                   TRUE},
 205   {"Eb", "cert-type",                TRUE},
 206   {"Ec", "key",                      TRUE},
 207   {"Ed", "key-type",                 TRUE},
 208   {"Ee", "pass",                     TRUE},
 209   {"Ef", "engine",                   TRUE},
 210   {"Eg", "capath ",                  TRUE},
 211   {"Eh", "pubkey",                   TRUE},
 212   {"Ei", "hostpubmd5",               TRUE},
 213   {"Ej", "crlfile",                  TRUE},
 214   {"Ek", "tlsuser",                  TRUE},
 215   {"El", "tlspassword",              TRUE},
 216   {"Em", "tlsauthtype",              TRUE},
 217   {"En", "ssl-allow-beast",          FALSE},
 218   {"Eo", "login-options",            TRUE},
 219   {"Ep", "pinnedpubkey",             TRUE},
 220   {"f",  "fail",                     FALSE},
 221   {"F",  "form",                     TRUE},
 222   {"Fs", "form-string",              TRUE},
 223   {"g",  "globoff",                  FALSE},
 224   {"G",  "get",                      FALSE},
 225   {"h",  "help",                     FALSE},
 226   {"H",  "header",                   TRUE},
 227   {"Hp", "proxy-header",             TRUE},
 228   {"i",  "include",                  FALSE},
 229   {"I",  "head",                     FALSE},
 230   {"j",  "junk-session-cookies",     FALSE},
 231   {"J",  "remote-header-name",       FALSE},
 232   {"k",  "insecure",                 FALSE},
 233   {"K",  "config",                   TRUE},
 234   {"l",  "list-only",                FALSE},
 235   {"L",  "location",                 FALSE},
 236   {"Lt", "location-trusted",         FALSE},
 237   {"m",  "max-time",                 TRUE},
 238   {"M",  "manual",                   FALSE},
 239   {"n",  "netrc",                    FALSE},
 240   {"no", "netrc-optional",           FALSE},
 241   {"ne", "netrc-file",               TRUE},
 242   {"N",  "buffer",                   FALSE},
 243          /* 'buffer' listed as --no-buffer in the help */
 244   {"o",  "output",                   TRUE},
 245   {"O",  "remote-name",              FALSE},
 246   {"Oa", "remote-name-all",          FALSE},
 247   {"p",  "proxytunnel",              FALSE},
 248   {"P",  "ftpport",                  TRUE},
 249          /* 'ftpport' old version */
 250   {"P",  "ftp-port",                 TRUE},
 251   {"q",  "disable",                  FALSE},
 252   {"Q",  "quote",                    TRUE},
 253   {"r",  "range",                    TRUE},
 254   {"R",  "remote-time",              FALSE},
 255   {"s",  "silent",                   FALSE},
 256   {"S",  "show-error",               FALSE},
 257   {"t",  "telnet-options",           TRUE},
 258          /* 'telnet-options' documented as telnet-option */
 259   {"T",  "upload-file",              TRUE},
 260   {"u",  "user",                     TRUE},
 261   {"U",  "proxy-user",               TRUE},
 262   {"v",  "verbose",                  FALSE},
 263   {"V",  "version",                  FALSE},
 264   {"w",  "write-out",                TRUE},
 265   {"x",  "proxy",                    TRUE},
 266   {"X",  "request",                  TRUE},
 267   {"X",  "http-request",             TRUE},
 268          /* 'http-request' OBSOLETE VERSION */
 269   {"Y",  "speed-limit",              TRUE},
 270   {"y",  "speed-time",               TRUE},
 271   {"z",  "time-cond",                TRUE},
 272   {"#",  "progress-bar",             FALSE},
 273   {":",  "next",                     FALSE},
 274   {"~",  "xattr",                    FALSE},
 275 };
 276
 277 /* Split the argument of -E to 'certname' and 'passphrase' separated by colon.
 278  * We allow ':' and '\' to be escaped by '\' so that we can use certificate
 279  * nicknames containing ':'.  See <https://sourceforge.net/p/curl/bugs/1196/>
 280  * for details. */
 281 #ifndef UNITTESTS
 282 static
 283 #endif
 284 void parse_cert_parameter(const char *cert_parameter,
 285                           char **certname,
 286                           char **passphrase)
 287 {
 288   size_t param_length = strlen(cert_parameter);
 289   size_t span;
 290   const char *param_place = NULL;
 291   char *certname_place = NULL;
 292   *certname = NULL;
 293   *passphrase = NULL;
 294
 295   /* most trivial assumption: cert_parameter is empty */
 296   if(param_length == 0)
 297     return;
 298
 299   /* next less trivial: cert_parameter contains no colon nor backslash; this
 300    * means no passphrase was given and no characters escaped */
 301   if(!strpbrk(cert_parameter, ":\\")) {
 302     *certname = strdup(cert_parameter);
 303     return;
 304   }
 305   /* deal with escaped chars; find unescaped colon if it exists */
 306   certname_place = malloc(param_length + 1);
 307   if(!certname_place)
 308     return;
 309
 310   *certname = certname_place;
 311   param_place = cert_parameter;
 312   while(*param_place) {
 313     span = strcspn(param_place, ":\\");
 314     strncpy(certname_place, param_place, span);
 315     param_place += span;
 316     certname_place += span;
 317     /* we just ate all the non-special chars. now we're on either a special
 318      * char or the end of the string. */
 319     switch(*param_place) {
 320     case '\0':
 321       break;
 322     case '\\':
 323       param_place++;
 324       switch(*param_place) {
 325         case '\0':
 326           *certname_place++ = '\\';
 327           break;
 328         case '\\':
 329           *certname_place++ = '\\';
 330           param_place++;
 331           break;
 332         case ':':
 333           *certname_place++ = ':';
 334           param_place++;
 335           break;
 336         default:
 337           *certname_place++ = '\\';
 338           *certname_place++ = *param_place;
 339           param_place++;
 340           break;
 341       }
 342       break;
 343     case ':':
 344       /* Since we live in a world of weirdness and confusion, the win32
 345          dudes can use : when using drive letters and thus c:\file:password
 346          needs to work. In order not to break compatibility, we still use : as
 347          separator, but we try to detect when it is used for a file name! On
 348          windows. */
 349 #ifdef WIN32
 350       if(param_place &&
 351           (param_place == &cert_parameter[1]) &&
 352           (cert_parameter[2] == '\\' || cert_parameter[2] == '/') &&
 353           (ISALPHA(cert_parameter[0])) ) {
 354         /* colon in the second column, followed by a backslash, and the
 355            first character is an alphabetic letter:
 356
 357            this is a drive letter colon */
 358         *certname_place++ = ':';
 359         param_place++;
 360         break;
 361       }
 362 #endif
 363       /* escaped colons and Windows drive letter colons were handled
 364        * above; if we're still here, this is a separating colon */
 365       param_place++;
 366       if(strlen(param_place) > 0) {
 367         *passphrase = strdup(param_place);
 368       }
 369       goto done;
 370     }
 371   }
 372 done:
 373   *certname_place = '\0';
 374 }
 375
 376 ParameterError getparameter(char *flag,    /* f or -long-flag */
 377                             char *nextarg, /* NULL if unset */
 378                             bool *usedarg, /* set to TRUE if the arg
 379                                               has been used */
 380                             struct GlobalConfig *global,
 381                             struct OperationConfig *config)
 382 {
 383   char letter;
 384   char subletter = '\0'; /* subletters can only occur on long options */
 385   int rc;
 386   const char *parse = NULL;
 387   unsigned int j;
 388   time_t now;
 389   int hit = -1;
 390   bool longopt = FALSE;
 391   bool singleopt = FALSE; /* when true means '-o foo' used '-ofoo' */
 392   ParameterError err;
 393   bool toggle = TRUE; /* how to switch boolean options, on or off. Controlled
 394                          by using --OPTION or --no-OPTION */
 395
 396
 397   if(('-' != flag[0]) ||
 398      (('-' == flag[0]) && ('-' == flag[1]))) {
 399     /* this should be a long name */
 400     char *word = ('-' == flag[0]) ? flag+2 : flag;
 401     size_t fnam = strlen(word);
 402     int numhits = 0;
 403
 404     if(!strncmp(word, "no-", 3)) {
 405       /* disable this option but ignore the "no-" part when looking for it */
 406       word += 3;
 407       toggle = FALSE;
 408     }
 409
 410     for(j = 0; j < sizeof(aliases)/sizeof(aliases[0]); j++) {
 411       if(curlx_strnequal(aliases[j].lname, word, fnam)) {
 412         longopt = TRUE;
 413         numhits++;
 414         if(curlx_raw_equal(aliases[j].lname, word)) {
 415           parse = aliases[j].letter;
 416           hit = j;
 417           numhits = 1; /* a single unique hit */
 418           break;
 419         }
 420         parse = aliases[j].letter;
 421         hit = j;
 422       }
 423     }
 424     if(numhits > 1) {
 425       /* this is at least the second match! */
 426       return PARAM_OPTION_AMBIGUOUS;
 427     }
 428     if(hit < 0) {
 429       return PARAM_OPTION_UNKNOWN;
 430     }
 431   }
 432   else {
 433     flag++; /* prefixed with one dash, pass it */
 434     hit = -1;
 435     parse = flag;
 436   }
 437
 438   do {
 439     /* we can loop here if we have multiple single-letters */
 440
 441     if(!longopt) {
 442       letter = (char)*parse;
 443       subletter='\0';
 444     }
 445     else {
 446       letter = parse[0];
 447       subletter = parse[1];
 448     }
 449     *usedarg = FALSE; /* default is that we don't use the arg */
 450
 451     if(hit < 0) {
 452       for(j = 0; j < sizeof(aliases)/sizeof(aliases[0]); j++) {
 453         if(letter == aliases[j].letter[0]) {
 454           hit = j;
 455           break;
 456         }
 457       }
 458       if(hit < 0) {
 459         return PARAM_OPTION_UNKNOWN;
 460       }
 461     }
 462
 463     if(aliases[hit].extraparam) {
 464       /* this option requires an extra parameter */
 465       if(!longopt && parse[1]) {
 466         nextarg = (char *)&parse[1]; /* this is the actual extra parameter */
 467         singleopt = TRUE;   /* don't loop anymore after this */
 468       }
 469       else if(!nextarg)
 470         return PARAM_REQUIRES_PARAMETER;
 471       else
 472         *usedarg = TRUE; /* mark it as used */
 473     }
 474
 475     switch(letter) {
 476     case '*': /* options without a short option */
 477       switch(subletter) {
 478       case '4': /* --dns-ipv4-addr */
 479         /* addr in dot notation */
 480         GetStr(&config->dns_ipv4_addr, nextarg);
 481         break;
 482       case '6': /* --dns-ipv6-addr */
 483         /* addr in dot notation */
 484         GetStr(&config->dns_ipv6_addr, nextarg);
 485         break;
 486       case 'a': /* random-file */
 487         GetStr(&config->random_file, nextarg);
 488         break;
 489       case 'b': /* egd-file */
 490         GetStr(&config->egd_file, nextarg);
 491         break;
 492       case 'B': /* XOAUTH2 Bearer */
 493         GetStr(&config->xoauth2_bearer, nextarg);
 494         break;
 495       case 'c': /* connect-timeout */
 496         err = str2udouble(&config->connecttimeout, nextarg);
 497         if(err)
 498           return err;
 499         break;
 500       case 'd': /* ciphers */
 501         GetStr(&config->cipher_list, nextarg);
 502         break;
 503       case 'D': /* --dns-interface */
 504         /* interface name */
 505         GetStr(&config->dns_interface, nextarg);
 506         break;
 507       case 'e': /* --disable-epsv */
 508         config->disable_epsv = toggle;
 509         break;
 510       case 'E': /* --epsv */
 511         config->disable_epsv = (!toggle)?TRUE:FALSE;
 512         break;
 513 #ifdef USE_ENVIRONMENT
 514       case 'f':
 515         config->writeenv = toggle;
 516         break;
 517 #endif
 518       case 'F': /* --dns-servers */
 519         /* IP addrs of DNS servers */
 520         GetStr(&config->dns_servers, nextarg);
 521         break;
 522       case 'g': /* --trace */
 523         GetStr(&global->trace_dump, nextarg);
 524         if(global->tracetype && (global->tracetype != TRACE_BIN))
 525           warnf(config, "--trace overrides an earlier trace/verbose option\n");
 526         global->tracetype = TRACE_BIN;
 527         break;
 528       case 'G': /* --npn */
 529         config->nonpn = (!toggle)?TRUE:FALSE;
 530         break;
 531       case 'h': /* --trace-ascii */
 532         GetStr(&global->trace_dump, nextarg);
 533         if(global->tracetype && (global->tracetype != TRACE_ASCII))
 534           warnf(config,
 535                 "--trace-ascii overrides an earlier trace/verbose option\n");
 536         global->tracetype = TRACE_ASCII;
 537         break;
 538       case 'H': /* --alpn */
 539         config->noalpn = (!toggle)?TRUE:FALSE;
 540         break;
 541       case 'i': /* --limit-rate */
 542       {
 543         /* We support G, M, K too */
 544         char *unit;
 545         curl_off_t value = curlx_strtoofft(nextarg, &unit, 0);
 546
 547         if(!*unit)
 548           unit = (char *)"b";
 549         else if(strlen(unit) > 1)
 550           unit = (char *)"w"; /* unsupported */
 551
 552         switch(*unit) {
 553         case 'G':
 554         case 'g':
 555           value *= 1024*1024*1024;
 556           break;
 557         case 'M':
 558         case 'm':
 559           value *= 1024*1024;
 560           break;
 561         case 'K':
 562         case 'k':
 563           value *= 1024;
 564           break;
 565         case 'b':
 566         case 'B':
 567           /* for plain bytes, leave as-is */
 568           break;
 569         default:
 570           warnf(config, "unsupported rate unit. Use G, M, K or B!\n");
 571           return PARAM_BAD_USE;
 572         }
 573         config->recvpersecond = value;
 574         config->sendpersecond = value;
 575       }
 576       break;
 577
 578       case 'j': /* --compressed */
 579         if(toggle && !(curlinfo->features & CURL_VERSION_LIBZ))
 580           return PARAM_LIBCURL_DOESNT_SUPPORT;
 581         config->encoding = toggle;
 582         break;
 583
 584       case 'J': /* --tr-encoding */
 585         config->tr_encoding = toggle;
 586         break;
 587
 588       case 'k': /* --digest */
 589         if(toggle)
 590           config->authtype |= CURLAUTH_DIGEST;
 591         else
 592           config->authtype &= ~CURLAUTH_DIGEST;
 593         break;
 594
 595       case 'l': /* --negotiate */
 596         if(toggle) {
 597           if(curlinfo->features & CURL_VERSION_SPNEGO)
 598             config->authtype |= CURLAUTH_NEGOTIATE;
 599           else
 600             return PARAM_LIBCURL_DOESNT_SUPPORT;
 601         }
 602         else
 603           config->authtype &= ~CURLAUTH_NEGOTIATE;
 604         break;
 605
 606       case 'm': /* --ntlm */
 607         if(toggle) {
 608           if(curlinfo->features & CURL_VERSION_NTLM)
 609             config->authtype |= CURLAUTH_NTLM;
 610           else
 611             return PARAM_LIBCURL_DOESNT_SUPPORT;
 612         }
 613         else
 614           config->authtype &= ~CURLAUTH_NTLM;
 615         break;
 616
 617       case 'M': /* --ntlm-wb */
 618         if(toggle) {
 619           if(curlinfo->features & CURL_VERSION_NTLM_WB)
 620             config->authtype |= CURLAUTH_NTLM_WB;
 621           else
 622             return PARAM_LIBCURL_DOESNT_SUPPORT;
 623         }
 624         else
 625           config->authtype &= ~CURLAUTH_NTLM_WB;
 626         break;
 627
 628       case 'n': /* --basic for completeness */
 629         if(toggle)
 630           config->authtype |= CURLAUTH_BASIC;
 631         else
 632           config->authtype &= ~CURLAUTH_BASIC;
 633         break;
 634
 635       case 'o': /* --anyauth, let libcurl pick it */
 636         if(toggle)
 637           config->authtype = CURLAUTH_ANY;
 638         /* --no-anyauth simply doesn't touch it */
 639         break;
 640
 641 #ifdef USE_WATT32
 642       case 'p': /* --wdebug */
 643         dbug_init();
 644         break;
 645 #endif
 646       case 'q': /* --ftp-create-dirs */
 647         config->ftp_create_dirs = toggle;
 648         break;
 649
 650       case 'r': /* --create-dirs */
 651         config->create_dirs = toggle;
 652         break;
 653
 654       case 's': /* --max-redirs */
 655         /* specified max no of redirects (http(s)), this accepts -1 as a
 656            special condition */
 657         err = str2num(&config->maxredirs, nextarg);
 658         if(err)
 659           return err;
 660         if(config->maxredirs < -1)
 661           return PARAM_BAD_NUMERIC;
 662         break;
 663
 664       case 't': /* --proxy-ntlm */
 665         if(curlinfo->features & CURL_VERSION_NTLM)
 666           config->proxyntlm = toggle;
 667         else
 668           return PARAM_LIBCURL_DOESNT_SUPPORT;
 669         break;
 670
 671       case 'u': /* --crlf */
 672         /* LF -> CRLF conversion? */
 673         config->crlf = toggle;
 674         break;
 675
 676       case 'v': /* --stderr */
 677         if(strcmp(nextarg, "-")) {
 678           FILE *newfile = fopen(nextarg, "wt");
 679           if(!newfile)
 680             warnf(config, "Failed to open %s!\n", nextarg);
 681           else {
 682             if(global->errors_fopened)
 683               fclose(global->errors);
 684             global->errors = newfile;
 685             global->errors_fopened = TRUE;
 686           }
 687         }
 688         else
 689           global->errors = stdout;
 690         break;
 691       case 'w': /* --interface */
 692         /* interface */
 693         GetStr(&config->iface, nextarg);
 694         break;
 695       case 'x': /* --krb */
 696         /* kerberos level string */
 697         if(curlinfo->features & CURL_VERSION_KERBEROS4)
 698           GetStr(&config->krblevel, nextarg);
 699         else
 700           return PARAM_LIBCURL_DOESNT_SUPPORT;
 701         break;
 702       case 'y': /* --max-filesize */
 703         err = str2offset(&config->max_filesize, nextarg);
 704         if(err)
 705           return err;
 706         break;
 707       case 'z': /* --disable-eprt */
 708         config->disable_eprt = toggle;
 709         break;
 710       case 'Z': /* --eprt */
 711         config->disable_eprt = (!toggle)?TRUE:FALSE;
 712         break;
 713
 714       default: /* the URL! */
 715       {
 716         struct getout *url;
 717         if(config->url_get || ((config->url_get = config->url_list) != NULL)) {
 718           /* there's a node here, if it already is filled-in continue to find
 719              an "empty" node */
 720           while(config->url_get && (config->url_get->flags & GETOUT_URL))
 721             config->url_get = config->url_get->next;
 722         }
 723
 724         /* now there might or might not be an available node to fill in! */
 725
 726         if(config->url_get)
 727           /* existing node */
 728           url = config->url_get;
 729         else
 730           /* there was no free node, create one! */
 731           url = new_getout(config);
 732
 733         if(!url)
 734           return PARAM_NO_MEM;
 735         else {
 736           /* fill in the URL */
 737           GetStr(&url->url, nextarg);
 738           url->flags |= GETOUT_URL;
 739         }
 740       }
 741       }
 742       break;
 743     case '$': /* more options without a short option */
 744       switch(subletter) {
 745       case 'a': /* --ftp-ssl */
 746         if(toggle && !(curlinfo->features & CURL_VERSION_SSL))
 747           return PARAM_LIBCURL_DOESNT_SUPPORT;
 748         config->ftp_ssl = toggle;
 749         break;
 750       case 'b': /* --ftp-pasv */
 751         Curl_safefree(config->ftpport);
 752         break;
 753       case 'c': /* --socks5 specifies a socks5 proxy to use, and resolves
 754                    the name locally and passes on the resolved address */
 755         GetStr(&config->socksproxy, nextarg);
 756         config->socksver = CURLPROXY_SOCKS5;
 757         break;
 758       case 't': /* --socks4 specifies a socks4 proxy to use */
 759         GetStr(&config->socksproxy, nextarg);
 760         config->socksver = CURLPROXY_SOCKS4;
 761         break;
 762       case 'T': /* --socks4a specifies a socks4a proxy to use */
 763         GetStr(&config->socksproxy, nextarg);
 764         config->socksver = CURLPROXY_SOCKS4A;
 765         break;
 766       case '2': /* --socks5-hostname specifies a socks5 proxy and enables name
 767                    resolving with the proxy */
 768         GetStr(&config->socksproxy, nextarg);
 769         config->socksver = CURLPROXY_SOCKS5_HOSTNAME;
 770         break;
 771       case 'd': /* --tcp-nodelay option */
 772         config->tcp_nodelay = toggle;
 773         break;
 774       case 'e': /* --proxy-digest */
 775         config->proxydigest = toggle;
 776         break;
 777       case 'f': /* --proxy-basic */
 778         config->proxybasic = toggle;
 779         break;
 780       case 'g': /* --retry */
 781         err = str2unum(&config->req_retry, nextarg);
 782         if(err)
 783           return err;
 784         break;
 785       case 'h': /* --retry-delay */
 786         err = str2unum(&config->retry_delay, nextarg);
 787         if(err)
 788           return err;
 789         break;
 790       case 'i': /* --retry-max-time */
 791         err = str2unum(&config->retry_maxtime, nextarg);
 792         if(err)
 793           return err;
 794         break;
 795
 796       case 'k': /* --proxy-negotiate */
 797         if(curlinfo->features & CURL_VERSION_SPNEGO)
 798           config->proxynegotiate = toggle;
 799         else
 800           return PARAM_LIBCURL_DOESNT_SUPPORT;
 801         break;
 802
 803       case 'm': /* --ftp-account */
 804         GetStr(&config->ftp_account, nextarg);
 805         break;
 806       case 'n': /* --proxy-anyauth */
 807         config->proxyanyauth = toggle;
 808         break;
 809       case 'o': /* --trace-time */
 810         global->tracetime = toggle;
 811         break;
 812       case 'p': /* --ignore-content-length */
 813         config->ignorecl = toggle;
 814         break;
 815       case 'q': /* --ftp-skip-pasv-ip */
 816         config->ftp_skip_ip = toggle;
 817         break;
 818       case 'r': /* --ftp-method (undocumented at this point) */
 819         config->ftp_filemethod = ftpfilemethod(config, nextarg);
 820         break;
 821       case 's': /* --local-port */
 822         rc = sscanf(nextarg, "%d - %d",
 823                     &config->localport,
 824                     &config->localportrange);
 825         if(!rc)
 826           return PARAM_BAD_USE;
 827         else if(rc == 1)
 828           config->localportrange = 1; /* default number of ports to try */
 829         else {
 830           config->localportrange -= config->localport;
 831           if(config->localportrange < 1) {
 832             warnf(config, "bad range input\n");
 833             return PARAM_BAD_USE;
 834           }
 835         }
 836         break;
 837       case 'u': /* --ftp-alternative-to-user */
 838         GetStr(&config->ftp_alternative_to_user, nextarg);
 839         break;
 840       case 'v': /* --ftp-ssl-reqd */
 841         if(toggle && !(curlinfo->features & CURL_VERSION_SSL))
 842           return PARAM_LIBCURL_DOESNT_SUPPORT;
 843         config->ftp_ssl_reqd = toggle;
 844         break;
 845       case 'w': /* --no-sessionid */
 846         config->disable_sessionid = (!toggle)?TRUE:FALSE;
 847         break;
 848       case 'x': /* --ftp-ssl-control */
 849         if(toggle && !(curlinfo->features & CURL_VERSION_SSL))
 850           return PARAM_LIBCURL_DOESNT_SUPPORT;
 851         config->ftp_ssl_control = toggle;
 852         break;
 853       case 'y': /* --ftp-ssl-ccc */
 854         config->ftp_ssl_ccc = toggle;
 855         if(!config->ftp_ssl_ccc_mode)
 856           config->ftp_ssl_ccc_mode = CURLFTPSSL_CCC_PASSIVE;
 857         break;
 858       case 'j': /* --ftp-ssl-ccc-mode */
 859         config->ftp_ssl_ccc = TRUE;
 860         config->ftp_ssl_ccc_mode = ftpcccmethod(config, nextarg);
 861         break;
 862       case 'z': /* --libcurl */
 863 #ifdef CURL_DISABLE_LIBCURL_OPTION
 864         warnf(config,
 865               "--libcurl option was disabled at build-time!\n");
 866         return PARAM_OPTION_UNKNOWN;
 867 #else
 868         GetStr(&global->libcurl, nextarg);
 869         break;
 870 #endif
 871       case '#': /* --raw */
 872         config->raw = toggle;
 873         break;
 874       case '0': /* --post301 */
 875         config->post301 = toggle;
 876         break;
 877       case '1': /* --no-keepalive */
 878         config->nokeepalive = (!toggle)?TRUE:FALSE;
 879         break;
 880       case '3': /* --keepalive-time */
 881         err = str2unum(&config->alivetime, nextarg);
 882         if(err)
 883           return err;
 884         break;
 885       case '4': /* --post302 */
 886         config->post302 = toggle;
 887         break;
 888       case 'I': /* --post303 */
 889         config->post303 = toggle;
 890         break;
 891       case '5': /* --noproxy */
 892         /* This specifies the noproxy list */
 893         GetStr(&config->noproxy, nextarg);
 894         break;
 895 #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
 896       case '6': /* --socks5-gssapi-service */
 897         GetStr(&config->socks5_gssapi_service, nextarg);
 898         break;
 899       case '7': /* --socks5-gssapi-nec*/
 900         config->socks5_gssapi_nec = toggle;
 901         break;
 902 #endif
 903       case '8': /* --proxy1.0 */
 904         /* http 1.0 proxy */
 905         GetStr(&config->proxy, nextarg);
 906         config->proxyver = CURLPROXY_HTTP_1_0;
 907         break;
 908       case '9': /* --tftp-blksize */
 909         err = str2unum(&config->tftp_blksize, nextarg);
 910         if(err)
 911           return err;
 912         break;
 913       case 'A': /* --mail-from */
 914         GetStr(&config->mail_from, nextarg);
 915         break;
 916       case 'B': /* --mail-rcpt */
 917         /* append receiver to a list */
 918         err = add2list(&config->mail_rcpt, nextarg);
 919         if(err)
 920           return err;
 921         break;
 922       case 'C': /* --ftp-pret */
 923         config->ftp_pret = toggle;
 924         break;
 925       case 'D': /* --proto */
 926         config->proto_present = TRUE;
 927         if(proto2num(config, &config->proto, nextarg))
 928           return PARAM_BAD_USE;
 929         break;
 930       case 'E': /* --proto-redir */
 931         config->proto_redir_present = TRUE;
 932         if(proto2num(config, &config->proto_redir, nextarg))
 933           return PARAM_BAD_USE;
 934         break;
 935       case 'F': /* --resolve */
 936         err = add2list(&config->resolve, nextarg);
 937         if(err)
 938           return err;
 939         break;
 940       case 'G': /* --delegation LEVEL */
 941         config->gssapi_delegation = delegation(config, nextarg);
 942         break;
 943       case 'H': /* --mail-auth */
 944         GetStr(&config->mail_auth, nextarg);
 945         break;
 946       case 'J': /* --metalink */
 947         {
 948 #ifdef USE_METALINK
 949           int mlmaj, mlmin, mlpatch;
 950           metalink_get_version(&mlmaj, &mlmin, &mlpatch);
 951           if((mlmaj*10000)+(mlmin*100)+mlpatch < CURL_REQ_LIBMETALINK_VERS) {
 952             warnf(config,
 953                   "--metalink option cannot be used because the version of "
 954                   "the linked libmetalink library is too old. "
 955                   "Required: %d.%d.%d, found %d.%d.%d\n",
 956                   CURL_REQ_LIBMETALINK_MAJOR,
 957                   CURL_REQ_LIBMETALINK_MINOR,
 958                   CURL_REQ_LIBMETALINK_PATCH,
 959                   mlmaj, mlmin, mlpatch);
 960             return PARAM_BAD_USE;
 961           }
 962           else
 963             config->use_metalink = toggle;
 964 #else
 965           warnf(config, "--metalink option is ignored because the binary is "
 966                 "built without the Metalink support.\n");
 967 #endif
 968           break;
 969         }
 970       case 'K': /* --sasl-ir */
 971         config->sasl_ir = toggle;
 972         break;
 973       case 'L': /* --test-event */
 974 #ifdef CURLDEBUG
 975         config->test_event_based = toggle;
 976 #else
 977         warnf(config, "--test-event is ignored unless a debug build!\n");
 978 #endif
 979         break;
 980       case 'M': /* --unix-socket */
 981         GetStr(&config->unix_socket_path, nextarg);
 982         break;
 983       }
 984       break;
 985     case '#': /* --progress-bar */
 986       if(toggle)
 987         global->progressmode = CURL_PROGRESS_BAR;
 988       else
 989         global->progressmode = CURL_PROGRESS_STATS;
 990       break;
 991     case ':': /* --next */
 992       return PARAM_NEXT_OPERATION;
 993     case '~': /* --xattr */
 994       config->xattr = toggle;
 995       break;
 996     case '0': /* --http* options */
 997       switch(subletter) {
 998       case '\0':
 999         /* HTTP version 1.0 */
1000         config->httpversion = CURL_HTTP_VERSION_1_0;
1001         break;
1002       case '1':
1003         /* HTTP version 1.1 */
1004         config->httpversion = CURL_HTTP_VERSION_1_1;
1005         break;
1006       case '2':
1007         /* HTTP version 2.0 */
1008         config->httpversion = CURL_HTTP_VERSION_2_0;
1009         break;
1010       }
1011       break;
1012     case '1': /* --tlsv1* options */
1013       switch(subletter) {
1014       case '\0':
1015         /* TLS version 1.x */
1016         config->ssl_version = CURL_SSLVERSION_TLSv1;
1017         break;
1018       case '0':
1019         /* TLS version 1.0 */
1020         config->ssl_version = CURL_SSLVERSION_TLSv1_0;
1021         break;
1022       case '1':
1023         /* TLS version 1.1 */
1024         config->ssl_version = CURL_SSLVERSION_TLSv1_1;
1025         break;
1026       case '2':
1027         /* TLS version 1.2 */
1028         config->ssl_version = CURL_SSLVERSION_TLSv1_2;
1029         break;
1030       }
1031       break;
1032     case '2':
1033       /* SSL version 2 */
1034       config->ssl_version = CURL_SSLVERSION_SSLv2;
1035       break;
1036     case '3':
1037       /* SSL version 3 */
1038       config->ssl_version = CURL_SSLVERSION_SSLv3;
1039       break;
1040     case '4':
1041       /* IPv4 */
1042       config->ip_version = 4;
1043       break;
1044     case '6':
1045       /* IPv6 */
1046       config->ip_version = 6;
1047       break;
1048     case 'a':
1049       /* This makes the FTP sessions use APPE instead of STOR */
1050       config->ftp_append = toggle;
1051       break;
1052     case 'A':
1053       /* This specifies the User-Agent name */
1054       GetStr(&config->useragent, nextarg);
1055       break;
1056     case 'b': /* cookie string coming up: */
1057       if(nextarg[0] == '@') {
1058         nextarg++;
1059       }
1060       else if(strchr(nextarg, '=')) {
1061         /* A cookie string must have a =-letter */
1062         GetStr(&config->cookie, nextarg);
1063         break;
1064       }
1065       /* We have a cookie file to read from! */
1066       GetStr(&config->cookiefile, nextarg);
1067       break;
1068     case 'B':
1069       /* use ASCII/text when transferring */
1070       config->use_ascii = toggle;
1071       break;
1072     case 'c':
1073       /* get the file name to dump all cookies in */
1074       GetStr(&config->cookiejar, nextarg);
1075       break;
1076     case 'C':
1077       /* This makes us continue an ftp transfer at given position */
1078       if(!curlx_strequal(nextarg, "-")) {
1079         err = str2offset(&config->resume_from, nextarg);
1080         if(err)
1081           return err;
1082         config->resume_from_current = FALSE;
1083       }
1084       else {
1085         config->resume_from_current = TRUE;
1086         config->resume_from = 0;
1087       }
1088       config->use_resume=TRUE;
1089       break;
1090     case 'd':
1091       /* postfield data */
1092     {
1093       char *postdata = NULL;
1094       FILE *file;
1095       size_t size = 0;
1096
1097       if(subletter == 'e') { /* --data-urlencode*/
1098         /* [name]=[content], we encode the content part only
1099          * [name]@[file name]
1100          *
1101          * Case 2: we first load the file using that name and then encode
1102          * the content.
1103          */
1104         const char *p = strchr(nextarg, '=');
1105         size_t nlen;
1106         char is_file;
1107         if(!p)
1108           /* there was no '=' letter, check for a '@' instead */
1109           p = strchr(nextarg, '@');
1110         if(p) {
1111           nlen = p - nextarg; /* length of the name part */
1112           is_file = *p++; /* pass the separator */
1113         }
1114         else {
1115           /* neither @ nor =, so no name and it isn't a file */
1116           nlen = is_file = 0;
1117           p = nextarg;
1118         }
1119         if('@' == is_file) {
1120           /* a '@' letter, it means that a file name or - (stdin) follows */
1121
1122           if(curlx_strequal("-", p)) {
1123             file = stdin;
1124             set_binmode(stdin);
1125           }
1126           else {
1127             file = fopen(p, "rb");
1128             if(!file)
1129               warnf(config,
1130                     "Couldn't read data from file \"%s\", this makes "
1131                     "an empty POST.\n", nextarg);
1132           }
1133
1134           err = file2memory(&postdata, &size, file);
1135
1136           if(file && (file != stdin))
1137             fclose(file);
1138           if(err)
1139             return err;
1140         }
1141         else {
1142           GetStr(&postdata, p);
1143           if(postdata)
1144             size = strlen(postdata);
1145         }
1146
1147         if(!postdata) {
1148           /* no data from the file, point to a zero byte string to make this
1149              get sent as a POST anyway */
1150           postdata = strdup("");
1151           if(!postdata)
1152             return PARAM_NO_MEM;
1153           size = 0;
1154         }
1155         else {
1156           char *enc = curl_easy_escape(config->easy, postdata, (int)size);
1157           Curl_safefree(postdata); /* no matter if it worked or not */
1158           if(enc) {
1159             /* now make a string with the name from above and append the
1160                encoded string */
1161             size_t outlen = nlen + strlen(enc) + 2;
1162             char *n = malloc(outlen);
1163             if(!n) {
1164               curl_free(enc);
1165               return PARAM_NO_MEM;
1166             }
1167             if(nlen > 0) { /* only append '=' if we have a name */
1168               snprintf(n, outlen, "%.*s=%s", nlen, nextarg, enc);
1169               size = outlen-1;
1170             }
1171             else {
1172               strcpy(n, enc);
1173               size = outlen-2; /* since no '=' was inserted */
1174             }
1175             curl_free(enc);
1176             postdata = n;
1177           }
1178           else
1179             return PARAM_NO_MEM;
1180         }
1181       }
1182       else if('@' == *nextarg) {
1183         /* the data begins with a '@' letter, it means that a file name
1184            or - (stdin) follows */
1185         nextarg++; /* pass the @ */
1186
1187         if(curlx_strequal("-", nextarg)) {
1188           file = stdin;
1189           if(subletter == 'b') /* forced data-binary */
1190             set_binmode(stdin);
1191         }
1192         else {
1193           file = fopen(nextarg, "rb");
1194           if(!file)
1195             warnf(config, "Couldn't read data from file \"%s\", this makes "
1196                   "an empty POST.\n", nextarg);
1197         }
1198
1199         if(subletter == 'b')
1200           /* forced binary */
1201           err = file2memory(&postdata, &size, file);
1202         else {
1203           err = file2string(&postdata, file);
1204           if(postdata)
1205             size = strlen(postdata);
1206         }
1207
1208         if(file && (file != stdin))
1209           fclose(file);
1210         if(err)
1211           return err;
1212
1213         if(!postdata) {
1214           /* no data from the file, point to a zero byte string to make this
1215              get sent as a POST anyway */
1216           postdata = strdup("");
1217           if(!postdata)
1218             return PARAM_NO_MEM;
1219         }
1220       }
1221       else {
1222         GetStr(&postdata, nextarg);
1223         if(postdata)
1224           size = strlen(postdata);
1225       }
1226
1227 #ifdef CURL_DOES_CONVERSIONS
1228       if(subletter != 'b') {
1229         /* NOT forced binary, convert to ASCII */
1230         if(convert_to_network(postdata, strlen(postdata))) {
1231           Curl_safefree(postdata);
1232           return PARAM_NO_MEM;
1233         }
1234       }
1235 #endif
1236
1237       if(config->postfields) {
1238         /* we already have a string, we append this one with a separating
1239            &-letter */
1240         char *oldpost = config->postfields;
1241         curl_off_t oldlen = config->postfieldsize;
1242         curl_off_t newlen = oldlen + curlx_uztoso(size) + 2;
1243         config->postfields = malloc((size_t)newlen);
1244         if(!config->postfields) {
1245           Curl_safefree(oldpost);
1246           Curl_safefree(postdata);
1247           return PARAM_NO_MEM;
1248         }
1249         memcpy(config->postfields, oldpost, (size_t)oldlen);
1250         /* use byte value 0x26 for '&' to accommodate non-ASCII platforms */
1251         config->postfields[oldlen] = '\x26';
1252         memcpy(&config->postfields[oldlen+1], postdata, size);
1253         config->postfields[oldlen+1+size] = '\0';
1254         Curl_safefree(oldpost);
1255         Curl_safefree(postdata);
1256         config->postfieldsize += size+1;
1257       }
1258       else {
1259         config->postfields = postdata;
1260         config->postfieldsize = curlx_uztoso(size);
1261       }
1262     }
1263     /*
1264       We can't set the request type here, as this data might be used in
1265       a simple GET if -G is used. Already or soon.
1266
1267       if(SetHTTPrequest(HTTPREQ_SIMPLEPOST, &config->httpreq)) {
1268         Curl_safefree(postdata);
1269         return PARAM_BAD_USE;
1270       }
1271     */
1272     break;
1273     case 'D':
1274       /* dump-header to given file name */
1275       GetStr(&config->headerfile, nextarg);
1276       break;
1277     case 'e':
1278     {
1279       char *ptr = strstr(nextarg, ";auto");
1280       if(ptr) {
1281         /* Automatic referer requested, this may be combined with a
1282            set initial one */
1283         config->autoreferer = TRUE;
1284         *ptr = 0; /* zero terminate here */
1285       }
1286       else
1287         config->autoreferer = FALSE;
1288       GetStr(&config->referer, nextarg);
1289     }
1290     break;
1291     case 'E':
1292       switch(subletter) {
1293       case 'a': /* CA info PEM file */
1294         /* CA info PEM file */
1295         GetStr(&config->cacert, nextarg);
1296         break;
1297       case 'b': /* cert file type */
1298         GetStr(&config->cert_type, nextarg);
1299         break;
1300       case 'c': /* private key file */
1301         GetStr(&config->key, nextarg);
1302         break;
1303       case 'd': /* private key file type */
1304         GetStr(&config->key_type, nextarg);
1305         break;
1306       case 'e': /* private key passphrase */
1307         GetStr(&config->key_passwd, nextarg);
1308         cleanarg(nextarg);
1309         break;
1310       case 'f': /* crypto engine */
1311         GetStr(&config->engine, nextarg);
1312         if(config->engine && curlx_raw_equal(config->engine,"list"))
1313           return PARAM_ENGINES_REQUESTED;
1314         break;
1315       case 'g': /* CA info PEM file */
1316         /* CA cert directory */
1317         GetStr(&config->capath, nextarg);
1318         break;
1319       case 'h': /* --pubkey public key file */
1320         GetStr(&config->pubkey, nextarg);
1321         break;
1322       case 'i': /* --hostpubmd5 md5 of the host public key */
1323         GetStr(&config->hostpubmd5, nextarg);
1324         if(!config->hostpubmd5 || strlen(config->hostpubmd5) != 32)
1325           return PARAM_BAD_USE;
1326         break;
1327       case 'j': /* CRL info PEM file */
1328         /* CRL file */
1329         GetStr(&config->crlfile, nextarg);
1330         break;
1331       case 'k': /* TLS username */
1332         if(curlinfo->features & CURL_VERSION_TLSAUTH_SRP)
1333           GetStr(&config->tls_username, nextarg);
1334         else
1335           return PARAM_LIBCURL_DOESNT_SUPPORT;
1336         break;
1337       case 'l': /* TLS password */
1338         if(curlinfo->features & CURL_VERSION_TLSAUTH_SRP)
1339           GetStr(&config->tls_password, nextarg);
1340         else
1341           return PARAM_LIBCURL_DOESNT_SUPPORT;
1342         break;
1343       case 'm': /* TLS authentication type */
1344         if(curlinfo->features & CURL_VERSION_TLSAUTH_SRP) {
1345           GetStr(&config->tls_authtype, nextarg);
1346           if(!strequal(config->tls_authtype, "SRP"))
1347             return PARAM_LIBCURL_DOESNT_SUPPORT; /* only support TLS-SRP */
1348         }
1349         else
1350           return PARAM_LIBCURL_DOESNT_SUPPORT;
1351         break;
1352       case 'n': /* no empty SSL fragments, --ssl-allow-beast */
1353         if(curlinfo->features & CURL_VERSION_SSL)
1354           config->ssl_allow_beast = toggle;
1355         break;
1356
1357       case 'o': /* --login-options */
1358         GetStr(&config->login_options, nextarg);
1359         break;
1360
1361       case 'p': /* Pinned public key DER file */
1362         /* Pinned public key DER file */
1363         GetStr(&config->pinnedpubkey, nextarg);
1364         break;
1365
1366       default: /* certificate file */
1367       {
1368         char *certname, *passphrase;
1369         parse_cert_parameter(nextarg, &certname, &passphrase);
1370         Curl_safefree(config->cert);
1371         config->cert = certname;
1372         if(passphrase) {
1373           Curl_safefree(config->key_passwd);
1374           config->key_passwd = passphrase;
1375         }
1376         cleanarg(nextarg);
1377       }
1378       }
1379       break;
1380     case 'f':
1381       /* fail hard on errors  */
1382       config->failonerror = toggle;
1383       break;
1384     case 'F':
1385       /* "form data" simulation, this is a little advanced so lets do our best
1386          to sort this out slowly and carefully */
1387       if(formparse(config,
1388                    nextarg,
1389                    &config->httppost,
1390                    &config->last_post,
1391                    (subletter=='s')?TRUE:FALSE)) /* 's' means literal string */
1392         return PARAM_BAD_USE;
1393       if(SetHTTPrequest(config, HTTPREQ_POST, &config->httpreq))
1394         return PARAM_BAD_USE;
1395       break;
1396
1397     case 'g': /* g disables URLglobbing */
1398       config->globoff = toggle;
1399       break;
1400
1401     case 'G': /* HTTP GET */
1402       config->use_httpget = TRUE;
1403       break;
1404
1405     case 'h': /* h for help */
1406       if(toggle) {
1407         return PARAM_HELP_REQUESTED;
1408       }
1409       /* we now actually support --no-help too! */
1410       break;
1411     case 'H':
1412       /* A custom header to append to a list */
1413       if(subletter == 'p') /* --proxy-header */
1414         err = add2list(&config->proxyheaders, nextarg);
1415       else
1416         err = add2list(&config->headers, nextarg);
1417       if(err)
1418         return err;
1419       break;
1420     case 'i':
1421       config->include_headers = toggle; /* include the headers as well in the
1422                                            general output stream */
1423       break;
1424     case 'j':
1425       config->cookiesession = toggle;
1426       break;
1427     case 'I':
1428       /*
1429        * no_body will imply include_headers later on
1430        */
1431       config->no_body = toggle;
1432       if(SetHTTPrequest(config,
1433                         (config->no_body)?HTTPREQ_HEAD:HTTPREQ_GET,
1434                         &config->httpreq))
1435         return PARAM_BAD_USE;
1436       break;
1437     case 'J': /* --remote-header-name */
1438       if(config->include_headers) {
1439         warnf(config,
1440               "--include and --remote-header-name cannot be combined.\n");
1441         return PARAM_BAD_USE;
1442       }
1443       config->content_disposition = toggle;
1444       break;
1445     case 'k': /* allow insecure SSL connects */
1446       config->insecure_ok = toggle;
1447       break;
1448     case 'K': /* parse config file */
1449       if(parseconfig(nextarg, global))
1450         warnf(config, "error trying read config from the '%s' file\n",
1451               nextarg);
1452       break;
1453     case 'l':
1454       config->dirlistonly = toggle; /* only list the names of the FTP dir */
1455       break;
1456     case 'L':
1457       config->followlocation = toggle; /* Follow Location: HTTP headers */
1458       switch (subletter) {
1459       case 't':
1460         /* Continue to send authentication (user+password) when following
1461          * locations, even when hostname changed */
1462         config->unrestricted_auth = toggle;
1463         break;
1464       }
1465       break;
1466     case 'm':
1467       /* specified max time */
1468       err = str2udouble(&config->timeout, nextarg);
1469       if(err)
1470         return err;
1471       break;
1472     case 'M': /* M for manual, huge help */
1473       if(toggle) { /* --no-manual shows no manual... */
1474 #ifdef USE_MANUAL
1475         return PARAM_MANUAL_REQUESTED;
1476 #else
1477         warnf(config,
1478               "built-in manual was disabled at build-time!\n");
1479         return PARAM_OPTION_UNKNOWN;
1480 #endif
1481       }
1482       break;
1483     case 'n':
1484       switch(subletter) {
1485       case 'o': /* CA info PEM file */
1486         /* use .netrc or URL */
1487         config->netrc_opt = toggle;
1488         break;
1489       case 'e': /* netrc-file */
1490         GetStr(&config->netrc_file, nextarg);
1491         break;
1492       default:
1493         /* pick info from .netrc, if this is used for http, curl will
1494            automatically enfore user+password with the request */
1495         config->netrc = toggle;
1496         break;
1497       }
1498       break;
1499     case 'N':
1500       /* disable the output I/O buffering. note that the option is called
1501          --buffer but is mostly used in the negative form: --no-buffer */
1502       if(longopt)
1503         config->nobuffer = (!toggle)?TRUE:FALSE;
1504       else
1505         config->nobuffer = toggle;
1506       break;
1507     case 'O': /* --remote-name */
1508       if(subletter == 'a') { /* --remote-name-all */
1509         config->default_node_flags = toggle?GETOUT_USEREMOTE:0;
1510         break;
1511       }
1512       /* fall-through! */
1513     case 'o': /* --output */
1514       /* output file */
1515     {
1516       struct getout *url;
1517       if(config->url_out || ((config->url_out = config->url_list) != NULL)) {
1518         /* there's a node here, if it already is filled-in continue to find
1519            an "empty" node */
1520         while(config->url_out && (config->url_out->flags & GETOUT_OUTFILE))
1521           config->url_out = config->url_out->next;
1522       }
1523
1524       /* now there might or might not be an available node to fill in! */
1525
1526       if(config->url_out)
1527         /* existing node */
1528         url = config->url_out;
1529       else
1530         /* there was no free node, create one! */
1531         url = new_getout(config);
1532
1533       if(!url)
1534         return PARAM_NO_MEM;
1535       else {
1536         /* fill in the outfile */
1537         if('o' == letter) {
1538           GetStr(&url->outfile, nextarg);
1539           url->flags &= ~GETOUT_USEREMOTE; /* switch off */
1540         }
1541         else {
1542           url->outfile = NULL; /* leave it */
1543           if(toggle)
1544             url->flags |= GETOUT_USEREMOTE;  /* switch on */
1545           else
1546             url->flags &= ~GETOUT_USEREMOTE; /* switch off */
1547         }
1548         url->flags |= GETOUT_OUTFILE;
1549       }
1550     }
1551     break;
1552     case 'P':
1553       /* This makes the FTP sessions use PORT instead of PASV */
1554       /* use <eth0> or <192.168.10.10> style addresses. Anything except
1555          this will make us try to get the "default" address.
1556          NOTE: this is a changed behaviour since the released 4.1!
1557       */
1558       GetStr(&config->ftpport, nextarg);
1559       break;
1560     case 'p':
1561       /* proxy tunnel for non-http protocols */
1562       config->proxytunnel = toggle;
1563       break;
1564
1565     case 'q': /* if used first, already taken care of, we do it like
1566                  this so we don't cause an error! */
1567       break;
1568     case 'Q':
1569       /* QUOTE command to send to FTP server */
1570       switch(nextarg[0]) {
1571       case '-':
1572         /* prefixed with a dash makes it a POST TRANSFER one */
1573         nextarg++;
1574         err = add2list(&config->postquote, nextarg);
1575         break;
1576       case '+':
1577         /* prefixed with a plus makes it a just-before-transfer one */
1578         nextarg++;
1579         err = add2list(&config->prequote, nextarg);
1580         break;
1581       default:
1582         err = add2list(&config->quote, nextarg);
1583         break;
1584       }
1585       if(err)
1586         return err;
1587       break;
1588     case 'r':
1589       /* Specifying a range WITHOUT A DASH will create an illegal HTTP range
1590          (and won't actually be range by definition). The man page previously
1591          claimed that to be a good way, why this code is added to work-around
1592          it. */
1593       if(ISDIGIT(*nextarg) && !strchr(nextarg, '-')) {
1594         char buffer[32];
1595         curl_off_t off;
1596         warnf(config,
1597               "A specified range MUST include at least one dash (-). "
1598               "Appending one for you!\n");
1599         off = curlx_strtoofft(nextarg, NULL, 10);
1600         snprintf(buffer, sizeof(buffer), "%" CURL_FORMAT_CURL_OFF_T "-", off);
1601         Curl_safefree(config->range);
1602         config->range = strdup(buffer);
1603         if(!config->range)
1604           return PARAM_NO_MEM;
1605       }
1606       {
1607         /* byte range requested */
1608         char *tmp_range;
1609         tmp_range = nextarg;
1610         while(*tmp_range != '\0') {
1611           if(!ISDIGIT(*tmp_range) && *tmp_range != '-' && *tmp_range != ',') {
1612             warnf(config,"Invalid character is found in given range. "
1613                   "A specified range MUST have only digits in "
1614                   "\'start\'-\'stop\'. The server's response to this "
1615                   "request is uncertain.\n");
1616             break;
1617           }
1618           tmp_range++;
1619         }
1620         /* byte range requested */
1621         GetStr(&config->range, nextarg);
1622       }
1623       break;
1624     case 'R':
1625       /* use remote file's time */
1626       config->remote_time = toggle;
1627       break;
1628     case 's':
1629       /* don't show progress meter, don't show errors : */
1630       if(toggle)
1631         global->mute = global->noprogress = TRUE;
1632       else
1633         global->mute = global->noprogress = FALSE;
1634       if(global->showerror < 0)
1635         /* if still on the default value, set showerror to the reverse of
1636            toggle. This is to allow -S and -s to be used in an independent
1637            order but still have the same effect. */
1638         global->showerror = (!toggle)?TRUE:FALSE; /* toggle off */
1639       break;
1640     case 'S':
1641       /* show errors */
1642       global->showerror = toggle?1:0; /* toggle on if used with -s */
1643       break;
1644     case 't':
1645       /* Telnet options */
1646       err = add2list(&config->telnet_options, nextarg);
1647       if(err)
1648         return err;
1649       break;
1650     case 'T':
1651       /* we are uploading */
1652     {
1653       struct getout *url;
1654       if(config->url_out || ((config->url_out = config->url_list) != NULL)) {
1655         /* there's a node here, if it already is filled-in continue to find
1656            an "empty" node */
1657         while(config->url_out && (config->url_out->flags & GETOUT_UPLOAD))
1658           config->url_out = config->url_out->next;
1659       }
1660
1661       /* now there might or might not be an available node to fill in! */
1662
1663       if(config->url_out)
1664         /* existing node */
1665         url = config->url_out;
1666       else
1667         /* there was no free node, create one! */
1668         url = new_getout(config);
1669
1670       if(!url)
1671         return PARAM_NO_MEM;
1672       else {
1673         url->flags |= GETOUT_UPLOAD; /* mark -T used */
1674         if(!*nextarg)
1675           url->flags |= GETOUT_NOUPLOAD;
1676         else {
1677           /* "-" equals stdin, but keep the string around for now */
1678           GetStr(&url->infile, nextarg);
1679         }
1680       }
1681     }
1682     break;
1683     case 'u':
1684       /* user:password  */
1685       GetStr(&config->userpwd, nextarg);
1686       cleanarg(nextarg);
1687       break;
1688     case 'U':
1689       /* Proxy user:password  */
1690       GetStr(&config->proxyuserpwd, nextarg);
1691       cleanarg(nextarg);
1692       break;
1693     case 'v':
1694       if(toggle) {
1695         /* the '%' thing here will cause the trace get sent to stderr */
1696         Curl_safefree(global->trace_dump);
1697         global->trace_dump = strdup("%");
1698         if(!global->trace_dump)
1699           return PARAM_NO_MEM;
1700         if(global->tracetype && (global->tracetype != TRACE_PLAIN))
1701           warnf(config,
1702                 "-v, --verbose overrides an earlier trace/verbose option\n");
1703         global->tracetype = TRACE_PLAIN;
1704       }
1705       else
1706         /* verbose is disabled here */
1707         global->tracetype = TRACE_NONE;
1708       break;
1709     case 'V':
1710       if(toggle)    /* --no-version yields no output! */
1711         return PARAM_VERSION_INFO_REQUESTED;
1712       break;
1713
1714     case 'w':
1715       /* get the output string */
1716       if('@' == *nextarg) {
1717         /* the data begins with a '@' letter, it means that a file name
1718            or - (stdin) follows */
1719         FILE *file;
1720         const char *fname;
1721         nextarg++; /* pass the @ */
1722         if(curlx_strequal("-", nextarg)) {
1723           fname = "<stdin>";
1724           file = stdin;
1725         }
1726         else {
1727           fname = nextarg;
1728           file = fopen(nextarg, "r");
1729         }
1730         err = file2string(&config->writeout, file);
1731         if(file && (file != stdin))
1732           fclose(file);
1733         if(err)
1734           return err;
1735         if(!config->writeout)
1736           warnf(config, "Failed to read %s", fname);
1737       }
1738       else
1739         GetStr(&config->writeout, nextarg);
1740       break;
1741     case 'x':
1742       /* proxy */
1743       GetStr(&config->proxy, nextarg);
1744       config->proxyver = CURLPROXY_HTTP;
1745       break;
1746     case 'X':
1747       /* set custom request */
1748       GetStr(&config->customrequest, nextarg);
1749       break;
1750     case 'y':
1751       /* low speed time */
1752       err = str2unum(&config->low_speed_time, nextarg);
1753       if(err)
1754         return err;
1755       if(!config->low_speed_limit)
1756         config->low_speed_limit = 1;
1757       break;
1758     case 'Y':
1759       /* low speed limit */
1760       err = str2unum(&config->low_speed_limit, nextarg);
1761       if(err)
1762         return err;
1763       if(!config->low_speed_time)
1764         config->low_speed_time = 30;
1765       break;
1766     case 'z': /* time condition coming up */
1767       switch(*nextarg) {
1768       case '+':
1769         nextarg++;
1770         /* FALLTHROUGH */
1771       default:
1772         /* If-Modified-Since: (section 14.28 in RFC2068) */
1773         config->timecond = CURL_TIMECOND_IFMODSINCE;
1774         break;
1775       case '-':
1776         /* If-Unmodified-Since:  (section 14.24 in RFC2068) */
1777         config->timecond = CURL_TIMECOND_IFUNMODSINCE;
1778         nextarg++;
1779         break;
1780       case '=':
1781         /* Last-Modified:  (section 14.29 in RFC2068) */
1782         config->timecond = CURL_TIMECOND_LASTMOD;
1783         nextarg++;
1784         break;
1785       }
1786       now = time(NULL);
1787       config->condtime=curl_getdate(nextarg, &now);
1788       if(-1 == (int)config->condtime) {
1789         /* now let's see if it is a file name to get the time from instead! */
1790         struct_stat statbuf;
1791         if(-1 == stat(nextarg, &statbuf)) {
1792           /* failed, remove time condition */
1793           config->timecond = CURL_TIMECOND_NONE;
1794           warnf(config,
1795                 "Illegal date format for -z, --timecond (and not "
1796                 "a file name). Disabling time condition. "
1797                 "See curl_getdate(3) for valid date syntax.\n");
1798         }
1799         else {
1800           /* pull the time out from the file */
1801           config->condtime = statbuf.st_mtime;
1802         }
1803       }
1804       break;
1805     default: /* unknown flag */
1806       return PARAM_OPTION_UNKNOWN;
1807     }
1808     hit = -1;
1809
1810   } while(!longopt && !singleopt && *++parse && !*usedarg);
1811
1812   return PARAM_OK;
1813 }
1814
1815 ParameterError parse_args(struct GlobalConfig *config, int argc,
1816                           argv_item_t argv[])
1817 {
1818   int i;
1819   bool stillflags;
1820   char *orig_opt = NULL;
1821   ParameterError result = PARAM_OK;
1822   struct OperationConfig *operation = config->first;
1823
1824   for(i = 1, stillflags = TRUE; i < argc && !result; i++) {
1825     orig_opt = argv[i];
1826
1827     if(stillflags && ('-' == argv[i][0])) {
1828       char *nextarg;
1829       bool passarg;
1830       char *flag = argv[i];
1831
1832       if(curlx_strequal("--", argv[i]))
1833         /* This indicates the end of the flags and thus enables the
1834            following (URL) argument to start with -. */
1835         stillflags = FALSE;
1836       else {
1837         nextarg = (i < (argc - 1)) ? argv[i + 1] : NULL;
1838
1839         result = getparameter(flag, nextarg, &passarg, config, operation);
1840         if(result == PARAM_NEXT_OPERATION) {
1841           /* Reset result as PARAM_NEXT_OPERATION is only used here and not
1842              returned from this function */
1843           result = PARAM_OK;
1844
1845           if(operation->url_list && operation->url_list->url) {
1846             /* Allocate the next config */
1847             operation->next = malloc(sizeof(struct OperationConfig));
1848             if(operation->next) {
1849               /* Initialise the newly created config */
1850               config_init(operation->next);
1851
1852               /* Copy the easy handle */
1853               operation->next->easy = config->easy;
1854
1855               /* Set the global config pointer */
1856               operation->next->global = config;
1857
1858               /* Update the last operation pointer */
1859               config->last = operation->next;
1860
1861               /* Move onto the new config */
1862               operation->next->prev = operation;
1863               operation = operation->next;
1864             }
1865             else
1866               result = PARAM_NO_MEM;
1867           }
1868         }
1869         else if(!result && passarg)
1870           i++; /* we're supposed to skip this */
1871       }
1872     }
1873     else {
1874       bool used;
1875
1876       /* Just add the URL please */
1877       result = getparameter((char *)"--url", argv[i], &used, config,
1878                             operation);
1879     }
1880   }
1881
1882   if(result && result != PARAM_HELP_REQUESTED &&
1883      result != PARAM_MANUAL_REQUESTED &&
1884      result != PARAM_VERSION_INFO_REQUESTED &&
1885      result != PARAM_ENGINES_REQUESTED) {
1886     const char *reason = param2text(result);
1887
1888     if(orig_opt && !curlx_strequal(":", orig_opt))
1889       helpf(config->errors, "option %s: %s\n", orig_opt, reason);
1890     else
1891       helpf(config->errors, "%s\n", reason);
1892   }
1893
1894   return result;
1895 }