/***************************************************************************
*
* CurlS#arp
*
* Copyright (c) 2014 Dr. Masroor Ehsan (masroore@gmail.com)
* Portions copyright (c) 2004, 2005 Jeff Phillips (jeff@jeffp.net)
*
* This software is licensed as described in the file LICENSE, which you
* should have received as part of this distribution.
*
* You may opt to use, copy, modify, merge, publish, distribute and/or sell
* copies of this Software, and permit persons to whom the Software is
* furnished to do so, under the terms of the LICENSE file.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
* ANY KIND, either express or implied.
*
**************************************************************************/
using CurlSharp.Callbacks;
namespace CurlSharp.Enums
{
///
/// One of these is passed as the first parameter to
/// . The Description column of
/// the table describes the value that should be passed as the second parameter.
///
public enum CurlOption
{
///
/// Pass a true parameter to enable this. When enabled, libcurl
/// will automatically set the Referer: field in requests where it follows
/// a Location: redirect.
///
AutoReferer = 58,
///
/// Pass an int specifying your preferred size for the receive buffer
/// in libcurl. The main point of this would be that the write callback gets
/// called more often and with smaller chunks. This is just treated as a
/// request, not an order. You cannot be guaranteed to actually get the
/// requested size. (Added in 7.10)
///
BufferSize = 98,
///
/// Pass a string naming a file holding one or more certificates
/// to verify the peer with. This only makes sense when used in combination
/// with the SslVerifyPeer option.
///
CaInfo = 10065,
///
/// Pass a string naming a directory holding multiple CA certificates
/// to verify the peer with. The certificate directory must be prepared
/// using the openssl c_rehash utility. This only makes sense when used in
/// combination with the SslVerifyPeer option. The
/// CaPath function apparently does not work in Windows due
/// to some limitation in openssl. (Added in 7.9.8)
///
CaPath = 10097,
///
/// Pass an int. This option sets what policy libcurl should use when
/// the connection cache is filled and one of the open connections has to be
/// closed to make room for a new connection. This must be one of the
/// members. Use
/// to make
/// libcurl close the connection that was least recently used, that connection
/// is also least likely to be capable of re-use. Use
/// to make libcurl close
/// the oldest connection, the one that was created first among the ones in
/// the connection cache. The other close policies are not supported yet.
///
ClosePolicy = 72,
///
/// Time-out connect operations after this amount of seconds, if connects
/// are OK within this time, then fine... This only aborts the connect
/// phase. [Only works on unix-style/SIGALRM operating systems]
///
ConnectTimeout = 78,
///
/// Pass a string as parameter. It will be used to set a cookie
/// in the http request. The format of the string should be NAME=CONTENTS,
/// where NAME is the cookie name and CONTENTS is what the cookie should contain.
///
/// If you need to set multiple cookies, you need to set them all using a
/// single option and thus you need to concatenate them all in one single
/// string. Set multiple cookies in one string like this:
/// "name1=content1; name2=content2;" etc.
///
///
/// Using this option multiple times will only make the latest string override
/// the previously ones.
///
///
Cookie = 10022,
///
/// Pass a string as parameter. It should contain the name of your
/// file holding cookie data to read. The cookie data may be in Netscape /
/// Mozilla cookie data format or just regular HTTP-style headers dumped
/// to a file.
///
/// Given an empty or non-existing file, this option will enable cookies
/// for this CurlEasy object, making it understand and parse received cookies
/// and then use matching cookies in future request.
///
///
CookieFile = 10031,
///
/// Pass a file name as string. This will make libcurl write all
/// internally known cookies to the specified file when
/// is called. If no cookies are known, no file
/// will be created. Using this option also enables cookies for this
/// session, so if you for example follow a location it will make matching
/// cookies get sent accordingly.
///
/// If the cookie jar file can't be created or written to
/// (when is called), libcurl will not and
/// cannot report an error for this. Using Verbose or
/// CurlDebugCallback will get a warning to display, but that
/// is the only visible feedback you get about this possibly lethal situation.
///
///
CookieJar = 10082,
///
/// Pass a bool set to true to mark this as a new cookie
/// "session". It will force libcurl to ignore all cookies it is about to
/// load that are "session cookies" from the previous session. By default,
/// libcurl always stores and loads all cookies, independent of whether they are
/// session cookies. Session cookies are cookies without expiry date and they
/// are meant to be alive and existing for this "session" only.
///
CookieSession = 96,
///
/// Convert Unix newlines to CRLF newlines on transfers.
///
CRLF = 27,
///
/// Pass a string as parameter. It will be used instead of GET or
/// HEAD when doing an HTTP request, or instead of LIST or NLST when
/// doing an ftp directory listing. This is useful for doing DELETE or
/// other more or less obscure HTTP requests. Don't do this at will,
/// make sure your server supports the command first.
///
/// Restore to the internal default by setting this to null.
///
///
/// Many people have wrongly used this option to replace the entire
/// request with their own, including multiple headers and POST contents.
/// While that might work in many cases, it will cause libcurl to send
/// invalid requests and it could possibly confuse the remote server badly.
/// Use Post and PostFields to set POST data.
/// Use HttpHeader to replace or extend the set of headers
/// sent by libcurl. Use HttpVersion to change HTTP version.
///
///
CustomRequest = 10036,
///
/// Pass an object referene to whatever you want passed to your
/// delegate's extraData argument.
/// This reference is not used internally by libcurl, it is only passed to
/// the delegate.
///
DebugData = 10095,
///
/// Pass a reference to an delegate.
/// Verbose must be in effect. This delegate receives debug
/// information, as specified with the argument.
/// This function must return 0.
///
DebugFunction = 20094,
///
/// Pass an int, specifying the timeout in seconds. Name resolves
/// will be kept in memory for this number of seconds. Set to zero (0)
/// to completely disable caching, or set to -1 to make the cached
/// entries remain forever. By default, libcurl caches this info for 60
/// seconds.
///
DnsCacheTimeout = 92,
///
/// Not supported.
///
DnsUseGlobalCache = 91,
///
/// Pass a string containing the path name to the Entropy Gathering
/// Daemon socket. It will be used to seed the random engine for Ssl.
///
EgdSocket = 10077,
///
/// Set this option to the file name of your .netrc file you want libcurl to parse (using the CURLOPT_NETRC option). If
/// not set, libcurl will do a poor attempt to find the user's home directory and check for a .netrc file in there.
///
NetRcFile = 118,
///
/// Sets the contents of the Accept-Encoding: header sent in an HTTP request,
/// and enables decoding of a response when a Content-Encoding: header is
/// received. Three encodings are supported: identity, which does
/// nothing, deflate which requests the server to compress its
/// response using the zlib algorithm, and gzip which requests the
/// gzip algorithm. If a zero-length string is set, then an Accept-Encoding:
/// header containing all supported encodings is sent.
///
Encoding = 10102,
///
/// Not supported.
///
ErrorBuffer = 10010,
///
/// A true parameter tells the library to fail silently if the
/// HTTP code returned is equal to or larger than 300. The default
/// action would be to return the page normally, ignoring that code.
///
FailOnError = 45,
///
/// Pass a bool. If it is true, libcurl will attempt to get
/// the modification date of the remote document in this operation. This
/// requires that the remote server sends the time or replies to a time
/// querying command. The CurlEasy.GetInfo function with the
/// argument can be used after a
/// transfer to extract the received time (if any).
///
Filetime = 69,
///
/// A true parameter tells the library to follow any Location:
/// header that the server sends as part of an HTTP header.
///
/// this means that the library will re-send the same request on the
/// new location and follow new Location: headers all the way until no
/// more such headers are returned. MaxRedirs can be used
/// to limit the number of redirects libcurl will follow.
///
///
FollowLocation = 52,
///
/// Pass a bool. Set to true to make the next transfer
/// explicitly close the connection when done. Normally, libcurl keeps all
/// connections alive when done with one transfer in case there comes a
/// succeeding one that can re-use them. This option should be used with
/// caution and only if you understand what it does. Set to false
/// to have libcurl keep the connection open for possibly later re-use
/// (default behavior).
///
ForbidReuse = 75,
///
/// Pass a bool. Set to true to make the next transfer use a
/// new (fresh) connection by force. If the connection cache is full before
/// this connection, one of the existing connections will be closed as
/// according to the selected or default policy. This option should be used
/// with caution and only if you understand what it does. Set this to
/// false to have libcurl attempt re-using an existing connection
/// (default behavior).
///
FreshConnect = 74,
///
/// String that will be passed to the FTP server when it requests
/// account info.
///
FtpAccount = 10134,
///
/// A true parameter tells the library to append to the remote
/// file instead of overwrite it. This is only useful when uploading
/// to an ftp site.
///
FtpAppend = 50,
///
/// A true parameter tells the library to just list the names of
/// an ftp directory, instead of doing a full directory listing that
/// would include file sizes, dates etc.
///
/// This causes an FTP NLST command to be sent. Beware that some FTP
/// servers list only files in their response to NLST; they might not
/// include subdirectories and symbolic links.
///
///
FtpListOnly = 48,
///
/// Pass a string as parameter. It will be used to get the IP
/// address to use for the ftp PORT instruction. The PORT instruction
/// tells the remote server to connect to our specified IP address.
/// The string may be a plain IP address, a host name, an network
/// interface name (under Unix) or just a '-' letter to let the library
/// use your systems default IP address. Default FTP operations are
/// passive, and thus won't use PORT.
///
/// You disable PORT again and go back to using the passive version
/// by setting this option to NULL.
///
///
FtpPort = 10017,
///
/// When FTP over Ssl/TLS is selected (with FtpSsl),
/// this option can be used to change libcurl's default action which
/// is to first try "AUTH Ssl" and then "AUTH TLS" in this order,
/// and proceed when a OK response has been received.
///
/// Pass a member of the enumeration.
///
///
FtpSslAuth = 129,
///
/// Pass a bool. If the value is true, cURL will attempt to
/// create any remote directory that it fails to CWD into. CWD is the
/// command that changes working directory. (Added in 7.10.7)
///
FtpCreateMissingDirs = 110,
///
/// Pass an int. Causes libcurl to set a timeout period (in seconds)
/// on the amount of time that the server is allowed to take in order to
/// generate a response message for a command before the session is
/// considered hung. Note that while libcurl is waiting for a response, this
/// value overrides Timeout. It is recommended that if used in
/// conjunction with Timeout, you set
/// FtpResponseTimeout to a value smaller than
/// Timeout. (Added in 7.10.8)
///
FtpResponseTimeout = 112,
///
/// Pass a member of the enumeration.
///
FtpSsl = 119,
///
/// Pass a bool. If the value is true, it tells curl to use
/// the EPRT (and LPRT) command when doing active FTP downloads (which is
/// enabled by FtpPort). Using EPRT means that it will first attempt
/// to use EPRT and then LPRT before using PORT, but if you pass false
/// to this option, it will not try using EPRT or LPRT, only plain PORT.
/// (Added in 7.10.5)
///
FtpUseEprt = 106,
///
/// Pass a bool. If the value is true, it tells curl to use
/// the EPSV command when doing passive FTP downloads (which it always does
/// by default). Using EPSV means that it will first attempt to use EPSV
/// before using PASV, but if you pass false to this option, it will
/// not try using EPSV, only plain PASV.
///
FtpUseEpsv = 85,
///
/// A true parameter tells the library to include the header in
/// the body output. This is only relevant for protocols that actually
/// have headers preceding the data (like HTTP).
///
Header = 42,
///
/// Object reference to pass to the
/// delegate. Note that if you specify the CurlHeaderCallback,
/// this is the reference you'll get as the extraData parameter.
///
HeaderData = 10029,
///
/// Provide an delegate reference.
/// This delegate gets called by libcurl as soon as there is received
/// header data that needs to be written down. The headers are guaranteed
/// to be written one-by-one and only complete lines are written. Parsing
/// headers should be easy enough using this. The size of the data contained
/// in buf is size multiplied with nmemb.
/// Return the number of bytes actually written or return -1 to signal
/// error to the library (it will cause it to abort the transfer with a
/// return code).
///
HeaderFunction = 20079,
///
/// Pass an of aliases to be treated as valid HTTP
/// 200 responses. Some servers respond with a custom header response line.
/// For example, IceCast servers respond with "ICY 200 OK". By including
/// this string in your list of aliases, the response will be treated as a
/// valid HTTP header line such as "HTTP/1.0 200 OK". (Added in 7.10.3)
///
/// The alias itself is not parsed for any version strings. So if your alias
/// is "MYHTTP/9.9", libcurl will not treat the server as responding with
/// HTTP version 9.9. Instead libcurl will use the value set by option
/// HttpVersion.
///
///
Http200Aliases = 10104,
///
/// Pass an int as parameter, which is set to a bitmask
/// of , to tell libcurl what authentication
/// method(s) you want it to use. If more than one bit is set, libcurl will
/// first query the site to see what authentication methods it supports and
/// then pick the best one you allow it to use. Note that for some methods,
/// this will induce an extra network round-trip. Set the actual name and
/// password with the UserPwd option. (Added in 7.10.6)
///
HttpAuth = 107,
///
/// Pass a bool. If it's true, this forces the HTTP request
/// to get back to GET. Usable if a POST, HEAD, PUT or a custom request
/// has been used previously using the same object.
///
HttpGet = 80,
///
/// Pass an reference containing HTTP headers to pass to
/// the server in your HTTP request. If you add a header that is otherwise
/// generated and used by libcurl internally, your added one will be used
/// instead. If you add a header with no contents as in 'Accept:' (no data
/// on the right side of the colon), the internally used header will get
/// disabled. Thus, using this option you can add new headers, replace
/// internal headers and remove internal headers. The headers included in the
/// CurlSlist must not be CRLF-terminated, because curl adds CRLF after
/// each header item. Failure to comply with this will result in strange bugs
/// because the server will most likely ignore part of the headers you specified.
///
/// The first line in a request (usually containing a GET or POST) is not
/// a header and cannot be replaced using this option. Only the lines
/// following the request-line are headers.
///
///
/// Pass a null to this to reset back to no custom headers.
///
///
/// The most commonly replaced headers have "shortcuts" in the options
/// Cookie, UserAgent and Referer.
///
///
HttpHeader = 10023,
///
/// Tells libcurl you want a multipart/formdata HTTP POST to be made and you
/// instruct what data to pass on to the server. Pass a reference to a
/// object as parameter.
/// The best and most elegant way to do this, is to use
/// as documented.
///
/// Using POST with HTTP 1.1 implies the use of a "Expect: 100-continue"
/// header. You can disable this header with HttpHeader as usual.
///
///
HttpPost = 10024,
///
/// Set the parameter to true to get the library to tunnel all
/// operations through a given HTTP proxy. Note that there is a big
/// difference between using a proxy and tunneling through it. If you
/// don't know what this means, you probably don't want this tunneling option.
///
HttpProxyTunnel = 61,
///
/// Pass a member of the enumeration. These
/// values force libcurl to use the specific HTTP versions. This is not
/// sensible to do unless you have a good reason.
///
HttpVersion = 84,
///
/// Provide an delegate reference.
/// This delegate gets called by libcurl when an IOCTL operation,
/// such as a rewind of a file being sent via FTP, is required on
/// the client side.
///
IoctlFunction = 20130,
///
/// Provide an object, such as a FileStream, upon which
/// you may need to perform an IOCTL operation. Right now, only
/// rewind is supported.
///
IoctlData = 10131,
///
/// When uploading a file to a remote site, this option should be used to
/// tell libcurl what the expected size of the infile is. This value should
/// be passed as an int.
///
InfileSize = 14,
///
/// When uploading a file to a remote site, this option should be used to
/// tell libcurl what the expected size of the infile is. This value should
/// be passed as a long. (Added in 7.11.0)
///
InFileSizeLarge = 30115,
///
/// Pass a string as parameter. This sets the interface name to use
/// as the outgoing network interface. The name can be an interface name,
/// an IP address or a host name.
///
Interface = 10062,
///
/// Pass one of the members of the enumeration.
///
IpResolve = 113,
///
/// Pass a string as parameter. Set the kerberos4 security level;
/// this also enables kerberos4 awareness. This is a string, 'clear', 'safe',
/// 'confidential' or 'private'. If the string is set but doesn't match
/// one of these, 'private' will be used. Set the string to null
/// to disable kerberos4. The kerberos support only works for FTP.
///
Krb4Level = 10063,
///
/// Pass an int as parameter. It contains the transfer speed in bytes
/// per second that the transfer should be below during
/// LowSpeedTime seconds for the library to consider it
/// too slow and abort.
///
LowSpeedLimit = 19,
///
/// Pass an int as parameter. It contains the time in seconds that
/// the transfer should be below the LowSpeedLimit for the
/// library to consider it too slow and abort.
///
LowSpeedTime = 20,
///
/// Pass an int. The set number will be the persistent connection
/// cache size. The set amount will be the maximum amount of simultaneously
/// open connections that libcurl may cache. Default is 5, and there isn't
/// much point in changing this value unless you are perfectly aware of how
/// this works and changes libcurl's behaviour. This concerns connections
/// using any of the protocols that support persistent connections.
///
/// When reaching the maximum limit, cURL uses the ClosePolicy
/// to figure out which of the existing connections to close to prevent the
/// number of open connections to increase.
///
///
/// if you already have performed transfers with this CurlEasy object, setting a
/// smaller MaxConnects than before may cause open connections
/// to get closed unnecessarily.
///
///
MaxConnects = 71,
///
/// Pass an int as parameter. This allows you to specify the maximum
/// size (in bytes) of a file to download. If the file requested is larger
/// than this value, the transfer will not start and
/// will be returned.
///
/// The file size is not always known prior to download, and for such files
/// this option has no effect even if the file transfer ends up being larger
/// than this given limit. This concerns both FTP and HTTP transfers.
///
///
MaxFileSize = 114,
///
/// Pass a long as parameter. This allows you to specify the
/// maximum size (in bytes) of a file to download. If the file requested
/// is larger than this value, the transfer will not start and
/// will be returned.
/// (Added in 7.11.0)
///
/// The file size is not always known prior to download, and for such files
/// this option has no effect even if the file transfer ends up being larger
/// than this given limit. This concerns both FTP and HTTP transfers.
///
///
MaxFileSizeLarge = 30117,
///
/// Pass an int. The set number will be the redirection limit. If
/// that many redirections have been followed, the next redirect will cause
/// an error (TooManyRedirects). This option only makes sense
/// if the FollowLocation is used at the same time.
///
MaxRedirs = 68,
///
/// This parameter controls the preference of libcurl between using
/// user names and passwords from your ~/.netrc file, relative to
/// user names and passwords in the URL supplied with Url.
///
/// libcurl uses a user name (and supplied or prompted password)
/// supplied with UserPwd in preference to any of the
/// options controlled by this parameter.
///
///
/// Pass a member of the enumeration.
///
///
/// Only machine name, user name and password are taken into account
/// (init macros and similar things aren't supported).
///
///
/// libcurl does not verify that the file has the correct properties
/// set (as the standard Unix ftp client does). It should only be
/// readable by user.
///
///
Netrc = 51,
///
/// Pass a string as parameter, containing the full path name to the
/// file you want libcurl to use as .netrc file. If this option is omitted,
/// and Netrc is set, libcurl will attempt to find the a
/// .netrc file in the current user's home directory. (Added in 7.10.9)
///
NetrcFile = 10118,
///
/// A true parameter tells the library to not include the
/// body-part in the output. This is only relevant for protocols that
/// have separate header and body parts. On HTTP(S) servers, this
/// will make libcurl do a HEAD request.
///
/// To change back to GET, you should use HttpGet. To
/// change back to POST, you should use Post. Setting
/// NoBody to false has no effect.
///
///
NoBody = 44,
///
/// A true parameter tells the library to shut off progress
/// reporting.
///
NoProgress = 43,
///
/// Pass a bool. If it is true, libcurl will not use any
/// functions that install signal handlers or any functions that cause
/// signals to be sent to the process. This option is mainly here to allow
/// multi-threaded unix applications to still set/use all timeout options
/// etc, without risking getting signals. (Added in 7.10)
///
/// Consider using libcurl with ares built-in to enable asynchronous Dns
/// lookups. It enables nice timeouts for name resolves without signals.
///
///
NoSignal = 99,
///
/// Not supported.
///
PasvHost = 126,
///
/// Pass an int specifying what remote port number to connect to,
/// instead of the one specified in the URL or the default port for the
/// used protocol.
///
Port = 3,
///
/// A true parameter tells the library to do a regular HTTP post.
/// This will also make the library use the a "Content-Type:
/// application/x-www-form-urlencoded" header. (This is by far the most
/// commonly used POST method).
///
/// Use the PostFields option to specify what data to post
/// and PostFieldSize to set the data size. Optionally,
/// you can provide data to POST using the CurlReadCallback and
/// ReadData options.
///
///
/// You can override the default POST Content-Type: header by setting
/// your own with HttpHeader.
///
///
/// Using POST with HTTP 1.1 implies the use of a "Expect: 100-continue"
/// header. You can disable this header with HttpHeader as usual.
///
///
/// If you use POST to a HTTP 1.1 server, you can send data without knowing
/// the size before starting the POST if you use chunked encoding. You
/// enable this by adding a header like "Transfer-Encoding: chunked" with
/// HttpHeader. With HTTP 1.0 or without chunked transfer,
/// you must specify the size in the request.
///
///
/// if you have issued a POST request and want to make a HEAD or GET instead,
/// you must explictly pick the new request type using NoBody
/// or HttpGet or similar.
///
///
Post = 47,
///
/// Pass a string as parameter, which should be the full data to post
/// in an HTTP POST operation. You must make sure that the data is formatted
/// the way you want the server to receive it. libcurl will not convert or
/// encode it for you. Most web servers will assume this data to be
/// url-encoded. Take note.
///
/// This POST is a normal application/x-www-form-urlencoded kind (and
/// libcurl will set that Content-Type by default when this option is used),
/// which is the most commonly used one by HTML forms. See also the
/// Post. Using PostFields implies
/// Post.
///
///
/// Using POST with HTTP 1.1 implies the use of a "Expect: 100-continue"
/// header. You can disable this header with HttpHeader as usual.
///
///
/// to make multipart/formdata posts (aka rfc1867-posts), check out the
/// HttpPost option.
///
///
PostFields = 10015,
///
/// If you want to post data to the server without letting libcurl do a
/// strlen() to measure the data size, this option must be used. When
/// this option is used you can post fully binary data, which otherwise
/// is likely to fail. If this size is set to zero, the library will use
/// strlen() to get the size.
///
PostFieldSize = 60,
///
/// Pass a long as parameter. Use this to set the size of the
/// PostFields data to prevent libcurl from doing
/// strlen() on the data to figure out the size. This is the large
/// file version of the PostFieldSize option. (Added in 7.11.1)
///
PostFieldSizeLarge = 30120,
///
/// Pass an of FTP commands to pass to the server after
/// your ftp transfer request. Disable this operation again by setting this
/// option to null.
///
Postquote = 10039,
///
/// Pass an containing the FTP commands to pass to
/// the server after the transfer type is set. Disable this operation
/// again by setting a null to this option.
///
Prequote = 10093,
///
/// Pass an object as parameter, referencing data that should be
/// associated with this object. The object can
/// subsequently be retrieved using CurlEasy.GetInfo with the
/// option. libcurl itself does
/// nothing with this data. (Added in 7.10.3)
///
Private = 10103,
///
/// Pass an object reference that will be untouched by libcurl
/// and passed as the first argument in the progress delegate set with
/// CurlProgressCallback.
///
ProgressData = 10057,
///
/// Pass an delegate reference. This
/// delegate gets called by libcurl at a frequent interval during data
/// transfer. Unknown/unused argument values will be set to zero (like if
/// you only download data, the upload size will remain 0). Returning a
/// non-zero value from this delegate will cause libcurl to abort the
/// transfer and return .
///
/// NoProgress must be set to false to make this
/// function actually get called.
///
///
ProgressFunction = 20056,
///
/// Set HTTP proxy to use. The parameter should be a string holding
/// the host name or dotted IP address. To specify port number in this
/// string, append :[port] to the end of the host name. The proxy
/// string may be prefixed with [protocol]:// since any such prefix
/// will be ignored. The proxy's port number may optionally be specified
/// with the separate option ProxyPort.
///
/// NOTE: when you tell the library to use an HTTP proxy, libcurl will
/// transparently convert operations to HTTP even if you specify an FTP
/// URL etc. This may have an impact on what other features of the library
/// you can use, such as Quote and similar FTP specifics
/// that don't work unless you tunnel through the HTTP proxy. Such tunneling
/// is activated with HttpProxyTunnel.
///
///
Proxy = 10004,
///
/// Pass a bitmask of as the paramter, to tell
/// libcurl what authentication method(s) you want it to use for your proxy
/// authentication. If more than one bit is set, libcurl will first query the
/// site to see what authentication methods it supports and then pick the best
/// one you allow it to use. Note that for some methods, this will induce an
/// extra network round-trip. Set the actual name and password with the
/// ProxyUserPwd option. The bitmask can be constructed by
/// or'ing together the bits. As of this writing,
/// only and
/// work. (Added in 7.10.7)
///
ProxyAuth = 111,
///
/// Pass an int with this option to set the proxy port to connect
/// to unless it is specified in the proxy string Proxy.
///
ProxyPort = 59,
///
/// Pass a to set type of the proxy.
///
ProxyType = 101,
///
/// Pass a string as parameter, which should be
/// [user name]:[password] to use for the connection to the
/// HTTP proxy. Use ProxyAuth to decide authentication method.
///
ProxyUserPwd = 10006,
///
/// A true parameter tells the library to use HTTP PUT to transfer
/// data. The data should be set with ReadData and
/// InfileSize.
///
/// This option is deprecated and starting with version 7.12.1 you should
/// instead use Upload.
///
///
Put = 54,
///
/// Pass a reference to an containing FTP commands to
/// pass to the server prior to your ftp request. This will be done before
/// any other FTP commands are issued (even before the CWD command).
/// Disable this operation again by setting a null to this option.
///
Quote = 10028,
///
/// Pass a string containing the file name. The file will be used
/// to read from to seed the random engine for Ssl. The more random the
/// specified file is, the more secure the Ssl connection will become.
///
RandomFile = 10076,
///
/// Pass a string as parameter, which should contain the
/// specified range you want. It should be in the format X-Y, where X
/// or Y may be left out. HTTP transfers also support several intervals,
/// separated with commas as in X-Y,N-M. Using this kind of multiple
/// intervals will cause the HTTP server to send the response document
/// in pieces (using standard MIME separation techniques). Pass a
/// null to this option to disable the use of ranges.
///
Range = 10007,
///
/// Object reference to pass to the
/// delegate. Note that if you specify the CurlReadCallback,
/// this is the reference you'll get as input.
///
ReadData = 10009,
///
/// Pass a reference to an delegate.
/// This delegate gets called by libcurl as soon as it needs to read data
/// in order to send it to the peer. The data area referenced by the
/// buf may be filled with at most size multiplied with
/// nmemb number of bytes. Your function must return the actual
/// number of bytes that you stored in that byte array. Returning 0 will
/// signal end-of-file to the library and cause it to stop the current transfer.
///
/// If you stop the current transfer by returning 0 "pre-maturely"
/// (i.e before the server expected it, like when you've told you will
/// upload N bytes and you upload less than N bytes), you may experience that
/// the server "hangs" waiting for the rest of the data that won't come.
///
///
ReadFunction = 20012,
///
/// Pass a string as parameter. It will be used to set the Referer:
/// header in the http request sent to the remote server. This can be used
/// to fool servers or scripts. You can also set any custom header with
/// HttpHeader.
///
Referer = 10016,
///
/// Pass an int as parameter. It contains the offset in number of
/// bytes that you want the transfer to start from. Set this option to 0
/// to make the transfer start from the beginning (effectively disabling resume).
///
ResumeFrom = 21,
///
/// Pass a long as parameter. It contains the offset in number of
/// bytes that you want the transfer to start from. (Added in 7.11.0)
///
ResumeFromLarge = 30116,
///
/// Pass an initialized reference as a parameter.
/// Setting this option will make this object use the
/// data from the CurlShare object instead of keeping the data to itself. This
/// enables several CurlEasy objects to share data. If the CurlEasy objects are used
/// simultaneously, you MUST use the CurlShare object's locking methods.
/// See for details.
///
Share = 10100,
///
/// Not supported.
///
SourceHost = 10122,
///
/// Not supported.
///
SourcePath = 10124,
///
/// Not supported.
///
SourcePort = 125,
///
/// When doing a third-party transfer, set the source post-quote list,
/// as an .
///
SourcePostquote = 10128,
///
/// When doing a third-party transfer, set the source pre-quote list,
/// as an .
///
SourcePrequote = 10127,
///
/// When doing a third-party transfer, set a quote list,
/// as an .
///
SourceQuote = 10133,
///
/// Set the source URL for a third-party transfer.
///
SourceUrl = 10132,
///
/// When doing 3rd party transfer, set the source user and password, as
/// a string with format user:password.
///
SourceUserpwd = 10123,
///
/// Pass a string as parameter. The string should be the file name
/// of your certificate. The default format is "PEM" and can be changed
/// with SslCertType.
///
SslCert = 10025,
///
/// Pass a string as parameter. It will be used as the password
/// required to use the SslCert certificate.
///
/// This option is replaced by SslKeyPasswd and should only
/// be used for backward compatibility. You never needed a pass phrase to
/// load a certificate but you need one to load your private key.
///
///
SslCertPasswd = 10026,
///
/// Pass a string as parameter. The string should be the format of
/// your certificate. Supported formats are "PEM" and "DER". (Added in 7.9.3)
///
SslCertType = 10086,
///
/// Pass a string as parameter. It will be used as the identifier
/// for the crypto engine you want to use for your private key.
///
/// If the crypto device cannot be loaded,
/// is returned.
///
///
SslEngine = 10089,
///
/// Sets the actual crypto engine as the default for (asymmetric)
/// crypto operations.
///
/// If the crypto device cannot be set,
/// is returned.
///
///
SslEngineDefault = 90,
///
/// Pass a string as parameter. The string should be the file name
/// of your private key. The default format is "PEM" and can be changed
/// with SslKeyType.
///
SslKey = 10087,
///
/// Pass a string as parameter. It will be used as the password
/// required to use the SslKey private key.
///
SslKeyPasswd = 10026,
///
/// Pass a string as parameter. The string should be the format of
/// your private key. Supported formats are "PEM", "DER" and "ENG".
///
/// The format "ENG" enables you to load the private key from a crypto
/// engine. In this case SslKey is used as an identifier
/// passed to the engine. You have to set the crypto engine with
/// SslEngine. "DER" format key file currently does not
/// work because of a bug in OpenSSL.
///
///
SslKeyType = 10088,
///
/// Pass a member of the enumeration as the
/// parameter to set the Ssl version to use. By default
/// the Ssl library will try to solve this by itself although some servers
/// servers make this difficult why you at times may have to use this
/// option.
///
SslVersion = 32,
///
/// Pass a string holding the list of ciphers to use for the Ssl
/// connection. The list must be syntactically correct, it consists of
/// one or more cipher strings separated by colons. Commas or spaces are
/// also acceptable separators but colons are normally used, !, - and +
/// can be used as operators. Valid examples of cipher lists include
/// 'RC4-SHA', ´SHA1+DES´, 'Tlsv1' and 'DEFAULT'. The default list is
/// normally set when you compile OpenSSL.
///
/// You'll find more details about cipher lists on this URL:
/// http://www.openssl.org/docs/apps/ciphers.html
///
///
SslCipherList = 10083,
///
/// Object reference to pass to the ssl context delegate set by the option
/// SslCtxFunction, this is the pointer you'll get as the
/// second parameter, otherwise null. (Added in 7.11.0)
///
SslCtxData = 10109,
///
/// Reference to an delegate.
/// This delegate gets called by libcurl just before the initialization of
/// an Ssl connection after having processed all other Ssl related options
/// to give a last chance to an application to modify the behaviour of
/// openssl's ssl initialization. The parameter
/// wraps a pointer to an openssl SSL_CTX. If an error is returned no attempt
/// to establish a connection is made and the perform operation will return
/// the error code from this callback function. Set the parm argument with
/// the SslCtxData option. This option was introduced
/// in 7.11.0.
///
/// To use this properly, a non-trivial amount of knowledge of the openssl
/// libraries is necessary. Using this function allows for example to use
/// openssl callbacks to add additional validation code for certificates,
/// and even to change the actual URI of an HTTPS request.
///
///
SslCtxFunction = 20108,
///
/// Pass an int. Set if we should verify the common name from the
/// peer certificate in the Ssl handshake, set 1 to check existence, 2 to
/// ensure that it matches the provided hostname. This is by default set
/// to 2. (default changed in 7.10)
///
SslVerifyhost = 81,
///
/// Pass a bool that is set to false to stop curl from
/// verifying the peer's certificate (7.10 starting setting this option
/// to non-zero by default). Alternate certificates to verify against
/// can be specified with the CaInfo option or a
/// certificate directory can be specified with the CaPath
/// option. As of 7.10, curl installs a default bundle.
/// SslVerifyhost may also need to be set to 1
/// or 0 if SslVerifyPeer is disabled (it defaults to 2).
///
SslVerifyPeer = 64,
///
/// Not supported.
///
Stderr = 10037,
///
/// Pass a bool specifying whether the TCP_NODELAY option should be
/// set or cleared (true = set, false = clear). The option is
/// cleared by default. This will have no effect after the connection has
/// been established.
///
/// Setting this option will disable TCP's Nagle algorithm. The purpose of
/// this algorithm is to try to minimize the number of small packets on the
/// network (where "small packets" means TCP segments less than the Maximum
/// Segment Size (MSS) for the network).
///
///
/// Maximizing the amount of data sent per TCP segment is good because it
/// amortizes the overhead of the send. However, in some cases (most notably
/// telnet or rlogin) small segments may need to be sent without delay. This
/// is less efficient than sending larger amounts of data at a time, and can
/// contribute to congestion on the network if overdone.
///
///
TcpNoDelay = 121,
///
/// Pass a bool specifying whether to ignore Content-Length
///
IgnoreContentLength = 136,
///
/// Set to true to skip the IP address received in a 227 PASV FTP server response. Typically used for FTP-SSL purposes
/// but is not restricted to that. libcurl will then instead use the same IP address it used for the control
/// connection.
///
FtpSkipPasvIp = 137,
///
/// Provide an with variables to pass to the telnet
/// negotiations. The variables should be in the format "option=value".
/// libcurl supports the options 'TTYPE', 'XDISPLOC' and 'NEW_ENV'. See
/// the TELNET standard for details.
///
TelnetOptions = 10070,
///
/// Pass a member of the enumeration as
/// parameter. This defines how the TimeValue time
/// value is treated. This feature applies to HTTP and FTP.
///
/// The last modification time of a file is not always known and in such
/// instances this feature will have no effect even if the given time
/// condition would have not been met.
///
///
TimeCondition = 33,
///
/// Pass a int as parameter containing the maximum time in seconds
/// that you allow the libcurl transfer operation to take. Normally, name
/// lookups can take a considerable time and limiting operations to less
/// than a few minutes risk aborting perfectly normal operations. This
/// option will cause curl to use the SIGALRM to enable time-outing
/// system calls.
///
/// this is not recommended to use in unix multi-threaded programs,
/// as it uses signals unless NoSignal (see above) is set.
///
///
Timeout = 13,
///
/// Pass a as parameter. This time will be
/// used in a condition as specified with TimeCondition.
///
TimeValue = 34,
///
/// A true parameter tells the library to use ASCII mode for ftp
/// transfers, instead of the default binary transfer. For LDAP transfers
/// it gets the data in plain text instead of HTML and for win32 systems
/// it does not set the stdout to binary mode. This option can be usable
/// when transferring text data between systems with different views on
/// certain characters, such as newlines or similar.
///
TransferText = 53,
///
/// A true parameter tells the library it can continue to send
/// authentication (user+password) when following locations, even when
/// hostname changed. Note that this is meaningful only when setting
/// FollowLocation.
///
UnrestrictedAuth = 105,
///
/// A true parameter tells the library to prepare for an
/// upload. The ReadData and InfileSize
/// or InFileSizeLarge are also interesting for uploads.
/// If the protocol is HTTP, uploading means using the PUT request
/// unless you tell libcurl otherwise.
///
/// Using PUT with HTTP 1.1 implies the use of a "Expect: 100-continue"
/// header. You can disable this header with HttpHeader as usual.
///
///
/// If you use PUT to a HTTP 1.1 server, you can upload data without
/// knowing the size before starting the transfer if you use chunked
/// encoding. You enable this by adding a header like
/// "Transfer-Encoding: chunked" with HttpHeader. With
/// HTTP 1.0 or without chunked transfer, you must specify the size.
///
///
Upload = 46,
///
/// The actual URL to deal with. The parameter should be a string.
/// If the given URL lacks the protocol part ("http://" or "ftp://" etc), it
/// will attempt to guess which protocol to use based on the given host name.
///
/// If the given protocol of the set URL is not supported, libcurl will return
/// an error CurlCode.()
/// when you call CurlEasy's or
/// CurlMulti's .
///
///
/// Use for detailed info
/// on which protocols that are supported.
///
///
Url = 10002,
///
/// Pass a string as parameter. It will be used to set the
/// User-Agent: header in the http request sent to the remote server.
/// This can be used to fool servers or scripts. You can also set any
/// custom header with HttpHeader.
///
UserAgent = 10018,
///
/// Pass a string as parameter, which should be
/// [user name]:[password] to use for the connection. Use
/// HttpAuth to decide authentication method.
///
/// When using HTTP and FollowLocation, libcurl might
/// perform several requests to possibly different hosts. libcurl will
/// only send this user and password information to hosts using the
/// initial host name (unless UnrestrictedAuth is set),
/// so if libcurl follows locations to other hosts it will not send the
/// user and password to those. This is enforced to prevent accidental
/// information leakage.
///
///
UserPwd = 10005,
///
/// Set the parameter to true to get the library to display a lot
/// of verbose information about its operations. Very useful for libcurl
/// and/or protocol debugging and understanding. The verbose information
/// will be sent to the delegate, if it's
/// implemented. You hardly ever want this set in production use, you will
/// almost always want this when you debug/report problems.
///
Verbose = 41,
///
/// Object reference to pass to the
/// delegate. Note that if you specify the CurlWriteCallback,
/// this is the object you'll get as input.
///
WriteData = 10001,
///
/// Pass a reference to an delegate.
/// The delegate gets called by libcurl as soon as there is data received
/// that needs to be saved. The size of the data referenced by buf
/// is size multiplied with nmemb, it will not be zero
/// terminated. Return the number of bytes actually taken care of. If
/// that amount differs from the amount passed to your function, it'll
/// signal an error to the library and it will abort the transfer and
/// return CurlCode..
///
/// This function may be called with zero bytes data if the
/// transfered file is empty.
///
///
WriteFunction = 20011,
///
/// Pass a string of the output using full variable-replacement
/// as described elsewhere.
///
WriteInfo = 10040,
///
/// Set to true to enable the "TE:" header in HTTP requests to ask for compressed transfer-encoded responses. Set to 0
/// to disable the use of TE: in outgoing requests. The current default is false, but it might change in a future
/// libcurl release. libcurl will ask for the compressed methods it knows of, and if that isn't any, it will not ask
/// for transfer-encoding at all even if this option is set to true.
///
TransferEncoding = 207,
///
/// Callback function for closing socket (instead of close(2)). The callback should have type curl_closesocket_callback
///
CloseSocketFunction = 20208,
CloseSocketData = 10209,
///
/// feed cookies into cookie engine
///
CookieList = 10135,
///
/// Select "file method" to use when doing FTP, see the curl_ftpmethod above.
///
FtpFileMethod = 138,
///
/// Local port number to bind the socket to
///
LocalPort = 139,
///
/// Number of ports to try, including the first one set with LocalPort. Thus, setting it to 1 will make no additional
/// attempts but the first.
///
LocalPortRange = 140,
///
/// No transfer, set up connection and let application use the socket by extracting it with CURLINFO_LASTSOCKET
///
ConnectOnly = 141,
///
/// if the connection proceeds too quickly then need to slow it down limit-rate: maximum number of bytes per second to
/// send or receive
///
MaxSendSpeedLarge = 30145,
MaxRecvSpeedLarge = 30146,
///
/// Pointer to command string to send if USER/PASS fails.
///
FtpAlternativeToUser = 10147,
///
/// Callback function for setting socket options
///
SockoptFunction = 20148,
SockoptData = 149,
///
/// Set to false to disable session ID re-use for this transfer, default is enabled (== true)
///
SslSessionidCache = 150,
///
/// Allowed SSH authentication methods
///
SshAuthTypes = 151,
///
/// Used by scp/sftp to do public/private key authentication
///
SshPublicKeyfile = 10152,
SshPrivateKeyfile = 10152,
///
/// Same as Timeout and ConnectTimeout, but with ms resolution
///
TimeoutMs = 155,
ConnectTimeoutMs = 156,
///
/// Set to false to disable the libcurl's decoding and thus pass the raw body data to the application even when it is
/// encoded/compressed
///
HttpTransferDecoding = 157,
HttpContentDecoding = 158,
///
/// Permission used when creating new files and directories on the remote server for protocols that support it,
/// SFTP/SCP/FILE
///
NewFilePerms = 159,
NewDirectoryPerms = 160,
///
/// Set the behaviour of POST when redirecting. Values must be set to one of CURL_REDIR* defines below. This used to be
/// called CURLOPT_POST301
///
PostRedir = 161,
///
/// Used by scp/sftp to verify the host's public key
///
SshHostPublicKeyMd5 = 10162,
///
/// Callback function for opening socket (instead of socket(2)). Optionally, callback is able change the address or
/// refuse to connect returning CURL_SOCKET_BAD. The callback should have type curl_opensocket_callback
///
OpenSocketFunction = 20163,
OpenSocketData = 10164,
///
/// POST volatile input fields.
///
CopyPostFields = 10165,
///
/// set transfer mode (;type=) when doing FTP via an HTTP proxy
///
ProxyTransferMode = 166,
///
/// Callback function for seeking in the input stream
///
SeekFunction = 20167,
SeekData = 10168,
///
/// CRL file
///
CrlFile = 10169,
///
/// Issuer certificate
///
IssuerCert = 10170,
///
/// (IPv6) Address scope
///
AddressScope = 171,
///
/// Collect certificate chain info and allow it to get retrievable with CURLINFO_CERTINFO after the transfer is
/// complete.
///
CertInfo = 172,
///
/// "name" and "pwd" to use when fetching.
///
Username = 10173,
Password = 10174,
///
/// "name" and "pwd" to use with Proxy when fetching.
///
ProxyUsername = 10175,
ProxyPassword = 10176,
///
/// Comma separated list of hostnames defining no-proxy zones. These should match both hostnames directly, and
/// hostnames within a domain. For example, local.com will match local.com and www.local.com, but NOT notlocal.com or
/// www.notlocal.com. For compatibility with other implementations of this, .local.com will be considered to be the
/// same as local.com. A single * is the only valid wildcard, and effectively disables the use of proxy.
///
NoProxy = 10177,
///
/// block size for TFTP transfers
///
TftpBlksize = 178,
///
/// Socks service
///
Socks5GssApiService = 10179,
Socks5GssApiNec = 180,
///
/// set the bitmask for the protocols that are allowed to be used for the transfer, which thus helps the app which
/// takes URLs from users or other external inputs and want to restrict what protocol(s) to deal with. Defaults to
/// CURLPROTO_ALL.
///
Protocols = 181,
///
/// set the bitmask for the protocols that libcurl is allowed to follow to, as a subset of the CURLOPT_PROTOCOLS ones.
/// That means the protocol needs to be set in both bitmasks to be allowed to get redirected to. Defaults to all
/// protocols except FILE and SCP.
///
RedirProtocols = 182,
///
/// Set the SSH knownhost file name to use
///
SshKnownHosts = 10183,
///
/// set the SSH host key callback, must point to a curl_sshkeycallback function
///
SshKeyFunction = 20184,
///
/// Set the SSH host key callback custom pointer
///
SshKeydata = 10185,
///
/// Set the SMTP mail originator
///
MailFrom = 10186,
///
/// Set the SMTP mail receiver(s)
///
MailRcpt = 10187,
///
/// FTP: send PRET before PASV
///
FtpUsePret = 188,
///
/// Set the interface string to use as outgoing network interface for DNS requests. Only supported by the c-ares DNS
/// backend */
///
DnsInterface = 10221,
///
/// Set the local IPv4 address to use for outgoing DNS requests. Only supported by the c-ares DNS backend
///
DnsLocalIp4 = 10222,
///
/// Set the local IPv6 address to use for outgoing DNS requests. Only supported by the c-ares DNS backend
///
DnsLocalIp6 = 10223,
///
/// Set authentication options directly
///
LoginOptions = 10224,
///
/// Enable/disable TLS NPN extension (http2 over ssl might fail without)
///
SslEnableNpn = 225,
///
/// Enable/disable TLS ALPN extension (http2 over ssl might fail without)
///
SslEnableAlpn = 226,
///
/// Time to wait for a response to a HTTP request containing an Expect: 100-continue header before sending the data
/// anyway.
///
Expect100TimeoutMs = 227,
///
/// This points to a linked list of headers used for proxy requests only, struct curl_slist kind
///
ProxyHeader = 228,
///
/// Pass in a bitmask of "header options"
///
HeaderOpt = 229,
///
/// Last numeric entry in the enumeration. Don't use this in your
/// application code.
///
LastEntry = 230,
};
}