luna - curl/src/tool

   1/***************************************************************************
   2 *                                  _   _ ____  _
   3 *  Project                     ___| | | |  _ \| |
   4 *                             / __| | | | |_) | |
   5 *                            | (__| |_| |  _ <| |___
   6 *                             \___|\___/|_| \_\_____|
   7 *
   8 * Copyright (C) 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.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 * SPDX-License-Identifier: curl
  22 *
  23 ***************************************************************************/
  24#include "tool_setup.h"
  25
  26#include "tool_cfgable.h"
  27#include "tool_cb_prg.h"
  28#include "tool_filetime.h"
  29#include "tool_formparse.h"
  30#include "tool_getparam.h"
  31#include "tool_helpers.h"
  32#include "tool_libinfo.h"
  33#include "tool_msgs.h"
  34#include "tool_paramhlp.h"
  35#include "tool_parsecfg.h"
  36#include "tool_main.h"
  37#include "tool_stderr.h"
  38#include "tool_help.h"
  39#include "var.h"
  40
  41#define ALLOW_BLANK TRUE
  42#define DENY_BLANK  FALSE
  43
  44static ParameterError getstr(char **str, const char *val, bool allowblank)
  45{
  46  if(*str) {
  47    curlx_free(*str);
  48    *str = NULL;
  49  }
  50  DEBUGASSERT(val);
  51  if(!allowblank && !val[0])
  52    return PARAM_BLANK_STRING;
  53
  54  *str = curlx_strdup(val);
  55  if(!*str)
  56    return PARAM_NO_MEM;
  57
  58  return PARAM_OK;
  59}
  60
  61static ParameterError getstrn(char **str, const char *val,
  62                              size_t len, bool allowblank)
  63{
  64  if(*str) {
  65    curlx_free(*str);
  66    *str = NULL;
  67  }
  68  DEBUGASSERT(val);
  69  if(!allowblank && !val[0])
  70    return PARAM_BLANK_STRING;
  71
  72  *str = curlx_memdup0(val, len);
  73  if(!*str)
  74    return PARAM_NO_MEM;
  75
  76  return PARAM_OK;
  77}
  78
  79/* this array MUST be alphasorted based on the 'lname' */
  80static const struct LongShort aliases[]= {
  81  {"abstract-unix-socket",       ARG_FILE, ' ', C_ABSTRACT_UNIX_SOCKET},
  82  {"alpn",                       ARG_BOOL|ARG_NO|ARG_TLS, ' ', C_ALPN},
  83  {"alt-svc",                    ARG_STRG, ' ', C_ALT_SVC},
  84  {"anyauth",                    ARG_NONE, ' ', C_ANYAUTH},
  85  {"append",                     ARG_BOOL, 'a', C_APPEND},
  86  {"aws-sigv4",                  ARG_STRG, ' ', C_AWS_SIGV4},
  87  {"basic",                      ARG_BOOL, ' ', C_BASIC},
  88  {"buffer",                     ARG_BOOL|ARG_NO, 'N', C_BUFFER},
  89  {"ca-native",                  ARG_BOOL|ARG_TLS, ' ', C_CA_NATIVE},
  90  {"cacert",                     ARG_FILE|ARG_TLS, ' ', C_CACERT},
  91  {"capath",                     ARG_FILE|ARG_TLS, ' ', C_CAPATH},
  92  {"cert",                       ARG_FILE|ARG_TLS|ARG_CLEAR, 'E', C_CERT},
  93  {"cert-status",                ARG_BOOL|ARG_TLS, ' ', C_CERT_STATUS},
  94  {"cert-type",                  ARG_STRG|ARG_TLS, ' ', C_CERT_TYPE},
  95  {"ciphers",                    ARG_STRG|ARG_TLS, ' ', C_CIPHERS},
  96  {"clobber",                    ARG_BOOL|ARG_NO, ' ', C_CLOBBER},
  97  {"compressed",                 ARG_BOOL, ' ', C_COMPRESSED},
  98  {"compressed-ssh",             ARG_BOOL, ' ', C_COMPRESSED_SSH},
  99  {"config",                     ARG_FILE, 'K', C_CONFIG},
 100  {"connect-timeout",            ARG_SECS, ' ', C_CONNECT_TIMEOUT},
 101  {"connect-to",                 ARG_STRG, ' ', C_CONNECT_TO},
 102  {"continue-at",                ARG_STRG, 'C', C_CONTINUE_AT},
 103  {"cookie",                     ARG_STRG, 'b', C_COOKIE},
 104  {"cookie-jar",                 ARG_STRG, 'c', C_COOKIE_JAR},
 105  {"create-dirs",                ARG_BOOL, ' ', C_CREATE_DIRS},
 106  {"create-file-mode",           ARG_STRG, ' ', C_CREATE_FILE_MODE},
 107  {"crlf",                       ARG_BOOL, ' ', C_CRLF},
 108  {"crlfile",                    ARG_FILE|ARG_TLS, ' ', C_CRLFILE},
 109  {"curves",                     ARG_STRG|ARG_TLS, ' ', C_CURVES},
 110  {"data",                       ARG_STRG, 'd', C_DATA},
 111  {"data-ascii",                 ARG_STRG, ' ', C_DATA_ASCII},
 112  {"data-binary",                ARG_STRG, ' ', C_DATA_BINARY},
 113  {"data-raw",                   ARG_STRG, ' ', C_DATA_RAW},
 114  {"data-urlencode",             ARG_STRG, ' ', C_DATA_URLENCODE},
 115  {"delegation",                 ARG_STRG, ' ', C_DELEGATION},
 116  {"digest",                     ARG_BOOL, ' ', C_DIGEST},
 117  {"disable",                    ARG_BOOL, 'q', C_DISABLE},
 118  {"disable-eprt",               ARG_BOOL, ' ', C_DISABLE_EPRT},
 119  {"disable-epsv",               ARG_BOOL, ' ', C_DISABLE_EPSV},
 120  {"disallow-username-in-url",   ARG_BOOL, ' ', C_DISALLOW_USERNAME_IN_URL},
 121  {"dns-interface",              ARG_STRG, ' ', C_DNS_INTERFACE},
 122  {"dns-ipv4-addr",              ARG_STRG, ' ', C_DNS_IPV4_ADDR},
 123  {"dns-ipv6-addr",              ARG_STRG, ' ', C_DNS_IPV6_ADDR},
 124  {"dns-servers",                ARG_STRG, ' ', C_DNS_SERVERS},
 125  {"doh-cert-status",            ARG_BOOL|ARG_TLS, ' ', C_DOH_CERT_STATUS},
 126  {"doh-insecure",               ARG_BOOL|ARG_TLS, ' ', C_DOH_INSECURE},
 127  {"doh-url",                    ARG_STRG, ' ', C_DOH_URL},
 128  {"dump-ca-embed",              ARG_NONE|ARG_TLS, ' ', C_DUMP_CA_EMBED},
 129  {"dump-header",                ARG_FILE, 'D', C_DUMP_HEADER},
 130  {"ech",                        ARG_STRG|ARG_TLS, ' ', C_ECH},
 131  {"egd-file",                   ARG_STRG|ARG_DEPR, ' ', C_EGD_FILE},
 132  {"engine",                     ARG_STRG|ARG_TLS, ' ', C_ENGINE},
 133  {"eprt",                       ARG_BOOL, ' ', C_EPRT},
 134  {"epsv",                       ARG_BOOL, ' ', C_EPSV},
 135  {"etag-compare",               ARG_FILE, ' ', C_ETAG_COMPARE},
 136  {"etag-save",                  ARG_FILE, ' ', C_ETAG_SAVE},
 137  {"expect100-timeout",          ARG_SECS, ' ', C_EXPECT100_TIMEOUT},
 138  {"fail",                       ARG_BOOL, 'f', C_FAIL},
 139  {"fail-early",                 ARG_BOOL, ' ', C_FAIL_EARLY},
 140  {"fail-with-body",             ARG_BOOL, ' ', C_FAIL_WITH_BODY},
 141  {"false-start",                ARG_BOOL, ' ', C_FALSE_START},
 142  {"follow",                     ARG_BOOL, ' ', C_FOLLOW},
 143  {"form",                       ARG_STRG, 'F', C_FORM},
 144  {"form-escape",                ARG_BOOL, ' ', C_FORM_ESCAPE},
 145  {"form-string",                ARG_STRG, ' ', C_FORM_STRING},
 146  {"ftp-account",                ARG_STRG, ' ', C_FTP_ACCOUNT},
 147  {"ftp-alternative-to-user",    ARG_STRG, ' ', C_FTP_ALTERNATIVE_TO_USER},
 148  {"ftp-create-dirs",            ARG_BOOL, ' ', C_FTP_CREATE_DIRS},
 149  {"ftp-method",                 ARG_STRG, ' ', C_FTP_METHOD},
 150  {"ftp-pasv",                   ARG_NONE, ' ', C_FTP_PASV},
 151  {"ftp-port",                   ARG_STRG, 'P', C_FTP_PORT},
 152  {"ftp-pret",                   ARG_BOOL, ' ', C_FTP_PRET},
 153  {"ftp-skip-pasv-ip",           ARG_BOOL, ' ', C_FTP_SKIP_PASV_IP},
 154  {"ftp-ssl",                    ARG_BOOL|ARG_TLS, ' ', C_FTP_SSL},
 155  {"ftp-ssl-ccc",                ARG_BOOL|ARG_TLS, ' ', C_FTP_SSL_CCC},
 156  {"ftp-ssl-ccc-mode",           ARG_STRG|ARG_TLS, ' ', C_FTP_SSL_CCC_MODE},
 157  {"ftp-ssl-control",            ARG_BOOL|ARG_TLS, ' ', C_FTP_SSL_CONTROL},
 158  {"ftp-ssl-reqd",               ARG_BOOL|ARG_TLS, ' ', C_FTP_SSL_REQD},
 159  {"get",                        ARG_BOOL, 'G', C_GET},
 160  {"globoff",                    ARG_BOOL, 'g', C_GLOBOFF},
 161  {"happy-eyeballs-timeout-ms",  ARG_UNUM, ' ', C_HAPPY_EYEBALLS_TIMEOUT_MS},
 162  {"haproxy-clientip",           ARG_STRG, ' ', C_HAPROXY_CLIENTIP},
 163  {"haproxy-protocol",           ARG_BOOL, ' ', C_HAPROXY_PROTOCOL},
 164  {"head",                       ARG_BOOL, 'I', C_HEAD},
 165  {"header",                     ARG_STRG, 'H', C_HEADER},
 166  {"help",                       ARG_STRG, 'h', C_HELP},
 167  {"hostpubmd5",                 ARG_STRG, ' ', C_HOSTPUBMD5},
 168  {"hostpubsha256",              ARG_STRG, ' ', C_HOSTPUBSHA256},
 169  {"hsts",                       ARG_STRG|ARG_TLS, ' ', C_HSTS},
 170  {"http0.9",                    ARG_BOOL, ' ', C_HTTP0_9},
 171  {"http1.0",                    ARG_NONE, '0', C_HTTP1_0},
 172  {"http1.1",                    ARG_NONE, ' ', C_HTTP1_1},
 173  {"http2",                      ARG_NONE, ' ', C_HTTP2},
 174  {"http2-prior-knowledge",      ARG_NONE, ' ', C_HTTP2_PRIOR_KNOWLEDGE},
 175  {"http3",                      ARG_NONE|ARG_TLS, ' ', C_HTTP3},
 176  {"http3-only",                 ARG_NONE|ARG_TLS, ' ', C_HTTP3_ONLY},
 177  {"ignore-content-length",      ARG_BOOL, ' ', C_IGNORE_CONTENT_LENGTH},
 178  {"include",                    ARG_BOOL, ' ', C_INCLUDE},
 179  {"insecure",                   ARG_BOOL, 'k', C_INSECURE},
 180  {"interface",                  ARG_STRG, ' ', C_INTERFACE},
 181  {"ip-tos",                     ARG_STRG, ' ', C_IP_TOS},
 182#ifndef CURL_DISABLE_IPFS
 183  {"ipfs-gateway",               ARG_STRG, ' ', C_IPFS_GATEWAY},
 184#endif
 185  {"ipv4",                       ARG_NONE, '4', C_IPV4},
 186  {"ipv6",                       ARG_NONE, '6', C_IPV6},
 187  {"json",                       ARG_STRG, ' ', C_JSON},
 188  {"junk-session-cookies",       ARG_BOOL, 'j', C_JUNK_SESSION_COOKIES},
 189  {"keepalive",                  ARG_BOOL|ARG_NO, ' ', C_KEEPALIVE},
 190  {"keepalive-cnt",              ARG_UNUM, ' ', C_KEEPALIVE_CNT},
 191  {"keepalive-time",             ARG_UNUM, ' ', C_KEEPALIVE_TIME},
 192  {"key",                        ARG_FILE, ' ', C_KEY},
 193  {"key-type",                   ARG_STRG|ARG_TLS, ' ', C_KEY_TYPE},
 194  {"knownhosts",                 ARG_FILE, ' ', C_KNOWNHOSTS},
 195  {"krb",                        ARG_STRG|ARG_DEPR, ' ', C_KRB},
 196  {"krb4",                       ARG_STRG|ARG_DEPR, ' ', C_KRB4},
 197  {"libcurl",                    ARG_STRG, ' ', C_LIBCURL},
 198  {"limit-rate",                 ARG_STRG, ' ', C_LIMIT_RATE},
 199  {"list-only",                  ARG_BOOL, 'l', C_LIST_ONLY},
 200  {"local-port",                 ARG_STRG, ' ', C_LOCAL_PORT},
 201  {"location",                   ARG_BOOL, 'L', C_LOCATION},
 202  {"location-trusted",           ARG_BOOL, ' ', C_LOCATION_TRUSTED},
 203  {"login-options",              ARG_STRG, ' ', C_LOGIN_OPTIONS},
 204  {"mail-auth",                  ARG_STRG, ' ', C_MAIL_AUTH},
 205  {"mail-from",                  ARG_STRG, ' ', C_MAIL_FROM},
 206  {"mail-rcpt",                  ARG_STRG, ' ', C_MAIL_RCPT},
 207  {"mail-rcpt-allowfails",       ARG_BOOL, ' ', C_MAIL_RCPT_ALLOWFAILS},
 208  {"manual",                     ARG_BOOL, 'M', C_MANUAL},
 209  {"max-filesize",               ARG_STRG, ' ', C_MAX_FILESIZE},
 210  {"max-redirs",                 ARG_STRG, ' ', C_MAX_REDIRS},
 211  {"max-time",                   ARG_SECS, 'm', C_MAX_TIME},
 212  {"metalink",                   ARG_BOOL|ARG_DEPR, ' ', C_METALINK},
 213  {"mptcp",                      ARG_BOOL, ' ', C_MPTCP},
 214  {"negotiate",                  ARG_BOOL, ' ', C_NEGOTIATE},
 215  {"netrc",                      ARG_BOOL, 'n', C_NETRC},
 216  {"netrc-file",                 ARG_FILE, ' ', C_NETRC_FILE},
 217  {"netrc-optional",             ARG_BOOL, ' ', C_NETRC_OPTIONAL},
 218  {"next",                       ARG_NONE, ':', C_NEXT},
 219  {"noproxy",                    ARG_STRG, ' ', C_NOPROXY},
 220  {"npn",                        ARG_BOOL|ARG_DEPR, ' ', C_NPN},
 221  {"ntlm",                       ARG_BOOL, ' ', C_NTLM},
 222  {"ntlm-wb",                    ARG_BOOL|ARG_DEPR, ' ', C_NTLM_WB},
 223  {"oauth2-bearer",              ARG_STRG|ARG_CLEAR, ' ', C_OAUTH2_BEARER},
 224  {"out-null",                   ARG_BOOL, ' ', C_OUT_NULL},
 225  {"output",                     ARG_FILE, 'o', C_OUTPUT},
 226  {"output-dir",                 ARG_STRG, ' ', C_OUTPUT_DIR},
 227  {"parallel",                   ARG_BOOL, 'Z', C_PARALLEL},
 228  {"parallel-immediate",         ARG_BOOL, ' ', C_PARALLEL_IMMEDIATE},
 229  {"parallel-max",               ARG_UNUM, ' ', C_PARALLEL_MAX},
 230  {"parallel-max-host",          ARG_UNUM, ' ', C_PARALLEL_HOST},
 231  {"pass",                       ARG_STRG|ARG_CLEAR, ' ', C_PASS},
 232  {"path-as-is",                 ARG_BOOL, ' ', C_PATH_AS_IS},
 233  {"pinnedpubkey",               ARG_STRG|ARG_TLS, ' ', C_PINNEDPUBKEY},
 234  {"post301",                    ARG_BOOL, ' ', C_POST301},
 235  {"post302",                    ARG_BOOL, ' ', C_POST302},
 236  {"post303",                    ARG_BOOL, ' ', C_POST303},
 237  {"preproxy",                   ARG_STRG, ' ', C_PREPROXY},
 238  {"progress-bar",               ARG_BOOL, '#', C_PROGRESS_BAR},
 239  {"progress-meter",             ARG_BOOL|ARG_NO, ' ', C_PROGRESS_METER},
 240  {"proto",                      ARG_STRG, ' ', C_PROTO},
 241  {"proto-default",              ARG_STRG, ' ', C_PROTO_DEFAULT},
 242  {"proto-redir",                ARG_STRG, ' ', C_PROTO_REDIR},
 243  {"proxy",                      ARG_STRG, 'x', C_PROXY},
 244  {"proxy-anyauth",              ARG_BOOL, ' ', C_PROXY_ANYAUTH},
 245  {"proxy-basic",                ARG_BOOL, ' ', C_PROXY_BASIC},
 246  {"proxy-ca-native",            ARG_BOOL|ARG_TLS, ' ', C_PROXY_CA_NATIVE},
 247  {"proxy-cacert",               ARG_FILE|ARG_TLS, ' ', C_PROXY_CACERT},
 248  {"proxy-capath",               ARG_FILE|ARG_TLS, ' ', C_PROXY_CAPATH},
 249  {"proxy-cert",                 ARG_FILE|ARG_TLS|ARG_CLEAR, ' ',
 250   C_PROXY_CERT},
 251  {"proxy-cert-type",            ARG_STRG|ARG_TLS, ' ', C_PROXY_CERT_TYPE},
 252  {"proxy-ciphers",              ARG_STRG|ARG_TLS, ' ', C_PROXY_CIPHERS},
 253  {"proxy-crlfile",              ARG_FILE|ARG_TLS, ' ', C_PROXY_CRLFILE},
 254  {"proxy-digest",               ARG_BOOL, ' ', C_PROXY_DIGEST},
 255  {"proxy-header",               ARG_STRG, ' ', C_PROXY_HEADER},
 256  {"proxy-http2",                ARG_BOOL, ' ', C_PROXY_HTTP2},
 257  {"proxy-insecure",             ARG_BOOL, ' ', C_PROXY_INSECURE},
 258  {"proxy-key",                  ARG_FILE|ARG_TLS, ' ', C_PROXY_KEY},
 259  {"proxy-key-type",             ARG_STRG|ARG_TLS, ' ', C_PROXY_KEY_TYPE},
 260  {"proxy-negotiate",            ARG_BOOL, ' ', C_PROXY_NEGOTIATE},
 261  {"proxy-ntlm",                 ARG_BOOL, ' ', C_PROXY_NTLM},
 262  {"proxy-pass",                 ARG_STRG|ARG_CLEAR, ' ', C_PROXY_PASS},
 263  {"proxy-pinnedpubkey",         ARG_STRG|ARG_TLS, ' ', C_PROXY_PINNEDPUBKEY},
 264  {"proxy-service-name",         ARG_STRG, ' ', C_PROXY_SERVICE_NAME},
 265  {"proxy-ssl-allow-beast",      ARG_BOOL|ARG_TLS, ' ',
 266   C_PROXY_SSL_ALLOW_BEAST},
 267  {"proxy-ssl-auto-client-cert", ARG_BOOL|ARG_TLS, ' ',
 268   C_PROXY_SSL_AUTO_CLIENT_CERT},
 269  {"proxy-tls13-ciphers",        ARG_STRG|ARG_TLS, ' ', C_PROXY_TLS13_CIPHERS},
 270  {"proxy-tlsauthtype",          ARG_STRG|ARG_TLS, ' ', C_PROXY_TLSAUTHTYPE},
 271  {"proxy-tlspassword",  ARG_STRG|ARG_TLS|ARG_CLEAR, ' ', C_PROXY_TLSPASSWORD},
 272  {"proxy-tlsuser",          ARG_STRG|ARG_TLS|ARG_CLEAR, ' ', C_PROXY_TLSUSER},
 273  {"proxy-tlsv1",                ARG_NONE|ARG_TLS, ' ', C_PROXY_TLSV1},
 274  {"proxy-user",                 ARG_STRG|ARG_CLEAR, 'U', C_PROXY_USER},
 275  {"proxy1.0",                   ARG_STRG, ' ', C_PROXY1_0},
 276  {"proxytunnel",                ARG_BOOL, 'p', C_PROXYTUNNEL},
 277  {"pubkey",                     ARG_STRG, ' ', C_PUBKEY},
 278  {"quote",                      ARG_STRG, 'Q', C_QUOTE},
 279  {"random-file",                ARG_FILE|ARG_DEPR, ' ', C_RANDOM_FILE},
 280  {"range",                      ARG_STRG, 'r', C_RANGE},
 281  {"rate",                       ARG_STRG, ' ', C_RATE},
 282  {"raw",                        ARG_BOOL, ' ', C_RAW},
 283  {"referer",                    ARG_STRG, 'e', C_REFERER},
 284  {"remote-header-name",         ARG_BOOL, 'J', C_REMOTE_HEADER_NAME},
 285  {"remote-name",                ARG_BOOL, 'O', C_REMOTE_NAME},
 286  {"remote-name-all",            ARG_BOOL, ' ', C_REMOTE_NAME_ALL},
 287  {"remote-time",                ARG_BOOL, 'R', C_REMOTE_TIME},
 288  {"remove-on-error",            ARG_BOOL, ' ', C_REMOVE_ON_ERROR},
 289  {"request",                    ARG_STRG, 'X', C_REQUEST},
 290  {"request-target",             ARG_STRG, ' ', C_REQUEST_TARGET},
 291  {"resolve",                    ARG_STRG, ' ', C_RESOLVE},
 292  {"retry",                      ARG_UNUM, ' ', C_RETRY},
 293  {"retry-all-errors",           ARG_BOOL, ' ', C_RETRY_ALL_ERRORS},
 294  {"retry-connrefused",          ARG_BOOL, ' ', C_RETRY_CONNREFUSED},
 295  {"retry-delay",                ARG_SECS, ' ', C_RETRY_DELAY},
 296  {"retry-max-time",             ARG_SECS, ' ', C_RETRY_MAX_TIME},
 297  {"sasl-authzid",               ARG_STRG, ' ', C_SASL_AUTHZID},
 298  {"sasl-ir",                    ARG_BOOL, ' ', C_SASL_IR},
 299  {"service-name",               ARG_STRG, ' ', C_SERVICE_NAME},
 300  {"sessionid",                  ARG_BOOL|ARG_NO, ' ', C_SESSIONID},
 301  {"show-error",                 ARG_BOOL, 'S', C_SHOW_ERROR},
 302  {"show-headers",               ARG_BOOL, 'i', C_SHOW_HEADERS},
 303  {"sigalgs",                    ARG_STRG|ARG_TLS, ' ',
 304   C_SIGNATURE_ALGORITHMS},
 305  {"silent",                     ARG_BOOL, 's', C_SILENT},
 306  {"skip-existing",              ARG_BOOL, ' ', C_SKIP_EXISTING},
 307  {"socks4",                     ARG_STRG, ' ', C_SOCKS4},
 308  {"socks4a",                    ARG_STRG, ' ', C_SOCKS4A},
 309  {"socks5",                     ARG_STRG, ' ', C_SOCKS5},
 310  {"socks5-basic",               ARG_BOOL, ' ', C_SOCKS5_BASIC},
 311  {"socks5-gssapi",              ARG_BOOL, ' ', C_SOCKS5_GSSAPI},
 312  {"socks5-gssapi-nec",          ARG_BOOL, ' ', C_SOCKS5_GSSAPI_NEC},
 313  {"socks5-gssapi-service",      ARG_STRG, ' ', C_SOCKS5_GSSAPI_SERVICE},
 314  {"socks5-hostname",            ARG_STRG, ' ', C_SOCKS5_HOSTNAME},
 315  {"speed-limit",                ARG_UNUM, 'Y', C_SPEED_LIMIT},
 316  {"speed-time",                 ARG_UNUM, 'y', C_SPEED_TIME},
 317  {"ssl",                        ARG_BOOL|ARG_TLS, ' ', C_SSL},
 318  {"ssl-allow-beast",            ARG_BOOL|ARG_TLS, ' ', C_SSL_ALLOW_BEAST},
 319  {"ssl-auto-client-cert",       ARG_BOOL|ARG_TLS, ' ',
 320   C_SSL_AUTO_CLIENT_CERT},
 321  {"ssl-no-revoke",              ARG_BOOL|ARG_TLS, ' ', C_SSL_NO_REVOKE},
 322  {"ssl-reqd",                   ARG_BOOL|ARG_TLS, ' ', C_SSL_REQD},
 323  {"ssl-revoke-best-effort",     ARG_BOOL|ARG_TLS, ' ',
 324   C_SSL_REVOKE_BEST_EFFORT},
 325  {"ssl-sessions",               ARG_FILE|ARG_TLS, ' ', C_SSL_SESSIONS},
 326  {"sslv2",                      ARG_NONE|ARG_DEPR, '2', C_SSLV2},
 327  {"sslv3",                      ARG_NONE|ARG_DEPR, '3', C_SSLV3},
 328  {"stderr",                     ARG_FILE, ' ', C_STDERR},
 329  {"styled-output",              ARG_BOOL, ' ', C_STYLED_OUTPUT},
 330  {"suppress-connect-headers",   ARG_BOOL, ' ', C_SUPPRESS_CONNECT_HEADERS},
 331  {"tcp-fastopen",               ARG_BOOL, ' ', C_TCP_FASTOPEN},
 332  {"tcp-nodelay",                ARG_BOOL, ' ', C_TCP_NODELAY},
 333  {"telnet-option",              ARG_STRG, 't', C_TELNET_OPTION},
 334#ifdef DEBUGBUILD
 335  {"test-duphandle",             ARG_BOOL, ' ', C_TEST_DUPHANDLE},
 336  {"test-event",                 ARG_BOOL, ' ', C_TEST_EVENT},
 337#endif
 338  {"tftp-blksize",               ARG_UNUM, ' ', C_TFTP_BLKSIZE},
 339  {"tftp-no-options",            ARG_BOOL, ' ', C_TFTP_NO_OPTIONS},
 340  {"time-cond",                  ARG_STRG, 'z', C_TIME_COND},
 341  {"tls-earlydata",              ARG_BOOL|ARG_TLS, ' ', C_TLS_EARLYDATA},
 342  {"tls-max",                    ARG_STRG|ARG_TLS, ' ', C_TLS_MAX},
 343  {"tls13-ciphers",              ARG_STRG|ARG_TLS, ' ', C_TLS13_CIPHERS},
 344  {"tlsauthtype",                ARG_STRG|ARG_TLS, ' ', C_TLSAUTHTYPE},
 345  {"tlspassword",              ARG_STRG|ARG_TLS|ARG_CLEAR, ' ', C_TLSPASSWORD},
 346  {"tlsuser",                    ARG_STRG|ARG_TLS|ARG_CLEAR, ' ', C_TLSUSER},
 347  {"tlsv1",                      ARG_NONE|ARG_TLS, '1', C_TLSV1},
 348  {"tlsv1.0",                    ARG_NONE|ARG_TLS, ' ', C_TLSV1_0},
 349  {"tlsv1.1",                    ARG_NONE|ARG_TLS, ' ', C_TLSV1_1},
 350  {"tlsv1.2",                    ARG_NONE|ARG_TLS, ' ', C_TLSV1_2},
 351  {"tlsv1.3",                    ARG_NONE|ARG_TLS, ' ', C_TLSV1_3},
 352  {"tr-encoding",                ARG_BOOL, ' ', C_TR_ENCODING},
 353  {"trace",                      ARG_FILE, ' ', C_TRACE},
 354  {"trace-ascii",                ARG_FILE, ' ', C_TRACE_ASCII},
 355  {"trace-config",               ARG_STRG, ' ', C_TRACE_CONFIG},
 356  {"trace-ids",                  ARG_BOOL, ' ', C_TRACE_IDS},
 357  {"trace-time",                 ARG_BOOL, ' ', C_TRACE_TIME},
 358  {"unix-socket",                ARG_FILE, ' ', C_UNIX_SOCKET},
 359  {"upload-file",                ARG_FILE, 'T', C_UPLOAD_FILE},
 360  {"upload-flags",               ARG_STRG, ' ', C_UPLOAD_FLAGS},
 361  {"url",                        ARG_STRG, ' ', C_URL},
 362  {"url-query",                  ARG_STRG, ' ', C_URL_QUERY},
 363  {"use-ascii",                  ARG_BOOL, 'B', C_USE_ASCII},
 364  {"user",                       ARG_STRG|ARG_CLEAR, 'u', C_USER},
 365  {"user-agent",                 ARG_STRG, 'A', C_USER_AGENT},
 366  {"variable",                   ARG_STRG, ' ', C_VARIABLE},
 367  {"verbose",                    ARG_BOOL, 'v', C_VERBOSE},
 368  {"version",                    ARG_BOOL, 'V', C_VERSION},
 369  {"vlan-priority",              ARG_UNUM, ' ', C_VLAN_PRIORITY},
 370#ifdef USE_WATT32
 371  {"wdebug",                     ARG_BOOL, ' ', C_WDEBUG},
 372#endif
 373  {"write-out",                  ARG_STRG, 'w', C_WRITE_OUT},
 374  {"xattr",                      ARG_BOOL, ' ', C_XATTR},
 375};
 376
 377/* Split the argument of -E to 'certname' and 'passphrase' separated by colon.
 378 * We allow ':' and '\' to be escaped by '\' so that we can use certificate
 379 * nicknames containing ':'. See <https://sourceforge.net/p/curl/bugs/1196/>
 380 * for details.
 381 *
 382 * Unit test 1394
 383 */
 384UNITTEST ParameterError parse_cert_parameter(const char *cert_parameter,
 385                                             char **certname,
 386                                             char **passphrase)
 387{
 388  size_t param_length = strlen(cert_parameter);
 389  size_t span;
 390  const char *param_place = NULL;
 391  char *certname_place = NULL;
 392  ParameterError err = PARAM_OK;
 393  *certname = NULL;
 394  *passphrase = NULL;
 395
 396  /* most trivial assumption: cert_parameter is empty */
 397  if(param_length == 0)
 398    return PARAM_BLANK_STRING;
 399
 400  /* next less trivial: cert_parameter starts 'pkcs11:' and thus
 401   * looks like a RFC7512 PKCS#11 URI which can be used as-is.
 402   * Also if cert_parameter contains no colon nor backslash, this
 403   * means no passphrase was given and no characters escaped */
 404  if(curl_strnequal(cert_parameter, "pkcs11:", 7) ||
 405     !strpbrk(cert_parameter, ":\\")) {
 406    *certname = curlx_strdup(cert_parameter);
 407    if(!*certname)
 408      return PARAM_NO_MEM;
 409    return PARAM_OK;
 410  }
 411  /* deal with escaped chars; find unescaped colon if it exists */
 412  certname_place = curlx_malloc(param_length + 1);
 413  if(!certname_place) {
 414    err = PARAM_NO_MEM;
 415    goto done;
 416  }
 417
 418  *certname = certname_place;
 419  param_place = cert_parameter;
 420  while(*param_place) {
 421    span = strcspn(param_place, ":\\");
 422    memcpy(certname_place, param_place, span);
 423    param_place += span;
 424    certname_place += span;
 425    /* we ate all the non-special chars. now we are on either a special
 426     * char or the end of the string. */
 427    switch(*param_place) {
 428    case '\0':
 429      break;
 430    case '\\':
 431      param_place++;
 432      switch(*param_place) {
 433      case '\0':
 434        *certname_place++ = '\\';
 435        break;
 436      case '\\':
 437        *certname_place++ = '\\';
 438        param_place++;
 439        break;
 440      case ':':
 441        *certname_place++ = ':';
 442        param_place++;
 443        break;
 444      default:
 445        *certname_place++ = '\\';
 446        *certname_place++ = *param_place;
 447        param_place++;
 448        break;
 449      }
 450      break;
 451    case ':':
 452      /* Since we live in a world of weirdness and confusion, the Windows
 453         dudes can use : when using drive letters and thus c:\file:password
 454         needs to work. In order not to break compatibility, we still use : as
 455         separator, but we try to detect when it is used for a filename! On
 456         Windows. */
 457#ifdef _WIN32
 458      if((param_place == &cert_parameter[1]) &&
 459         (cert_parameter[2] == '\\' || cert_parameter[2] == '/') &&
 460         ISALPHA(cert_parameter[0])) {
 461        /* colon in the second column, followed by a backslash, and the
 462           first character is an alphabetic letter:
 463
 464           this is a drive letter colon */
 465        *certname_place++ = ':';
 466        param_place++;
 467        break;
 468      }
 469#endif
 470      /* escaped colons and Windows drive letter colons were handled
 471       * above; if we are still here, this is a separating colon */
 472      param_place++;
 473      if(*param_place) {
 474        *passphrase = curlx_strdup(param_place);
 475        if(!*passphrase)
 476          err = PARAM_NO_MEM;
 477      }
 478      goto done;
 479    }
 480  }
 481done:
 482  if(err) {
 483    curlx_safefree(*certname);
 484  }
 485  else
 486    *certname_place = '\0';
 487  return err;
 488}
 489
 490/* Replace (in-place) '%20' by '+' according to RFC1866 */
 491static size_t replace_url_encoded_space_by_plus(char *url)
 492{
 493  size_t orig_len = strlen(url);
 494  size_t orig_index = 0;
 495  size_t new_index = 0;
 496
 497  while(orig_index < orig_len) {
 498    if((url[orig_index] == '%') &&
 499       (url[orig_index + 1] == '2') &&
 500       (url[orig_index + 2] == '0')) {
 501      url[new_index] = '+';
 502      orig_index += 3;
 503    }
 504    else {
 505      if(new_index != orig_index) {
 506        url[new_index] = url[orig_index];
 507      }
 508      orig_index++;
 509    }
 510    new_index++;
 511  }
 512
 513  url[new_index] = 0; /* terminate string */
 514
 515  return new_index; /* new size */
 516}
 517
 518static ParameterError GetFileAndPassword(const char *nextarg, char **file,
 519                                         char **password)
 520{
 521  char *certname, *passphrase;
 522  ParameterError err;
 523  /* nextarg is never NULL here */
 524  err = parse_cert_parameter(nextarg, &certname, &passphrase);
 525  if(!err) {
 526    curlx_free(*file);
 527    *file = certname;
 528    if(passphrase) {
 529      curlx_free(*password);
 530      *password = passphrase;
 531    }
 532  }
 533  return err;
 534}
 535
 536struct sizeunit {
 537  char unit; /* single lowercase ASCII letter */
 538  curl_off_t mul;
 539  size_t mlen; /* number of digits in 'mul', when written in decimal */
 540};
 541
 542static const struct sizeunit *getunit(char unit)
 543{
 544  static const struct sizeunit list[] = {
 545    {'p', (curl_off_t)1125899906842624, 16 }, /* Peta */
 546    {'t', (curl_off_t)1099511627776,    13 }, /* Tera */
 547    {'g', 1073741824,                   10 }, /* Giga */
 548    {'m', 1048576,                       7 }, /* Mega */
 549    {'k', 1024,                          4 }, /* Kilo */
 550  };
 551
 552  size_t i;
 553  for(i = 0; i < CURL_ARRAYSIZE(list); i++)
 554    if((unit | 0x20) == list[i].unit)
 555      return &list[i];
 556  return NULL;
 557}
 558
 559/* Get a size parameter for '--limit-rate' or '--max-filesize'.
 560   We support P, T, G, M and K (case insensitive) suffixes.
 561
 562   Unit test 1623
 563 */
 564UNITTEST ParameterError GetSizeParameter(const char *arg, curl_off_t *out)
 565{
 566  const char *unit = arg;
 567  curl_off_t value;
 568  curl_off_t prec = 0;
 569  size_t plen = 0;
 570  curl_off_t add = 0;
 571  curl_off_t mul = 1;
 572  int rc;
 573
 574  rc = curlx_str_number(&unit, &value, CURL_OFF_T_MAX);
 575  if(rc == STRE_OVERFLOW)
 576    return PARAM_NUMBER_TOO_LARGE;
 577  else if(rc)
 578    return PARAM_BAD_NUMERIC;
 579
 580  if(!curlx_str_single(&unit, '.')) {
 581    const char *s = unit;
 582    if(curlx_str_number(&unit, &prec, CURL_OFF_T_MAX))
 583      return PARAM_BAD_NUMERIC;
 584    plen = unit - s;
 585  }
 586
 587  if(strlen(unit) > 1)
 588    return PARAM_BAD_USE;
 589  else if(!*unit || ((*unit | 0x20) == 'b')) {
 590    if(plen)
 591      /* cannot handle partial bytes */
 592      return PARAM_BAD_USE;
 593  }
 594  else {
 595    const struct sizeunit *su = getunit(*unit);
 596    if(!su)
 597      return PARAM_BAD_USE;
 598    mul = su->mul;
 599
 600    if(prec) {
 601      /* precision was provided */
 602      curl_off_t frac = 1;
 603
 604      /* too many precision digits, trim them */
 605      while(su->mlen <= plen) {
 606        prec /= 10;
 607        plen--;
 608      }
 609
 610      while(plen--)
 611        frac *= 10;
 612
 613      if((CURL_OFF_T_MAX / mul) > prec)
 614        add = mul * prec / frac;
 615      else
 616        add = (mul / frac) * prec;
 617    }
 618  }
 619  if(value > ((CURL_OFF_T_MAX - add) / mul))
 620    return PARAM_NUMBER_TOO_LARGE;
 621
 622  *out = (value * mul) + add;
 623  return PARAM_OK;
 624}
 625
 626#ifdef HAVE_WRITABLE_ARGV
 627static void cleanarg(char *str)
 628{
 629  /* now that getstr has copied the contents of nextarg, wipe the next
 630   * argument out so that the username:password is not displayed in the
 631   * system process list */
 632  if(str) {
 633    size_t len = strlen(str);
 634    memset(str, '*', len);
 635  }
 636}
 637#else
 638#define cleanarg(x) tool_nop_stmt
 639#endif
 640
 641/* the maximum size we allow the dynbuf generated string */
 642#define MAX_DATAURLENCODE (500 * 1024 * 1024)
 643
 644/* --data-urlencode */
 645static ParameterError data_urlencode(const char *nextarg,
 646                                     char **postp,
 647                                     size_t *lenp)
 648{
 649  /* [name]=[content], we encode the content part only
 650   * [name]@[filename]
 651   *
 652   * Case 2: we first load the file using that name and then encode
 653   * the content.
 654   */
 655  ParameterError err;
 656  const char *p = strchr(nextarg, '=');
 657  size_t nlen;
 658  char is_file;
 659  char *postdata = NULL;
 660  size_t size = 0;
 661  if(!p)
 662    /* there was no '=' letter, check for a '@' instead */
 663    p = strchr(nextarg, '@');
 664  if(p) {
 665    nlen = p - nextarg; /* length of the name part */
 666    is_file = *p++; /* pass the separator */
 667  }
 668  else {
 669    /* neither @ nor =, so no name and it is not a file */
 670    nlen = 0;
 671    is_file = 0;
 672    p = nextarg;
 673  }
 674  if('@' == is_file) {
 675    FILE *file;
 676    /* a '@' letter, it means that a filename or - (stdin) follows */
 677    if(!strcmp("-", p)) {
 678      file = stdin;
 679      CURL_BINMODE(stdin);
 680    }
 681    else {
 682      file = curlx_fopen(p, "rb");
 683      if(!file) {
 684        errorf("Failed to open %s", p);
 685        return PARAM_READ_ERROR;
 686      }
 687    }
 688
 689    err = file2memory(&postdata, &size, file);
 690
 691    if(file && (file != stdin))
 692      curlx_fclose(file);
 693    if(err)
 694      return err;
 695  }
 696  else {
 697    err = getstr(&postdata, p, ALLOW_BLANK);
 698    if(err)
 699      goto error;
 700    size = strlen(postdata);
 701  }
 702
 703  if(!postdata) {
 704    /* no data from the file, point to a zero byte string to make this
 705       get sent as a POST anyway */
 706    postdata = curlx_strdup("");
 707    if(!postdata)
 708      return PARAM_NO_MEM;
 709    size = 0;
 710  }
 711  else {
 712    char *enc = curl_easy_escape(NULL, postdata, (int)size);
 713    curlx_safefree(postdata); /* no matter if it worked or not */
 714    if(enc) {
 715      char *n;
 716      replace_url_encoded_space_by_plus(enc);
 717      if(nlen > 0) { /* only append '=' if we have a name */
 718        struct dynbuf dyn;
 719        curlx_dyn_init(&dyn, MAX_DATAURLENCODE);
 720        if(curlx_dyn_addn(&dyn, nextarg, nlen) ||
 721           curlx_dyn_addn(&dyn, "=", 1) ||
 722           curlx_dyn_add(&dyn, enc)) {
 723          curl_free(enc);
 724          return PARAM_NO_MEM;
 725        }
 726        curl_free(enc);
 727        n = curlx_dyn_ptr(&dyn);
 728        size = curlx_dyn_len(&dyn);
 729      }
 730      else {
 731        /* make sure we return "our memory" */
 732        n = curlx_strdup(enc);
 733        curl_free(enc);
 734        if(!n)
 735          return PARAM_NO_MEM;
 736        size = strlen(n);
 737      }
 738      postdata = n;
 739    }
 740    else
 741      return PARAM_NO_MEM;
 742  }
 743  *postp = postdata;
 744  *lenp = size;
 745  return PARAM_OK;
 746error:
 747  return err;
 748}
 749
 750static void sethttpver(struct OperationConfig *config, long httpversion)
 751{
 752  if(config->httpversion &&
 753     (config->httpversion != httpversion))
 754    warnf("Overrides previous HTTP version option");
 755
 756  config->httpversion = httpversion;
 757}
 758
 759static CURLcode set_trace_config(const char *token)
 760{
 761  CURLcode result = CURLE_OK;
 762  const char *next, *name;
 763  bool toggle;
 764
 765  while(token) {
 766    size_t len;
 767    next = strchr(token, ',');
 768
 769    if(next)
 770      len = next - token;
 771    else
 772      len = strlen(token);
 773
 774    switch(*token) {
 775    case '-':
 776      toggle = FALSE;
 777      name = token + 1;
 778      len--;
 779      break;
 780    case '+':
 781      toggle = TRUE;
 782      name = token + 1;
 783      len--;
 784      break;
 785    default:
 786      toggle = TRUE;
 787      name = token;
 788      break;
 789    }
 790
 791    if((len == 3) && curl_strnequal(name, "all", 3)) {
 792      global->traceids = toggle;
 793      global->tracetime = toggle;
 794      if(toggle)
 795        result = curl_global_trace("all,-lib-ids");
 796      else
 797        result = curl_global_trace(token);
 798      if(result)
 799        goto out;
 800    }
 801    else if((len == 3) && curl_strnequal(name, "ids", 3)) {
 802      global->traceids = toggle;
 803    }
 804    else if((len == 4) && curl_strnequal(name, "time", 4)) {
 805      global->tracetime = toggle;
 806    }
 807    else {
 808      char buffer[64];
 809      curl_msnprintf(buffer, sizeof(buffer), "%c%.*s,-lib-ids",
 810                     toggle ? '+' : '-', (int)len, name);
 811      result = curl_global_trace(buffer);
 812      if(result)
 813        goto out;
 814    }
 815    if(next) {
 816      next++;
 817      if(*next == ' ')
 818        next++;
 819    }
 820    token = next;
 821  }
 822out:
 823  return result;
 824}
 825
 826static int findarg(const void *a, const void *b)
 827{
 828  const struct LongShort *aa = a;
 829  const struct LongShort *bb = b;
 830  return strcmp(aa->lname, bb->lname);
 831}
 832
 833const struct LongShort *findshortopt(char letter)
 834{
 835  static const struct LongShort *singles[128 - ' ']; /* ASCII => pointer */
 836  static bool singles_done = FALSE;
 837  if((letter >= 127) || (letter <= ' '))
 838    return NULL;
 839
 840  if(!singles_done) {
 841    unsigned int j;
 842    for(j = 0; j < CURL_ARRAYSIZE(aliases); j++) {
 843      if(aliases[j].letter != ' ') {
 844        unsigned char l = (unsigned char)aliases[j].letter;
 845        singles[l - ' '] = &aliases[j];
 846      }
 847    }
 848    singles_done = TRUE;
 849  }
 850  return singles[letter - ' '];
 851}
 852
 853struct TOSEntry {
 854  const char *name;
 855  unsigned char value;
 856};
 857
 858static const struct TOSEntry tos_entries[] = {
 859  { "AF11", 0x28 },
 860  { "AF12", 0x30 },
 861  { "AF13", 0x38 },
 862  { "AF21", 0x48 },
 863  { "AF22", 0x50 },
 864  { "AF23", 0x58 },
 865  { "AF31", 0x68 },
 866  { "AF32", 0x70 },
 867  { "AF33", 0x78 },
 868  { "AF41", 0x88 },
 869  { "AF42", 0x90 },
 870  { "AF43", 0x98 },
 871  { "CE",   0x03 },
 872  { "CS0",  0x00 },
 873  { "CS1",  0x20 },
 874  { "CS2",  0x40 },
 875  { "CS3",  0x60 },
 876  { "CS4",  0x80 },
 877  { "CS5",  0xa0 },
 878  { "CS6",  0xc0 },
 879  { "CS7",  0xe0 },
 880  { "ECT0", 0x02 },
 881  { "ECT1", 0x01 },
 882  { "EF",   0xb8 },
 883  { "LE",   0x04 },
 884  { "LOWCOST",     0x02 },
 885  { "LOWDELAY",    0x10 },
 886  { "MINCOST",     0x02 },
 887  { "RELIABILITY", 0x04 },
 888  { "THROUGHPUT",  0x08 },
 889  { "VOICE-ADMIT", 0xb0 }
 890};
 891
 892static int find_tos(const void *a, const void *b)
 893{
 894  const struct TOSEntry *aa = a;
 895  const struct TOSEntry *bb = b;
 896  return strcmp(aa->name, bb->name);
 897}
 898
 899#define MAX_QUERY_LEN 100000 /* larger is not likely to ever work */
 900static ParameterError url_query(const char *nextarg,
 901                                struct OperationConfig *config)
 902{
 903  size_t size = 0;
 904  ParameterError err = PARAM_OK;
 905  char *query;
 906  struct dynbuf dyn;
 907  curlx_dyn_init(&dyn, MAX_QUERY_LEN);
 908
 909  if(*nextarg == '+') {
 910    /* use without encoding */
 911    query = curlx_strdup(&nextarg[1]);
 912    if(!query)
 913      err = PARAM_NO_MEM;
 914  }
 915  else
 916    err = data_urlencode(nextarg, &query, &size);
 917
 918  if(!err) {
 919    if(config->query) {
 920      CURLcode result = curlx_dyn_addf(&dyn, "%s&%s", config->query, query);
 921      curlx_free(query);
 922      if(result)
 923        err = PARAM_NO_MEM;
 924      else {
 925        curlx_free(config->query);
 926        config->query = curlx_dyn_ptr(&dyn);
 927      }
 928    }
 929    else
 930      config->query = query;
 931  }
 932  return err;
 933}
 934
 935static ParameterError set_data(cmdline_t cmd,
 936                               const char *nextarg,
 937                               struct OperationConfig *config)
 938{
 939  char *postdata = NULL;
 940  FILE *file;
 941  size_t size = 0;
 942  ParameterError err = PARAM_OK;
 943
 944  if(cmd == C_DATA_URLENCODE) { /* --data-urlencode */
 945    err = data_urlencode(nextarg, &postdata, &size);
 946    if(err)
 947      return err;
 948  }
 949  else if('@' == *nextarg && (cmd != C_DATA_RAW)) {
 950    /* the data begins with a '@' letter, it means that a filename
 951       or - (stdin) follows */
 952    nextarg++; /* pass the @ */
 953
 954    if(!strcmp("-", nextarg)) {
 955      file = stdin;
 956      if(cmd == C_DATA_BINARY) /* forced data-binary */
 957        CURL_BINMODE(stdin);
 958    }
 959    else {
 960      file = curlx_fopen(nextarg, "rb");
 961      if(!file) {
 962        errorf("Failed to open %s", nextarg);
 963        return PARAM_READ_ERROR;
 964      }
 965    }
 966
 967    if((cmd == C_DATA_BINARY) || /* --data-binary */
 968       (cmd == C_JSON) /* --json */)
 969      /* forced binary */
 970      err = file2memory(&postdata, &size, file);
 971    else {
 972      err = file2string(&postdata, file);
 973      if(postdata)
 974        size = strlen(postdata);
 975    }
 976
 977    if(file && (file != stdin))
 978      curlx_fclose(file);
 979    if(err)
 980      return err;
 981
 982    if(!postdata) {
 983      /* no data from the file, point to a zero byte string to make this
 984         get sent as a POST anyway */
 985      postdata = curlx_strdup("");
 986      if(!postdata)
 987        return PARAM_NO_MEM;
 988    }
 989  }
 990  else {
 991    err = getstr(&postdata, nextarg, ALLOW_BLANK);
 992    if(err)
 993      return err;
 994    size = strlen(postdata);
 995  }
 996  if(cmd == C_JSON)
 997    config->jsoned = TRUE;
 998
 999  if(curlx_dyn_len(&config->postdata)) {
1000    /* skip separator append for --json */
1001    if(!err && (cmd != C_JSON) &&
1002       curlx_dyn_addn(&config->postdata, "&", 1))
1003      err = PARAM_NO_MEM;
1004  }
1005
1006  if(!err && curlx_dyn_addn(&config->postdata, postdata, size))
1007    err = PARAM_NO_MEM;
1008
1009  curlx_safefree(postdata);
1010
1011  config->postfields = curlx_dyn_ptr(&config->postdata);
1012  return err;
1013}
1014
1015static ParameterError set_rate(const char *nextarg)
1016{
1017  /* --rate */
1018  /* support a few different suffixes, extract the suffix first, then
1019     get the number and convert to per hour.
1020     /s == per second
1021     /m == per minute
1022     /h == per hour (default)
1023     /d == per day (24 hours)
1024   */
1025  ParameterError err = PARAM_OK;
1026  const char *p = nextarg;
1027  curl_off_t denominator;
1028  curl_off_t numerator = 60 * 60 * 1000; /* default per hour */
1029
1030  if(curlx_str_number(&p, &denominator, CURL_OFF_T_MAX))
1031    return PARAM_BAD_NUMERIC;
1032
1033  if(denominator < 1)
1034    return PARAM_BAD_USE;
1035
1036  if(!curlx_str_single(&p, '/')) {
1037    curl_off_t numunits;
1038
1039    if(curlx_str_number(&p, &numunits, CURL_OFF_T_MAX))
1040      numunits = 1;
1041
1042    switch(*p) {
1043    case 's': /* per second */
1044      numerator = 1000;
1045      break;
1046    case 'm': /* per minute */
1047      numerator = 60 * 1000;
1048      break;
1049    case 'h': /* per hour */
1050      break;
1051    case 'd': /* per day */
1052      numerator = 24 * 60 * 60 * 1000;
1053      break;
1054    default:
1055      errorf("unsupported --rate unit");
1056      err = PARAM_BAD_USE;
1057      break;
1058    }
1059
1060    if((CURL_OFF_T_MAX / numerator) < numunits) {
1061      /* overflow, too large number */
1062      errorf("too large --rate unit");
1063      err = PARAM_NUMBER_TOO_LARGE;
1064    }
1065    else
1066      /* this typecast is okay based on the check above */
1067      numerator *= numunits;
1068  }
1069
1070  if(err)
1071    ;
1072  else if(denominator > numerator)
1073    err = PARAM_NUMBER_TOO_LARGE;
1074  else
1075    global->ms_per_transfer = numerator / denominator;
1076
1077  return err;
1078}
1079
1080const struct LongShort *findlongopt(const char *opt)
1081{
1082  struct LongShort key;
1083  key.lname = opt;
1084
1085  return bsearch(&key, aliases, CURL_ARRAYSIZE(aliases),
1086                 sizeof(aliases[0]), findarg);
1087}
1088
1089static ParameterError add_url(struct OperationConfig *config,
1090                              const char *thisurl,
1091                              bool remote_noglob)
1092{
1093  ParameterError err = PARAM_OK;
1094  struct getout *url;
1095
1096  if(!config->url_get)
1097    config->url_get = config->url_list;
1098
1099  if(config->url_get) {
1100    /* there is a node here, if it already is filled-in continue to find
1101       an "empty" node */
1102    while(config->url_get && config->url_get->urlset)
1103      config->url_get = config->url_get->next;
1104  }
1105
1106  /* now there might or might not be an available node to fill in! */
1107
1108  if(config->url_get)
1109    /* existing node */
1110    url = config->url_get;
1111  else
1112    /* there was no free node, create one! */
1113    config->url_get = url = new_getout(config);
1114
1115  if(!url)
1116    return PARAM_NO_MEM;
1117  else {
1118    /* fill in the URL */
1119    err = getstr(&url->url, thisurl, DENY_BLANK);
1120    url->urlset = TRUE;
1121    if(remote_noglob)
1122      url->useremote = url->noglob = TRUE;
1123    if(!err && (++config->num_urls > 1) &&
1124       (config->etag_save_file || config->etag_compare_file)) {
1125      errorf("The etag options only work on a single URL");
1126      return PARAM_BAD_USE;
1127    }
1128  }
1129  return err;
1130}
1131
1132static ParameterError parse_url(struct OperationConfig *config,
1133                                const char *nextarg)
1134{
1135  /* nextarg is never NULL here */
1136  if(nextarg[0] == '@') {
1137    /* read URLs from a file, treat all as -O */
1138    struct dynbuf line;
1139    ParameterError err = PARAM_OK;
1140    bool error = FALSE;
1141    bool fromstdin = !strcmp("-", &nextarg[1]);
1142    FILE *f;
1143
1144    if(fromstdin)
1145      f = stdin;
1146    else
1147      f = curlx_fopen(&nextarg[1], FOPEN_READTEXT);
1148    if(f) {
1149      curlx_dyn_init(&line, 8092);
1150      while(my_get_line(f, &line, &error)) {
1151        const char *ptr = curlx_dyn_ptr(&line);
1152        err = add_url(config, ptr, TRUE);
1153        if(err)
1154          break;
1155      }
1156      if(!fromstdin)
1157        curlx_fclose(f);
1158      curlx_dyn_free(&line);
1159      if(error || err)
1160        return PARAM_READ_ERROR;
1161      return PARAM_OK;
1162    }
1163    return PARAM_READ_ERROR; /* file not found */
1164  }
1165  return add_url(config, nextarg, FALSE);
1166}
1167
1168static ParameterError parse_localport(struct OperationConfig *config,
1169                                      const char *nextarg)
1170{
1171  const char *pp = NULL;
1172  const char *p = nextarg;
1173  char buffer[22];
1174  size_t plen = 0;
1175  while(ISDIGIT(*p))
1176    p++;
1177  plen = p - nextarg;
1178  if(*p) {
1179    pp = p;
1180    /* check for ' - [end]' */
1181    if(ISBLANK(*pp))
1182      pp++;
1183    if(*pp != '-')
1184      return PARAM_BAD_USE;
1185    pp++;
1186    if(ISBLANK(*pp))
1187      pp++;
1188  }
1189  curl_msnprintf(buffer, sizeof(buffer), "%.*s", (int)plen, nextarg);
1190  if(str2unummax(&config->localport, buffer, 65535))
1191    return PARAM_BAD_USE;
1192  if(!pp)
1193    config->localportrange = 1; /* default number of ports to try */
1194  else {
1195    if(str2unummax(&config->localportrange, pp, 65535))
1196      return PARAM_BAD_USE;
1197    config->localportrange -= (config->localport - 1);
1198    if(config->localportrange < 1)
1199      return PARAM_BAD_USE;
1200  }
1201  return PARAM_OK;
1202}
1203
1204static ParameterError parse_continue_at(struct OperationConfig *config,
1205                                        const char *nextarg)
1206{
1207  ParameterError err = PARAM_OK;
1208  if(config->range) {
1209    errorf("--continue-at is mutually exclusive with --range");
1210    return PARAM_BAD_USE;
1211  }
1212  if(config->rm_partial) {
1213    errorf("--continue-at is mutually exclusive with --remove-on-error");
1214    return PARAM_BAD_USE;
1215  }
1216  if(config->file_clobber_mode == CLOBBER_NEVER) {
1217    errorf("--continue-at is mutually exclusive with --no-clobber");
1218    return PARAM_BAD_USE;
1219  }
1220  /* This makes us continue an ftp transfer at given position */
1221  if(strcmp(nextarg, "-")) {
1222    err = str2offset(&config->resume_from, nextarg);
1223    config->resume_from_current = FALSE;
1224  }
1225  else {
1226    config->resume_from_current = TRUE;
1227    config->resume_from = 0;
1228  }
1229  config->use_resume = TRUE;
1230  return err;
1231}
1232
1233static ParameterError parse_ech(struct OperationConfig *config,
1234                                const char *nextarg)
1235{
1236  ParameterError err = PARAM_OK;
1237  if(!feature_ech)
1238    err = PARAM_LIBCURL_DOESNT_SUPPORT;
1239  else if(strlen(nextarg) > 4 && curl_strnequal("pn:", nextarg, 3)) {
1240    /* a public_name */
1241    err = getstr(&config->ech_public, nextarg, DENY_BLANK);
1242  }
1243  else if(strlen(nextarg) > 5 && curl_strnequal("ecl:", nextarg, 4)) {
1244    /* an ECHConfigList */
1245    if('@' != *(nextarg + 4)) {
1246      err = getstr(&config->ech_config, nextarg, DENY_BLANK);
1247    }
1248    else {
1249      /* Indirect case: @filename or @- for stdin */
1250      char *tmpcfg = NULL;
1251      FILE *file;
1252
1253      nextarg += 5;        /* skip over 'ecl:@' */
1254      if(!strcmp("-", nextarg)) {
1255        file = stdin;
1256      }
1257      else {
1258        file = curlx_fopen(nextarg, FOPEN_READTEXT);
1259      }
1260      if(!file) {
1261        warnf("Could not read file \"%s\" "
1262              "specified for \"--ech ecl:\" option",
1263              nextarg);
1264        return PARAM_BAD_USE;
1265      }
1266      err = file2string(&tmpcfg, file);
1267      if(file != stdin)
1268        curlx_fclose(file);
1269      if(err)
1270        return err;
1271      {
1272        char *tmp = curl_maprintf("ecl:%s", tmpcfg);
1273        curlx_free(tmpcfg);
1274        if(!tmp)
1275          return PARAM_NO_MEM;
1276        config->ech_config = curlx_strdup(tmp);
1277        curl_free(tmp);
1278        if(!config->ech_config)
1279          return PARAM_NO_MEM;
1280      }
1281    } /* file done */
1282  }
1283  else {
1284    /* Simple case: a string, with a keyword */
1285    err = getstr(&config->ech, nextarg, DENY_BLANK);
1286  }
1287  return err;
1288}
1289
1290static ParameterError parse_header(struct OperationConfig *config,
1291                                   cmdline_t cmd,
1292                                   const char *nextarg)
1293{
1294  ParameterError err = PARAM_OK;
1295
1296  /* A custom header to append to a list */
1297  if(nextarg[0] == '@') {
1298    /* read many headers from a file or stdin */
1299    bool use_stdin = !strcmp(&nextarg[1], "-");
1300    FILE *file = use_stdin ? stdin : curlx_fopen(&nextarg[1], FOPEN_READTEXT);
1301    if(!file) {
1302      errorf("Failed to open %s", &nextarg[1]);
1303      err = PARAM_READ_ERROR;
1304    }
1305    else {
1306      struct dynbuf line;
1307      bool error = FALSE;
1308      curlx_dyn_init(&line, 1024 * 100);
1309      while(my_get_line(file, &line, &error)) {
1310        const char *ptr = curlx_dyn_ptr(&line);
1311        err = add2list(cmd == C_PROXY_HEADER ? /* --proxy-header? */
1312                       &config->proxyheaders :
1313                       &config->headers, ptr);
1314        if(err)
1315          break;
1316      }
1317      if(error)
1318        err = PARAM_READ_ERROR;
1319      curlx_dyn_free(&line);
1320      if(!use_stdin)
1321        curlx_fclose(file);
1322    }
1323  }
1324  else {
1325    if(!strchr(nextarg, ':') && !strchr(nextarg, ';')) {
1326      warnf("The provided %s header '%s' does not look like a header?",
1327            (cmd == C_PROXY_HEADER) ? "proxy" : "HTTP", nextarg);
1328    }
1329    if(cmd == C_PROXY_HEADER) /* --proxy-header */
1330      err = add2list(&config->proxyheaders, nextarg);
1331    else
1332      err = add2list(&config->headers, nextarg);
1333  }
1334  return err;
1335}
1336
1337static ParameterError parse_output(struct OperationConfig *config,
1338                                   const char *nextarg)
1339{
1340  ParameterError err = PARAM_OK;
1341  struct getout *url;
1342
1343  /* output file */
1344  if(!config->url_out)
1345    config->url_out = config->url_list;
1346  if(config->url_out) {
1347    /* there is a node here, if it already is filled-in continue to find
1348       an "empty" node */
1349    while(config->url_out && config->url_out->outset)
1350      config->url_out = config->url_out->next;
1351  }
1352
1353  /* now there might or might not be an available node to fill in! */
1354
1355  if(config->url_out)
1356    /* existing node */
1357    url = config->url_out;
1358  else {
1359    /* there was no free node, create one! */
1360    config->url_out = url = new_getout(config);
1361  }
1362
1363  if(!url)
1364    return PARAM_NO_MEM;
1365
1366  /* fill in the outfile */
1367  if(nextarg)
1368    err = getstr(&url->outfile, nextarg, DENY_BLANK);
1369  else
1370    url->outfile = NULL;
1371  url->useremote = FALSE; /* switch off */
1372  url->outset = TRUE;
1373  url->out_null = !nextarg;
1374  return err;
1375}
1376
1377static ParameterError parse_remote_name(struct OperationConfig *config,
1378                                        bool toggle)
1379{
1380  ParameterError err = PARAM_OK;
1381  struct getout *url;
1382
1383  if(!toggle && !config->remote_name_all)
1384    return err; /* nothing to do */
1385
1386  /* output file */
1387  if(!config->url_out)
1388    config->url_out = config->url_list;
1389  if(config->url_out) {
1390    /* there is a node here, if it already is filled-in continue to find
1391       an "empty" node */
1392    while(config->url_out && config->url_out->outset)
1393      config->url_out = config->url_out->next;
1394  }
1395
1396  /* now there might or might not be an available node to fill in! */
1397
1398  if(config->url_out)
1399    /* existing node */
1400    url = config->url_out;
1401  else {
1402    /* there was no free node, create one! */
1403    config->url_out = url = new_getout(config);
1404  }
1405
1406  if(!url)
1407    return PARAM_NO_MEM;
1408
1409  url->outfile = NULL; /* leave it */
1410  url->useremote = toggle;
1411  url->outset = TRUE;
1412  url->out_null = FALSE;
1413  return PARAM_OK;
1414}
1415
1416static ParameterError parse_quote(struct OperationConfig *config,
1417                                  const char *nextarg)
1418{
1419  ParameterError err = PARAM_OK;
1420
1421  /* QUOTE command to send to FTP server */
1422  switch(nextarg[0]) {
1423  case '-':
1424    /* prefixed with a dash makes it a POST TRANSFER one */
1425    nextarg++;
1426    err = add2list(&config->postquote, nextarg);
1427    break;
1428  case '+':
1429    /* prefixed with a plus makes it an immediately-before-transfer one */
1430    nextarg++;
1431    err = add2list(&config->prequote, nextarg);
1432    break;
1433  default:
1434    err = add2list(&config->quote, nextarg);
1435    break;
1436  }
1437  return err;
1438}
1439
1440static ParameterError parse_range(struct OperationConfig *config,
1441                                  const char *nextarg)
1442{
1443  ParameterError err = PARAM_OK;
1444  curl_off_t value;
1445  const char *orig = nextarg;
1446
1447  if(config->use_resume) {
1448    errorf("--continue-at is mutually exclusive with --range");
1449    return PARAM_BAD_USE;
1450  }
1451  if(!curlx_str_number(&nextarg, &value, CURL_OFF_T_MAX) &&
1452     curlx_str_single(&nextarg, '-')) {
1453    /* Specifying a range WITHOUT A DASH does create an illegal HTTP range
1454       (and does not actually be range by definition). The man page previously
1455       claimed that to be a good way, why this code is added to work-around
1456       it. */
1457    char buffer[32];
1458    warnf("A specified range MUST include at least one dash (-). "
1459          "Appending one for you");
1460    curl_msnprintf(buffer, sizeof(buffer), "%" CURL_FORMAT_CURL_OFF_T "-",
1461                   value);
1462    curlx_free(config->range);
1463    config->range = curlx_strdup(buffer);
1464    if(!config->range)
1465      err = PARAM_NO_MEM;
1466  }
1467  else {
1468    /* byte range requested */
1469    while(*nextarg) {
1470      if(!ISDIGIT(*nextarg) && *nextarg != '-' && *nextarg != ',') {
1471        warnf("Invalid character is found in given range. "
1472              "A specified range MUST have only digits in "
1473              "\'start\'-\'stop\'. The server's response to this "
1474              "request is uncertain.");
1475        break;
1476      }
1477      nextarg++;
1478    }
1479    err = getstr(&config->range, orig, DENY_BLANK);
1480  }
1481  return err;
1482}
1483
1484static ParameterError parse_upload_file(struct OperationConfig *config,
1485                                        const char *nextarg)
1486{
1487  ParameterError err = PARAM_OK;
1488  struct getout *url;
1489
1490  /* we are uploading */
1491  if(!config->url_ul)
1492    config->url_ul = config->url_list;
1493  if(config->url_ul) {
1494    /* there is a node here, if it already is filled-in continue to find
1495       an "empty" node */
1496    while(config->url_ul && config->url_ul->uploadset)
1497      config->url_ul = config->url_ul->next;
1498  }
1499
1500  /* now there might or might not be an available node to fill in! */
1501
1502  if(config->url_ul)
1503    /* existing node */
1504    url = config->url_ul;
1505  else
1506    /* there was no free node, create one! */
1507    config->url_ul = url = new_getout(config);
1508
1509  if(!url)
1510    return PARAM_NO_MEM;
1511
1512  url->uploadset = TRUE; /* mark -T used */
1513  if(!*nextarg)
1514    url->noupload = TRUE;
1515  else {
1516    /* "-" equals stdin, but keep the string around for now */
1517    err = getstr(&url->infile, nextarg, DENY_BLANK);
1518  }
1519  return err;
1520}
1521
1522static size_t verbose_nopts;
1523
1524static ParameterError parse_verbose(bool toggle)
1525{
1526  ParameterError err = PARAM_OK;
1527
1528  /* This option is a super-boolean with side effect when applied
1529   * more than once in the same argument flag, like `-vvv`. */
1530  if(!toggle) {
1531    global->verbosity = 0;
1532    if(set_trace_config("-all"))
1533      err = PARAM_NO_MEM;
1534    global->tracetype = TRACE_NONE;
1535    return err;
1536  }
1537  else if(!verbose_nopts) {
1538    /* first `-v` in an argument resets to base verbosity */
1539    global->verbosity = 0;
1540    if(!global->trace_set && set_trace_config("-all"))
1541      return PARAM_NO_MEM;
1542  }
1543  /* the '%' thing here causes the trace get sent to stderr */
1544  switch(global->verbosity) {
1545  case 0:
1546    global->verbosity = 1;
1547    curlx_free(global->trace_dump);
1548    global->trace_dump = curlx_strdup("%");
1549    if(!global->trace_dump)
1550      err = PARAM_NO_MEM;
1551    else {
1552      if(global->tracetype && (global->tracetype != TRACE_PLAIN))
1553        warnf("-v, --verbose overrides an earlier trace option");
1554      global->tracetype = TRACE_PLAIN;
1555    }
1556    break;
1557  case 1:
1558    global->verbosity = 2;
1559    if(set_trace_config("ids,time,protocol"))
1560      err = PARAM_NO_MEM;
1561    break;
1562  case 2:
1563    global->verbosity = 3;
1564    global->tracetype = TRACE_ASCII;
1565    if(set_trace_config("ssl,read,write"))
1566      err = PARAM_NO_MEM;
1567    break;
1568  case 3:
1569    global->verbosity = 4;
1570    if(set_trace_config("network"))
1571      err = PARAM_NO_MEM;
1572    break;
1573  default:
1574    /* no effect for now */
1575    break;
1576  }
1577  return err;
1578}
1579
1580static ParameterError parse_writeout(struct OperationConfig *config,
1581                                     const char *nextarg)
1582{
1583  ParameterError err = PARAM_OK;
1584
1585  /* get the output string */
1586  if('@' == *nextarg) {
1587    /* the data begins with a '@' letter, it means that a filename
1588       or - (stdin) follows */
1589    FILE *file;
1590    const char *fname;
1591    nextarg++; /* pass the @ */
1592    if(!strcmp("-", nextarg)) {
1593      fname = "<stdin>";
1594      file = stdin;
1595    }
1596    else {
1597      fname = nextarg;
1598      file = curlx_fopen(fname, FOPEN_READTEXT);
1599      if(!file) {
1600        errorf("Failed to open %s", fname);
1601        return PARAM_READ_ERROR;
1602      }
1603    }
1604    curlx_safefree(config->writeout);
1605    err = file2string(&config->writeout, file);
1606    if(file && (file != stdin))
1607      curlx_fclose(file);
1608    if(err)
1609      return err;
1610    if(!config->writeout)
1611      warnf("Failed to read %s", fname);
1612  }
1613  else
1614    err = getstr(&config->writeout, nextarg, ALLOW_BLANK);
1615
1616  return err;
1617}
1618
1619static ParameterError parse_time_cond(struct OperationConfig *config,
1620                                      const char *nextarg)
1621{
1622  ParameterError err = PARAM_OK;
1623
1624  switch(*nextarg) {
1625  case '+':
1626    nextarg++;
1627    FALLTHROUGH();
1628  default:
1629    /* If-Modified-Since: (section 14.28 in RFC2068) */
1630    config->timecond = CURL_TIMECOND_IFMODSINCE;
1631    break;
1632  case '-':
1633    /* If-Unmodified-Since:  (section 14.24 in RFC2068) */
1634    config->timecond = CURL_TIMECOND_IFUNMODSINCE;
1635    nextarg++;
1636    break;
1637  case '=':
1638    /* Last-Modified:  (section 14.29 in RFC2068) */
1639    config->timecond = CURL_TIMECOND_LASTMOD;
1640    nextarg++;
1641    break;
1642  }
1643  config->condtime = (curl_off_t)curl_getdate(nextarg, NULL);
1644  if(config->condtime == -1) {
1645    curl_off_t value;
1646    /* now let's see if it is a filename to get the time from instead! */
1647    int rc = getfiletime(nextarg, &value);
1648    if(!rc)
1649      /* pull the time out from the file */
1650      config->condtime = value;
1651    else {
1652      /* failed, remove time condition */
1653      config->timecond = CURL_TIMECOND_NONE;
1654      warnf("Illegal date format for -z, --time-cond (and not "
1655            "a filename). Disabling time condition. "
1656            "See curl_getdate(3) for valid date syntax.");
1657    }
1658  }
1659  return err;
1660}
1661
1662struct flagmap {
1663  const char *name;
1664  size_t len;
1665  unsigned char flag;
1666};
1667
1668static const struct flagmap flag_table[] = {
1669  { "answered", 8, CURLULFLAG_ANSWERED },
1670  { "deleted",  7, CURLULFLAG_DELETED },
1671  { "draft",    5, CURLULFLAG_DRAFT },
1672  { "flagged",  7, CURLULFLAG_FLAGGED },
1673  { "seen",     4, CURLULFLAG_SEEN },
1674  { NULL,       0, 0 }
1675};
1676
1677static ParameterError parse_upload_flags(struct OperationConfig *config,
1678                                         const char *flag)
1679{
1680  ParameterError err = PARAM_OK;
1681
1682  while(flag) {
1683    bool negate;
1684    const struct flagmap *map;
1685    size_t len;
1686    const char *next = strchr(flag, ','); /* Find next comma or end */
1687    if(next)
1688      len = next - flag;
1689    else
1690      len = strlen(flag);
1691
1692    negate = (*flag == '-');
1693    if(negate) {
1694      flag++;
1695      len--;
1696    }
1697
1698    for(map = flag_table; map->name; map++) {
1699      if((len == map->len) && !strncmp(flag, map->name, map->len)) {
1700        if(negate)
1701          config->upload_flags &= (unsigned char)~map->flag;
1702        else
1703          config->upload_flags |= map->flag;
1704        break;
1705      }
1706    }
1707
1708    if(!map->name) {
1709      err = PARAM_OPTION_UNKNOWN;
1710      break;
1711    }
1712
1713    if(next)
1714      /* move over the comma */
1715      next++;
1716    flag = next;
1717  }
1718
1719  return err;
1720}
1721
1722/* if 'toggle' is TRUE, set the 'bits' in 'modify'.
1723   if 'toggle' is FALSE, clear the 'bits' in 'modify'
1724*/
1725static void togglebit(bool toggle, unsigned long *modify, unsigned long bits)
1726{
1727  if(toggle)
1728    *modify |= bits;
1729  else
1730    *modify &= ~bits;
1731}
1732
1733/* opt_depr is the function that handles ARG_DEPR options */
1734static void opt_depr(const struct LongShort *a)
1735{
1736  warnf("--%s is deprecated and has no function anymore", a->lname);
1737}
1738
1739static ParameterError opt_sslver(struct OperationConfig *config,
1740                                 unsigned char ver)
1741{
1742  if(config->ssl_version_max &&
1743     (config->ssl_version_max < ver)) {
1744    errorf("Minimum TLS version set higher than max");
1745    return PARAM_BAD_USE;
1746  }
1747  config->ssl_version = ver;
1748  return PARAM_OK;
1749}
1750
1751/* opt_none is the function that handles ARG_NONE options */
1752static ParameterError opt_none(struct OperationConfig *config,
1753                               const struct LongShort *a)
1754{
1755  ParameterError err = PARAM_OK;
1756  switch(a->cmd) {
1757  case C_ANYAUTH: /* --anyauth */
1758    config->authtype = CURLAUTH_ANY;
1759    break;
1760  case C_DUMP_CA_EMBED: /* --dump-ca-embed */
1761    return PARAM_CA_EMBED_REQUESTED;
1762  case C_FTP_PASV: /* --ftp-pasv */
1763    curlx_safefree(config->ftpport);
1764    break;
1765
1766  case C_HTTP1_0: /* --http1.0 */
1767    /* HTTP version 1.0 */
1768    sethttpver(config, CURL_HTTP_VERSION_1_0);
1769    break;
1770  case C_HTTP1_1: /* --http1.1 */
1771    /* HTTP version 1.1 */
1772    sethttpver(config, CURL_HTTP_VERSION_1_1);
1773    break;
1774  case C_HTTP2: /* --http2 */
1775    /* HTTP version 2.0 */
1776    if(!feature_http2)
1777      return PARAM_LIBCURL_DOESNT_SUPPORT;
1778    sethttpver(config, CURL_HTTP_VERSION_2_0);
1779    break;
1780  case C_HTTP2_PRIOR_KNOWLEDGE: /* --http2-prior-knowledge */
1781    /* HTTP version 2.0 over clean TCP */
1782    if(!feature_http2)
1783      return PARAM_LIBCURL_DOESNT_SUPPORT;
1784    sethttpver(config, CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE);
1785    break;
1786  case C_HTTP3: /* --http3: */
1787    /* Try HTTP/3, allow fallback */
1788    if(!feature_http3)
1789      return PARAM_LIBCURL_DOESNT_SUPPORT;
1790    else
1791      sethttpver(config, CURL_HTTP_VERSION_3);
1792    break;
1793  case C_HTTP3_ONLY: /* --http3-only */
1794    /* Try HTTP/3 without fallback */
1795    if(!feature_http3)
1796      return PARAM_LIBCURL_DOESNT_SUPPORT;
1797    else
1798      sethttpver(config, CURL_HTTP_VERSION_3ONLY);
1799    break;
1800  case C_TLSV1: /* --tlsv1 */
1801    err = opt_sslver(config, 1);
1802    break;
1803  case C_TLSV1_0: /* --tlsv1.0 */
1804    err = opt_sslver(config, 1);
1805    break;
1806  case C_TLSV1_1: /* --tlsv1.1 */
1807    err = opt_sslver(config, 2);
1808    break;
1809  case C_TLSV1_2: /* --tlsv1.2 */
1810    err = opt_sslver(config, 3);
1811    break;
1812  case C_TLSV1_3: /* --tlsv1.3 */
1813    err = opt_sslver(config, 4);
1814    break;
1815  case C_IPV4: /* --ipv4 */
1816    config->ip_version = CURL_IPRESOLVE_V4;
1817    break;
1818  case C_IPV6: /* --ipv6 */
1819    config->ip_version = CURL_IPRESOLVE_V6;
1820    break;
1821  case C_NEXT: /* --next */
1822    return PARAM_NEXT_OPERATION;
1823  case C_PROXY_TLSV1: /* --proxy-tlsv1 */
1824    /* TLS version 1 for proxy */
1825    config->proxy_ssl_version = CURL_SSLVERSION_TLSv1;
1826    break;
1827  }
1828  return err;
1829}
1830
1831/* opt_bool is the function that handles boolean options */
1832static ParameterError opt_bool(struct OperationConfig *config,
1833                               const struct LongShort *a,
1834                               bool toggle)
1835{
1836  switch(a->cmd) {
1837  case C_ALPN: /* --alpn */
1838    config->noalpn = !toggle;
1839    break;
1840  case C_DISABLE_EPSV: /* --disable-epsv */
1841    config->disable_epsv = toggle;
1842    break;
1843  case C_DISALLOW_USERNAME_IN_URL: /* --disallow-username-in-url */
1844    config->disallow_username_in_url = toggle;
1845    break;
1846  case C_EPSV: /* --epsv */
1847    config->disable_epsv = !toggle;
1848    break;
1849  case C_COMPRESSED: /* --compressed */
1850    if(toggle && !(feature_libz || feature_brotli || feature_zstd))
1851      return PARAM_LIBCURL_DOESNT_SUPPORT;
1852    else
1853      config->encoding = toggle;
1854    break;
1855  case C_TR_ENCODING: /* --tr-encoding */
1856    config->tr_encoding = toggle;
1857    break;
1858  case C_DIGEST: /* --digest */
1859    togglebit(toggle, &config->authtype, CURLAUTH_DIGEST);
1860    break;
1861  case C_FTP_CREATE_DIRS: /* --ftp-create-dirs */
1862    config->ftp_create_dirs = toggle;
1863    break;
1864  case C_CREATE_DIRS: /* --create-dirs */
1865    config->create_dirs = toggle;
1866    break;
1867  case C_PROXY_NTLM: /* --proxy-ntlm */
1868    if(!feature_ntlm)
1869      return PARAM_LIBCURL_DOESNT_SUPPORT;
1870    else
1871      config->proxyntlm = toggle;
1872    break;
1873  case C_CRLF: /* --crlf */
1874    config->crlf = toggle;
1875    break;
1876  case C_HAPROXY_PROTOCOL: /* --haproxy-protocol */
1877    config->haproxy_protocol = toggle;
1878    break;
1879  case C_NEGOTIATE: /* --negotiate */
1880    if(!feature_spnego && toggle)
1881      return PARAM_LIBCURL_DOESNT_SUPPORT;
1882    togglebit(toggle, &config->authtype, CURLAUTH_NEGOTIATE);
1883    break;
1884  case C_NTLM: /* --ntlm */
1885    if(!feature_ntlm && toggle)
1886      return PARAM_LIBCURL_DOESNT_SUPPORT;
1887    togglebit(toggle, &config->authtype, CURLAUTH_NTLM);
1888    break;
1889  case C_OUT_NULL: /* --out-null */
1890    return parse_output(config, NULL);
1891  case C_BASIC: /* --basic */
1892    togglebit(toggle, &config->authtype, CURLAUTH_BASIC);
1893    break;
1894#ifdef USE_WATT32
1895  case C_WDEBUG: /* --wdebug */
1896    dbug_init();
1897    break;
1898#endif
1899  case C_DISABLE_EPRT: /* --disable-eprt */
1900    config->disable_eprt = toggle;
1901    break;
1902  case C_EPRT: /* --eprt */
1903    config->disable_eprt = !toggle;
1904    break;
1905  case C_XATTR: /* --xattr */
1906    config->xattr = toggle;
1907    break;
1908  case C_FTP_SSL: /* --ftp-ssl */
1909  case C_SSL: /* --ssl */
1910    config->ftp_ssl = toggle;
1911    if(config->ftp_ssl)
1912      warnf("--%s is an insecure option, consider --ssl-reqd instead",
1913            a->lname);
1914    break;
1915  case C_FTP_SSL_CCC: /* --ftp-ssl-ccc */
1916    config->ftp_ssl_ccc = toggle;
1917    if(!config->ftp_ssl_ccc_mode)
1918      config->ftp_ssl_ccc_mode = CURLFTPSSL_CCC_PASSIVE;
1919    break;
1920  case C_TCP_NODELAY: /* --tcp-nodelay */
1921    config->tcp_nodelay = toggle;
1922    break;
1923  case C_PROXY_DIGEST: /* --proxy-digest */
1924    config->proxydigest = toggle;
1925    break;
1926  case C_PROXY_BASIC: /* --proxy-basic */
1927    config->proxybasic = toggle;
1928    break;
1929  case C_RETRY_CONNREFUSED: /* --retry-connrefused */
1930    config->retry_connrefused = toggle;
1931    break;
1932  case C_RETRY_ALL_ERRORS: /* --retry-all-errors */
1933    config->retry_all_errors = toggle;
1934    break;
1935  case C_PROXY_NEGOTIATE: /* --proxy-negotiate */
1936    if(!feature_spnego)
1937      return PARAM_LIBCURL_DOESNT_SUPPORT;
1938    else
1939      config->proxynegotiate = toggle;
1940    break;
1941  case C_FORM_ESCAPE: /* --form-escape */
1942    togglebit(toggle, &config->mime_options, CURLMIMEOPT_FORMESCAPE);
1943    break;
1944  case C_PROXY_ANYAUTH: /* --proxy-anyauth */
1945    config->proxyanyauth = toggle;
1946    break;
1947  case C_TRACE_TIME: /* --trace-time */
1948    global->tracetime = toggle;
1949    break;
1950  case C_IGNORE_CONTENT_LENGTH: /* --ignore-content-length */
1951    config->ignorecl = toggle;
1952    break;
1953  case C_FTP_SKIP_PASV_IP: /* --ftp-skip-pasv-ip */
1954    config->ftp_skip_ip = toggle;
1955    break;
1956  case C_FTP_SSL_REQD: /* --ftp-ssl-reqd */
1957  case C_SSL_REQD: /* --ssl-reqd */
1958    config->ftp_ssl_reqd = toggle;
1959    break;
1960  case C_SESSIONID: /* --sessionid */
1961    config->disable_sessionid = !toggle;
1962    break;
1963  case C_FTP_SSL_CONTROL: /* --ftp-ssl-control */
1964    config->ftp_ssl_control = toggle;
1965    break;
1966  case C_RAW: /* --raw */
1967    config->raw = toggle;
1968    break;
1969  case C_KEEPALIVE: /* --keepalive */
1970    config->nokeepalive = !toggle;
1971    break;
1972  case C_POST301: /* --post301 */
1973    config->post301 = toggle;
1974    break;
1975  case C_POST302: /* --post302 */
1976    config->post302 = toggle;
1977    break;
1978  case C_POST303: /* --post303 */
1979    config->post303 = toggle;
1980    break;
1981  case C_SOCKS5_GSSAPI_NEC: /* --socks5-gssapi-nec */
1982    config->socks5_gssapi_nec = toggle;
1983    break;
1984  case C_FTP_PRET: /* --ftp-pret */
1985    config->ftp_pret = toggle;
1986    break;
1987  case C_SASL_IR: /* --sasl-ir */
1988    config->sasl_ir = toggle;
1989    break;
1990#ifdef DEBUGBUILD
1991  case C_TEST_DUPHANDLE: /* --test-duphandle */
1992    global->test_duphandle = toggle;
1993    break;
1994  case C_TEST_EVENT: /* --test-event */
1995    global->test_event_based = toggle;
1996    break;
1997#endif
1998  case C_PATH_AS_IS: /* --path-as-is */
1999    config->path_as_is = toggle;
2000    break;
2001  case C_TFTP_NO_OPTIONS: /* --tftp-no-options */
2002    config->tftp_no_options = toggle;
2003    break;
2004  case C_TLS_EARLYDATA: /* --tls-earlydata */
2005    config->ssl_allow_earlydata = toggle;
2006    break;
2007  case C_SUPPRESS_CONNECT_HEADERS: /* --suppress-connect-headers */
2008    config->suppress_connect_headers = toggle;
2009    break;
2010  case C_COMPRESSED_SSH: /* --compressed-ssh */
2011    config->ssh_compression = toggle;
2012    break;
2013  case C_TRACE_IDS: /* --trace-ids */
2014    global->traceids = toggle;
2015    break;
2016  case C_PROGRESS_METER: /* --progress-meter */
2017    global->noprogress = !toggle;
2018    break;
2019  case C_PROGRESS_BAR: /* --progress-bar */
2020    global->progressmode = toggle ? CURL_PROGRESS_BAR : CURL_PROGRESS_STATS;
2021    break;
2022  case C_HTTP0_9: /* --http0.9 */
2023    config->http09_allowed = toggle;
2024    break;
2025  case C_PROXY_HTTP2: /* --proxy-http2 */
2026    if(!feature_httpsproxy || !feature_http2)
2027      return PARAM_LIBCURL_DOESNT_SUPPORT;
2028
2029    config->proxyver = toggle ? CURLPROXY_HTTPS2 : CURLPROXY_HTTPS;
2030    break;
2031  case C_APPEND: /* --append */
2032    config->ftp_append = toggle;
2033    break;
2034  case C_USE_ASCII: /* --use-ascii */
2035    config->use_ascii = toggle;
2036    break;
2037  case C_CA_NATIVE: /* --ca-native */
2038    config->native_ca_store = toggle;
2039    break;
2040  case C_PROXY_CA_NATIVE: /* --proxy-ca-native */
2041    config->proxy_native_ca_store = toggle;
2042    break;
2043  case C_SSL_ALLOW_BEAST: /* --ssl-allow-beast */
2044    config->ssl_allow_beast = toggle;
2045    break;
2046  case C_SSL_AUTO_CLIENT_CERT: /* --ssl-auto-client-cert */
2047    config->ssl_auto_client_cert = toggle;
2048    break;
2049  case C_PROXY_SSL_AUTO_CLIENT_CERT: /* --proxy-ssl-auto-client-cert */
2050    config->proxy_ssl_auto_client_cert = toggle;
2051    break;
2052  case C_CERT_STATUS: /* --cert-status */
2053    config->verifystatus = toggle;
2054    break;
2055  case C_DOH_CERT_STATUS: /* --doh-cert-status */
2056    config->doh_verifystatus = toggle;
2057    break;
2058  case C_FALSE_START: /* --false-start */
2059    opt_depr(a);
2060    break;
2061  case C_SSL_NO_REVOKE: /* --ssl-no-revoke */
2062    config->ssl_no_revoke = toggle;
2063    break;
2064  case C_SSL_REVOKE_BEST_EFFORT: /* --ssl-revoke-best-effort */
2065    config->ssl_revoke_best_effort = toggle;
2066    break;
2067  case C_TCP_FASTOPEN: /* --tcp-fastopen */
2068    config->tcp_fastopen = toggle;
2069    break;
2070  case C_PROXY_SSL_ALLOW_BEAST: /* --proxy-ssl-allow-beast */
2071    config->proxy_ssl_allow_beast = toggle;
2072    break;
2073  case C_PROXY_INSECURE: /* --proxy-insecure */
2074    config->proxy_insecure_ok = toggle;
2075    break;
2076  case C_SOCKS5_BASIC: /* --socks5-basic */
2077    togglebit(toggle, &config->socks5_auth, CURLAUTH_BASIC);
2078    break;
2079  case C_SOCKS5_GSSAPI: /* --socks5-gssapi */
2080    togglebit(toggle, &config->socks5_auth, CURLAUTH_GSSAPI);
2081    break;
2082  case C_FAIL_EARLY: /* --fail-early */
2083    global->fail_early = toggle;
2084    break;
2085  case C_STYLED_OUTPUT: /* --styled-output */
2086    global->styled_output = toggle;
2087    break;
2088  case C_MAIL_RCPT_ALLOWFAILS: /* --mail-rcpt-allowfails */
2089    config->mail_rcpt_allowfails = toggle;
2090    break;
2091  case C_REMOVE_ON_ERROR: /* --remove-on-error */
2092    if(config->use_resume && toggle) {
2093      errorf("--continue-at is mutually exclusive with --remove-on-error");
2094      return PARAM_BAD_USE;
2095    }
2096    config->rm_partial = toggle;
2097    break;
2098  case C_FAIL: /* --fail without body */
2099    if(toggle && (config->fail == FAIL_WITH_BODY))
2100      warnf("--fail deselects --fail-with-body here");
2101    config->fail = toggle ? FAIL_WO_BODY : FAIL_NONE;
2102    break;
2103  case C_FAIL_WITH_BODY: /* --fail-with-body */
2104    if(toggle && (config->fail == FAIL_WO_BODY))
2105      warnf("--fail-with-body deselects --fail here");
2106    config->fail = toggle ? FAIL_WITH_BODY : FAIL_NONE;
2107    break;
2108  case C_GLOBOFF: /* --globoff */
2109    config->globoff = toggle;
2110    break;
2111  case C_GET: /* --get */
2112    config->use_httpget = toggle;
2113    break;
2114  case C_INCLUDE: /* --include */
2115  case C_SHOW_HEADERS: /* --show-headers */
2116    config->show_headers = toggle;
2117    break;
2118  case C_JUNK_SESSION_COOKIES: /* --junk-session-cookies */
2119    config->cookiesession = toggle;
2120    break;
2121  case C_HEAD: /* --head */
2122    config->no_body = toggle;
2123    config->show_headers = toggle;
2124    if(SetHTTPrequest((config->no_body) ? TOOL_HTTPREQ_HEAD :
2125                      TOOL_HTTPREQ_GET, &config->httpreq))
2126      return PARAM_BAD_USE;
2127    break;
2128  case C_REMOTE_HEADER_NAME: /* --remote-header-name */
2129    config->content_disposition = toggle;
2130    break;
2131  case C_INSECURE: /* --insecure */
2132    config->insecure_ok = toggle;
2133    break;
2134  case C_DOH_INSECURE: /* --doh-insecure */
2135    config->doh_insecure_ok = toggle;
2136    break;
2137  case C_LIST_ONLY: /* --list-only */
2138    config->dirlistonly = toggle; /* only list names of the FTP directory */
2139    break;
2140  case C_MANUAL: /* --manual */
2141    if(toggle)   /* --no-manual shows no manual... */
2142      return PARAM_MANUAL_REQUESTED;
2143    break;
2144  case C_NETRC_OPTIONAL: /* --netrc-optional */
2145    config->netrc_opt = toggle;
2146    break;
2147  case C_NETRC: /* --netrc */
2148    config->netrc = toggle;
2149    break;
2150  case C_BUFFER: /* --buffer */
2151    config->nobuffer = !toggle;
2152    break;
2153  case C_REMOTE_NAME_ALL: /* --remote-name-all */
2154    config->remote_name_all = toggle;
2155    break;
2156  case C_CLOBBER: /* --clobber */
2157    if(config->use_resume && !toggle) {
2158      errorf("--continue-at is mutually exclusive with --no-clobber");
2159      return PARAM_BAD_USE;
2160    }
2161    config->file_clobber_mode = toggle ? CLOBBER_ALWAYS : CLOBBER_NEVER;
2162    break;
2163  case C_REMOTE_NAME: /* --remote-name */
2164    return parse_remote_name(config, toggle);
2165  case C_PROXYTUNNEL: /* --proxytunnel */
2166    config->proxytunnel = toggle;
2167    break;
2168  case C_DISABLE: /* --disable */
2169    /* if used first, already taken care of, we do it like this so we do not
2170       cause an error! */
2171    break;
2172  case C_REMOTE_TIME: /* --remote-time */
2173    config->remote_time = toggle;
2174    break;
2175  case C_SILENT: /* --silent */
2176    global->silent = toggle;
2177    break;
2178  case C_SKIP_EXISTING: /* --skip-existing */
2179    config->skip_existing = toggle;
2180    break;
2181  case C_SHOW_ERROR: /* --show-error */
2182    global->showerror = toggle;
2183    break;
2184  case C_VERBOSE: /* --verbose */
2185    return parse_verbose(toggle);
2186  case C_VERSION: /* --version */
2187    if(toggle)    /* --no-version yields no output! */
2188      return PARAM_VERSION_INFO_REQUESTED;
2189    break;
2190  case C_PARALLEL: /* --parallel */
2191    global->parallel = toggle;
2192    break;
2193  case C_PARALLEL_IMMEDIATE:   /* --parallel-immediate */
2194    global->parallel_connect = toggle;
2195    break;
2196  case C_MPTCP: /* --mptcp */
2197    config->mptcp = toggle;
2198    break;
2199  case C_LOCATION_TRUSTED: /* --location-trusted */
2200    config->unrestricted_auth = toggle;
2201    FALLTHROUGH();
2202  case C_LOCATION: /* --location */
2203    if(config->followlocation == CURLFOLLOW_OBEYCODE)
2204      warnf("--location overrides --follow");
2205    config->followlocation = toggle ? CURLFOLLOW_ALL : 0;
2206    break;
2207  case C_FOLLOW: /* --follow */
2208    if(config->followlocation == CURLFOLLOW_ALL)
2209      warnf("--follow overrides --location");
2210    config->followlocation = toggle ? CURLFOLLOW_OBEYCODE : 0;
2211    break;
2212  default:
2213    return PARAM_OPTION_UNKNOWN;
2214  }
2215  return PARAM_OK;
2216}
2217
2218static ParameterError existingfile(char **store,
2219                                   const struct LongShort *a,
2220                                   const char *filename)
2221{
2222  curlx_struct_stat info;
2223  if(curlx_stat(filename, &info)) {
2224    errorf("The file '%s' provided to --%s does not exist",
2225           filename, a->lname);
2226    return PARAM_BAD_USE;
2227  }
2228  return getstr(store, filename, DENY_BLANK);
2229}
2230
2231/* opt_file handles file options */
2232static ParameterError opt_file(struct OperationConfig *config,
2233                               const struct LongShort *a,
2234                               const char *nextarg,
2235                               int max_recursive)
2236{
2237  ParameterError err = PARAM_OK;
2238  if((nextarg[0] == '-') && nextarg[1]) {
2239    /* if the filename looks like a command line option */
2240    warnf("The filename argument '%s' looks like a flag.", nextarg);
2241  }
2242  switch(a->cmd) {
2243  case C_ABSTRACT_UNIX_SOCKET: /* --abstract-unix-socket */
2244    config->abstract_unix_socket = TRUE;
2245    err = getstr(&config->unix_socket_path, nextarg, DENY_BLANK);
2246    break;
2247  case C_CACERT: /* --cacert */
2248    err = existingfile(&config->cacert, a, nextarg);
2249    break;
2250  case C_CAPATH: /* --capath */
2251    err = getstr(&config->capath, nextarg, DENY_BLANK);
2252    break;
2253  case C_CERT: /* --cert */
2254    err = GetFileAndPassword(nextarg, &config->cert, &config->key_passwd);
2255    break;
2256  case C_CONFIG: /* --config */
2257    if(--max_recursive < 0) {
2258      errorf("Max config file recursion level reached (%d)",
2259             CONFIG_MAX_LEVELS);
2260      err = PARAM_BAD_USE;
2261    }
2262    else {
2263      err = parseconfig(nextarg, max_recursive, NULL);
2264    }
2265    break;
2266  case C_CRLFILE: /* --crlfile */
2267    err = existingfile(&config->crlfile, a, nextarg);
2268    break;
2269  case C_DUMP_HEADER: /* --dump-header */
2270    err = getstr(&config->headerfile, nextarg, DENY_BLANK);
2271    break;
2272  case C_ETAG_SAVE: /* --etag-save */
2273    if(config->num_urls > 1) {
2274      errorf("The etag options only work on a single URL");
2275      err = PARAM_BAD_USE;
2276    }
2277    else
2278      err = getstr(&config->etag_save_file, nextarg, DENY_BLANK);
2279    break;
2280  case C_ETAG_COMPARE: /* --etag-compare */
2281    if(config->num_urls > 1) {
2282      errorf("The etag options only work on a single URL");
2283      err = PARAM_BAD_USE;
2284    }
2285    else
2286      err = getstr(&config->etag_compare_file, nextarg, DENY_BLANK);
2287    break;
2288  case C_KEY: /* --key */
2289    err = getstr(&config->key, nextarg, DENY_BLANK);
2290    break;
2291  case C_KNOWNHOSTS: /* --knownhosts */
2292    err = existingfile(&config->knownhosts, a, nextarg);
2293    break;
2294  case C_NETRC_FILE: /* --netrc-file */
2295    err = existingfile(&config->netrc_file, a, nextarg);
2296    break;
2297  case C_OUTPUT: /* --output */
2298    err = parse_output(config, nextarg);
2299    break;
2300  case C_PROXY_CACERT: /* --proxy-cacert */
2301    err = existingfile(&config->proxy_cacert, a, nextarg);
2302    break;
2303  case C_PROXY_CAPATH: /* --proxy-capath */
2304    err = getstr(&config->proxy_capath, nextarg, DENY_BLANK);
2305    break;
2306  case C_PROXY_CERT: /* --proxy-cert */
2307    err = GetFileAndPassword(nextarg, &config->proxy_cert,
2308                             &config->proxy_key_passwd);
2309    break;
2310  case C_PROXY_CRLFILE: /* --proxy-crlfile */
2311    err = existingfile(&config->proxy_crlfile, a, nextarg);
2312    break;
2313  case C_PROXY_KEY: /* --proxy-key */
2314    err = getstr(&config->proxy_key, nextarg, ALLOW_BLANK);
2315    break;
2316  case C_SSL_SESSIONS: /* --ssl-sessions */
2317    if(feature_ssls_export)
2318      err = getstr(&global->ssl_sessions, nextarg, DENY_BLANK);
2319    else
2320      err = PARAM_LIBCURL_DOESNT_SUPPORT;
2321    break;
2322  case C_STDERR: /* --stderr */
2323    tool_set_stderr_file(nextarg);
2324    break;
2325  case C_TRACE: /* --trace */
2326    err = getstr(&global->trace_dump, nextarg, DENY_BLANK);
2327    if(!err) {
2328      if(global->tracetype && (global->tracetype != TRACE_BIN))
2329        warnf("--trace overrides an earlier trace/verbose option");
2330      global->tracetype = TRACE_BIN;
2331    }
2332    break;
2333  case C_TRACE_ASCII: /* --trace-ascii */
2334    err = getstr(&global->trace_dump, nextarg, DENY_BLANK);
2335    if(!err) {
2336      if(global->tracetype && (global->tracetype != TRACE_ASCII))
2337        warnf("--trace-ascii overrides an earlier trace/verbose option");
2338      global->tracetype = TRACE_ASCII;
2339    }
2340    break;
2341  case C_UNIX_SOCKET: /* --unix-socket */
2342    config->abstract_unix_socket = FALSE;
2343    err = getstr(&config->unix_socket_path, nextarg, DENY_BLANK);
2344    break;
2345  case C_UPLOAD_FILE: /* --upload-file */
2346    err = parse_upload_file(config, nextarg);
2347    break;
2348  }
2349  return err;
2350}
2351
2352/* options that accept unsigned numbers */
2353static ParameterError opt_unum(struct OperationConfig *config,
2354                               const struct LongShort *a,
2355                               const char *nextarg)
2356{
2357  ParameterError err = PARAM_OK;
2358  long val;
2359  err = str2unum(&val, nextarg);
2360  if(err)
2361    return err;
2362  switch(a->cmd) {
2363  case C_VLAN_PRIORITY: /* --vlan-priority */
2364    if(val > 7)
2365      return PARAM_NUMBER_TOO_LARGE;
2366    config->vlan_priority = val;
2367    break;
2368  case C_RETRY: /* --retry */
2369    config->req_retry = val;
2370    break;
2371  case C_KEEPALIVE_TIME: /* --keepalive-time */
2372    config->alivetime = val;
2373    break;
2374  case C_KEEPALIVE_CNT: /* --keepalive-cnt */
2375    config->alivecnt = val;
2376    break;
2377  case C_TFTP_BLKSIZE: /* --tftp-blksize */
2378    config->tftp_blksize = val;
2379    break;
2380  case C_HAPPY_EYEBALLS_TIMEOUT_MS: /* --happy-eyeballs-timeout-ms */
2381    config->happy_eyeballs_timeout_ms = val;
2382    /* 0 is a valid value for this timeout */
2383    break;
2384  case C_SPEED_TIME: /* --speed-time */
2385    /* low speed time */
2386    config->low_speed_time = val;
2387    if(!config->low_speed_limit)
2388      config->low_speed_limit = 1;
2389    break;
2390  case C_SPEED_LIMIT: /* --speed-limit */
2391    /* low speed limit */
2392    config->low_speed_limit = val;
2393    if(!config->low_speed_time)
2394      config->low_speed_time = 30;
2395    break;
2396  case C_PARALLEL_HOST: /* --parallel-max-host */
2397    if(val > MAX_PARALLEL_HOST)
2398      global->parallel_host = MAX_PARALLEL_HOST;
2399    else if(val < 1)
2400      global->parallel_host = PARALLEL_HOST_DEFAULT;
2401    else
2402      global->parallel_host = (unsigned short)val;
2403    break;
2404  case C_PARALLEL_MAX:  /* --parallel-max */
2405    if(val > MAX_PARALLEL)
2406      global->parallel_max = MAX_PARALLEL;
2407    else if(val < 1)
2408      global->parallel_max = PARALLEL_DEFAULT;
2409    else
2410      global->parallel_max = (unsigned short)val;
2411    break;
2412  default:
2413    DEBUGASSERT(0);
2414    return PARAM_OPTION_UNKNOWN;
2415  }
2416  return err;
2417}
2418
2419/* handle options that accept seconds */
2420static ParameterError opt_secs(struct OperationConfig *config,
2421                               const struct LongShort *a,
2422                               const char *nextarg)
2423{
2424  long val;
2425  ParameterError err = secs2ms(&val, nextarg);
2426  if(err)
2427    return err;
2428  switch(a->cmd) {
2429  case C_CONNECT_TIMEOUT: /* --connect-timeout */
2430    config->connecttimeout_ms = val;
2431    break;
2432  case C_RETRY_DELAY: /* --retry-delay */
2433    if(val >= INT32_MAX)
2434      val = INT32_MAX;
2435    config->retry_delay_ms = (uint32_t)val;
2436    break;
2437  case C_RETRY_MAX_TIME: /* --retry-max-time */
2438    config->retry_maxtime_ms = val;
2439    break;
2440  case C_EXPECT100_TIMEOUT: /* --expect100-timeout */
2441    config->expect100timeout_ms = val;
2442    break;
2443  case C_MAX_TIME: /* --max-time */
2444    /* specified max time */
2445    config->timeout_ms = val;
2446    break;
2447  default:
2448    DEBUGASSERT(0);
2449    return PARAM_OPTION_UNKNOWN;
2450  }
2451  return err;
2452}
2453
2454/* opt_string handles string options */
2455static ParameterError opt_string(struct OperationConfig *config,
2456                                 const struct LongShort *a,
2457                                 const char *nextarg)
2458{
2459  ParameterError err = PARAM_OK;
2460  curl_off_t value;
2461  static const char *redir_protos[] = {
2462    "http",
2463    "https",
2464    "ftp",
2465    "ftps",
2466    NULL
2467  };
2468  if(!nextarg)
2469    nextarg = "";
2470
2471  switch(a->cmd) {
2472  case C_DNS_IPV4_ADDR: /* --dns-ipv4-addr */
2473    if(!curlinfo->ares_num) /* c-ares is needed for this */
2474      return PARAM_LIBCURL_DOESNT_SUPPORT;
2475    /* addr in dot notation */
2476    return getstr(&config->dns_ipv4_addr, nextarg, DENY_BLANK);
2477
2478  case C_DNS_IPV6_ADDR: /* --dns-ipv6-addr */
2479    if(!curlinfo->ares_num) /* c-ares is needed for this */
2480      return PARAM_LIBCURL_DOESNT_SUPPORT;
2481    /* addr in dot notation */
2482    return getstr(&config->dns_ipv6_addr, nextarg, DENY_BLANK);
2483
2484  case C_OAUTH2_BEARER: /* --oauth2-bearer */
2485    config->authtype |= CURLAUTH_BEARER;
2486    return getstr(&config->oauth_bearer, nextarg, DENY_BLANK);
2487
2488  case C_DOH_URL: /* --doh-url */
2489    err = getstr(&config->doh_url, nextarg, ALLOW_BLANK);
2490    if(!err && config->doh_url && !config->doh_url[0])
2491      /* if given a blank string, make it NULL again */
2492      curlx_safefree(config->doh_url);
2493    break;
2494
2495  case C_CIPHERS: /* -- ciphers */
2496    err = getstr(&config->cipher_list, nextarg, DENY_BLANK);
2497    break;
2498
2499  case C_DNS_INTERFACE: /* --dns-interface */
2500    if(!curlinfo->ares_num) /* c-ares is needed for this */
2501      err = PARAM_LIBCURL_DOESNT_SUPPORT;
2502    else
2503      /* interface name */
2504      err = getstr(&config->dns_interface, nextarg, DENY_BLANK);
2505    break;
2506  case C_DNS_SERVERS: /* --dns-servers */
2507    if(!curlinfo->ares_num) /* c-ares is needed for this */
2508      err = PARAM_LIBCURL_DOESNT_SUPPORT;
2509    else
2510      /* IP addrs of DNS servers */
2511      err = getstr(&config->dns_servers, nextarg, DENY_BLANK);
2512    break;
2513  case C_LIMIT_RATE: /* --limit-rate */
2514    err = GetSizeParameter(nextarg, &value);
2515    if(!err) {
2516      config->recvpersecond = value;
2517      config->sendpersecond = value;
2518    }
2519    break;
2520  case C_RATE:
2521    err = set_rate(nextarg);
2522    break;
2523  case C_CREATE_FILE_MODE: /* --create-file-mode */
2524    err = oct2nummax(&config->create_file_mode, nextarg, 0777);
2525    break;
2526  case C_MAX_REDIRS: /* --max-redirs */
2527    /* specified max no of redirects (http(s)), this accepts -1 as a
2528       special condition */
2529    err = str2num(&config->maxredirs, nextarg);
2530    if(!err && (config->maxredirs < -1))
2531      err = PARAM_BAD_NUMERIC;
2532    break;
2533#ifndef CURL_DISABLE_IPFS
2534  case C_IPFS_GATEWAY: /* --ipfs-gateway */
2535    err = getstr(&config->ipfs_gateway, nextarg, DENY_BLANK);
2536    break;
2537#endif
2538  case C_AWS_SIGV4: /* --aws-sigv4 */
2539    config->authtype |= CURLAUTH_AWS_SIGV4;
2540    err = getstr(&config->aws_sigv4, nextarg, ALLOW_BLANK);
2541    break;
2542  case C_INTERFACE: /* --interface */
2543    /* interface */
2544    err = getstr(&config->iface, nextarg, DENY_BLANK);
2545    break;
2546  case C_HAPROXY_CLIENTIP: /* --haproxy-clientip */
2547    err = getstr(&config->haproxy_clientip, nextarg, DENY_BLANK);
2548    break;
2549  case C_MAX_FILESIZE: /* --max-filesize */
2550    err = GetSizeParameter(nextarg, &value);
2551    if(!err)
2552      config->max_filesize = value;
2553    break;
2554  case C_URL: /* --url */
2555    err = parse_url(config, nextarg);
2556    break;
2557  case C_SOCKS5: /* --socks5 */
2558    /*  socks5 proxy to use, and resolves the name locally and passes on the
2559        resolved address */
2560    err = getstr(&config->proxy, nextarg, DENY_BLANK);
2561    config->proxyver = CURLPROXY_SOCKS5;
2562    break;
2563  case C_SOCKS4: /* --socks4 */
2564    err = getstr(&config->proxy, nextarg, DENY_BLANK);
2565    config->proxyver = CURLPROXY_SOCKS4;
2566    break;
2567  case C_SOCKS4A: /* --socks4a */
2568    err = getstr(&config->proxy, nextarg, DENY_BLANK);
2569    config->proxyver = CURLPROXY_SOCKS4A;
2570    break;
2571  case C_SOCKS5_HOSTNAME: /* --socks5-hostname */
2572    err = getstr(&config->proxy, nextarg, DENY_BLANK);
2573    config->proxyver = CURLPROXY_SOCKS5_HOSTNAME;
2574    break;
2575  case C_IP_TOS: { /* --ip-tos */
2576    struct TOSEntry find;
2577    const struct TOSEntry *entry;
2578    find.name = nextarg;
2579    entry = bsearch(&find, tos_entries,
2580                    CURL_ARRAYSIZE(tos_entries),
2581                    sizeof(*tos_entries), find_tos);
2582    if(entry)
2583      config->ip_tos = entry->value;
2584    else /* numeric tos value */
2585      err = str2unummax(&config->ip_tos, nextarg, 0xFF);
2586    break;
2587  }
2588  case C_FTP_ACCOUNT: /* --ftp-account */
2589    err = getstr(&config->ftp_account, nextarg, DENY_BLANK);
2590    break;
2591  case C_FTP_METHOD: /* --ftp-method */
2592    config->ftp_filemethod = ftpfilemethod(nextarg);
2593    break;
2594  case C_LOCAL_PORT: /* --local-port */
2595    err = parse_localport(config, nextarg);
2596    break;
2597  case C_FTP_ALTERNATIVE_TO_USER: /* --ftp-alternative-to-user */
2598    err = getstr(&config->ftp_alternative_to_user, nextarg, DENY_BLANK);
2599    break;
2600  case C_LIBCURL: /* --libcurl */
2601#ifdef CURL_DISABLE_LIBCURL_OPTION
2602    warnf("--libcurl option was disabled at build-time");
2603    err = PARAM_OPTION_UNKNOWN;
2604#else
2605    err = getstr(&global->libcurl, nextarg, DENY_BLANK);
2606#endif
2607    break;
2608  case C_NOPROXY: /* --noproxy */
2609    /* This specifies the noproxy list */
2610    err = getstr(&config->noproxy, nextarg, ALLOW_BLANK);
2611    break;
2612  case C_PROXY1_0: /* --proxy1.0 */
2613    /* http 1.0 proxy */
2614    err = getstr(&config->proxy, nextarg, DENY_BLANK);
2615    config->proxyver = CURLPROXY_HTTP_1_0;
2616    break;
2617  case C_MAIL_FROM: /* --mail-from */
2618    err = getstr(&config->mail_from, nextarg, DENY_BLANK);
2619    break;
2620  case C_MAIL_RCPT: /* --mail-rcpt */
2621    /* append receiver to a list */
2622    err = add2list(&config->mail_rcpt, nextarg);
2623    break;
2624  case C_PROTO: /* --proto */
2625    config->proto_present = TRUE;
2626    err = proto2num(built_in_protos, &config->proto_str, nextarg);
2627    break;
2628  case C_PROTO_REDIR: /* --proto-redir */
2629    config->proto_redir_present = TRUE;
2630    if(proto2num(redir_protos, &config->proto_redir_str, nextarg))
2631      err = PARAM_BAD_USE;
2632    break;
2633  case C_RESOLVE: /* --resolve */
2634    err = add2list(&config->resolve, nextarg);
2635    break;
2636  case C_DELEGATION: /* --delegation */
2637    config->gssapi_delegation = delegation(nextarg);
2638    break;
2639  case C_MAIL_AUTH: /* --mail-auth */
2640    err = getstr(&config->mail_auth, nextarg, DENY_BLANK);
2641    break;
2642  case C_SASL_AUTHZID: /* --sasl-authzid */
2643    err = getstr(&config->sasl_authzid, nextarg, DENY_BLANK);
2644    break;
2645  case C_PROXY_SERVICE_NAME: /* --proxy-service-name */
2646    err = getstr(&config->proxy_service_name, nextarg, DENY_BLANK);
2647    break;
2648  case C_SERVICE_NAME: /* --service-name */
2649    err = getstr(&config->service_name, nextarg, DENY_BLANK);
2650    break;
2651  case C_PROTO_DEFAULT: /* --proto-default */
2652    err = getstr(&config->proto_default, nextarg, DENY_BLANK);
2653    if(!err)
2654      err = check_protocol(config->proto_default);
2655    break;
2656  case C_CONNECT_TO: /* --connect-to */
2657    err = add2list(&config->connect_to, nextarg);
2658    break;
2659  case C_TLS_MAX: /* --tls-max */
2660    err = str2tls_max(&config->ssl_version_max, nextarg);
2661    if(!err && (config->ssl_version_max < config->ssl_version)) {
2662      errorf("--tls-max set lower than minimum accepted version");
2663      err = PARAM_BAD_USE;
2664    }
2665    break;
2666  case C_TRACE_CONFIG: /* --trace-config */
2667    global->trace_set = TRUE;
2668    if(set_trace_config(nextarg))
2669      err = PARAM_NO_MEM;
2670    break;
2671  case C_VARIABLE: /* --variable */
2672    err = setvariable(nextarg);
2673    break;
2674  case C_TLS13_CIPHERS: /* --tls13-ciphers */
2675    err = getstr(&config->cipher13_list, nextarg, DENY_BLANK);
2676    break;
2677  case C_PROXY_TLS13_CIPHERS: /* --proxy-tls13-ciphers */
2678    err = getstr(&config->proxy_cipher13_list, nextarg, DENY_BLANK);
2679    break;
2680  case C_USER_AGENT: /* --user-agent */
2681    err = getstr(&config->useragent, nextarg, ALLOW_BLANK);
2682    break;
2683  case C_ALT_SVC: /* --alt-svc */
2684    if(!feature_altsvc)
2685      err = PARAM_LIBCURL_DOESNT_SUPPORT;
2686    else
2687      err = getstr(&config->altsvc, nextarg, ALLOW_BLANK);
2688    break;
2689  case C_HSTS: /* --hsts */
2690    if(!feature_hsts)
2691      err = PARAM_LIBCURL_DOESNT_SUPPORT;
2692    else
2693      err = getstr(&config->hsts, nextarg, ALLOW_BLANK);
2694    break;
2695  case C_COOKIE: /* --cookie */
2696    if(strchr(nextarg, '=')) {
2697      /* A cookie string must have a =-letter */
2698      err = add2list(&config->cookies, nextarg);
2699      break;
2700    }
2701    else {
2702      /* We have a cookie file to read from! */
2703      err = add2list(&config->cookiefiles, nextarg);
2704    }
2705    break;
2706  case C_COOKIE_JAR: /* --cookie-jar */
2707    err = getstr(&config->cookiejar, nextarg, DENY_BLANK);
2708    break;
2709  case C_CONTINUE_AT: /* --continue-at */
2710    err = parse_continue_at(config, nextarg);
2711    break;
2712  case C_DATA: /* --data */
2713  case C_DATA_ASCII:  /* --data-ascii */
2714  case C_DATA_BINARY:  /* --data-binary */
2715  case C_DATA_URLENCODE:  /* --data-urlencode */
2716  case C_JSON:  /* --json */
2717  case C_DATA_RAW:  /* --data-raw */
2718    err = set_data((cmdline_t)a->cmd, nextarg, config);
2719    break;
2720  case C_URL_QUERY:  /* --url-query */
2721    err = url_query(nextarg, config);
2722    break;
2723  case C_REFERER: { /* --referer */
2724    size_t len = strlen(nextarg);
2725    /* does it end with ;auto ? */
2726    if(len >= 5 && !strcmp(";auto", &nextarg[len - 5])) {
2727      /* Automatic referer requested, this may be combined with a set initial
2728         one */
2729      config->autoreferer = TRUE;
2730      len -= 5;
2731    }
2732    else
2733      config->autoreferer = FALSE;
2734
2735    if(len)
2736      err = getstrn(&config->referer, nextarg, len, ALLOW_BLANK);
2737    else
2738      curlx_safefree(config->referer);
2739  }
2740    break;
2741  case C_CERT_TYPE: /* --cert-type */
2742    err = getstr(&config->cert_type, nextarg, DENY_BLANK);
2743    break;
2744  case C_KEY_TYPE: /* --key-type */
2745    err = getstr(&config->key_type, nextarg, DENY_BLANK);
2746    break;
2747  case C_PASS: /* --pass */
2748    err = getstr(&config->key_passwd, nextarg, DENY_BLANK);
2749    break;
2750  case C_ENGINE: /* --engine */
2751    err = getstr(&config->engine, nextarg, DENY_BLANK);
2752    if(!err &&
2753       config->engine && !strcmp(config->engine, "list")) {
2754      err = PARAM_ENGINES_REQUESTED;
2755    }
2756    break;
2757  case C_ECH: /* --ech */
2758    err = parse_ech(config, nextarg);
2759    break;
2760  case C_PUBKEY: /* --pubkey */
2761    err = getstr(&config->pubkey, nextarg, DENY_BLANK);
2762    break;
2763  case C_HOSTPUBMD5: /* --hostpubmd5 */
2764    err = getstr(&config->hostpubmd5, nextarg, DENY_BLANK);
2765    if(!err) {
2766      if(!config->hostpubmd5 || strlen(config->hostpubmd5) != 32)
2767        err = PARAM_BAD_USE;
2768    }
2769    break;
2770  case C_HOSTPUBSHA256: /* --hostpubsha256 */
2771    err = getstr(&config->hostpubsha256, nextarg, DENY_BLANK);
2772    break;
2773  case C_TLSUSER: /* --tlsuser */
2774    if(!feature_tls_srp)
2775      err = PARAM_LIBCURL_DOESNT_SUPPORT;
2776    else
2777      err = getstr(&config->tls_username, nextarg, DENY_BLANK);
2778    break;
2779  case C_TLSPASSWORD: /* --tlspassword */
2780    if(!feature_tls_srp)
2781      err = PARAM_LIBCURL_DOESNT_SUPPORT;
2782    else
2783      err = getstr(&config->tls_password, nextarg, ALLOW_BLANK);
2784    break;
2785  case C_TLSAUTHTYPE: /* --tlsauthtype */
2786    if(!feature_tls_srp)
2787      err = PARAM_LIBCURL_DOESNT_SUPPORT;
2788    else {
2789      err = getstr(&config->tls_authtype, nextarg, DENY_BLANK);
2790      if(!err && config->tls_authtype && strcmp(config->tls_authtype, "SRP"))
2791        err = PARAM_LIBCURL_DOESNT_SUPPORT; /* only support TLS-SRP */
2792    }
2793    break;
2794  case C_PINNEDPUBKEY: /* --pinnedpubkey */
2795    err = getstr(&config->pinnedpubkey, nextarg, DENY_BLANK);
2796    break;
2797  case C_PROXY_PINNEDPUBKEY: /* --proxy-pinnedpubkey */
2798    err = getstr(&config->proxy_pinnedpubkey, nextarg, DENY_BLANK);
2799    break;
2800  case C_PROXY_TLSUSER: /* --proxy-tlsuser */
2801    if(!feature_tls_srp)
2802      err = PARAM_LIBCURL_DOESNT_SUPPORT;
2803    else
2804      err = getstr(&config->proxy_tls_username, nextarg, ALLOW_BLANK);
2805    break;
2806  case C_PROXY_TLSPASSWORD: /* --proxy-tlspassword */
2807    if(!feature_tls_srp)
2808      err = PARAM_LIBCURL_DOESNT_SUPPORT;
2809    else
2810      err = getstr(&config->proxy_tls_password, nextarg, DENY_BLANK);
2811    break;
2812  case C_PROXY_TLSAUTHTYPE: /* --proxy-tlsauthtype */
2813    if(!feature_tls_srp)
2814      err = PARAM_LIBCURL_DOESNT_SUPPORT;
2815    else {
2816      err = getstr(&config->proxy_tls_authtype, nextarg, DENY_BLANK);
2817      if(!err && config->proxy_tls_authtype &&
2818         strcmp(config->proxy_tls_authtype, "SRP"))
2819        err = PARAM_LIBCURL_DOESNT_SUPPORT; /* only support TLS-SRP */
2820    }
2821    break;
2822  case C_PROXY_CERT_TYPE: /* --proxy-cert-type */
2823    err = getstr(&config->proxy_cert_type, nextarg, DENY_BLANK);
2824    break;
2825  case C_PROXY_KEY_TYPE: /* --proxy-key-type */
2826    err = getstr(&config->proxy_key_type, nextarg, DENY_BLANK);
2827    break;
2828  case C_PROXY_PASS: /* --proxy-pass */
2829    err = getstr(&config->proxy_key_passwd, nextarg, ALLOW_BLANK);
2830    break;
2831  case C_PROXY_CIPHERS: /* --proxy-ciphers */
2832    err = getstr(&config->proxy_cipher_list, nextarg, DENY_BLANK);
2833    break;
2834  case C_LOGIN_OPTIONS: /* --login-options */
2835    err = getstr(&config->login_options, nextarg, ALLOW_BLANK);
2836    break;
2837  case C_CURVES: /* --curves */
2838    err = getstr(&config->ssl_ec_curves, nextarg, DENY_BLANK);
2839    break;
2840  case C_SIGNATURE_ALGORITHMS: /* --sigalgs */
2841    err = getstr(&config->ssl_signature_algorithms, nextarg, DENY_BLANK);
2842    break;
2843  case C_FORM: /* --form */
2844  case C_FORM_STRING: /* --form-string */
2845    /* "form data" simulation, this is a little advanced so lets do our best
2846       to sort this out slowly and carefully */
2847    if(formparse(nextarg, &config->mimeroot, &config->mimecurrent,
2848                 (a->cmd == C_FORM_STRING))) /* literal string */
2849      err = PARAM_BAD_USE;
2850    else if(SetHTTPrequest(TOOL_HTTPREQ_MIMEPOST, &config->httpreq))
2851      err = PARAM_BAD_USE;
2852    break;
2853  case C_REQUEST_TARGET: /* --request-target */
2854    err = getstr(&config->request_target, nextarg, DENY_BLANK);
2855    break;
2856  case C_HEADER: /* --header */
2857  case C_PROXY_HEADER: /* --proxy-header */
2858    err = parse_header(config, (cmdline_t)a->cmd, nextarg);
2859    break;
2860  case C_OUTPUT_DIR: /* --output-dir */
2861    err = getstr(&config->output_dir, nextarg, DENY_BLANK);
2862    break;
2863  case C_FTP_PORT: /* --ftp-port */
2864    /* This makes the FTP sessions use PORT instead of PASV */
2865    /* use <eth0> or <192.168.10.10> style addresses. Anything except
2866       this makes us try to get the "default" address.
2867       NOTE: this is a changed behavior since the released 4.1!
2868     */
2869    err = getstr(&config->ftpport, nextarg, DENY_BLANK);
2870    break;
2871  case C_FTP_SSL_CCC_MODE: /* --ftp-ssl-ccc-mode */
2872    config->ftp_ssl_ccc = TRUE;
2873    config->ftp_ssl_ccc_mode = ftpcccmethod(nextarg);
2874    break;
2875  case C_QUOTE: /* --quote */
2876    err = parse_quote(config, nextarg);
2877    break;
2878  case C_RANGE: /* --range */
2879    err = parse_range(config, nextarg);
2880    break;
2881  case C_TELNET_OPTION: /* --telnet-option */
2882    /* Telnet options */
2883    err = add2list(&config->telnet_options, nextarg);
2884    break;
2885  case C_USER: /* --user */
2886    /* user:password */
2887    err = getstr(&config->userpwd, nextarg, ALLOW_BLANK);
2888    break;
2889  case C_PROXY_USER: /* --proxy-user */
2890    /* Proxy user:password */
2891    err = getstr(&config->proxyuserpwd, nextarg, ALLOW_BLANK);
2892    break;
2893  case C_WRITE_OUT: /* --write-out */
2894    err = parse_writeout(config, nextarg);
2895    break;
2896  case C_PREPROXY: /* --preproxy */
2897    err = getstr(&config->preproxy, nextarg, DENY_BLANK);
2898    break;
2899  case C_PROXY: /* --proxy */
2900    /* --proxy */
2901    err = getstr(&config->proxy, nextarg, ALLOW_BLANK);
2902    if(config->proxyver != CURLPROXY_HTTPS2)
2903      config->proxyver = CURLPROXY_HTTP;
2904    break;
2905  case C_REQUEST: /* --request */
2906    /* set custom request */
2907    err = getstr(&config->customrequest, nextarg, DENY_BLANK);
2908    break;
2909  case C_TIME_COND: /* --time-cond */
2910    err = parse_time_cond(config, nextarg);
2911    break;
2912  case C_UPLOAD_FLAGS: /* --upload-flags */
2913    err = parse_upload_flags(config, nextarg);
2914    break;
2915  }
2916  return err;
2917}
2918
2919/* detect e2 80 80 - e2 80 ff */
2920static bool has_leading_unicode(const unsigned char *arg)
2921{
2922  return (arg[0] == 0xe2) && (arg[1] == 0x80) && (arg[2] & 0x80);
2923}
2924
2925/* the longest command line option, excluding the leading -- */
2926#define MAX_OPTION_LEN 26
2927
2928ParameterError getparameter(const char *flag, /* f or -long-flag */
2929                            const char *nextarg,    /* NULL if unset */
2930                            bool *usedarg,    /* set to TRUE if the arg
2931                                                 has been used */
2932                            struct OperationConfig *config,
2933                            int max_recursive)
2934{
2935  const char *parse = NULL;
2936  bool longopt = FALSE;
2937  bool singleopt = FALSE; /* when true means '-o foo' used '-ofoo' */
2938  ParameterError err = PARAM_OK;
2939  bool toggle = TRUE; /* how to switch boolean options, on or off. Controlled
2940                         by using --OPTION or --no-OPTION */
2941  bool nextalloc = FALSE; /* if nextarg is allocated */
2942  bool consumearg = TRUE; /* the argument comes separate */
2943  const struct LongShort *a = NULL;
2944  verbose_nopts = 0; /* options processed in `flag`*/
2945
2946  *usedarg = FALSE; /* default is that we do not use the arg */
2947
2948  if(('-' != flag[0]) || ('-' == flag[1])) {
2949    /* this should be a long name */
2950    const char *word = ('-' == flag[0]) ? flag + 2 : flag;
2951    bool noflagged = FALSE;
2952    bool expand = FALSE;
2953    const char *p;
2954    struct Curl_str out;
2955
2956    if(!strncmp(word, "no-", 3)) {
2957      /* disable this option but ignore the "no-" part when looking for it */
2958      word += 3;
2959      toggle = FALSE;
2960      noflagged = TRUE;
2961    }
2962    else if(!strncmp(word, "expand-", 7)) {
2963      /* variable expansions is to be done on the argument */
2964      word += 7;
2965      expand = TRUE;
2966    }
2967
2968    p = word;
2969    /* is there an '=' ? */
2970    if(!curlx_str_until(&p, &out, MAX_OPTION_LEN, '=') &&
2971       !curlx_str_single(&p, '=')) {
2972      /* there is an equal sign */
2973      char tempword[MAX_OPTION_LEN + 1];
2974      memcpy(tempword, curlx_str(&out), curlx_strlen(&out));
2975      tempword[curlx_strlen(&out)] = 0;
2976      a = findlongopt(tempword);
2977      nextarg = p;
2978      consumearg = FALSE; /* it is not separate */
2979    }
2980    else
2981      a = findlongopt(word);
2982
2983    if(a) {
2984      longopt = TRUE;
2985    }
2986    else {
2987      err = PARAM_OPTION_UNKNOWN;
2988      goto error;
2989    }
2990    if(noflagged && (ARGTYPE(a->desc) != ARG_BOOL)) {
2991      /* --no- prefixed an option that is not boolean! */
2992      err = PARAM_NO_PREFIX;
2993      goto error;
2994    }
2995    else if(expand && nextarg) {
2996      struct dynbuf nbuf;
2997      bool replaced;
2998
2999      if(ARGTYPE(a->desc) < ARG_STRG) {
3000        /* --expand on an option that does not take an argument */
3001        err = PARAM_EXPAND_ERROR;
3002        goto error;
3003      }
3004      err = varexpand(nextarg, &nbuf, &replaced);
3005      if(err) {
3006        curlx_dyn_free(&nbuf);
3007        goto error;
3008      }
3009      if(replaced) {
3010        nextarg = curlx_dyn_ptr(&nbuf);
3011        nextalloc = TRUE;
3012      }
3013    }
3014  }
3015  else {
3016    flag++; /* prefixed with one dash, pass it */
3017    parse = flag;
3018  }
3019
3020  do {
3021    /* we can loop here if we have multiple single-letters */
3022    if(!longopt) {
3023      a = findshortopt(*parse);
3024      if(!a) {
3025        err = PARAM_OPTION_UNKNOWN;
3026        break;
3027      }
3028      toggle = !(a->desc & ARG_NO);
3029    }
3030    if((a->desc & ARG_TLS) && !feature_ssl) {
3031      err = PARAM_LIBCURL_DOESNT_SUPPORT;
3032      break;
3033    }
3034    else if(ARGTYPE(a->desc) >= ARG_STRG) {
3035      /* this option requires an extra parameter */
3036      if(!longopt && parse[1]) {
3037        nextarg = &parse[1]; /* this is the actual extra parameter */
3038        singleopt = TRUE;   /* do not loop anymore after this */
3039      }
3040      else if(a->cmd == C_HELP) {
3041        /* --help is special */
3042        tool_help((nextarg && *nextarg) ? nextarg : NULL);
3043        err = PARAM_HELP_REQUESTED;
3044        break;
3045      }
3046      else if(!nextarg) {
3047        err = PARAM_REQUIRES_PARAMETER;
3048        break;
3049      }
3050      else {
3051        *usedarg = consumearg; /* mark it as used */
3052      }
3053      if(a->desc & ARG_DEPR) {
3054        opt_depr(a);
3055        break;
3056      }
3057
3058      if(has_leading_unicode((const unsigned char *)nextarg)) {
3059        warnf("The argument '%s' starts with a Unicode character. "
3060              "Maybe ASCII was intended?", nextarg);
3061      }
3062      switch(ARGTYPE(a->desc)) {
3063      case ARG_FILE:
3064        err = opt_file(config, a, nextarg, max_recursive);
3065        break;
3066      case ARG_STRG:
3067        err = opt_string(config, a, nextarg);
3068        break;
3069      case ARG_SECS:
3070        err = opt_secs(config, a, nextarg);
3071        break;
3072      case ARG_UNUM:
3073        err = opt_unum(config, a, nextarg);
3074        break;
3075      default:
3076        DEBUGASSERT(0);
3077        err = PARAM_OPTION_UNKNOWN;
3078        break;
3079      }
3080      if(a->desc & ARG_CLEAR)
3081        cleanarg(CURL_UNCONST(nextarg));
3082    }
3083    else {
3084      if(a->desc & ARG_DEPR) {
3085        opt_depr(a);
3086        break;
3087      }
3088      /* ARG_NONE | ARG_BOOL */
3089      if(ARGTYPE(a->desc) == ARG_BOOL)
3090        err = opt_bool(config, a, toggle);
3091      else
3092        err = opt_none(config, a);
3093    }
3094
3095    ++verbose_nopts; /* processed one option from `flag` input, loop for
3096                        more */
3097  } while(!longopt && !singleopt && *++parse && !*usedarg && !err);
3098
3099error:
3100  if(nextalloc)
3101    curlx_free(CURL_UNCONST(nextarg));
3102  return err;
3103}
3104
3105ParameterError parse_args(int argc, argv_item_t argv[])
3106{
3107  int i;
3108  bool stillflags;
3109  const char *orig_opt = NULL;
3110  ParameterError err = PARAM_OK;
3111  struct OperationConfig *config = global->first;
3112
3113  stillflags = TRUE;
3114  for(i = 1; i < argc && !err; i++) {
3115    orig_opt = convert_tchar_to_UTF8(argv[i]);
3116    if(!orig_opt)
3117      return PARAM_NO_MEM;
3118
3119    if(stillflags && ('-' == orig_opt[0])) {
3120      bool passarg;
3121
3122      if(!strcmp("--", orig_opt))
3123        /* This indicates the end of the flags and thus enables the
3124           following (URL) argument to start with -. */
3125        stillflags = FALSE;
3126      else {
3127        const char *nextarg = NULL;
3128        if(i < (argc - 1)) {
3129          nextarg = convert_tchar_to_UTF8(argv[i + 1]);
3130          if(!nextarg) {
3131            unicodefree(CURL_UNCONST(orig_opt));
3132            return PARAM_NO_MEM;
3133          }
3134        }
3135
3136        err = getparameter(orig_opt, nextarg, &passarg, config,
3137                           CONFIG_MAX_LEVELS);
3138
3139        unicodefree(CURL_UNCONST(nextarg));
3140        config = global->last;
3141        if(err == PARAM_NEXT_OPERATION) {
3142          /* Reset err as PARAM_NEXT_OPERATION is only used here and not
3143             returned from this function */
3144          err = PARAM_OK;
3145
3146          if(config->url_list && config->url_list->url) {
3147            /* Allocate the next config */
3148            config->next = config_alloc();
3149            if(config->next) {
3150              /* Update the last config pointer */
3151              global->last = config->next;
3152
3153              /* Move onto the new config */
3154              config->next->prev = config;
3155              config = config->next;
3156            }
3157            else
3158              err = PARAM_NO_MEM;
3159          }
3160          else {
3161            errorf("missing URL before --next");
3162            err = PARAM_BAD_USE;
3163          }
3164        }
3165        else if(!err && passarg)
3166          i++; /* we are supposed to skip this */
3167      }
3168    }
3169    else {
3170      bool used;
3171
3172      /* add the URL please */
3173      err = getparameter("--url", orig_opt, &used, config, 0);
3174    }
3175
3176    if(!err) {
3177      unicodefree(CURL_UNCONST(orig_opt));
3178      orig_opt = NULL;
3179    }
3180  }
3181
3182  if(!err && config->content_disposition) {
3183    if(config->resume_from_current)
3184      err = PARAM_CONTDISP_RESUME_FROM;
3185  }
3186
3187  if(err &&
3188     err != PARAM_HELP_REQUESTED &&
3189     err != PARAM_MANUAL_REQUESTED &&
3190     err != PARAM_VERSION_INFO_REQUESTED &&
3191     err != PARAM_ENGINES_REQUESTED &&
3192     err != PARAM_CA_EMBED_REQUESTED) {
3193    const char *reason = param2text(err);
3194
3195    if(orig_opt && strcmp(":", orig_opt))
3196      helpf("option %s: %s", orig_opt, reason);
3197    else
3198      helpf("%s", reason);
3199  }
3200
3201  unicodefree(CURL_UNCONST(orig_opt));
3202  return err;
3203}