return PARAM_OK;
}
+/* one enum for every command line option. The name is the verbatim long
+ option name, but in uppercase with periods and minuses replaced with
+ underscores using a "C_" prefix. */
+typedef enum {
+ C_ABSTRACT_UNIX_SOCKET,
+ C_ALPN,
+ C_ALT_SVC,
+ C_ANYAUTH,
+ C_APPEND,
+ C_AWS_SIGV4,
+ C_BASIC,
+ C_BUFFER,
+ C_CA_NATIVE,
+ C_CACERT,
+ C_CAPATH,
+ C_CERT,
+ C_CERT_STATUS,
+ C_CERT_TYPE,
+ C_CIPHERS,
+ C_CLOBBER,
+ C_COMPRESSED,
+ C_COMPRESSED_SSH,
+ C_CONFIG,
+ C_CONNECT_TIMEOUT,
+ C_CONNECT_TO,
+ C_CONTINUE_AT,
+ C_COOKIE,
+ C_COOKIE_JAR,
+ C_CREATE_DIRS,
+ C_CREATE_FILE_MODE,
+ C_CRLF,
+ C_CRLFILE,
+ C_CURVES,
+ C_DATA,
+ C_DATA_ASCII,
+ C_DATA_BINARY,
+ C_DATA_RAW,
+ C_DATA_URLENCODE,
+ C_DELEGATION,
+ C_DIGEST,
+ C_DISABLE,
+ C_DISABLE_EPRT,
+ C_DISABLE_EPSV,
+ C_DISALLOW_USERNAME_IN_URL,
+ C_DNS_INTERFACE,
+ C_DNS_IPV4_ADDR,
+ C_DNS_IPV6_ADDR,
+ C_DNS_SERVERS,
+ C_DOH_CERT_STATUS,
+ C_DOH_INSECURE,
+ C_DOH_URL,
+ C_DUMP_HEADER,
+ C_EGD_FILE,
+ C_ENGINE,
+ C_EPRT,
+ C_EPSV,
+ C_ETAG_COMPARE,
+ C_ETAG_SAVE,
+ C_EXPECT100_TIMEOUT,
+ C_FAIL,
+ C_FAIL_EARLY,
+ C_FAIL_WITH_BODY,
+ C_FALSE_START,
+ C_FORM,
+ C_FORM_ESCAPE,
+ C_FORM_STRING,
+ C_FTP_ACCOUNT,
+ C_FTP_ALTERNATIVE_TO_USER,
+ C_FTP_CREATE_DIRS,
+ C_FTP_METHOD,
+ C_FTP_PASV,
+ C_FTP_PORT,
+ C_FTP_PRET,
+ C_FTP_SKIP_PASV_IP,
+ C_FTP_SSL,
+ C_FTP_SSL_CCC,
+ C_FTP_SSL_CCC_MODE,
+ C_FTP_SSL_CONTROL,
+ C_FTP_SSL_REQD,
+ C_GET,
+ C_GLOBOFF,
+ C_HAPPY_EYEBALLS_TIMEOUT_MS,
+ C_HAPROXY_CLIENTIP,
+ C_HAPROXY_PROTOCOL,
+ C_HEAD,
+ C_HEADER,
+ C_HELP,
+ C_HOSTPUBMD5,
+ C_HOSTPUBSHA256,
+ C_HSTS,
+ C_HTTP0_9,
+ C_HTTP1_0,
+ C_HTTP1_1,
+ C_HTTP2,
+ C_HTTP2_PRIOR_KNOWLEDGE,
+ C_HTTP3,
+ C_HTTP3_ONLY,
+ C_IGNORE_CONTENT_LENGTH,
+ C_INCLUDE,
+ C_INSECURE,
+ C_INTERFACE,
+ C_IPFS_GATEWAY,
+ C_IPV4,
+ C_IPV6,
+ C_JSON,
+ C_JUNK_SESSION_COOKIES,
+ C_KEEPALIVE,
+ C_KEEPALIVE_TIME,
+ C_KEY,
+ C_KEY_TYPE,
+ C_KRB,
+ C_KRB4,
+ C_LIBCURL,
+ C_LIMIT_RATE,
+ C_LIST_ONLY,
+ C_LOCAL_PORT,
+ C_LOCATION,
+ C_LOCATION_TRUSTED,
+ C_LOGIN_OPTIONS,
+ C_MAIL_AUTH,
+ C_MAIL_FROM,
+ C_MAIL_RCPT,
+ C_MAIL_RCPT_ALLOWFAILS,
+ C_MANUAL,
+ C_MAX_FILESIZE,
+ C_MAX_REDIRS,
+ C_MAX_TIME,
+ C_METALINK,
+ C_NEGOTIATE,
+ C_NETRC,
+ C_NETRC_FILE,
+ C_NETRC_OPTIONAL,
+ C_NEXT,
+ C_NOPROXY,
+ C_NPN,
+ C_NTLM,
+ C_NTLM_WB,
+ C_OAUTH2_BEARER,
+ C_OUTPUT,
+ C_OUTPUT_DIR,
+ C_PARALLEL,
+ C_PARALLEL_IMMEDIATE,
+ C_PARALLEL_MAX,
+ C_PASS,
+ C_PATH_AS_IS,
+ C_PINNEDPUBKEY,
+ C_POST301,
+ C_POST302,
+ C_POST303,
+ C_PREPROXY,
+ C_PROGRESS_BAR,
+ C_PROGRESS_METER,
+ C_PROTO,
+ C_PROTO_DEFAULT,
+ C_PROTO_REDIR,
+ C_PROXY,
+ C_PROXY_ANYAUTH,
+ C_PROXY_BASIC,
+ C_PROXY_CA_NATIVE,
+ C_PROXY_CACERT,
+ C_PROXY_CAPATH,
+ C_PROXY_CERT,
+ C_PROXY_CERT_TYPE,
+ C_PROXY_CIPHERS,
+ C_PROXY_CRLFILE,
+ C_PROXY_DIGEST,
+ C_PROXY_HEADER,
+ C_PROXY_HTTP2,
+ C_PROXY_INSECURE,
+ C_PROXY_KEY,
+ C_PROXY_KEY_TYPE,
+ C_PROXY_NEGOTIATE,
+ C_PROXY_NTLM,
+ C_PROXY_PASS,
+ C_PROXY_PINNEDPUBKEY,
+ C_PROXY_SERVICE_NAME,
+ C_PROXY_SSL_ALLOW_BEAST,
+ C_PROXY_SSL_AUTO_CLIENT_CERT,
+ C_PROXY_TLS13_CIPHERS,
+ C_PROXY_TLSAUTHTYPE,
+ C_PROXY_TLSPASSWORD,
+ C_PROXY_TLSUSER,
+ C_PROXY_TLSV1,
+ C_PROXY_USER,
+ C_PROXY1_0,
+ C_PROXYTUNNEL,
+ C_PUBKEY,
+ C_QUOTE,
+ C_RANDOM_FILE,
+ C_RANGE,
+ C_RATE,
+ C_RAW,
+ C_REFERER,
+ C_REMOTE_HEADER_NAME,
+ C_REMOTE_NAME,
+ C_REMOTE_NAME_ALL,
+ C_REMOTE_TIME,
+ C_REMOVE_ON_ERROR,
+ C_REQUEST,
+ C_REQUEST_TARGET,
+ C_RESOLVE,
+ C_RETRY,
+ C_RETRY_ALL_ERRORS,
+ C_RETRY_CONNREFUSED,
+ C_RETRY_DELAY,
+ C_RETRY_MAX_TIME,
+ C_SASL_AUTHZID,
+ C_SASL_IR,
+ C_SERVICE_NAME,
+ C_SESSIONID,
+ C_SHOW_ERROR,
+ C_SILENT,
+ C_SOCKS4,
+ C_SOCKS4A,
+ C_SOCKS5,
+ C_SOCKS5_BASIC,
+ C_SOCKS5_GSSAPI,
+ C_SOCKS5_GSSAPI_NEC,
+ C_SOCKS5_GSSAPI_SERVICE,
+ C_SOCKS5_HOSTNAME,
+ C_SPEED_LIMIT,
+ C_SPEED_TIME,
+ C_SSL,
+ C_SSL_ALLOW_BEAST,
+ C_SSL_AUTO_CLIENT_CERT,
+ C_SSL_NO_REVOKE,
+ C_SSL_REQD,
+ C_SSL_REVOKE_BEST_EFFORT,
+ C_SSLV2,
+ C_SSLV3,
+ C_STDERR,
+ C_STYLED_OUTPUT,
+ C_SUPPRESS_CONNECT_HEADERS,
+ C_TCP_FASTOPEN,
+ C_TCP_NODELAY,
+ C_TELNET_OPTION,
+ C_TEST_EVENT,
+ C_TFTP_BLKSIZE,
+ C_TFTP_NO_OPTIONS,
+ C_TIME_COND,
+ C_TLS_MAX,
+ C_TLS13_CIPHERS,
+ C_TLSAUTHTYPE,
+ C_TLSPASSWORD,
+ C_TLSUSER,
+ C_TLSV1,
+ C_TLSV1_0,
+ C_TLSV1_1,
+ C_TLSV1_2,
+ C_TLSV1_3,
+ C_TR_ENCODING,
+ C_TRACE,
+ C_TRACE_ASCII,
+ C_TRACE_CONFIG,
+ C_TRACE_IDS,
+ C_TRACE_TIME,
+ C_UNIX_SOCKET,
+ C_UPLOAD_FILE,
+ C_URL,
+ C_URL_QUERY,
+ C_USE_ASCII,
+ C_USER,
+ C_USER_AGENT,
+ C_VARIABLE,
+ C_VERBOSE,
+ C_VERSION,
+ C_WDEBUG,
+ C_WRITE_OUT,
+ C_XATTR
+} cmdline_t;
+
struct LongShort {
const char *lname; /* long name option */
enum {
- ARG_NONE, /* stand-alone but not a boolean */
- ARG_BOOL, /* accepts a --no-[name] prefix */
- ARG_STRING, /* requires an argument */
- ARG_FILENAME /* requires an argument, usually a file name */
+ ARG_NONE, /* stand-alone but not a boolean */
+ ARG_BOOL, /* accepts a --no-[name] prefix */
+ ARG_STRG, /* requires an argument */
+ ARG_FILE /* requires an argument, usually a file name */
} desc;
- const char *letter; /* short name option */
- /* 'letter' strings with more than one character have *no* short option. */
+ char letter; /* short name option or ' ' */
+ cmdline_t cmd;
};
/* this array MUST be alphasorted based on the 'lname' */
static const struct LongShort aliases[]= {
- {"abstract-unix-socket", ARG_FILENAME, "$W"},
- {"alpn", ARG_BOOL, "*H"},
- {"alt-svc", ARG_STRING, "ba"},
- {"anyauth", ARG_BOOL, "*o"},
- {"append", ARG_BOOL, "a",},
- {"aws-sigv4", ARG_STRING, "*V"},
- {"basic", ARG_BOOL, "*n"},
- {"buffer", ARG_BOOL, "N",},
- {"ca-native", ARG_BOOL, "EG"},
- {"cacert", ARG_FILENAME, "Ea"},
- {"capath", ARG_FILENAME, "Eg"},
- {"cert", ARG_FILENAME, "E",},
- {"cert-status", ARG_BOOL, "Eq"},
- {"cert-type", ARG_STRING, "Eb"},
- {"ciphers", ARG_STRING, "*d"},
- {"clobber", ARG_BOOL, "Oc"},
- {"compressed", ARG_BOOL, "*j"},
- {"compressed-ssh", ARG_BOOL, "$Z"},
- {"config", ARG_FILENAME, "K",},
- {"connect-timeout", ARG_STRING, "*c"},
- {"connect-to", ARG_STRING, "$U"},
- {"continue-at", ARG_STRING, "C",},
- {"cookie", ARG_STRING, "b",},
- {"cookie-jar", ARG_STRING, "c",},
- {"create-dirs", ARG_BOOL, "*r"},
- {"create-file-mode", ARG_STRING, "*R"},
- {"crlf", ARG_BOOL, "*u"},
- {"crlfile", ARG_FILENAME, "Ej"},
- {"curves", ARG_STRING, "EE"},
- {"data", ARG_STRING, "d",},
- {"data-ascii", ARG_STRING, "da"},
- {"data-binary", ARG_STRING, "db"},
- {"data-raw", ARG_STRING, "dr"},
- {"data-urlencode", ARG_STRING, "de"},
- {"delegation", ARG_STRING, "$G"},
- {"digest", ARG_BOOL, "*k"},
- {"disable", ARG_BOOL, "q",},
- {"disable-eprt", ARG_BOOL, "*z"},
- {"disable-epsv", ARG_BOOL, "*e"},
- {"disallow-username-in-url", ARG_BOOL, "*f"},
- {"dns-interface", ARG_STRING, "*D"},
- {"dns-ipv4-addr", ARG_STRING, "*4"},
- {"dns-ipv6-addr", ARG_STRING, "*6"},
- {"dns-servers", ARG_STRING, "*F"},
- {"doh-cert-status", ARG_BOOL, "EQ"},
- {"doh-insecure", ARG_BOOL, "kd"},
- {"doh-url" , ARG_STRING, "*C"},
- {"dump-header", ARG_FILENAME, "D",},
- {"egd-file", ARG_STRING, "*b"},
- {"engine", ARG_STRING, "Ef"},
- {"eprt", ARG_BOOL, "*Z"},
- {"epsv", ARG_BOOL, "*E"},
- {"etag-compare", ARG_FILENAME, "ED"},
- {"etag-save", ARG_FILENAME, "EC"},
- {"expect100-timeout", ARG_STRING, "$R"},
- {"fail", ARG_BOOL, "f",},
- {"fail-early", ARG_BOOL, "fa"},
- {"fail-with-body", ARG_BOOL, "fd"},
- {"false-start", ARG_BOOL, "Er"},
- {"form", ARG_STRING, "F",},
- {"form-escape", ARG_BOOL, "$l"},
- {"form-string", ARG_STRING, "Fs"},
- {"ftp-account", ARG_STRING, "$m"},
- {"ftp-alternative-to-user", ARG_STRING, "$u"},
- {"ftp-create-dirs", ARG_BOOL, "*q"},
- {"ftp-method", ARG_STRING, "$r"},
- {"ftp-pasv", ARG_BOOL, "$b"},
- {"ftp-port", ARG_STRING, "P",},
- {"ftp-pret", ARG_BOOL, "$C"},
- {"ftp-skip-pasv-ip", ARG_BOOL, "$q"},
- {"ftp-ssl", ARG_BOOL, "$a"},
- {"ftp-ssl-ccc", ARG_BOOL, "$y"},
- {"ftp-ssl-ccc-mode", ARG_STRING, "$j"},
- {"ftp-ssl-control", ARG_BOOL, "$x"},
- {"ftp-ssl-reqd", ARG_BOOL, "$v"},
- {"get", ARG_BOOL, "G",},
- {"globoff", ARG_BOOL, "g",},
- {"happy-eyeballs-timeout-ms", ARG_STRING, "$~"},
- {"haproxy-clientip", ARG_STRING, "*P"},
- {"haproxy-protocol", ARG_BOOL, "*X"},
- {"head", ARG_BOOL, "I",},
- {"header", ARG_STRING, "H",},
- {"help", ARG_BOOL, "h",},
- {"hostpubmd5", ARG_STRING, "Ei"},
- {"hostpubsha256", ARG_STRING, "EF"},
- {"hsts", ARG_STRING, "bb"},
- {"http0.9", ARG_BOOL, "09"},
- {"http1.0", ARG_NONE, "0",},
- {"http1.1", ARG_NONE, "01"},
- {"http2", ARG_NONE, "02"},
- {"http2-prior-knowledge", ARG_NONE, "03"},
- {"http3", ARG_NONE, "04"},
- {"http3-only", ARG_NONE, "05"},
- {"ignore-content-length", ARG_BOOL, "$p"},
- {"include", ARG_BOOL, "i",},
- {"insecure", ARG_BOOL, "k",},
- {"interface", ARG_STRING, "*w"},
- {"ipfs-gateway", ARG_STRING, "*S"},
- {"ipv4", ARG_NONE, "4",},
- {"ipv6", ARG_NONE, "6",},
- {"json", ARG_STRING, "df"},
- {"junk-session-cookies", ARG_BOOL, "j",},
- {"keepalive", ARG_BOOL, "$1"},
- {"keepalive-time", ARG_STRING, "$3"},
- {"key", ARG_FILENAME, "Ec"},
- {"key-type", ARG_STRING, "Ed"},
- {"krb", ARG_STRING, "*x"},
- {"krb4", ARG_STRING, "*x"},
- {"libcurl", ARG_STRING, "$z"},
- {"limit-rate", ARG_STRING, "*i"},
- {"list-only", ARG_BOOL, "l",},
- {"local-port", ARG_STRING, "$s"},
- {"location", ARG_BOOL, "L",},
- {"location-trusted", ARG_BOOL, "Lt"},
- {"login-options", ARG_STRING, "E5"},
- {"mail-auth", ARG_STRING, "$H"},
- {"mail-from", ARG_STRING, "$A"},
- {"mail-rcpt", ARG_STRING, "$B"},
- {"mail-rcpt-allowfails", ARG_BOOL, "fc"},
- {"manual", ARG_BOOL, "M",},
- {"max-filesize", ARG_STRING, "*y"},
- {"max-redirs", ARG_STRING, "*s"},
- {"max-time", ARG_STRING, "m",},
- {"metalink", ARG_BOOL, "$J"},
- {"negotiate", ARG_BOOL, "*l"},
- {"netrc", ARG_BOOL, "n",},
- {"netrc-file", ARG_FILENAME, "ne"},
- {"netrc-optional", ARG_BOOL, "no"},
- {"next", ARG_NONE, ":",},
- {"noproxy", ARG_STRING, "$5"},
- {"npn", ARG_BOOL, "*G"},
- {"ntlm", ARG_BOOL, "*m"},
- {"ntlm-wb", ARG_BOOL, "*M"},
- {"oauth2-bearer", ARG_STRING, "*B"},
- {"output", ARG_FILENAME, "o",},
- {"output-dir", ARG_STRING, "Ob"},
- {"parallel", ARG_BOOL, "Z",},
- {"parallel-immediate", ARG_BOOL, "Zc"},
- {"parallel-max", ARG_STRING, "Zb"},
- {"pass", ARG_STRING, "Ee"},
- {"path-as-is", ARG_BOOL, "$N"},
- {"pinnedpubkey", ARG_STRING, "Ep"},
- {"post301", ARG_BOOL, "$0"},
- {"post302", ARG_BOOL, "$4"},
- {"post303", ARG_BOOL, "$I"},
- {"preproxy", ARG_STRING, "xa"},
- {"progress-bar", ARG_BOOL, "#",},
- {"progress-meter", ARG_BOOL, "#m"},
- {"proto", ARG_STRING, "$D"},
- {"proto-default", ARG_STRING, "$Q"},
- {"proto-redir", ARG_STRING, "$E"},
- {"proxy", ARG_STRING, "x",},
- {"proxy-anyauth", ARG_BOOL, "$n"},
- {"proxy-basic", ARG_BOOL, "$f"},
- {"proxy-ca-native", ARG_BOOL, "EH"},
- {"proxy-cacert", ARG_FILENAME, "E6"},
- {"proxy-capath", ARG_FILENAME, "E7"},
- {"proxy-cert", ARG_FILENAME, "Ex"},
- {"proxy-cert-type", ARG_STRING, "Ey"},
- {"proxy-ciphers", ARG_STRING, "E2"},
- {"proxy-crlfile", ARG_FILENAME, "E3"},
- {"proxy-digest", ARG_BOOL, "$e"},
- {"proxy-header", ARG_STRING, "Hp"},
- {"proxy-http2", ARG_BOOL, "0a"},
- {"proxy-insecure", ARG_BOOL, "E8"},
- {"proxy-key", ARG_FILENAME, "Ez"},
- {"proxy-key-type", ARG_STRING, "E0"},
- {"proxy-negotiate", ARG_BOOL, "$k"},
- {"proxy-ntlm", ARG_BOOL, "*t"},
- {"proxy-pass", ARG_STRING, "E1"},
- {"proxy-pinnedpubkey", ARG_STRING, "EP"},
- {"proxy-service-name", ARG_STRING, "$O"},
- {"proxy-ssl-allow-beast", ARG_BOOL, "E4"},
- {"proxy-ssl-auto-client-cert", ARG_BOOL, "EO"},
- {"proxy-tls13-ciphers", ARG_STRING, "1B"},
- {"proxy-tlsauthtype", ARG_STRING, "Ew"},
- {"proxy-tlspassword", ARG_STRING, "Ev"},
- {"proxy-tlsuser", ARG_STRING, "Eu"},
- {"proxy-tlsv1", ARG_NONE, "E9"},
- {"proxy-user", ARG_STRING, "U",},
- {"proxy1.0", ARG_STRING, "$8"},
- {"proxytunnel", ARG_BOOL, "p",},
- {"pubkey", ARG_STRING, "Eh"},
- {"quote", ARG_STRING, "Q",},
- {"random-file", ARG_FILENAME, "*a"},
- {"range", ARG_STRING, "r",},
- {"rate", ARG_STRING, "*I"},
- {"raw", ARG_BOOL, "$#"},
- {"referer", ARG_STRING, "e",},
- {"remote-header-name", ARG_BOOL, "J",},
- {"remote-name", ARG_BOOL, "O",},
- {"remote-name-all", ARG_BOOL, "Oa"},
- {"remote-time", ARG_BOOL, "R",},
- {"remove-on-error", ARG_BOOL, "fe"},
- {"request", ARG_STRING, "X",},
- {"request-target", ARG_STRING, "Ga"},
- {"resolve", ARG_STRING, "$F"},
- {"retry", ARG_STRING, "$g"},
- {"retry-all-errors", ARG_BOOL, "$!"},
- {"retry-connrefused", ARG_BOOL, "$V"},
- {"retry-delay", ARG_STRING, "$h"},
- {"retry-max-time", ARG_STRING, "$i"},
- {"sasl-authzid", ARG_STRING, "$6"},
- {"sasl-ir", ARG_BOOL, "$K"},
- {"service-name", ARG_STRING, "$P"},
- {"sessionid", ARG_BOOL, "$w"},
- {"show-error", ARG_BOOL, "S",},
- {"silent", ARG_BOOL, "s",},
- {"socks4", ARG_STRING, "$t"},
- {"socks4a", ARG_STRING, "$T"},
- {"socks5", ARG_STRING, "$c"},
- {"socks5-basic", ARG_BOOL, "EA"},
- {"socks5-gssapi", ARG_BOOL, "EB"},
- {"socks5-gssapi-nec", ARG_BOOL, "$7"},
- {"socks5-gssapi-service", ARG_STRING, "$O"},
- {"socks5-hostname", ARG_STRING, "$2"},
- {"speed-limit", ARG_STRING, "Y",},
- {"speed-time", ARG_STRING, "y",},
- {"ssl", ARG_BOOL, "$a"},
- {"ssl-allow-beast", ARG_BOOL, "En"},
- {"ssl-auto-client-cert", ARG_BOOL, "Eo"},
- {"ssl-no-revoke", ARG_BOOL, "Es"},
- {"ssl-reqd", ARG_BOOL, "$v"},
- {"ssl-revoke-best-effort", ARG_BOOL, "ES"},
- {"sslv2", ARG_NONE, "2",},
- {"sslv3", ARG_NONE, "3",},
- {"stderr", ARG_FILENAME, "*v"},
- {"styled-output", ARG_BOOL, "fb"},
- {"suppress-connect-headers", ARG_BOOL, "$Y"},
- {"tcp-fastopen", ARG_BOOL, "Et"},
- {"tcp-nodelay", ARG_BOOL, "$d"},
- {"telnet-option", ARG_STRING, "t",},
- {"test-event", ARG_BOOL, "$L"},
- {"tftp-blksize", ARG_STRING, "$9"},
- {"tftp-no-options", ARG_BOOL, "$S"},
- {"time-cond", ARG_STRING, "z",},
- {"tls-max", ARG_STRING, "$X"},
- {"tls13-ciphers", ARG_STRING, "1A"},
- {"tlsauthtype", ARG_STRING, "Em"},
- {"tlspassword", ARG_STRING, "El"},
- {"tlsuser", ARG_STRING, "Ek"},
- {"tlsv1", ARG_NONE, "1",},
- {"tlsv1.0", ARG_NONE, "10"},
- {"tlsv1.1", ARG_NONE, "11"},
- {"tlsv1.2", ARG_NONE, "12"},
- {"tlsv1.3", ARG_NONE, "13"},
- {"tr-encoding", ARG_BOOL, "*J"},
- {"trace", ARG_FILENAME, "*g"},
- {"trace-ascii", ARG_FILENAME, "*h"},
- {"trace-config", ARG_STRING, "$&"},
- {"trace-ids", ARG_BOOL, "$%"},
- {"trace-time", ARG_BOOL, "$o"},
- {"unix-socket", ARG_FILENAME, "$M"},
- {"upload-file", ARG_FILENAME, "T",},
- {"url", ARG_STRING, "*@"},
- {"url-query", ARG_STRING, "dg"},
- {"use-ascii", ARG_BOOL, "B",},
- {"user", ARG_STRING, "u",},
- {"user-agent", ARG_STRING, "A",},
- {"variable", ARG_STRING, ":a"},
- {"verbose", ARG_BOOL, "v",},
- {"version", ARG_BOOL, "V",},
+ {"abstract-unix-socket", ARG_FILE, ' ', C_ABSTRACT_UNIX_SOCKET},
+ {"alpn", ARG_BOOL, ' ', C_ALPN},
+ {"alt-svc", ARG_STRG, ' ', C_ALT_SVC},
+ {"anyauth", ARG_BOOL, ' ', C_ANYAUTH},
+ {"append", ARG_BOOL, 'a', C_APPEND},
+ {"aws-sigv4", ARG_STRG, ' ', C_AWS_SIGV4},
+ {"basic", ARG_BOOL, ' ', C_BASIC},
+ {"buffer", ARG_BOOL, 'N', C_BUFFER},
+ {"ca-native", ARG_BOOL, ' ', C_CA_NATIVE},
+ {"cacert", ARG_FILE, ' ', C_CACERT},
+ {"capath", ARG_FILE, ' ', C_CAPATH},
+ {"cert", ARG_FILE, 'E', C_CERT},
+ {"cert-status", ARG_BOOL, ' ', C_CERT_STATUS},
+ {"cert-type", ARG_STRG, ' ', C_CERT_TYPE},
+ {"ciphers", ARG_STRG, ' ', C_CIPHERS},
+ {"clobber", ARG_BOOL, ' ', C_CLOBBER},
+ {"compressed", ARG_BOOL, ' ', C_COMPRESSED},
+ {"compressed-ssh", ARG_BOOL, ' ', C_COMPRESSED_SSH},
+ {"config", ARG_FILE, 'K', C_CONFIG},
+ {"connect-timeout", ARG_STRG, ' ', C_CONNECT_TIMEOUT},
+ {"connect-to", ARG_STRG, ' ', C_CONNECT_TO},
+ {"continue-at", ARG_STRG, 'C', C_CONTINUE_AT},
+ {"cookie", ARG_STRG, 'b', C_COOKIE},
+ {"cookie-jar", ARG_STRG, 'c', C_COOKIE_JAR},
+ {"create-dirs", ARG_BOOL, ' ', C_CREATE_DIRS},
+ {"create-file-mode", ARG_STRG, ' ', C_CREATE_FILE_MODE},
+ {"crlf", ARG_BOOL, ' ', C_CRLF},
+ {"crlfile", ARG_FILE, ' ', C_CRLFILE},
+ {"curves", ARG_STRG, ' ', C_CURVES},
+ {"data", ARG_STRG, 'd', C_DATA},
+ {"data-ascii", ARG_STRG, ' ', C_DATA_ASCII},
+ {"data-binary", ARG_STRG, ' ', C_DATA_BINARY},
+ {"data-raw", ARG_STRG, ' ', C_DATA_RAW},
+ {"data-urlencode", ARG_STRG, ' ', C_DATA_URLENCODE},
+ {"delegation", ARG_STRG, ' ', C_DELEGATION},
+ {"digest", ARG_BOOL, ' ', C_DIGEST},
+ {"disable", ARG_BOOL, 'q', C_DISABLE},
+ {"disable-eprt", ARG_BOOL, ' ', C_DISABLE_EPRT},
+ {"disable-epsv", ARG_BOOL, ' ', C_DISABLE_EPSV},
+ {"disallow-username-in-url", ARG_BOOL, ' ', C_DISALLOW_USERNAME_IN_URL},
+ {"dns-interface", ARG_STRG, ' ', C_DNS_INTERFACE},
+ {"dns-ipv4-addr", ARG_STRG, ' ', C_DNS_IPV4_ADDR},
+ {"dns-ipv6-addr", ARG_STRG, ' ', C_DNS_IPV6_ADDR},
+ {"dns-servers", ARG_STRG, ' ', C_DNS_SERVERS},
+ {"doh-cert-status", ARG_BOOL, ' ', C_DOH_CERT_STATUS},
+ {"doh-insecure", ARG_BOOL, ' ', C_DOH_INSECURE},
+ {"doh-url" , ARG_STRG, ' ', C_DOH_URL},
+ {"dump-header", ARG_FILE, 'D', C_DUMP_HEADER},
+ {"egd-file", ARG_STRG, ' ', C_EGD_FILE},
+ {"engine", ARG_STRG, ' ', C_ENGINE},
+ {"eprt", ARG_BOOL, ' ', C_EPRT},
+ {"epsv", ARG_BOOL, ' ', C_EPSV},
+ {"etag-compare", ARG_FILE, ' ', C_ETAG_COMPARE},
+ {"etag-save", ARG_FILE, ' ', C_ETAG_SAVE},
+ {"expect100-timeout", ARG_STRG, ' ', C_EXPECT100_TIMEOUT},
+ {"fail", ARG_BOOL, 'f', C_FAIL},
+ {"fail-early", ARG_BOOL, ' ', C_FAIL_EARLY},
+ {"fail-with-body", ARG_BOOL, ' ', C_FAIL_WITH_BODY},
+ {"false-start", ARG_BOOL, ' ', C_FALSE_START},
+ {"form", ARG_STRG, 'F', C_FORM},
+ {"form-escape", ARG_BOOL, ' ', C_FORM_ESCAPE},
+ {"form-string", ARG_STRG, ' ', C_FORM_STRING},
+ {"ftp-account", ARG_STRG, ' ', C_FTP_ACCOUNT},
+ {"ftp-alternative-to-user", ARG_STRG, ' ', C_FTP_ALTERNATIVE_TO_USER},
+ {"ftp-create-dirs", ARG_BOOL, ' ', C_FTP_CREATE_DIRS},
+ {"ftp-method", ARG_STRG, ' ', C_FTP_METHOD},
+ {"ftp-pasv", ARG_BOOL, ' ', C_FTP_PASV},
+ {"ftp-port", ARG_STRG, 'P', C_FTP_PORT},
+ {"ftp-pret", ARG_BOOL, ' ', C_FTP_PRET},
+ {"ftp-skip-pasv-ip", ARG_BOOL, ' ', C_FTP_SKIP_PASV_IP},
+ {"ftp-ssl", ARG_BOOL, ' ', C_FTP_SSL},
+ {"ftp-ssl-ccc", ARG_BOOL, ' ', C_FTP_SSL_CCC},
+ {"ftp-ssl-ccc-mode", ARG_STRG, ' ', C_FTP_SSL_CCC_MODE},
+ {"ftp-ssl-control", ARG_BOOL, ' ', C_FTP_SSL_CONTROL},
+ {"ftp-ssl-reqd", ARG_BOOL, ' ', C_FTP_SSL_REQD},
+ {"get", ARG_BOOL, 'G', C_GET},
+ {"globoff", ARG_BOOL, 'g', C_GLOBOFF},
+ {"happy-eyeballs-timeout-ms", ARG_STRG, ' ', C_HAPPY_EYEBALLS_TIMEOUT_MS},
+ {"haproxy-clientip", ARG_STRG, ' ', C_HAPROXY_CLIENTIP},
+ {"haproxy-protocol", ARG_BOOL, ' ', C_HAPROXY_PROTOCOL},
+ {"head", ARG_BOOL, 'I', C_HEAD},
+ {"header", ARG_STRG, 'H', C_HEADER},
+ {"help", ARG_BOOL, 'h', C_HELP},
+ {"hostpubmd5", ARG_STRG, ' ', C_HOSTPUBMD5},
+ {"hostpubsha256", ARG_STRG, ' ', C_HOSTPUBSHA256},
+ {"hsts", ARG_STRG, ' ', C_HSTS},
+ {"http0.9", ARG_BOOL, ' ', C_HTTP0_9},
+ {"http1.0", ARG_NONE, '0', C_HTTP1_0},
+ {"http1.1", ARG_NONE, ' ', C_HTTP1_1},
+ {"http2", ARG_NONE, ' ', C_HTTP2},
+ {"http2-prior-knowledge", ARG_NONE, ' ', C_HTTP2_PRIOR_KNOWLEDGE},
+ {"http3", ARG_NONE, ' ', C_HTTP3},
+ {"http3-only", ARG_NONE, ' ', C_HTTP3_ONLY},
+ {"ignore-content-length", ARG_BOOL, ' ', C_IGNORE_CONTENT_LENGTH},
+ {"include", ARG_BOOL, 'i', C_INCLUDE},
+ {"insecure", ARG_BOOL, 'k', C_INSECURE},
+ {"interface", ARG_STRG, ' ', C_INTERFACE},
+ {"ipfs-gateway", ARG_STRG, ' ', C_IPFS_GATEWAY},
+ {"ipv4", ARG_NONE, '4', C_IPV4},
+ {"ipv6", ARG_NONE, '6', C_IPV6},
+ {"json", ARG_STRG, ' ', C_JSON},
+ {"junk-session-cookies", ARG_BOOL, 'j', C_JUNK_SESSION_COOKIES},
+ {"keepalive", ARG_BOOL, ' ', C_KEEPALIVE},
+ {"keepalive-time", ARG_STRG, ' ', C_KEEPALIVE_TIME},
+ {"key", ARG_FILE, ' ', C_KEY},
+ {"key-type", ARG_STRG, ' ', C_KEY_TYPE},
+ {"krb", ARG_STRG, ' ', C_KRB},
+ {"krb4", ARG_STRG, ' ', C_KRB4},
+ {"libcurl", ARG_STRG, ' ', C_LIBCURL},
+ {"limit-rate", ARG_STRG, ' ', C_LIMIT_RATE},
+ {"list-only", ARG_BOOL, 'l', C_LIST_ONLY},
+ {"local-port", ARG_STRG, ' ', C_LOCAL_PORT},
+ {"location", ARG_BOOL, 'L', C_LOCATION},
+ {"location-trusted", ARG_BOOL, ' ', C_LOCATION_TRUSTED},
+ {"login-options", ARG_STRG, ' ', C_LOGIN_OPTIONS},
+ {"mail-auth", ARG_STRG, ' ', C_MAIL_AUTH},
+ {"mail-from", ARG_STRG, ' ', C_MAIL_FROM},
+ {"mail-rcpt", ARG_STRG, ' ', C_MAIL_RCPT},
+ {"mail-rcpt-allowfails", ARG_BOOL, ' ', C_MAIL_RCPT_ALLOWFAILS},
+ {"manual", ARG_BOOL, 'M', C_MANUAL},
+ {"max-filesize", ARG_STRG, ' ', C_MAX_FILESIZE},
+ {"max-redirs", ARG_STRG, ' ', C_MAX_REDIRS},
+ {"max-time", ARG_STRG, 'm', C_MAX_TIME},
+ {"metalink", ARG_BOOL, ' ', C_METALINK},
+ {"negotiate", ARG_BOOL, ' ', C_NEGOTIATE},
+ {"netrc", ARG_BOOL, 'n', C_NETRC},
+ {"netrc-file", ARG_FILE, ' ', C_NETRC_FILE},
+ {"netrc-optional", ARG_BOOL, ' ', C_NETRC_OPTIONAL},
+ {"next", ARG_NONE, ':', C_NEXT},
+ {"noproxy", ARG_STRG, ' ', C_NOPROXY},
+ {"npn", ARG_BOOL, ' ', C_NPN},
+ {"ntlm", ARG_BOOL, ' ', C_NTLM},
+ {"ntlm-wb", ARG_BOOL, ' ', C_NTLM_WB},
+ {"oauth2-bearer", ARG_STRG, ' ', C_OAUTH2_BEARER},
+ {"output", ARG_FILE, 'o', C_OUTPUT},
+ {"output-dir", ARG_STRG, ' ', C_OUTPUT_DIR},
+ {"parallel", ARG_BOOL, 'Z', C_PARALLEL},
+ {"parallel-immediate", ARG_BOOL, ' ', C_PARALLEL_IMMEDIATE},
+ {"parallel-max", ARG_STRG, ' ', C_PARALLEL_MAX},
+ {"pass", ARG_STRG, ' ', C_PASS},
+ {"path-as-is", ARG_BOOL, ' ', C_PATH_AS_IS},
+ {"pinnedpubkey", ARG_STRG, ' ', C_PINNEDPUBKEY},
+ {"post301", ARG_BOOL, ' ', C_POST301},
+ {"post302", ARG_BOOL, ' ', C_POST302},
+ {"post303", ARG_BOOL, ' ', C_POST303},
+ {"preproxy", ARG_STRG, ' ', C_PREPROXY},
+ {"progress-bar", ARG_BOOL, '#', C_PROGRESS_BAR},
+ {"progress-meter", ARG_BOOL, ' ', C_PROGRESS_METER},
+ {"proto", ARG_STRG, ' ', C_PROTO},
+ {"proto-default", ARG_STRG, ' ', C_PROTO_DEFAULT},
+ {"proto-redir", ARG_STRG, ' ', C_PROTO_REDIR},
+ {"proxy", ARG_STRG, 'x', C_PROXY},
+ {"proxy-anyauth", ARG_BOOL, ' ', C_PROXY_ANYAUTH},
+ {"proxy-basic", ARG_BOOL, ' ', C_PROXY_BASIC},
+ {"proxy-ca-native", ARG_BOOL, ' ', C_PROXY_CA_NATIVE},
+ {"proxy-cacert", ARG_FILE, ' ', C_PROXY_CACERT},
+ {"proxy-capath", ARG_FILE, ' ', C_PROXY_CAPATH},
+ {"proxy-cert", ARG_FILE, ' ', C_PROXY_CERT},
+ {"proxy-cert-type", ARG_STRG, ' ', C_PROXY_CERT_TYPE},
+ {"proxy-ciphers", ARG_STRG, ' ', C_PROXY_CIPHERS},
+ {"proxy-crlfile", ARG_FILE, ' ', C_PROXY_CRLFILE},
+ {"proxy-digest", ARG_BOOL, ' ', C_PROXY_DIGEST},
+ {"proxy-header", ARG_STRG, ' ', C_PROXY_HEADER},
+ {"proxy-http2", ARG_BOOL, ' ', C_PROXY_HTTP2},
+ {"proxy-insecure", ARG_BOOL, ' ', C_PROXY_INSECURE},
+ {"proxy-key", ARG_FILE, ' ', C_PROXY_KEY},
+ {"proxy-key-type", ARG_STRG, ' ', C_PROXY_KEY_TYPE},
+ {"proxy-negotiate", ARG_BOOL, ' ', C_PROXY_NEGOTIATE},
+ {"proxy-ntlm", ARG_BOOL, ' ', C_PROXY_NTLM},
+ {"proxy-pass", ARG_STRG, ' ', C_PROXY_PASS},
+ {"proxy-pinnedpubkey", ARG_STRG, ' ', C_PROXY_PINNEDPUBKEY},
+ {"proxy-service-name", ARG_STRG, ' ', C_PROXY_SERVICE_NAME},
+ {"proxy-ssl-allow-beast", ARG_BOOL, ' ', C_PROXY_SSL_ALLOW_BEAST},
+ {"proxy-ssl-auto-client-cert", ARG_BOOL, ' ', C_PROXY_SSL_AUTO_CLIENT_CERT},
+ {"proxy-tls13-ciphers", ARG_STRG, ' ', C_PROXY_TLS13_CIPHERS},
+ {"proxy-tlsauthtype", ARG_STRG, ' ', C_PROXY_TLSAUTHTYPE},
+ {"proxy-tlspassword", ARG_STRG, ' ', C_PROXY_TLSPASSWORD},
+ {"proxy-tlsuser", ARG_STRG, ' ', C_PROXY_TLSUSER},
+ {"proxy-tlsv1", ARG_NONE, ' ', C_PROXY_TLSV1},
+ {"proxy-user", ARG_STRG, 'U', C_PROXY_USER},
+ {"proxy1.0", ARG_STRG, ' ', C_PROXY1_0},
+ {"proxytunnel", ARG_BOOL, 'p', C_PROXYTUNNEL},
+ {"pubkey", ARG_STRG, ' ', C_PUBKEY},
+ {"quote", ARG_STRG, 'Q', C_QUOTE},
+ {"random-file", ARG_FILE, ' ', C_RANDOM_FILE},
+ {"range", ARG_STRG, 'r', C_RANGE},
+ {"rate", ARG_STRG, ' ', C_RATE},
+ {"raw", ARG_BOOL, ' ', C_RAW},
+ {"referer", ARG_STRG, 'e', C_REFERER},
+ {"remote-header-name", ARG_BOOL, 'J', C_REMOTE_HEADER_NAME},
+ {"remote-name", ARG_BOOL, 'O', C_REMOTE_NAME},
+ {"remote-name-all", ARG_BOOL, ' ', C_REMOTE_NAME_ALL},
+ {"remote-time", ARG_BOOL, 'R', C_REMOTE_TIME},
+ {"remove-on-error", ARG_BOOL, ' ', C_REMOVE_ON_ERROR},
+ {"request", ARG_STRG, 'X', C_REQUEST},
+ {"request-target", ARG_STRG, ' ', C_REQUEST_TARGET},
+ {"resolve", ARG_STRG, ' ', C_RESOLVE},
+ {"retry", ARG_STRG, ' ', C_RETRY},
+ {"retry-all-errors", ARG_BOOL, ' ', C_RETRY_ALL_ERRORS},
+ {"retry-connrefused", ARG_BOOL, ' ', C_RETRY_CONNREFUSED},
+ {"retry-delay", ARG_STRG, ' ', C_RETRY_DELAY},
+ {"retry-max-time", ARG_STRG, ' ', C_RETRY_MAX_TIME},
+ {"sasl-authzid", ARG_STRG, ' ', C_SASL_AUTHZID},
+ {"sasl-ir", ARG_BOOL, ' ', C_SASL_IR},
+ {"service-name", ARG_STRG, ' ', C_SERVICE_NAME},
+ {"sessionid", ARG_BOOL, ' ', C_SESSIONID},
+ {"show-error", ARG_BOOL, 'S', C_SHOW_ERROR},
+ {"silent", ARG_BOOL, 's', C_SILENT},
+ {"socks4", ARG_STRG, ' ', C_SOCKS4},
+ {"socks4a", ARG_STRG, ' ', C_SOCKS4A},
+ {"socks5", ARG_STRG, ' ', C_SOCKS5},
+ {"socks5-basic", ARG_BOOL, ' ', C_SOCKS5_BASIC},
+ {"socks5-gssapi", ARG_BOOL, ' ', C_SOCKS5_GSSAPI},
+ {"socks5-gssapi-nec", ARG_BOOL, ' ', C_SOCKS5_GSSAPI_NEC},
+ {"socks5-gssapi-service", ARG_STRG, ' ', C_SOCKS5_GSSAPI_SERVICE},
+ {"socks5-hostname", ARG_STRG, ' ', C_SOCKS5_HOSTNAME},
+ {"speed-limit", ARG_STRG, 'Y', C_SPEED_LIMIT},
+ {"speed-time", ARG_STRG, 'y', C_SPEED_TIME},
+ {"ssl", ARG_BOOL, ' ', C_SSL},
+ {"ssl-allow-beast", ARG_BOOL, ' ', C_SSL_ALLOW_BEAST},
+ {"ssl-auto-client-cert", ARG_BOOL, ' ', C_SSL_AUTO_CLIENT_CERT},
+ {"ssl-no-revoke", ARG_BOOL, ' ', C_SSL_NO_REVOKE},
+ {"ssl-reqd", ARG_BOOL, ' ', C_SSL_REQD},
+ {"ssl-revoke-best-effort", ARG_BOOL, ' ', C_SSL_REVOKE_BEST_EFFORT},
+ {"sslv2", ARG_NONE, '2', C_SSLV2},
+ {"sslv3", ARG_NONE, '3', C_SSLV3},
+ {"stderr", ARG_FILE, ' ', C_STDERR},
+ {"styled-output", ARG_BOOL, ' ', C_STYLED_OUTPUT},
+ {"suppress-connect-headers", ARG_BOOL, ' ', C_SUPPRESS_CONNECT_HEADERS},
+ {"tcp-fastopen", ARG_BOOL, ' ', C_TCP_FASTOPEN},
+ {"tcp-nodelay", ARG_BOOL, ' ', C_TCP_NODELAY},
+ {"telnet-option", ARG_STRG, 't', C_TELNET_OPTION},
+ {"test-event", ARG_BOOL, ' ', C_TEST_EVENT},
+ {"tftp-blksize", ARG_STRG, ' ', C_TFTP_BLKSIZE},
+ {"tftp-no-options", ARG_BOOL, ' ', C_TFTP_NO_OPTIONS},
+ {"time-cond", ARG_STRG, 'z', C_TIME_COND},
+ {"tls-max", ARG_STRG, ' ', C_TLS_MAX},
+ {"tls13-ciphers", ARG_STRG, ' ', C_TLS13_CIPHERS},
+ {"tlsauthtype", ARG_STRG, ' ', C_TLSAUTHTYPE},
+ {"tlspassword", ARG_STRG, ' ', C_TLSPASSWORD},
+ {"tlsuser", ARG_STRG, ' ', C_TLSUSER},
+ {"tlsv1", ARG_NONE, '1', C_TLSV1},
+ {"tlsv1.0", ARG_NONE, ' ', C_TLSV1_0},
+ {"tlsv1.1", ARG_NONE, ' ', C_TLSV1_1},
+ {"tlsv1.2", ARG_NONE, ' ', C_TLSV1_2},
+ {"tlsv1.3", ARG_NONE, ' ', C_TLSV1_3},
+ {"tr-encoding", ARG_BOOL, ' ', C_TR_ENCODING},
+ {"trace", ARG_FILE, ' ', C_TRACE},
+ {"trace-ascii", ARG_FILE, ' ', C_TRACE_ASCII},
+ {"trace-config", ARG_STRG, ' ', C_TRACE_CONFIG},
+ {"trace-ids", ARG_BOOL, ' ', C_TRACE_IDS},
+ {"trace-time", ARG_BOOL, ' ', C_TRACE_TIME},
+ {"unix-socket", ARG_FILE, ' ', C_UNIX_SOCKET},
+ {"upload-file", ARG_FILE, 'T', C_UPLOAD_FILE},
+ {"url", ARG_STRG, ' ', C_URL},
+ {"url-query", ARG_STRG, ' ', C_URL_QUERY},
+ {"use-ascii", ARG_BOOL, 'B', C_USE_ASCII},
+ {"user", ARG_STRG, 'u', C_USER},
+ {"user-agent", ARG_STRG, 'A', C_USER_AGENT},
+ {"variable", ARG_STRG, ' ', C_VARIABLE},
+ {"verbose", ARG_BOOL, 'v', C_VERBOSE},
+ {"version", ARG_BOOL, 'V', C_VERSION},
#ifdef USE_WATT32
- {"wdebug", ARG_BOOL, "*p"},
+ {"wdebug", ARG_BOOL, ' ', C_WDEBUG},
#endif
- {"write-out", ARG_STRING, "w",},
- {"xattr", ARG_BOOL, "*~"},
+ {"write-out", ARG_STRG, 'w', C_WRITE_OUT},
+ {"xattr", ARG_BOOL, ' ', C_XATTR},
};
/* Split the argument of -E to 'certname' and 'passphrase' separated by colon.
if(!singles_done) {
unsigned int j;
for(j = 0; j < sizeof(aliases)/sizeof(aliases[0]); j++) {
- if(!aliases[j].letter[1]) {
- unsigned char l = aliases[j].letter[0];
+ if(aliases[j].letter != ' ') {
+ unsigned char l = aliases[j].letter;
singles[l - ' '] = &aliases[j];
}
}
return err;
}
-static ParameterError set_data(char subletter,
+static ParameterError set_data(cmdline_t cmd,
char *nextarg,
struct GlobalConfig *global,
struct OperationConfig *config)
size_t size = 0;
ParameterError err = PARAM_OK;
- if(subletter == 'e') { /* --data-urlencode */
+ if(cmd == C_DATA_URLENCODE) { /* --data-urlencode */
err = data_urlencode(global, nextarg, &postdata, &size);
if(err)
return err;
}
- else if('@' == *nextarg && (subletter != 'r')) {
+ else if('@' == *nextarg && (cmd != C_DATA_RAW)) {
/* the data begins with a '@' letter, it means that a file name
or - (stdin) follows */
nextarg++; /* pass the @ */
if(!strcmp("-", nextarg)) {
file = stdin;
- if(subletter == 'b') /* forced data-binary */
+ if(cmd == C_DATA_BINARY) /* forced data-binary */
set_binmode(stdin);
}
else {
}
}
- if((subletter == 'b') || /* --data-binary */
- (subletter == 'f') /* --json */)
+ if((cmd == C_DATA_BINARY) || /* --data-binary */
+ (cmd == C_JSON) /* --json */)
/* forced binary */
err = file2memory(&postdata, &size, file);
else {
if(postdata)
size = strlen(postdata);
}
- if(subletter == 'f')
+ if(cmd == C_JSON)
config->jsoned = TRUE;
if(curlx_dyn_len(&config->postdata)) {
/* skip separator append for --json */
- if(!err && (subletter != 'f') &&
+ if(!err && (cmd != C_JSON) &&
curlx_dyn_addn(&config->postdata, "&", 1))
err = PARAM_NO_MEM;
}
}
-#define ONEOPT(x,y) (((int)x << 8) | y)
-
ParameterError getparameter(const char *flag, /* f or -long-flag */
char *nextarg, /* NULL if unset */
argv_item_t cleararg,
struct GlobalConfig *global,
struct OperationConfig *config)
{
- char letter;
- char subletter = '\0'; /* subletters can only occur on long options */
int rc;
const char *parse = NULL;
time_t now;
sizeof(aliases[0]), findarg);
if(a) {
longopt = TRUE;
- parse = a->letter;
}
else {
err = PARAM_OPTION_UNKNOWN;
struct curlx_dynbuf nbuf;
bool replaced;
- if((a->desc != ARG_STRING) &&
- (a->desc != ARG_FILENAME)) {
+ if((a->desc != ARG_STRG) &&
+ (a->desc != ARG_FILE)) {
/* --expand on an option that isn't a string or a filename */
err = PARAM_EXPAND_ERROR;
goto error;
do {
/* we can loop here if we have multiple single-letters */
+ char letter;
+ cmdline_t cmd;
- if(!longopt) {
- letter = (char)*parse;
- subletter = '\0';
- }
- else {
- letter = parse[0];
- subletter = parse[1];
- }
-
- if(!a) {
- a = single(letter);
+ if(!longopt && !a) {
+ a = single(*parse);
if(!a) {
err = PARAM_OPTION_UNKNOWN;
break;
}
}
-
- if(a->desc >= ARG_STRING) {
+ letter = a->letter;
+ cmd = a->cmd;
+ if(a->desc >= ARG_STRG) {
/* this option requires an extra parameter */
if(!longopt && parse[1]) {
nextarg = (char *)&parse[1]; /* this is the actual extra parameter */
*usedarg = TRUE; /* mark it as used */
}
- if((a->desc == ARG_FILENAME) &&
+ if((a->desc == ARG_FILE) &&
(nextarg[0] == '-') && nextarg[1]) {
/* if the file name looks like a command line option */
warnf(global, "The file name argument '%s' looks like a flag.",
that aware of that state */
nextarg = (char *)"";
- switch(ONEOPT(letter, subletter)) {
- case ONEOPT('*', '4'): /* --dns-ipv4-addr */
+ switch(cmd) {
+ case C_DNS_IPV4_ADDR: /* --dns-ipv4-addr */
if(!curlinfo->ares_num) /* c-ares is needed for this */
err = PARAM_LIBCURL_DOESNT_SUPPORT;
else
/* addr in dot notation */
err = getstr(&config->dns_ipv4_addr, nextarg, DENY_BLANK);
break;
- case ONEOPT('*', '6'): /* --dns-ipv6-addr */
+ case C_DNS_IPV6_ADDR: /* --dns-ipv6-addr */
if(!curlinfo->ares_num) /* c-ares is needed for this */
err = PARAM_LIBCURL_DOESNT_SUPPORT;
else
/* addr in dot notation */
err = getstr(&config->dns_ipv6_addr, nextarg, DENY_BLANK);
break;
- case ONEOPT('*', 'a'): /* --random-file */
+ case C_RANDOM_FILE: /* --random-file */
break;
- case ONEOPT('*', 'b'): /* --egd-file */
+ case C_EGD_FILE: /* --egd-file */
break;
- case ONEOPT('*', 'B'): /* --oauth2-bearer */
+ case C_OAUTH2_BEARER: /* --oauth2-bearer */
err = getstr(&config->oauth_bearer, nextarg, DENY_BLANK);
if(!err) {
cleanarg(clearthis);
config->authtype |= CURLAUTH_BEARER;
}
break;
- case ONEOPT('*', 'c'): /* --connect-timeout */
+ case C_CONNECT_TIMEOUT: /* --connect-timeout */
err = secs2ms(&config->connecttimeout_ms, nextarg);
break;
- case ONEOPT('*', 'C'): /* --doh-url */
+ case C_DOH_URL: /* --doh-url */
err = getstr(&config->doh_url, nextarg, ALLOW_BLANK);
if(!err && config->doh_url && !config->doh_url[0])
/* if given a blank string, make it NULL again */
Curl_safefree(config->doh_url);
break;
- case ONEOPT('*', 'd'): /* -- ciphers */
+ case C_CIPHERS: /* -- ciphers */
err = getstr(&config->cipher_list, nextarg, DENY_BLANK);
break;
- case ONEOPT('*', 'D'): /* --dns-interface */
+ case C_DNS_INTERFACE: /* --dns-interface */
if(!curlinfo->ares_num) /* c-ares is needed for this */
err = PARAM_LIBCURL_DOESNT_SUPPORT;
else
/* interface name */
err = getstr(&config->dns_interface, nextarg, DENY_BLANK);
break;
- case ONEOPT('*', 'e'): /* --disable-epsv */
+ case C_DISABLE_EPSV: /* --disable-epsv */
config->disable_epsv = toggle;
break;
- case ONEOPT('*', 'f'): /* --disallow-username-in-url */
+ case C_DISALLOW_USERNAME_IN_URL: /* --disallow-username-in-url */
config->disallow_username_in_url = toggle;
break;
- case ONEOPT('*', 'E'): /* --epsv */
+ case C_EPSV: /* --epsv */
config->disable_epsv = (!toggle)?TRUE:FALSE;
break;
- case ONEOPT('*', 'F'): /* --dns-servers */
+ case C_DNS_SERVERS: /* --dns-servers */
if(!curlinfo->ares_num) /* c-ares is needed for this */
err = PARAM_LIBCURL_DOESNT_SUPPORT;
else
/* IP addrs of DNS servers */
err = getstr(&config->dns_servers, nextarg, DENY_BLANK);
break;
- case ONEOPT('*', 'g'): /* --trace */
+ case C_TRACE: /* --trace */
err = getstr(&global->trace_dump, nextarg, DENY_BLANK);
if(!err) {
if(global->tracetype && (global->tracetype != TRACE_BIN))
global->tracetype = TRACE_BIN;
}
break;
- case ONEOPT('*', 'G'): /* --npn */
+ case C_NPN: /* --npn */
warnf(global, "--npn is no longer supported");
break;
- case ONEOPT('*', 'h'): /* --trace-ascii */
+ case C_TRACE_ASCII: /* --trace-ascii */
err = getstr(&global->trace_dump, nextarg, DENY_BLANK);
if(!err) {
if(global->tracetype && (global->tracetype != TRACE_ASCII))
global->tracetype = TRACE_ASCII;
}
break;
- case ONEOPT('*', 'H'): /* --alpn */
+ case C_ALPN: /* --alpn */
config->noalpn = (!toggle)?TRUE:FALSE;
break;
- case ONEOPT('*', 'i'): /* --limit-rate */
+ case C_LIMIT_RATE: /* --limit-rate */
err = GetSizeParameter(global, nextarg, "rate", &value);
if(!err) {
config->recvpersecond = value;
config->sendpersecond = value;
}
break;
- case ONEOPT('*', 'I'): { /* --rate */
+ case C_RATE: { /* --rate */
/* support a few different suffixes, extract the suffix first, then
get the number and convert to per hour.
/s == per second
}
break;
- case ONEOPT('*', 'j'): /* --compressed */
+ case C_COMPRESSED: /* --compressed */
if(toggle && !(feature_libz || feature_brotli || feature_zstd))
err = PARAM_LIBCURL_DOESNT_SUPPORT;
else
config->encoding = toggle;
break;
- case ONEOPT('*', 'J'): /* --tr-encoding */
+ case C_TR_ENCODING: /* --tr-encoding */
config->tr_encoding = toggle;
break;
- case ONEOPT('*', 'k'): /* --digest */
+ case C_DIGEST: /* --digest */
if(toggle)
config->authtype |= CURLAUTH_DIGEST;
else
config->authtype &= ~CURLAUTH_DIGEST;
break;
- case ONEOPT('*', 'l'): /* --negotiate */
+ case C_NEGOTIATE: /* --negotiate */
if(!toggle)
config->authtype &= ~CURLAUTH_NEGOTIATE;
else if(feature_spnego)
err = PARAM_LIBCURL_DOESNT_SUPPORT;
break;
- case ONEOPT('*', 'm'): /* --ntlm */
+ case C_NTLM: /* --ntlm */
if(!toggle)
config->authtype &= ~CURLAUTH_NTLM;
else if(feature_ntlm)
err = PARAM_LIBCURL_DOESNT_SUPPORT;
break;
- case ONEOPT('*', 'M'): /* --ntlm-wb */
+ case C_NTLM_WB: /* --ntlm-wb */
if(!toggle)
config->authtype &= ~CURLAUTH_NTLM_WB;
else if(feature_ntlm_wb)
err = PARAM_LIBCURL_DOESNT_SUPPORT;
break;
- case ONEOPT('*', 'n'): /* --basic */
+ case C_BASIC: /* --basic */
if(toggle)
config->authtype |= CURLAUTH_BASIC;
else
config->authtype &= ~CURLAUTH_BASIC;
break;
- case ONEOPT('*', 'o'): /* --anyauth */
+ case C_ANYAUTH: /* --anyauth */
if(toggle)
config->authtype = CURLAUTH_ANY;
/* --no-anyauth simply doesn't touch it */
break;
#ifdef USE_WATT32
- case ONEOPT('*', 'p'): /* --wdebug */
+ case C_WDEBUG: /* --wdebug */
dbug_init();
break;
#endif
- case ONEOPT('*', 'q'): /* --ftp-create-dirs */
+ case C_FTP_CREATE_DIRS: /* --ftp-create-dirs */
config->ftp_create_dirs = toggle;
break;
- case ONEOPT('*', 'r'): /* --create-dirs */
+ case C_CREATE_DIRS: /* --create-dirs */
config->create_dirs = toggle;
break;
- case ONEOPT('*', 'R'): /* --create-file-mode */
+ case C_CREATE_FILE_MODE: /* --create-file-mode */
err = oct2nummax(&config->create_file_mode, nextarg, 0777);
break;
- case ONEOPT('*', 's'): /* --max-redirs */
+ case C_MAX_REDIRS: /* --max-redirs */
/* specified max no of redirects (http(s)), this accepts -1 as a
special condition */
err = str2num(&config->maxredirs, nextarg);
err = PARAM_BAD_NUMERIC;
break;
- case ONEOPT('*', 'S'): /* --ipfs-gateway */
+ case C_IPFS_GATEWAY: /* --ipfs-gateway */
err = getstr(&config->ipfs_gateway, nextarg, DENY_BLANK);
break;
- case ONEOPT('*', 't'): /* --proxy-ntlm */
+ case C_PROXY_NTLM: /* --proxy-ntlm */
if(!feature_ntlm)
err = PARAM_LIBCURL_DOESNT_SUPPORT;
else
config->proxyntlm = toggle;
break;
- case ONEOPT('*', 'u'): /* --crlf */
+ case C_CRLF: /* --crlf */
/* LF -> CRLF conversion? */
config->crlf = toggle;
break;
- case ONEOPT('*', 'V'): /* --aws-sigv4 */
+ case C_AWS_SIGV4: /* --aws-sigv4 */
config->authtype |= CURLAUTH_AWS_SIGV4;
err = getstr(&config->aws_sigv4, nextarg, DENY_BLANK);
break;
- case ONEOPT('*', 'v'): /* --stderr */
+ case C_STDERR: /* --stderr */
tool_set_stderr_file(global, nextarg);
break;
- case ONEOPT('*', 'w'): /* --interface */
+ case C_INTERFACE: /* --interface */
/* interface */
err = getstr(&config->iface, nextarg, DENY_BLANK);
break;
- case ONEOPT('*', 'x'): /* --krb */
+ case C_KRB: /* --krb */
/* kerberos level string */
if(!feature_spnego)
err = PARAM_LIBCURL_DOESNT_SUPPORT;
else
err = getstr(&config->krblevel, nextarg, DENY_BLANK);
break;
- case ONEOPT('*', 'X'): /* --haproxy-protocol */
+ case C_HAPROXY_PROTOCOL: /* --haproxy-protocol */
config->haproxy_protocol = toggle;
break;
- case ONEOPT('*', 'P'): /* --haproxy-clientip */
+ case C_HAPROXY_CLIENTIP: /* --haproxy-clientip */
err = getstr(&config->haproxy_clientip, nextarg, DENY_BLANK);
break;
- case ONEOPT('*', 'y'): /* --max-filesize */
+ case C_MAX_FILESIZE: /* --max-filesize */
err = GetSizeParameter(global, nextarg, "max-filesize", &value);
if(!err)
config->max_filesize = value;
break;
- case ONEOPT('*', 'z'): /* --disable-eprt */
+ case C_DISABLE_EPRT: /* --disable-eprt */
config->disable_eprt = toggle;
break;
- case ONEOPT('*', 'Z'): /* --eprt */
+ case C_EPRT: /* --eprt */
config->disable_eprt = (!toggle)?TRUE:FALSE;
break;
- case ONEOPT('*', '~'): /* --xattr */
+ case C_XATTR: /* --xattr */
config->xattr = toggle;
break;
- case ONEOPT('*', '@'): /* --url */
+ case C_URL: /* --url */
if(!config->url_get)
config->url_get = config->url_list;
/* there was no free node, create one! */
config->url_get = url = new_getout(config);
- if(!url) {
+ if(!url)
err = PARAM_NO_MEM;
- break;
+ else {
+ /* fill in the URL */
+ err = getstr(&url->url, nextarg, DENY_BLANK);
+ url->flags |= GETOUT_URL;
}
-
- /* fill in the URL */
- err = getstr(&url->url, nextarg, DENY_BLANK);
- url->flags |= GETOUT_URL;
break;
- case ONEOPT('$', 'a'): /* --ssl */
- if(toggle && !feature_ssl) {
+ case C_SSL: /* --ssl */
+ if(toggle && !feature_ssl)
err = PARAM_LIBCURL_DOESNT_SUPPORT;
- break;
+ else {
+ config->ftp_ssl = toggle;
+ if(config->ftp_ssl)
+ warnf(global,
+ "--ssl is an insecure option, consider --ssl-reqd instead");
}
- config->ftp_ssl = toggle;
- if(config->ftp_ssl)
- warnf(global,
- "--ssl is an insecure option, consider --ssl-reqd instead");
break;
- case ONEOPT('$', 'b'): /* --ftp-pasv */
+ case C_FTP_PASV: /* --ftp-pasv */
Curl_safefree(config->ftpport);
break;
- case ONEOPT('$', 'c'): /* --socks5 */
+ case C_SOCKS5: /* --socks5 */
/* socks5 proxy to use, and resolves the name locally and passes on the
resolved address */
err = getstr(&config->proxy, nextarg, DENY_BLANK);
config->proxyver = CURLPROXY_SOCKS5;
break;
- case ONEOPT('$', 't'): /* --socks4 */
+ case C_SOCKS4: /* --socks4 */
err = getstr(&config->proxy, nextarg, DENY_BLANK);
config->proxyver = CURLPROXY_SOCKS4;
break;
- case ONEOPT('$', 'T'): /* --socks4a */
+ case C_SOCKS4A: /* --socks4a */
err = getstr(&config->proxy, nextarg, DENY_BLANK);
config->proxyver = CURLPROXY_SOCKS4A;
break;
- case ONEOPT('$', '2'): /* --socks5-hostname */
+ case C_SOCKS5_HOSTNAME: /* --socks5-hostname */
err = getstr(&config->proxy, nextarg, DENY_BLANK);
config->proxyver = CURLPROXY_SOCKS5_HOSTNAME;
break;
- case ONEOPT('$', 'd'): /* --tcp-nodelay */
+ case C_TCP_NODELAY: /* --tcp-nodelay */
config->tcp_nodelay = toggle;
break;
- case ONEOPT('$', 'e'): /* --proxy-digest */
+ case C_PROXY_DIGEST: /* --proxy-digest */
config->proxydigest = toggle;
break;
- case ONEOPT('$', 'f'): /* --proxy-basic */
+ case C_PROXY_BASIC: /* --proxy-basic */
config->proxybasic = toggle;
break;
- case ONEOPT('$', 'g'): /* --retry */
+ case C_RETRY: /* --retry */
err = str2unum(&config->req_retry, nextarg);
break;
- case ONEOPT('$', 'V'): /* --retry-connrefused */
+ case C_RETRY_CONNREFUSED: /* --retry-connrefused */
config->retry_connrefused = toggle;
break;
- case ONEOPT('$', 'h'): /* --retry-delay */
+ case C_RETRY_DELAY: /* --retry-delay */
err = str2unummax(&config->retry_delay, nextarg, LONG_MAX/1000);
break;
- case ONEOPT('$', 'i'): /* --retry-max-time */
+ case C_RETRY_MAX_TIME: /* --retry-max-time */
err = str2unummax(&config->retry_maxtime, nextarg, LONG_MAX/1000);
break;
- case ONEOPT('$', '!'): /* --retry-all-errors */
+ case C_RETRY_ALL_ERRORS: /* --retry-all-errors */
config->retry_all_errors = toggle;
break;
- case ONEOPT('$', 'k'): /* --proxy-negotiate */
- if(!feature_spnego) {
+ case C_PROXY_NEGOTIATE: /* --proxy-negotiate */
+ if(!feature_spnego)
err = PARAM_LIBCURL_DOESNT_SUPPORT;
- break;
- }
- config->proxynegotiate = toggle;
+ else
+ config->proxynegotiate = toggle;
break;
- case ONEOPT('$', 'l'): /* --form-escape */
+ case C_FORM_ESCAPE: /* --form-escape */
config->mime_options &= ~CURLMIMEOPT_FORMESCAPE;
if(toggle)
config->mime_options |= CURLMIMEOPT_FORMESCAPE;
break;
- case ONEOPT('$', 'm'): /* --ftp-account */
+ case C_FTP_ACCOUNT: /* --ftp-account */
err = getstr(&config->ftp_account, nextarg, DENY_BLANK);
break;
- case ONEOPT('$', 'n'): /* --proxy-anyauth */
+ case C_PROXY_ANYAUTH: /* --proxy-anyauth */
config->proxyanyauth = toggle;
break;
- case ONEOPT('$', 'o'): /* --trace-time */
+ case C_TRACE_TIME: /* --trace-time */
global->tracetime = toggle;
break;
- case ONEOPT('$', 'p'): /* --ignore-content-length */
+ case C_IGNORE_CONTENT_LENGTH: /* --ignore-content-length */
config->ignorecl = toggle;
break;
- case ONEOPT('$', 'q'): /* --ftp-skip-pasv-ip */
+ case C_FTP_SKIP_PASV_IP: /* --ftp-skip-pasv-ip */
config->ftp_skip_ip = toggle;
break;
- case ONEOPT('$', 'r'): /* --ftp-method */
+ case C_FTP_METHOD: /* --ftp-method */
config->ftp_filemethod = ftpfilemethod(config, nextarg);
break;
- case ONEOPT('$', 's'): { /* --local-port */
+ case C_LOCAL_PORT: { /* --local-port */
/* 16bit base 10 is 5 digits, but we allow 6 so that this catches
overflows, not just truncates */
char lrange[7]="";
}
break;
}
- case ONEOPT('$', 'u'): /* --ftp-alternative-to-user */
+ case C_FTP_ALTERNATIVE_TO_USER: /* --ftp-alternative-to-user */
err = getstr(&config->ftp_alternative_to_user, nextarg, DENY_BLANK);
break;
- case ONEOPT('$', 'v'): /* --ssl-reqd */
+ case C_FTP_SSL_REQD: /* --ftp-ssl-reqd */
+ case C_SSL_REQD: /* --ssl-reqd */
if(toggle && !feature_ssl) {
err = PARAM_LIBCURL_DOESNT_SUPPORT;
break;
}
config->ftp_ssl_reqd = toggle;
break;
- case ONEOPT('$', 'w'): /* --no-sessionid */
+ case C_SESSIONID: /* --sessionid */
config->disable_sessionid = (!toggle)?TRUE:FALSE;
break;
- case ONEOPT('$', 'x'): /* --ftp-ssl-control */
- if(toggle && !feature_ssl) {
+ case C_FTP_SSL_CONTROL: /* --ftp-ssl-control */
+ if(toggle && !feature_ssl)
err = PARAM_LIBCURL_DOESNT_SUPPORT;
- break;
- }
- config->ftp_ssl_control = toggle;
+ else
+ config->ftp_ssl_control = toggle;
break;
- case ONEOPT('$', 'y'): /* --ftp-ssl-ccc */
+ case C_FTP_SSL_CCC: /* --ftp-ssl-ccc */
config->ftp_ssl_ccc = toggle;
if(!config->ftp_ssl_ccc_mode)
config->ftp_ssl_ccc_mode = CURLFTPSSL_CCC_PASSIVE;
break;
- case ONEOPT('$', 'j'): /* --ftp-ssl-ccc-mode */
+ case C_FTP_SSL_CCC_MODE: /* --ftp-ssl-ccc-mode */
config->ftp_ssl_ccc = TRUE;
config->ftp_ssl_ccc_mode = ftpcccmethod(config, nextarg);
break;
- case ONEOPT('$', 'z'): /* --libcurl */
+ case C_LIBCURL: /* --libcurl */
#ifdef CURL_DISABLE_LIBCURL_OPTION
warnf(global,
"--libcurl option was disabled at build-time");
err = getstr(&global->libcurl, nextarg, DENY_BLANK);
#endif
break;
- case ONEOPT('$', '#'): /* --raw */
+ case C_RAW: /* --raw */
config->raw = toggle;
break;
- case ONEOPT('$', '0'): /* --post301 */
- config->post301 = toggle;
- break;
- case ONEOPT('$', '1'): /* --no-keepalive */
+ case C_KEEPALIVE: /* --keepalive */
config->nokeepalive = (!toggle)?TRUE:FALSE;
break;
- case ONEOPT('$', '3'): /* --keepalive-time */
+ case C_KEEPALIVE_TIME: /* --keepalive-time */
err = str2unum(&config->alivetime, nextarg);
break;
- case ONEOPT('$', '4'): /* --post302 */
+ case C_POST301: /* --post301 */
+ config->post301 = toggle;
+ break;
+ case C_POST302: /* --post302 */
config->post302 = toggle;
break;
- case ONEOPT('$', 'I'): /* --post303 */
+ case C_POST303: /* --post303 */
config->post303 = toggle;
break;
- case ONEOPT('$', '5'): /* --noproxy */
+ case C_NOPROXY: /* --noproxy */
/* This specifies the noproxy list */
err = getstr(&config->noproxy, nextarg, ALLOW_BLANK);
break;
- case ONEOPT('$', '7'): /* --socks5-gssapi-nec */
+ case C_SOCKS5_GSSAPI_NEC: /* --socks5-gssapi-nec */
config->socks5_gssapi_nec = toggle;
break;
- case ONEOPT('$', '8'): /* --proxy1.0 */
+ case C_PROXY1_0: /* --proxy1.0 */
/* http 1.0 proxy */
err = getstr(&config->proxy, nextarg, DENY_BLANK);
config->proxyver = CURLPROXY_HTTP_1_0;
break;
- case ONEOPT('$', '9'): /* --tftp-blksize */
+ case C_TFTP_BLKSIZE: /* --tftp-blksize */
err = str2unum(&config->tftp_blksize, nextarg);
break;
- case ONEOPT('$', 'A'): /* --mail-from */
+ case C_MAIL_FROM: /* --mail-from */
err = getstr(&config->mail_from, nextarg, DENY_BLANK);
break;
- case ONEOPT('$', 'B'): /* --mail-rcpt */
+ case C_MAIL_RCPT: /* --mail-rcpt */
/* append receiver to a list */
err = add2list(&config->mail_rcpt, nextarg);
break;
- case ONEOPT('$', 'C'): /* --ftp-pret */
+ case C_FTP_PRET: /* --ftp-pret */
config->ftp_pret = toggle;
break;
- case ONEOPT('$', 'D'): /* --proto */
+ case C_PROTO: /* --proto */
config->proto_present = TRUE;
err = proto2num(config, built_in_protos, &config->proto_str, nextarg);
break;
- case ONEOPT('$', 'E'): /* --proto-redir */
+ case C_PROTO_REDIR: /* --proto-redir */
config->proto_redir_present = TRUE;
if(proto2num(config, redir_protos, &config->proto_redir_str,
- nextarg)) {
+ nextarg))
err = PARAM_BAD_USE;
- break;
- }
break;
- case ONEOPT('$', 'F'): /* --resolve */
+ case C_RESOLVE: /* --resolve */
err = add2list(&config->resolve, nextarg);
break;
- case ONEOPT('$', 'G'): /* --delegation */
+ case C_DELEGATION: /* --delegation */
config->gssapi_delegation = delegation(config, nextarg);
break;
- case ONEOPT('$', 'H'): /* --mail-auth */
+ case C_MAIL_AUTH: /* --mail-auth */
err = getstr(&config->mail_auth, nextarg, DENY_BLANK);
break;
- case ONEOPT('$', 'J'): /* --metalink */
+ case C_METALINK: /* --metalink */
errorf(global, "--metalink is disabled");
err = PARAM_BAD_USE;
break;
- case ONEOPT('$', '6'): /* --sasl-authzid */
+ case C_SASL_AUTHZID: /* --sasl-authzid */
err = getstr(&config->sasl_authzid, nextarg, DENY_BLANK);
break;
- case ONEOPT('$', 'K'): /* --sasl-ir */
+ case C_SASL_IR: /* --sasl-ir */
config->sasl_ir = toggle;
break;
- case ONEOPT('$', 'L'): /* --test-event */
+ case C_TEST_EVENT: /* --test-event */
#ifdef CURLDEBUG
global->test_event_based = toggle;
#else
warnf(global, "--test-event is ignored unless a debug build");
#endif
break;
- case ONEOPT('$', 'M'): /* --unix-socket */
+ case C_UNIX_SOCKET: /* --unix-socket */
config->abstract_unix_socket = FALSE;
err = getstr(&config->unix_socket_path, nextarg, DENY_BLANK);
break;
- case ONEOPT('$', 'N'): /* --path-as-is */
+ case C_PATH_AS_IS: /* --path-as-is */
config->path_as_is = toggle;
break;
- case ONEOPT('$', 'O'): /* --proxy-service-name */
+ case C_PROXY_SERVICE_NAME: /* --proxy-service-name */
err = getstr(&config->proxy_service_name, nextarg, DENY_BLANK);
break;
- case ONEOPT('$', 'P'): /* --service-name */
+ case C_SERVICE_NAME: /* --service-name */
err = getstr(&config->service_name, nextarg, DENY_BLANK);
break;
- case ONEOPT('$', 'Q'): /* --proto-default */
+ case C_PROTO_DEFAULT: /* --proto-default */
err = getstr(&config->proto_default, nextarg, DENY_BLANK);
if(!err)
err = check_protocol(config->proto_default);
break;
- case ONEOPT('$', 'R'): /* --expect100-timeout */
+ case C_EXPECT100_TIMEOUT: /* --expect100-timeout */
err = secs2ms(&config->expect100timeout_ms, nextarg);
break;
- case ONEOPT('$', 'S'): /* --tftp-no-options */
+ case C_TFTP_NO_OPTIONS: /* --tftp-no-options */
config->tftp_no_options = toggle;
break;
- case ONEOPT('$', 'U'): /* --connect-to */
+ case C_CONNECT_TO: /* --connect-to */
err = add2list(&config->connect_to, nextarg);
break;
- case ONEOPT('$', 'W'): /* --abstract-unix-socket */
+ case C_ABSTRACT_UNIX_SOCKET: /* --abstract-unix-socket */
config->abstract_unix_socket = TRUE;
err = getstr(&config->unix_socket_path, nextarg, DENY_BLANK);
break;
- case ONEOPT('$', 'X'): /* --tls-max */
+ case C_TLS_MAX: /* --tls-max */
err = str2tls_max(&config->ssl_version_max, nextarg);
break;
- case ONEOPT('$', 'Y'): /* --suppress-connect-headers */
+ case C_SUPPRESS_CONNECT_HEADERS: /* --suppress-connect-headers */
config->suppress_connect_headers = toggle;
break;
- case ONEOPT('$', 'Z'): /* --compressed-ssh */
+ case C_COMPRESSED_SSH: /* --compressed-ssh */
config->ssh_compression = toggle;
break;
- case ONEOPT('$', '~'): /* --happy-eyeballs-timeout-ms */
+ case C_HAPPY_EYEBALLS_TIMEOUT_MS: /* --happy-eyeballs-timeout-ms */
err = str2unum(&config->happy_eyeballs_timeout_ms, nextarg);
/* 0 is a valid value for this timeout */
break;
- case ONEOPT('$', '%'): /* --trace-ids */
+ case C_TRACE_IDS: /* --trace-ids */
global->traceids = toggle;
break;
- case ONEOPT('$', '&'): /* --trace-config */
- if(set_trace_config(global, nextarg)) {
+ case C_TRACE_CONFIG: /* --trace-config */
+ if(set_trace_config(global, nextarg))
err = PARAM_NO_MEM;
- }
break;
- case ONEOPT('#', 'm'): /* --progress-meter */
+ case C_PROGRESS_METER: /* --progress-meter */
global->noprogress = !toggle;
break;
- case ONEOPT('#', '\0'): /* --progress-bar */
+ case C_PROGRESS_BAR: /* --progress-bar */
global->progressmode = toggle ? CURL_PROGRESS_BAR : CURL_PROGRESS_STATS;
break;
-
- case ONEOPT(':', 'a'): /* --variable */
+ case C_VARIABLE: /* --Variable */
err = setvariable(global, nextarg);
break;
- case ONEOPT(':', '\0'): /* --next */
+ case C_NEXT: /* --next */
err = PARAM_NEXT_OPERATION;
break;
-
- case ONEOPT('0', '\0'): /* --http1.0 */
+ case C_HTTP1_0: /* --http1.0 */
/* HTTP version 1.0 */
sethttpver(global, config, CURL_HTTP_VERSION_1_0);
break;
- case ONEOPT('0', '1'): /* --http1.1 */
+ case C_HTTP1_1: /* --http1.1 */
/* HTTP version 1.1 */
sethttpver(global, config, CURL_HTTP_VERSION_1_1);
break;
- case ONEOPT('0', '2'): /* --http2 */
+ case C_HTTP2: /* --http2 */
/* HTTP version 2.0 */
if(!feature_http2)
return PARAM_LIBCURL_DOESNT_SUPPORT;
sethttpver(global, config, CURL_HTTP_VERSION_2_0);
break;
- case ONEOPT('0', '3'): /* --http2-prior-knowledge */
+ case C_HTTP2_PRIOR_KNOWLEDGE: /* --http2-prior-knowledge */
/* HTTP version 2.0 over clean TCP */
if(!feature_http2)
return PARAM_LIBCURL_DOESNT_SUPPORT;
sethttpver(global, config, CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE);
break;
- case ONEOPT('0', '4'): /* --http3: */
+ case C_HTTP3: /* --http3: */
/* Try HTTP/3, allow fallback */
- if(!feature_http3) {
+ if(!feature_http3)
err = PARAM_LIBCURL_DOESNT_SUPPORT;
- break;
- }
- sethttpver(global, config, CURL_HTTP_VERSION_3);
+ else
+ sethttpver(global, config, CURL_HTTP_VERSION_3);
break;
- case ONEOPT('0', '5'): /* --http3-only */
+ case C_HTTP3_ONLY: /* --http3-only */
/* Try HTTP/3 without fallback */
- if(!feature_http3) {
+ if(!feature_http3)
err = PARAM_LIBCURL_DOESNT_SUPPORT;
- break;
- }
- sethttpver(global, config, CURL_HTTP_VERSION_3ONLY);
+ else
+ sethttpver(global, config, CURL_HTTP_VERSION_3ONLY);
break;
- case ONEOPT('0', '9'): /* --http0.9 */
+ case C_HTTP0_9: /* --http0.9 */
/* Allow HTTP/0.9 responses! */
config->http09_allowed = toggle;
break;
- case ONEOPT('0', 'a'): /* --proxy-http2 */
+ case C_PROXY_HTTP2: /* --proxy-http2 */
if(!feature_httpsproxy || !feature_http2)
- return PARAM_LIBCURL_DOESNT_SUPPORT;
- config->proxyver = CURLPROXY_HTTPS2;
+ err = PARAM_LIBCURL_DOESNT_SUPPORT;
+ else
+ config->proxyver = CURLPROXY_HTTPS2;
break;
- case ONEOPT('1', '\0'): /* --tlsv1 */
+ case C_TLSV1: /* --tlsv1 */
config->ssl_version = CURL_SSLVERSION_TLSv1;
break;
- case ONEOPT('1', '0'): /* --tlsv1.0 */
+ case C_TLSV1_0: /* --tlsv1.0 */
config->ssl_version = CURL_SSLVERSION_TLSv1_0;
break;
- case ONEOPT('1', '1'): /* --tlsv1.1 */
+ case C_TLSV1_1: /* --tlsv1.1 */
config->ssl_version = CURL_SSLVERSION_TLSv1_1;
break;
- case ONEOPT('1', '2'): /* --tlsv1.2 */
+ case C_TLSV1_2: /* --tlsv1.2 */
config->ssl_version = CURL_SSLVERSION_TLSv1_2;
break;
- case ONEOPT('1', '3'): /* --tlsv1.3 */
+ case C_TLSV1_3: /* --tlsv1.3 */
config->ssl_version = CURL_SSLVERSION_TLSv1_3;
break;
- case ONEOPT('1', 'A'): /* --tls13-ciphers */
+ case C_TLS13_CIPHERS: /* --tls13-ciphers */
err = getstr(&config->cipher13_list, nextarg, DENY_BLANK);
break;
- case ONEOPT('1', 'B'): /* --proxy-tls13-ciphers */
+ case C_PROXY_TLS13_CIPHERS: /* --proxy-tls13-ciphers */
err = getstr(&config->proxy_cipher13_list, nextarg, DENY_BLANK);
break;
- case ONEOPT('2', '\0'): /* --sslv2 */
+ case C_SSLV2: /* --sslv2 */
warnf(global, "Ignores instruction to use SSLv2");
break;
- case ONEOPT('3', '\0'): /* --sslv3 */
+ case C_SSLV3: /* --sslv3 */
warnf(global, "Ignores instruction to use SSLv3");
break;
- case ONEOPT('4', '\0'): /* --ipv4 */
+ case C_IPV4: /* --ipv4 */
config->ip_version = CURL_IPRESOLVE_V4;
break;
- case ONEOPT('6', '\0'): /* --ipv6 */
+ case C_IPV6: /* --ipv6 */
config->ip_version = CURL_IPRESOLVE_V6;
break;
- case ONEOPT('a', '\0'): /* --append */
+ case C_APPEND: /* --append */
/* This makes the FTP sessions use APPE instead of STOR */
config->ftp_append = toggle;
break;
- case ONEOPT('A', '\0'): /* --user-agent */
+ case C_USER_AGENT: /* --user-agent */
err = getstr(&config->useragent, nextarg, ALLOW_BLANK);
break;
- case ONEOPT('b', 'a'): /* --alt-svc */
+ case C_ALT_SVC: /* --alt-svc */
if(!feature_altsvc)
err = PARAM_LIBCURL_DOESNT_SUPPORT;
else
err = getstr(&config->altsvc, nextarg, ALLOW_BLANK);
break;
- case ONEOPT('b', 'b'): /* --hsts */
+ case C_HSTS: /* --hsts */
if(!feature_hsts)
err = PARAM_LIBCURL_DOESNT_SUPPORT;
else
err = getstr(&config->hsts, nextarg, ALLOW_BLANK);
break;
- case ONEOPT('b', '\0'): /* --cookie */
+ case C_COOKIE: /* --cookie */
if(nextarg[0] == '@') {
nextarg++;
}
/* We have a cookie file to read from! */
err = add2list(&config->cookiefiles, nextarg);
break;
- case ONEOPT('B', '\0'): /* --use-ascii */
+ case C_USE_ASCII: /* --use-ascii */
config->use_ascii = toggle;
break;
- case ONEOPT('c', '\0'): /* --cookie-jar */
+ case C_COOKIE_JAR: /* --cookie-jar */
err = getstr(&config->cookiejar, nextarg, DENY_BLANK);
break;
- case ONEOPT('C', '\0'): /* --continue-at */
+ case C_CONTINUE_AT: /* --continue-at */
/* This makes us continue an ftp transfer at given position */
if(strcmp(nextarg, "-")) {
err = str2offset(&config->resume_from, nextarg);
- if(err)
- break;
config->resume_from_current = FALSE;
}
else {
}
config->use_resume = TRUE;
break;
- case ONEOPT('d', '\0'): /* --data */
- case ONEOPT('d', 'a'): /* --data-ascii */
- case ONEOPT('d', 'b'): /* --data-binary */
- case ONEOPT('d', 'e'): /* --data-urlencode */
- case ONEOPT('d', 'f'): /* --json */
- case ONEOPT('d', 'r'): /* --data-raw */
- err = set_data(subletter, nextarg, global, config);
+ case C_DATA: /* --data */
+ case C_DATA_ASCII: /* --data-ascii */
+ case C_DATA_BINARY: /* --data-binary */
+ case C_DATA_URLENCODE: /* --data-urlencode */
+ case C_JSON: /* --json */
+ case C_DATA_RAW: /* --data-raw */
+ err = set_data(cmd, nextarg, global, config);
break;
- case ONEOPT('d', 'g'): /* --url-query */
+ case C_URL_QUERY: /* --url-query */
err = url_query(nextarg, global, config);
break;
- case ONEOPT('D', '\0'): /* --dump-header */
+ case C_DUMP_HEADER: /* --dump-header */
err = getstr(&config->headerfile, nextarg, DENY_BLANK);
break;
- case ONEOPT('e', '\0'): { /* --referer */
+ case C_REFERER: { /* --referer */
char *ptr = strstr(nextarg, ";auto");
if(ptr) {
/* Automatic referer requested, this may be combined with a
err = getstr(&config->referer, ptr, ALLOW_BLANK);
}
break;
- case ONEOPT('E', '\0'): /* --cert */
+ case C_CERT: /* --cert */
cleanarg(clearthis);
GetFileAndPassword(nextarg, &config->cert, &config->key_passwd);
break;
- case ONEOPT('E', 'a'): /* --cacert */
+ case C_CACERT: /* --cacert */
err = getstr(&config->cacert, nextarg, DENY_BLANK);
break;
- case ONEOPT('E', 'G'): /* --ca-native */
+ case C_CA_NATIVE: /* --ca-native */
config->native_ca_store = toggle;
break;
- case ONEOPT('E', 'H'): /* --proxy-ca-native */
+ case C_PROXY_CA_NATIVE: /* --proxy-ca-native */
config->proxy_native_ca_store = toggle;
break;
- case ONEOPT('E', 'b'): /* --cert-type */
+ case C_CERT_TYPE: /* --cert-type */
err = getstr(&config->cert_type, nextarg, DENY_BLANK);
break;
- case ONEOPT('E', 'c'): /* --key */
+ case C_KEY: /* --key */
err = getstr(&config->key, nextarg, DENY_BLANK);
break;
- case ONEOPT('E', 'd'): /* --key-type */
+ case C_KEY_TYPE: /* --key-type */
err = getstr(&config->key_type, nextarg, DENY_BLANK);
break;
- case ONEOPT('E', 'e'): /* --pass */
+ case C_PASS: /* --pass */
err = getstr(&config->key_passwd, nextarg, DENY_BLANK);
cleanarg(clearthis);
break;
- case ONEOPT('E', 'f'): /* --engine */
+ case C_ENGINE: /* --engine */
err = getstr(&config->engine, nextarg, DENY_BLANK);
if(!err &&
config->engine && !strcmp(config->engine, "list")) {
err = PARAM_ENGINES_REQUESTED;
}
break;
- case ONEOPT('E', 'g'): /* --capath */
+ case C_CAPATH: /* --capath */
err = getstr(&config->capath, nextarg, DENY_BLANK);
break;
- case ONEOPT('E', 'h'): /* --pubkey */
+ case C_PUBKEY: /* --pubkey */
err = getstr(&config->pubkey, nextarg, DENY_BLANK);
break;
- case ONEOPT('E', 'i'): /* --hostpubmd5 */
+ case C_HOSTPUBMD5: /* --hostpubmd5 */
err = getstr(&config->hostpubmd5, nextarg, DENY_BLANK);
if(!err) {
if(!config->hostpubmd5 || strlen(config->hostpubmd5) != 32)
err = PARAM_BAD_USE;
}
break;
- case ONEOPT('E', 'F'): /* --hostpubsha256 */
+ case C_HOSTPUBSHA256: /* --hostpubsha256 */
err = getstr(&config->hostpubsha256, nextarg, DENY_BLANK);
break;
- case ONEOPT('E', 'j'): /* --crlfile */
+ case C_CRLFILE: /* --crlfile */
err = getstr(&config->crlfile, nextarg, DENY_BLANK);
break;
- case ONEOPT('E', 'k'): /* --tlsuser */
+ case C_TLSUSER: /* --tlsuser */
if(!feature_tls_srp)
err = PARAM_LIBCURL_DOESNT_SUPPORT;
else
err = getstr(&config->tls_username, nextarg, DENY_BLANK);
cleanarg(clearthis);
break;
- case ONEOPT('E', 'l'): /* --tlspassword */
+ case C_TLSPASSWORD: /* --tlspassword */
if(!feature_tls_srp)
err = PARAM_LIBCURL_DOESNT_SUPPORT;
else
err = getstr(&config->tls_password, nextarg, ALLOW_BLANK);
cleanarg(clearthis);
break;
- case ONEOPT('E', 'm'): /* --tlsauthtype */
+ case C_TLSAUTHTYPE: /* --tlsauthtype */
if(!feature_tls_srp)
err = PARAM_LIBCURL_DOESNT_SUPPORT;
else {
err = PARAM_LIBCURL_DOESNT_SUPPORT; /* only support TLS-SRP */
}
break;
- case ONEOPT('E', 'n'): /* --ssl-allow-beast */
+ case C_SSL_ALLOW_BEAST: /* --ssl-allow-beast */
if(feature_ssl)
config->ssl_allow_beast = toggle;
break;
-
- case ONEOPT('E', 'o'): /* --ssl-auto-client-cert */
+ case C_SSL_AUTO_CLIENT_CERT: /* --ssl-auto-client-cert */
if(feature_ssl)
config->ssl_auto_client_cert = toggle;
break;
-
- case ONEOPT('E', 'O'): /* --proxy-ssl-auto-client-cert */
+ case C_PROXY_SSL_AUTO_CLIENT_CERT: /* --proxy-ssl-auto-client-cert */
if(feature_ssl)
config->proxy_ssl_auto_client_cert = toggle;
break;
-
- case ONEOPT('E', 'p'): /* --pinnedpubkey */
+ case C_PINNEDPUBKEY: /* --pinnedpubkey */
err = getstr(&config->pinnedpubkey, nextarg, DENY_BLANK);
break;
-
- case ONEOPT('E', 'P'): /* --proxy-pinnedpubkey */
+ case C_PROXY_PINNEDPUBKEY: /* --proxy-pinnedpubkey */
err = getstr(&config->proxy_pinnedpubkey, nextarg, DENY_BLANK);
break;
-
- case ONEOPT('E', 'q'): /* --cert-status */
+ case C_CERT_STATUS: /* --cert-status */
config->verifystatus = TRUE;
break;
-
- case ONEOPT('E', 'Q'): /* --doh-cert-status */
+ case C_DOH_CERT_STATUS: /* --doh-cert-status */
config->doh_verifystatus = TRUE;
break;
-
- case ONEOPT('E', 'r'): /* --false-start */
+ case C_FALSE_START: /* --false-start */
config->falsestart = TRUE;
break;
-
- case ONEOPT('E', 's'): /* --ssl-no-revoke */
+ case C_SSL_NO_REVOKE: /* --ssl-no-revoke */
if(feature_ssl)
config->ssl_no_revoke = TRUE;
break;
-
- case ONEOPT('E', 'S'): /* --ssl-revoke-best-effort */
+ case C_SSL_REVOKE_BEST_EFFORT: /* --ssl-revoke-best-effort */
if(feature_ssl)
config->ssl_revoke_best_effort = TRUE;
break;
-
- case ONEOPT('E', 't'): /* --tcp-fastopen */
+ case C_TCP_FASTOPEN: /* --tcp-fastopen */
config->tcp_fastopen = TRUE;
break;
-
- case ONEOPT('E', 'u'): /* --proxy-tlsuser */
+ case C_PROXY_TLSUSER: /* --proxy-tlsuser */
cleanarg(clearthis);
if(!feature_tls_srp)
err = PARAM_LIBCURL_DOESNT_SUPPORT;
else
err = getstr(&config->proxy_tls_username, nextarg, ALLOW_BLANK);
break;
-
- case ONEOPT('E', 'v'): /* --proxy-tlspassword */
+ case C_PROXY_TLSPASSWORD: /* --proxy-tlspassword */
cleanarg(clearthis);
if(!feature_tls_srp)
err = PARAM_LIBCURL_DOESNT_SUPPORT;
else
err = getstr(&config->proxy_tls_password, nextarg, DENY_BLANK);
break;
-
- case ONEOPT('E', 'w'): /* --proxy-tlsauthtype */
+ case C_PROXY_TLSAUTHTYPE: /* --proxy-tlsauthtype */
if(!feature_tls_srp)
err = PARAM_LIBCURL_DOESNT_SUPPORT;
else {
err = PARAM_LIBCURL_DOESNT_SUPPORT; /* only support TLS-SRP */
}
break;
-
- case ONEOPT('E', 'x'): /* --proxy-cert */
+ case C_PROXY_CERT: /* --proxy-cert */
cleanarg(clearthis);
GetFileAndPassword(nextarg, &config->proxy_cert,
&config->proxy_key_passwd);
break;
-
- case ONEOPT('E', 'y'): /* --proxy-cert-type */
+ case C_PROXY_CERT_TYPE: /* --proxy-cert-type */
err = getstr(&config->proxy_cert_type, nextarg, DENY_BLANK);
break;
-
- case ONEOPT('E', 'z'): /* --proxy-key */
+ case C_PROXY_KEY: /* --proxy-key */
err = getstr(&config->proxy_key, nextarg, ALLOW_BLANK);
break;
-
- case ONEOPT('E', '0'): /* --proxy-key-type */
+ case C_PROXY_KEY_TYPE: /* --proxy-key-type */
err = getstr(&config->proxy_key_type, nextarg, DENY_BLANK);
break;
-
- case ONEOPT('E', '1'): /* --proxy-pass */
+ case C_PROXY_PASS: /* --proxy-pass */
err = getstr(&config->proxy_key_passwd, nextarg, ALLOW_BLANK);
cleanarg(clearthis);
break;
-
- case ONEOPT('E', '2'): /* --proxy-ciphers */
+ case C_PROXY_CIPHERS: /* --proxy-ciphers */
err = getstr(&config->proxy_cipher_list, nextarg, DENY_BLANK);
break;
-
- case ONEOPT('E', '3'): /* --proxy-crlfile */
+ case C_PROXY_CRLFILE: /* --proxy-crlfile */
err = getstr(&config->proxy_crlfile, nextarg, DENY_BLANK);
break;
-
- case ONEOPT('E', '4'): /* --proxy-allow-beast */
+ case C_PROXY_SSL_ALLOW_BEAST: /* --proxy-ssl-allow-beast */
if(feature_ssl)
config->proxy_ssl_allow_beast = toggle;
break;
-
- case ONEOPT('E', '5'): /* --login-options */
+ case C_LOGIN_OPTIONS: /* --login-options */
err = getstr(&config->login_options, nextarg, ALLOW_BLANK);
break;
-
- case ONEOPT('E', '6'): /* --proxy-cacert */
+ case C_PROXY_CACERT: /* --proxy-cacert */
err = getstr(&config->proxy_cacert, nextarg, DENY_BLANK);
break;
-
- case ONEOPT('E', '7'): /* --proxy-cainfo */
+ case C_PROXY_CAPATH: /* --proxy-capath */
err = getstr(&config->proxy_capath, nextarg, DENY_BLANK);
break;
-
- case ONEOPT('E', '8'): /* --proxy-insecure */
+ case C_PROXY_INSECURE: /* --proxy-insecure */
config->proxy_insecure_ok = toggle;
break;
-
- case ONEOPT('E', '9'): /* --proxy-tlsv1 */
+ case C_PROXY_TLSV1: /* --proxy-tlsv1 */
/* TLS version 1 for proxy */
config->proxy_ssl_version = CURL_SSLVERSION_TLSv1;
break;
-
- case ONEOPT('E', 'A'): /* --socks5-basic */
+ case C_SOCKS5_BASIC: /* --socks5-basic */
if(toggle)
config->socks5_auth |= CURLAUTH_BASIC;
else
config->socks5_auth &= ~CURLAUTH_BASIC;
break;
-
- case ONEOPT('E', 'B'): /* --socks5-gssapi */
+ case C_SOCKS5_GSSAPI: /* --socks5-gssapi */
if(toggle)
config->socks5_auth |= CURLAUTH_GSSAPI;
else
config->socks5_auth &= ~CURLAUTH_GSSAPI;
break;
-
- case ONEOPT('E', 'C'): /* --etag-save */
+ case C_ETAG_SAVE: /* --etag-save */
err = getstr(&config->etag_save_file, nextarg, DENY_BLANK);
break;
-
- case ONEOPT('E', 'D'): /* --etag-compare */
+ case C_ETAG_COMPARE: /* --etag-compare */
err = getstr(&config->etag_compare_file, nextarg, DENY_BLANK);
break;
-
- case ONEOPT('E', 'E'): /* --curves */
+ case C_CURVES: /* --curves */
err = getstr(&config->ssl_ec_curves, nextarg, DENY_BLANK);
break;
-
- case ONEOPT('f', 'a'): /* --fail-early */
+ case C_FAIL_EARLY: /* --fail-early */
global->fail_early = toggle;
break;
- case ONEOPT('f', 'b'): /* --styled-output */
+ case C_STYLED_OUTPUT: /* --styled-output */
global->styled_output = toggle;
break;
- case ONEOPT('f', 'c'): /* --mail-rcpt-allowfails */
+ case C_MAIL_RCPT_ALLOWFAILS: /* --mail-rcpt-allowfails */
config->mail_rcpt_allowfails = toggle;
break;
- case ONEOPT('f', 'd'): /* --fail-with-body */
+ case C_FAIL_WITH_BODY: /* --fail-with-body */
config->failwithbody = toggle;
if(config->failonerror && config->failwithbody) {
errorf(config->global, "You must select either --fail or "
err = PARAM_BAD_USE;
}
break;
- case ONEOPT('f', 'e'): /* --remove-on-error */
+ case C_REMOVE_ON_ERROR: /* --remove-on-error */
config->rm_partial = toggle;
break;
- case ONEOPT('f', '\0'): /* --fail */
+ case C_FAIL: /* --fail */
config->failonerror = toggle;
if(config->failonerror && config->failwithbody) {
errorf(config->global, "You must select either --fail or "
err = PARAM_BAD_USE;
}
break;
-
- case ONEOPT('F', '\0'): /* --form */
- case ONEOPT('F', 's'): /* --form-string */
+ case C_FORM: /* --form */
+ case C_FORM_STRING: /* --form-string */
/* "form data" simulation, this is a little advanced so lets do our best
to sort this out slowly and carefully */
if(formparse(config,
nextarg,
&config->mimeroot,
&config->mimecurrent,
- (subletter == 's')?TRUE:FALSE)) { /* 's' is literal
- string */
+ (cmd == C_FORM_STRING)?TRUE:FALSE)) /* literal string */
err = PARAM_BAD_USE;
- }
else if(SetHTTPrequest(config, HTTPREQ_MIMEPOST, &config->httpreq))
err = PARAM_BAD_USE;
break;
-
- case ONEOPT('g', '\0'): /* --globoff */
+ case C_GLOBOFF: /* --globoff */
config->globoff = toggle;
break;
-
- case ONEOPT('G', '\0'): /* --get */
+ case C_GET: /* --get */
config->use_httpget = toggle;
break;
-
- case ONEOPT('G', 'a'): /* --request-target */
+ case C_REQUEST_TARGET: /* --request-target */
err = getstr(&config->request_target, nextarg, DENY_BLANK);
break;
-
- case ONEOPT('h', '\0'): /* --help */
+ case C_HELP: /* --help */
if(toggle) {
if(*nextarg) {
global->help_category = strdup(nextarg);
}
/* we now actually support --no-help too! */
break;
- case ONEOPT('H', '\0'): /* --header */
- case ONEOPT('H', 'p'): /* --proxy-header */
+ case C_HEADER: /* --header */
+ case C_PROXY_HEADER: /* --proxy-header */
/* A custom header to append to a list */
if(nextarg[0] == '@') {
/* read many headers from a file or stdin */
if(!file) {
errorf(global, "Failed to open %s", &nextarg[1]);
err = PARAM_READ_ERROR;
- break;
}
else {
err = file2memory(&string, &len, file);
/* !checksrc! disable BANNEDFUNC 2 */
char *h = strtok(string, "\r\n");
while(h) {
- if(subletter == 'p') /* --proxy-header */
+ if(cmd == C_PROXY_HEADER) /* --proxy-header */
err = add2list(&config->proxyheaders, h);
else
err = add2list(&config->headers, h);
}
if(!use_stdin)
fclose(file);
- if(err)
- break;
}
}
else {
- if(subletter == 'p') /* --proxy-header */
+ if(cmd == C_PROXY_HEADER) /* --proxy-header */
err = add2list(&config->proxyheaders, nextarg);
else
err = add2list(&config->headers, nextarg);
}
break;
- case ONEOPT('i', '\0'): /* --include */
+ case C_INCLUDE: /* --include */
config->show_headers = toggle; /* show the headers as well in the
general output stream */
break;
- case ONEOPT('j', '\0'): /* --junk-session-cookies */
+ case C_JUNK_SESSION_COOKIES: /* --junk-session-cookies */
config->cookiesession = toggle;
break;
- case ONEOPT('I', '\0'): /* --head */
+ case C_HEAD: /* --head */
config->no_body = toggle;
config->show_headers = toggle;
if(SetHTTPrequest(config,
&config->httpreq))
err = PARAM_BAD_USE;
break;
- case ONEOPT('J', '\0'): /* --remote-header-name */
+ case C_REMOTE_HEADER_NAME: /* --remote-header-name */
config->content_disposition = toggle;
break;
- case ONEOPT('k', '\0'): /* --insecure */
+ case C_INSECURE: /* --insecure */
config->insecure_ok = toggle;
break;
- case ONEOPT('k', 'd'): /* --doh-insecure */
+ case C_DOH_INSECURE: /* --doh-insecure */
config->doh_insecure_ok = toggle;
break;
- case ONEOPT('K', '\0'): /* --config */
+ case C_CONFIG: /* --config */
if(parseconfig(nextarg, global)) {
errorf(global, "cannot read config from '%s'", nextarg);
err = PARAM_READ_ERROR;
}
break;
- case ONEOPT('l', '\0'): /* --list-only */
+ case C_LIST_ONLY: /* --list-only */
config->dirlistonly = toggle; /* only list the names of the FTP dir */
break;
- case ONEOPT('L', '\0'): /* --location */
- case ONEOPT('L', 't'): /* --location-trusted */
+ case C_LOCATION_TRUSTED: /* --location-trusted */
+ /* Continue to send authentication (user+password) when following
+ * locations, even when hostname changed */
+ config->unrestricted_auth = toggle;
+ FALLTHROUGH();
+ case C_LOCATION: /* --location */
config->followlocation = toggle; /* Follow Location: HTTP headers */
- if(subletter == 't')
- /* Continue to send authentication (user+password) when following
- * locations, even when hostname changed */
- config->unrestricted_auth = toggle;
break;
- case ONEOPT('m', '\0'): /* --max-time */
+ case C_MAX_TIME: /* --max-time */
/* specified max time */
err = secs2ms(&config->timeout_ms, nextarg);
break;
- case ONEOPT('M', '\0'): /* --manual */
+ case C_MANUAL: /* --manual */
if(toggle) { /* --no-manual shows no manual... */
#ifndef USE_MANUAL
warnf(global,
err = PARAM_MANUAL_REQUESTED;
}
break;
-
- case ONEOPT('n', 'o'): /* --netrc-optional */
+ case C_NETRC_OPTIONAL: /* --netrc-optional */
config->netrc_opt = toggle;
break;
- case ONEOPT('n', 'e'): /* --netrc-file */
+ case C_NETRC_FILE: /* --netrc-file */
err = getstr(&config->netrc_file, nextarg, DENY_BLANK);
break;
- case ONEOPT('n', '\0'): /* --netrc */
+ case C_NETRC: /* --netrc */
/* pick info from .netrc, if this is used for http, curl will
automatically enforce user+password with the request */
config->netrc = toggle;
break;
-
- case ONEOPT('N', '\0'): /* --buffer */
+ case C_BUFFER: /* --buffer */
/* disable the output I/O buffering. note that the option is called
--buffer but is mostly used in the negative form: --no-buffer */
config->nobuffer = longopt ? !toggle : TRUE;
break;
-
- case ONEOPT('O', 'a'): /* --remote-name-all */
+ case C_REMOTE_NAME_ALL: /* --remote-name-all */
config->default_node_flags = toggle?GETOUT_USEREMOTE:0;
break;
-
- case ONEOPT('O', 'b'): /* --output-dir */
+ case C_OUTPUT_DIR: /* --output-dir */
err = getstr(&config->output_dir, nextarg, DENY_BLANK);
break;
-
- case ONEOPT('O', 'c'): /* --clobber */
+ case C_CLOBBER: /* --clobber */
config->file_clobber_mode = toggle ? CLOBBER_ALWAYS : CLOBBER_NEVER;
break;
-
- case ONEOPT('o', '\0'): /* --output */
- case ONEOPT('O', '\0'): /* --remote-name */
+ case C_OUTPUT: /* --output */
+ case C_REMOTE_NAME: /* --remote-name */
/* output file */
if(!config->url_out)
config->url_out = config->url_list;
}
url->flags |= GETOUT_OUTFILE;
break;
- case ONEOPT('P', '\0'): /* --ftp-port */
+ case C_FTP_PORT: /* --ftp-port */
/* This makes the FTP sessions use PORT instead of PASV */
/* use <eth0> or <192.168.10.10> style addresses. Anything except
this will make us try to get the "default" address.
*/
err = getstr(&config->ftpport, nextarg, DENY_BLANK);
break;
- case ONEOPT('p', '\0'): /* --proxytunnel */
+ case C_PROXYTUNNEL: /* --proxytunnel */
/* proxy tunnel for non-http protocols */
config->proxytunnel = toggle;
break;
- case ONEOPT('q', '\0'): /* --disable */
+ case C_DISABLE: /* --disable */
/* if used first, already taken care of, we do it like this so we don't
cause an error! */
break;
- case ONEOPT('Q', '\0'): /* --quote */
+ case C_QUOTE: /* --quote */
/* QUOTE command to send to FTP server */
switch(nextarg[0]) {
case '-':
break;
}
break;
- case ONEOPT('r', '\0'): /* --range */
+ case C_RANGE: /* --range */
/* Specifying a range WITHOUT A DASH will create an illegal HTTP range
(and won't actually be range by definition). The man page previously
claimed that to be a good way, why this code is added to work-around
if(curlx_strtoofft(nextarg, NULL, 10, &value)) {
warnf(global, "unsupported range point");
err = PARAM_BAD_USE;
- break;
}
- warnf(global,
- "A specified range MUST include at least one dash (-). "
- "Appending one for you");
- msnprintf(buffer, sizeof(buffer), "%" CURL_FORMAT_CURL_OFF_T "-",
- value);
- Curl_safefree(config->range);
- config->range = strdup(buffer);
- if(!config->range) {
- err = PARAM_NO_MEM;
- break;
+ else {
+ warnf(global,
+ "A specified range MUST include at least one dash (-). "
+ "Appending one for you");
+ msnprintf(buffer, sizeof(buffer), "%" CURL_FORMAT_CURL_OFF_T "-",
+ value);
+ Curl_safefree(config->range);
+ config->range = strdup(buffer);
+ if(!config->range)
+ err = PARAM_NO_MEM;
}
}
else {
/* byte range requested */
const char *tmp_range = nextarg;
- while(*tmp_range != '\0') {
+ while(*tmp_range) {
if(!ISDIGIT(*tmp_range) && *tmp_range != '-' && *tmp_range != ',') {
warnf(global, "Invalid character is found in given range. "
"A specified range MUST have only digits in "
err = getstr(&config->range, nextarg, DENY_BLANK);
}
break;
- case ONEOPT('R', '\0'): /* --remote-time */
+ case C_REMOTE_TIME: /* --remote-time */
/* use remote file's time */
config->remote_time = toggle;
break;
- case ONEOPT('s', '\0'): /* --silent */
+ case C_SILENT: /* --silent */
global->silent = toggle;
break;
- case ONEOPT('S', '\0'): /* --show-error */
+ case C_SHOW_ERROR: /* --show-error */
global->showerror = toggle;
break;
- case ONEOPT('t', '\0'): /* --telnet-option */
+ case C_TELNET_OPTION: /* --telnet-option */
/* Telnet options */
err = add2list(&config->telnet_options, nextarg);
break;
- case ONEOPT('T', '\0'): /* --upload */
+ case C_UPLOAD_FILE: /* --upload-file */
/* we are uploading */
if(!config->url_ul)
config->url_ul = config->url_list;
err = getstr(&url->infile, nextarg, DENY_BLANK);
}
break;
- case ONEOPT('u', '\0'): /* --user */
+ case C_USER: /* --user */
/* user:password */
err = getstr(&config->userpwd, nextarg, ALLOW_BLANK);
cleanarg(clearthis);
break;
- case ONEOPT('U', '\0'): /* --proxy-user */
+ case C_PROXY_USER: /* --proxy-user */
/* Proxy user:password */
err = getstr(&config->proxyuserpwd, nextarg, ALLOW_BLANK);
cleanarg(clearthis);
break;
- case ONEOPT('v', '\0'): /* --verbose */
+ case C_VERBOSE: /* --verbose */
if(toggle) {
/* the '%' thing here will cause the trace get sent to stderr */
Curl_safefree(global->trace_dump);
/* verbose is disabled here */
global->tracetype = TRACE_NONE;
break;
- case ONEOPT('V', '\0'): /* --version */
+ case C_VERSION: /* --version */
if(toggle) /* --no-version yields no output! */
err = PARAM_VERSION_INFO_REQUESTED;
break;
-
- case ONEOPT('w', '\0'): /* --write-out */
+ case C_WRITE_OUT: /* --write-out */
/* get the output string */
if('@' == *nextarg) {
/* the data begins with a '@' letter, it means that a file name
else
err = getstr(&config->writeout, nextarg, DENY_BLANK);
break;
- case ONEOPT('x', 'a'): /* --preproxy */
+ case C_PREPROXY: /* --preproxy */
err = getstr(&config->preproxy, nextarg, DENY_BLANK);
break;
- case ONEOPT('x', '\0'): /* --proxy */
+ case C_PROXY: /* --proxy */
/* --proxy */
err = getstr(&config->proxy, nextarg, ALLOW_BLANK);
if(config->proxyver != CURLPROXY_HTTPS2)
config->proxyver = CURLPROXY_HTTP;
break;
-
- case ONEOPT('X', '\0'): /* --request */
+ case C_REQUEST: /* --request */
/* set custom request */
err = getstr(&config->customrequest, nextarg, DENY_BLANK);
break;
- case ONEOPT('y', '\0'): /* --speed-limit */
+ case C_SPEED_TIME: /* --speed-time */
/* low speed time */
err = str2unum(&config->low_speed_time, nextarg);
if(!err && !config->low_speed_limit)
config->low_speed_limit = 1;
break;
- case ONEOPT('Y', '\0'): /* --speed-time */
+ case C_SPEED_LIMIT: /* --speed-limit */
/* low speed limit */
err = str2unum(&config->low_speed_limit, nextarg);
if(!err && !config->low_speed_time)
config->low_speed_time = 30;
break;
- case ONEOPT('Z', '\0'): /* --parallel */
+ case C_PARALLEL: /* --parallel */
global->parallel = toggle;
break;
- case ONEOPT('Z', 'b'): { /* --parallel-max */
+ case C_PARALLEL_MAX: { /* --parallel-max */
long val;
err = str2unum(&val, nextarg);
if(err)
global->parallel_max = (unsigned short)val;
break;
}
- case ONEOPT('Z', 'c'): /* --parallel-immediate */
+ case C_PARALLEL_IMMEDIATE: /* --parallel-immediate */
global->parallel_connect = toggle;
break;
-
- case ONEOPT('z', '\0'): /* --time-cond */
+ case C_TIME_COND: /* --time-cond */
switch(*nextarg) {
case '+':
nextarg++;
projects / thirdparty / curl.git / commitdiff
