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