// CkUploadW.h: interface for the CkUploadW class. // ////////////////////////////////////////////////////////////////////// // This header is generated for Chilkat 11.3.0 #ifndef _CkUploadW_H #define _CkUploadW_H #include "chilkatDefs.h" #include "CkString.h" #include "CkClassWithCallbacksW.h" class CkTaskW; class CkByteData; class CkBaseProgressW; #if !defined(__sun__) && !defined(__sun) #pragma pack (push, 8) #endif // CLASS: CkUploadW class CK_VISIBLE_PUBLIC CkUploadW : public CkClassWithCallbacksW { private: bool m_cbOwned; private: // Don't allow assignment or copying these objects. CkUploadW(const CkUploadW &); CkUploadW &operator=(const CkUploadW &); public: CkUploadW(void); virtual ~CkUploadW(void); static CkUploadW *createNew(void); CkUploadW(bool bCallbackOwned); static CkUploadW *createNew(bool bCallbackOwned); void CK_VISIBLE_PRIVATE inject(void *impl); // May be called when finished with the object to free/dispose of any // internal resources held by the object. void dispose(void); CkBaseProgressW *get_EventCallbackObject(void) const; void put_EventCallbackObject(CkBaseProgressW *progress); // BEGIN PUBLIC INTERFACE // ---------------------- // Properties // ---------------------- // When set to true, causes the currently running method to abort. Methods that // always finish quickly (i.e.have no length file operations or network // communications) are not affected. If no method is running, then this property is // automatically reset to false when the next method is called. When the abort // occurs, this property is reset to false. Both synchronous and asynchronous // method calls can be aborted. (A synchronous method call could be aborted by // setting this property from a separate thread.) bool get_AbortCurrent(void); // When set to true, causes the currently running method to abort. Methods that // always finish quickly (i.e.have no length file operations or network // communications) are not affected. If no method is running, then this property is // automatically reset to false when the next method is called. When the abort // occurs, this property is reset to false. Both synchronous and asynchronous // method calls can be aborted. (A synchronous method call could be aborted by // setting this property from a separate thread.) void put_AbortCurrent(bool newVal); // If non-zero, limits (throttles) the upload bandwidth to approximately this // maximum number of bytes per second. The default value of this property is 0. int get_BandwidthThrottleUp(void); // If non-zero, limits (throttles) the upload bandwidth to approximately this // maximum number of bytes per second. The default value of this property is 0. void put_BandwidthThrottleUp(int newVal); // The chunk size (in bytes) used by the underlying TCP/IP sockets for uploading // files. The default value is 65535. int get_ChunkSize(void); // The chunk size (in bytes) used by the underlying TCP/IP sockets for uploading // files. The default value is 65535. void put_ChunkSize(int newVal); // The IP address to use for computers with multiple network interfaces or IP // addresses. For computers with a single network interface (i.e. most computers), // this property should not be set. For multihoming computers, the default IP // address is automatically used if this property is not set. // // The IP address is a string such as in dotted notation using numbers, not domain // names, such as 165.164.55.124 . // void get_ClientIpAddress(CkString &str); // The IP address to use for computers with multiple network interfaces or IP // addresses. For computers with a single network interface (i.e. most computers), // this property should not be set. For multihoming computers, the default IP // address is automatically used if this property is not set. // // The IP address is a string such as in dotted notation using numbers, not domain // names, such as 165.164.55.124 . // const wchar_t *clientIpAddress(void); // The IP address to use for computers with multiple network interfaces or IP // addresses. For computers with a single network interface (i.e. most computers), // this property should not be set. For multihoming computers, the default IP // address is automatically used if this property is not set. // // The IP address is a string such as in dotted notation using numbers, not domain // names, such as 165.164.55.124 . // void put_ClientIpAddress(const wchar_t *newVal); // The current filename being uploaded while an asynchronous upload is in progress. void get_CurrentFilename(CkString &str); // The current filename being uploaded while an asynchronous upload is in progress. const wchar_t *currentFilename(void); // When true, the request header will included an Expect: 100-continue header // field. This indicates that the server should respond with an intermediate // response of 100 Continue or 417 Expectation Failed response based on the // information available in the request header. This helps avoid situations such as // limits on upload sizes. It allows the server to reject the upload, and then the // client can abort prior to uploading the data. // // The default value of this property is true. // bool get_Expect100Continue(void); // When true, the request header will included an Expect: 100-continue header // field. This indicates that the server should respond with an intermediate // response of 100 Continue or 417 Expectation Failed response based on the // information available in the request header. This helps avoid situations such as // limits on upload sizes. It allows the server to reject the upload, and then the // client can abort prior to uploading the data. // // The default value of this property is true. // void put_Expect100Continue(bool newVal); // The interval in milliseconds between each AbortCheck event callback, which // enables an application to abort certain method calls before they complete. By // default, HeartbeatMs is set to 0 , meaning no AbortCheck event callbacks will // trigger. // // References: // 1: #AbortCheck int get_HeartbeatMs(void); // The interval in milliseconds between each AbortCheck event callback, which // enables an application to abort certain method calls before they complete. By // default, HeartbeatMs is set to 0 , meaning no AbortCheck event callbacks will // trigger. // // References: // 1: #AbortCheck void put_HeartbeatMs(int newVal); // The hostname of the HTTP server that is the target of the upload. Do not include // http:// in the hostname. It can be a hostname, such as www.chilkatsoft.com , or // an IP address, such as 168.144.70.227 . void get_Hostname(CkString &str); // The hostname of the HTTP server that is the target of the upload. Do not include // http:// in the hostname. It can be a hostname, such as www.chilkatsoft.com , or // an IP address, such as 168.144.70.227 . const wchar_t *hostname(void); // The hostname of the HTTP server that is the target of the upload. Do not include // http:// in the hostname. It can be a hostname, such as www.chilkatsoft.com , or // an IP address, such as 168.144.70.227 . void put_Hostname(const wchar_t *newVal); // A timeout in milliseconds. The default value is 30000. If the upload hangs (i.e. // progress halts) for more than this time, the component will abort the upload. // (It will timeout.) int get_IdleTimeoutMs(void); // A timeout in milliseconds. The default value is 30000. If the upload hangs (i.e. // progress halts) for more than this time, the component will abort the upload. // (It will timeout.) void put_IdleTimeoutMs(int newVal); // The HTTP login for sites requiring authentication. Chilkat Upload supports Basic // HTTP authentication. void get_Login(CkString &str); // The HTTP login for sites requiring authentication. Chilkat Upload supports Basic // HTTP authentication. const wchar_t *login(void); // The HTTP login for sites requiring authentication. Chilkat Upload supports Basic // HTTP authentication. void put_Login(const wchar_t *newVal); // After an upload has completed, this property contains the number of bytes sent. // During asynchronous uploads, this property contains the current number of bytes // sent while the upload is in progress. unsigned long get_NumBytesSent(void); // The HTTP password for sites requiring authentication. Chilkat Upload supports // Basic HTTP authentication. void get_Password(CkString &str); // The HTTP password for sites requiring authentication. Chilkat Upload supports // Basic HTTP authentication. const wchar_t *password(void); // The HTTP password for sites requiring authentication. Chilkat Upload supports // Basic HTTP authentication. void put_Password(const wchar_t *newVal); // The path part of the upload URL. Some examples: // // desc> If the upload target (i.e. consumer) URL is: // http://www.freeaspupload.net/freeaspupload/testUpload.asp, then // // Hostname = www.freeaspupload.net Path = /freeaspupload/testUpload.asp // // If the upload target URL is // https://www.chilkatsoft.com/cgi-bin/ConsumeUpload.exe, then // // Hostname = www.chilkatsoft.com Path = /cgi-bin/ConsumeUpload.exe // void get_Path(CkString &str); // The path part of the upload URL. Some examples: // // desc> If the upload target (i.e. consumer) URL is: // http://www.freeaspupload.net/freeaspupload/testUpload.asp, then // // Hostname = www.freeaspupload.net Path = /freeaspupload/testUpload.asp // // If the upload target URL is // https://www.chilkatsoft.com/cgi-bin/ConsumeUpload.exe, then // // Hostname = www.chilkatsoft.com Path = /cgi-bin/ConsumeUpload.exe // const wchar_t *path(void); // The path part of the upload URL. Some examples: // // desc> If the upload target (i.e. consumer) URL is: // http://www.freeaspupload.net/freeaspupload/testUpload.asp, then // // Hostname = www.freeaspupload.net Path = /freeaspupload/testUpload.asp // // If the upload target URL is // https://www.chilkatsoft.com/cgi-bin/ConsumeUpload.exe, then // // Hostname = www.chilkatsoft.com Path = /cgi-bin/ConsumeUpload.exe // void put_Path(const wchar_t *newVal); // This property is only valid in programming environment and languages that allow // for event callbacks. // // Sets the value to be defined as 100% complete for the purpose of PercentDone // event callbacks. The defaut value of 100 means that at most 100 event // PercentDone callbacks will occur in a method that (1) is event enabled and (2) // is such that it is possible to measure progress as a percentage completed. This // property may be set to larger numbers to get more fine-grained PercentDone // callbacks. For example, setting this property equal to 1000 will provide // callbacks with .1 percent granularity. For example, a value of 453 would // indicate 45.3% competed. This property is clamped to a minimum value of 10, and // a maximum value of 100000. // int get_PercentDoneScale(void); // This property is only valid in programming environment and languages that allow // for event callbacks. // // Sets the value to be defined as 100% complete for the purpose of PercentDone // event callbacks. The defaut value of 100 means that at most 100 event // PercentDone callbacks will occur in a method that (1) is event enabled and (2) // is such that it is possible to measure progress as a percentage completed. This // property may be set to larger numbers to get more fine-grained PercentDone // callbacks. For example, setting this property equal to 1000 will provide // callbacks with .1 percent granularity. For example, a value of 453 would // indicate 45.3% competed. This property is clamped to a minimum value of 10, and // a maximum value of 100000. // void put_PercentDoneScale(int newVal); // Contains the current percentage completion (0 to 100) while an asynchronous // upload is in progress. unsigned long get_PercentUploaded(void); // The port number of the upload target (i.e. consumer) URL. The default value is // 80. If SSL is used, this should be set to 443 (typically). int get_Port(void); // The port number of the upload target (i.e. consumer) URL. The default value is // 80. If SSL is used, this should be set to 443 (typically). void put_Port(int newVal); // If true, then use IPv6 over IPv4 when both are supported for a particular // domain. The default value of this property is false, which will choose IPv4 // over IPv6. bool get_PreferIpv6(void); // If true, then use IPv6 over IPv4 when both are supported for a particular // domain. The default value of this property is false, which will choose IPv4 // over IPv6. void put_PreferIpv6(bool newVal); // The domain name of a proxy host if an HTTP proxy is used. Do not include the // http:// . The domain name may be a hostname, such as www.chilkatsoft.com , or an // IP address, such as 168.144.70.227 . void get_ProxyDomain(CkString &str); // The domain name of a proxy host if an HTTP proxy is used. Do not include the // http:// . The domain name may be a hostname, such as www.chilkatsoft.com , or an // IP address, such as 168.144.70.227 . const wchar_t *proxyDomain(void); // The domain name of a proxy host if an HTTP proxy is used. Do not include the // http:// . The domain name may be a hostname, such as www.chilkatsoft.com , or an // IP address, such as 168.144.70.227 . void put_ProxyDomain(const wchar_t *newVal); // If an HTTP proxy is used and it requires authentication, this property specifies // the HTTP proxy login. void get_ProxyLogin(CkString &str); // If an HTTP proxy is used and it requires authentication, this property specifies // the HTTP proxy login. const wchar_t *proxyLogin(void); // If an HTTP proxy is used and it requires authentication, this property specifies // the HTTP proxy login. void put_ProxyLogin(const wchar_t *newVal); // If an HTTP proxy is used and it requires authentication, this property specifies // the HTTP proxy password. void get_ProxyPassword(CkString &str); // If an HTTP proxy is used and it requires authentication, this property specifies // the HTTP proxy password. const wchar_t *proxyPassword(void); // If an HTTP proxy is used and it requires authentication, this property specifies // the HTTP proxy password. void put_ProxyPassword(const wchar_t *newVal); // The port number of a proxy server if an HTTP proxy is used. int get_ProxyPort(void); // The port number of a proxy server if an HTTP proxy is used. void put_ProxyPort(int newVal); // Returns the response body as a string. void get_ResponseBodyStr(CkString &str); // Returns the response body as a string. const wchar_t *responseBodyStr(void); // An HTTP upload is nothing more than an HTTP POST that contains the content of // the files being uploaded. Just as with any HTTP POST or GET, the server should // send an HTTP response that consists of header and body. // // desc>This property contains the header part of the HTTP response. // void get_ResponseHeader(CkString &str); // An HTTP upload is nothing more than an HTTP POST that contains the content of // the files being uploaded. Just as with any HTTP POST or GET, the server should // send an HTTP response that consists of header and body. // // desc>This property contains the header part of the HTTP response. // const wchar_t *responseHeader(void); // The HTTP response status code of the HTTP response. A list of HTTP status codes // can be found here: HTTP Response Status Codes. // // References: // 1: http://en.wikipedia.org/wiki/List_of_HTTP_status_codes int get_ResponseStatus(void); // Set this to true if the upload is to HTTPS. For example, if the target of the // upload is: // // https://www.myuploadtarget.com/consumeUpload.asp // // desc>then set: // // Ssl = true // Hostname = www.myuploadtarget.com // Path = /consumeupload.asp // Port = 443 // // bool get_Ssl(void); // Set this to true if the upload is to HTTPS. For example, if the target of the // upload is: // // https://www.myuploadtarget.com/consumeUpload.asp // // desc>then set: // // Ssl = true // Hostname = www.myuploadtarget.com // Path = /consumeupload.asp // Port = 443 // // void put_Ssl(bool newVal); // Provides a means for setting a list of ciphers that are allowed for SSL/TLS // connections. The default (empty string) indicates that all implemented ciphers // are possible. The TLS ciphers supported in Chilkat v9.5.0.55 and later are:TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 // TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 // TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256 // TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA // TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 // TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA // TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 // TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 // TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 // TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA // TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 // TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 // TLS_DHE_RSA_WITH_AES_256_CBC_SHA // TLS_RSA_WITH_AES_256_CBC_SHA256 // TLS_RSA_WITH_AES_256_GCM_SHA384 // TLS_RSA_WITH_AES_256_CBC_SHA // TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 // TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 // TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA // TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 // TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 // TLS_DHE_RSA_WITH_AES_128_CBC_SHA // TLS_RSA_WITH_AES_128_CBC_SHA256 // TLS_RSA_WITH_AES_128_GCM_SHA256 // TLS_RSA_WITH_AES_128_CBC_SHA // TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA // TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA // TLS_RSA_WITH_3DES_EDE_CBC_SHA // TLS_ECDHE_RSA_WITH_RC4_128_SHA // TLS_RSA_WITH_RC4_128_SHA // TLS_RSA_WITH_RC4_128_MD5 // TLS_DHE_RSA_WITH_DES_CBC_SHA // TLS_RSA_WITH_DES_CBC_SHA // To restrict SSL/TLS connections to one or more specific ciphers, set this // property to a comma-separated list of ciphers such as // TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384, TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 . // The order should be in terms of preference, with the preferred algorithms listed // first. (Note that the client cannot specifically choose the algorithm is picked // because it is the server that chooses. The client simply provides the server // with a list from which to choose.) // // The property can also disallow connections with servers having certificates with // RSA keys less than a certain size. By default, server certificates having RSA // keys of 512 bits or greater are allowed. Add the keyword rsa1024 to disallow // connections with servers having keys smaller than 1024 bits. Add the keyword // rsa2048 to disallow connections with servers having keys smaller than 2048 bits. // // Note: Prior to Chilkat v9.5.0.55, it was not possible to explicitly list allowed // cipher suites. The deprecated means for indicating allowed ciphers was both // incomplete and unprecise. For example, the following keywords could be listed to // allow matching ciphers: aes256-cbc , aes128-cbc , 3des-cbc , and rc4 . These // keywords will still be recognized, but programs should be updated to explicitly // list the allowed ciphers. // // secure-renegotiation: Starting in Chilkat v9.5.0.55, the keyword // secure-renegotiation may be added to require that all renegotions be done // securely (as per RFC 5746). // // best-practices: Starting in Chilkat v9.5.0.55, this property may be set to the // single keyword best-practices . This will allow ciphers based on the current // best practices. As new versions of Chilkat are released, the best practices may // change. Changes will be noted here. The current best practices are: // // * If the server uses an RSA key, it must be 1024 bits or greater. // * All renegotations must be secure renegotiations. // * All ciphers using RC4, DES, or 3DES are disallowed. // // Example: The following string would restrict to 2 specific cipher suites, // require RSA keys to be 1024 bits or greater, and require secure renegotiations: // TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, TLS_RSA_WITH_AES_256_CBC_SHA, rsa1024, // secure-renegotiation // void get_SslAllowedCiphers(CkString &str); // Provides a means for setting a list of ciphers that are allowed for SSL/TLS // connections. The default (empty string) indicates that all implemented ciphers // are possible. The TLS ciphers supported in Chilkat v9.5.0.55 and later are:TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 // TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 // TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256 // TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA // TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 // TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA // TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 // TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 // TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 // TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA // TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 // TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 // TLS_DHE_RSA_WITH_AES_256_CBC_SHA // TLS_RSA_WITH_AES_256_CBC_SHA256 // TLS_RSA_WITH_AES_256_GCM_SHA384 // TLS_RSA_WITH_AES_256_CBC_SHA // TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 // TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 // TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA // TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 // TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 // TLS_DHE_RSA_WITH_AES_128_CBC_SHA // TLS_RSA_WITH_AES_128_CBC_SHA256 // TLS_RSA_WITH_AES_128_GCM_SHA256 // TLS_RSA_WITH_AES_128_CBC_SHA // TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA // TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA // TLS_RSA_WITH_3DES_EDE_CBC_SHA // TLS_ECDHE_RSA_WITH_RC4_128_SHA // TLS_RSA_WITH_RC4_128_SHA // TLS_RSA_WITH_RC4_128_MD5 // TLS_DHE_RSA_WITH_DES_CBC_SHA // TLS_RSA_WITH_DES_CBC_SHA // To restrict SSL/TLS connections to one or more specific ciphers, set this // property to a comma-separated list of ciphers such as // TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384, TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 . // The order should be in terms of preference, with the preferred algorithms listed // first. (Note that the client cannot specifically choose the algorithm is picked // because it is the server that chooses. The client simply provides the server // with a list from which to choose.) // // The property can also disallow connections with servers having certificates with // RSA keys less than a certain size. By default, server certificates having RSA // keys of 512 bits or greater are allowed. Add the keyword rsa1024 to disallow // connections with servers having keys smaller than 1024 bits. Add the keyword // rsa2048 to disallow connections with servers having keys smaller than 2048 bits. // // Note: Prior to Chilkat v9.5.0.55, it was not possible to explicitly list allowed // cipher suites. The deprecated means for indicating allowed ciphers was both // incomplete and unprecise. For example, the following keywords could be listed to // allow matching ciphers: aes256-cbc , aes128-cbc , 3des-cbc , and rc4 . These // keywords will still be recognized, but programs should be updated to explicitly // list the allowed ciphers. // // secure-renegotiation: Starting in Chilkat v9.5.0.55, the keyword // secure-renegotiation may be added to require that all renegotions be done // securely (as per RFC 5746). // // best-practices: Starting in Chilkat v9.5.0.55, this property may be set to the // single keyword best-practices . This will allow ciphers based on the current // best practices. As new versions of Chilkat are released, the best practices may // change. Changes will be noted here. The current best practices are: // // * If the server uses an RSA key, it must be 1024 bits or greater. // * All renegotations must be secure renegotiations. // * All ciphers using RC4, DES, or 3DES are disallowed. // // Example: The following string would restrict to 2 specific cipher suites, // require RSA keys to be 1024 bits or greater, and require secure renegotiations: // TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, TLS_RSA_WITH_AES_256_CBC_SHA, rsa1024, // secure-renegotiation // const wchar_t *sslAllowedCiphers(void); // Provides a means for setting a list of ciphers that are allowed for SSL/TLS // connections. The default (empty string) indicates that all implemented ciphers // are possible. The TLS ciphers supported in Chilkat v9.5.0.55 and later are:TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 // TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 // TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256 // TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA // TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 // TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA // TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 // TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 // TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 // TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA // TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 // TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 // TLS_DHE_RSA_WITH_AES_256_CBC_SHA // TLS_RSA_WITH_AES_256_CBC_SHA256 // TLS_RSA_WITH_AES_256_GCM_SHA384 // TLS_RSA_WITH_AES_256_CBC_SHA // TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 // TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 // TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA // TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 // TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 // TLS_DHE_RSA_WITH_AES_128_CBC_SHA // TLS_RSA_WITH_AES_128_CBC_SHA256 // TLS_RSA_WITH_AES_128_GCM_SHA256 // TLS_RSA_WITH_AES_128_CBC_SHA // TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA // TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA // TLS_RSA_WITH_3DES_EDE_CBC_SHA // TLS_ECDHE_RSA_WITH_RC4_128_SHA // TLS_RSA_WITH_RC4_128_SHA // TLS_RSA_WITH_RC4_128_MD5 // TLS_DHE_RSA_WITH_DES_CBC_SHA // TLS_RSA_WITH_DES_CBC_SHA // To restrict SSL/TLS connections to one or more specific ciphers, set this // property to a comma-separated list of ciphers such as // TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384, TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 . // The order should be in terms of preference, with the preferred algorithms listed // first. (Note that the client cannot specifically choose the algorithm is picked // because it is the server that chooses. The client simply provides the server // with a list from which to choose.) // // The property can also disallow connections with servers having certificates with // RSA keys less than a certain size. By default, server certificates having RSA // keys of 512 bits or greater are allowed. Add the keyword rsa1024 to disallow // connections with servers having keys smaller than 1024 bits. Add the keyword // rsa2048 to disallow connections with servers having keys smaller than 2048 bits. // // Note: Prior to Chilkat v9.5.0.55, it was not possible to explicitly list allowed // cipher suites. The deprecated means for indicating allowed ciphers was both // incomplete and unprecise. For example, the following keywords could be listed to // allow matching ciphers: aes256-cbc , aes128-cbc , 3des-cbc , and rc4 . These // keywords will still be recognized, but programs should be updated to explicitly // list the allowed ciphers. // // secure-renegotiation: Starting in Chilkat v9.5.0.55, the keyword // secure-renegotiation may be added to require that all renegotions be done // securely (as per RFC 5746). // // best-practices: Starting in Chilkat v9.5.0.55, this property may be set to the // single keyword best-practices . This will allow ciphers based on the current // best practices. As new versions of Chilkat are released, the best practices may // change. Changes will be noted here. The current best practices are: // // * If the server uses an RSA key, it must be 1024 bits or greater. // * All renegotations must be secure renegotiations. // * All ciphers using RC4, DES, or 3DES are disallowed. // // Example: The following string would restrict to 2 specific cipher suites, // require RSA keys to be 1024 bits or greater, and require secure renegotiations: // TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, TLS_RSA_WITH_AES_256_CBC_SHA, rsa1024, // secure-renegotiation // void put_SslAllowedCiphers(const wchar_t *newVal); // Selects the secure protocol to be used for secure (SSL/TLS) connections. // Possible values are: // // default // TLS 1.3 // TLS 1.2 // TLS 1.1 // TLS 1.0 // SSL 3.0 // TLS 1.3 or higher // TLS 1.2 or higher // TLS 1.1 or higher // TLS 1.0 or higher // // // The default value is default which will choose the, which allows for the // protocol to be selected dynamically at runtime based on the requirements of the // server. Choosing an exact protocol will cause the connection to fail unless that // exact protocol is negotiated. It is better to choose X or higher than an exact // protocol. The default is effectively SSL 3.0 or higher . void get_SslProtocol(CkString &str); // Selects the secure protocol to be used for secure (SSL/TLS) connections. // Possible values are: // // default // TLS 1.3 // TLS 1.2 // TLS 1.1 // TLS 1.0 // SSL 3.0 // TLS 1.3 or higher // TLS 1.2 or higher // TLS 1.1 or higher // TLS 1.0 or higher // // // The default value is default which will choose the, which allows for the // protocol to be selected dynamically at runtime based on the requirements of the // server. Choosing an exact protocol will cause the connection to fail unless that // exact protocol is negotiated. It is better to choose X or higher than an exact // protocol. The default is effectively SSL 3.0 or higher . const wchar_t *sslProtocol(void); // Selects the secure protocol to be used for secure (SSL/TLS) connections. // Possible values are: // // default // TLS 1.3 // TLS 1.2 // TLS 1.1 // TLS 1.0 // SSL 3.0 // TLS 1.3 or higher // TLS 1.2 or higher // TLS 1.1 or higher // TLS 1.0 or higher // // // The default value is default which will choose the, which allows for the // protocol to be selected dynamically at runtime based on the requirements of the // server. Choosing an exact protocol will cause the connection to fail unless that // exact protocol is negotiated. It is better to choose X or higher than an exact // protocol. The default is effectively SSL 3.0 or higher . void put_SslProtocol(const wchar_t *newVal); // Specifies a set of pins for Public Key Pinning for TLS connections. This // property lists the expected SPKI fingerprints for the server certificates. If // the server's certificate (sent during the TLS handshake) does not match any of // the SPKI fingerprints, then the TLS handshake is aborted and the connection // fails. The format of this string property is as follows:hash_algorithm, encoding, SPKI_fingerprint_1, SPKI_fingerprint_2, ... // For example, the following string specifies a single sha256 base64-encoded SPKI // fingerprint:"sha256, base64, lKg1SIqyhPSK19tlPbjl8s02yChsVTDklQpkMCHvsTE=" // This example specifies two SPKI fingerprints:"sha256, base64, 4t37LpnGmrMEAG8HEz9yIrnvJV2euVRwCLb9EH5WZyI=, 68b0G5iqMvWVWvUCjMuhLEyekM5729PadtnU5tdXZKs=" // Any of the following hash algorithms are allowed:.sha1, sha256, sha384, sha512, // md2, md5, haval, ripemd128, ripemd160,ripemd256, or ripemd320. // // The following encodings are allowed: base64, hex, and any of the encodings // indicated in the link below. // void get_TlsPinSet(CkString &str); // Specifies a set of pins for Public Key Pinning for TLS connections. This // property lists the expected SPKI fingerprints for the server certificates. If // the server's certificate (sent during the TLS handshake) does not match any of // the SPKI fingerprints, then the TLS handshake is aborted and the connection // fails. The format of this string property is as follows:hash_algorithm, encoding, SPKI_fingerprint_1, SPKI_fingerprint_2, ... // For example, the following string specifies a single sha256 base64-encoded SPKI // fingerprint:"sha256, base64, lKg1SIqyhPSK19tlPbjl8s02yChsVTDklQpkMCHvsTE=" // This example specifies two SPKI fingerprints:"sha256, base64, 4t37LpnGmrMEAG8HEz9yIrnvJV2euVRwCLb9EH5WZyI=, 68b0G5iqMvWVWvUCjMuhLEyekM5729PadtnU5tdXZKs=" // Any of the following hash algorithms are allowed:.sha1, sha256, sha384, sha512, // md2, md5, haval, ripemd128, ripemd160,ripemd256, or ripemd320. // // The following encodings are allowed: base64, hex, and any of the encodings // indicated in the link below. // const wchar_t *tlsPinSet(void); // Specifies a set of pins for Public Key Pinning for TLS connections. This // property lists the expected SPKI fingerprints for the server certificates. If // the server's certificate (sent during the TLS handshake) does not match any of // the SPKI fingerprints, then the TLS handshake is aborted and the connection // fails. The format of this string property is as follows:hash_algorithm, encoding, SPKI_fingerprint_1, SPKI_fingerprint_2, ... // For example, the following string specifies a single sha256 base64-encoded SPKI // fingerprint:"sha256, base64, lKg1SIqyhPSK19tlPbjl8s02yChsVTDklQpkMCHvsTE=" // This example specifies two SPKI fingerprints:"sha256, base64, 4t37LpnGmrMEAG8HEz9yIrnvJV2euVRwCLb9EH5WZyI=, 68b0G5iqMvWVWvUCjMuhLEyekM5729PadtnU5tdXZKs=" // Any of the following hash algorithms are allowed:.sha1, sha256, sha384, sha512, // md2, md5, haval, ripemd128, ripemd160,ripemd256, or ripemd320. // // The following encodings are allowed: base64, hex, and any of the encodings // indicated in the link below. // void put_TlsPinSet(const wchar_t *newVal); // The total size of the upload (in bytes). This property will become set at the // beginning of an asynchronous upload. A program may monitor asynchronous uploads // by tracking both NumBytesSent and PercentUploaded. // // desc> This property is also set during synchronous uploads. // unsigned long get_TotalUploadSize(void); // Set to true when an asynchronous upload is started. When the asynchronous // upload is complete, this property becomes equal to false. A program will // typically begin an asynchronous upload by calling BeginUpload, and then // periodically checking the value of this property to determine when the upload is // complete. bool get_UploadInProgress(void); // Set to true (success) or false (failed) after an asynchronous upload // completes or aborts due to failure. When a program does an asynchronous upload, // it will wait until UploadInProgress becomes false. It will then check the // value of this property to determine if the upload was successful or not. bool get_UploadSuccess(void); // ---------------------- // Methods // ---------------------- // May be called during an asynchronous upload to abort. void AbortUpload(void); // Adds a custom HTTP header to the HTTP upload. void AddCustomHeader(const wchar_t *name, const wchar_t *value); // Adds a file to the list of files to be uploaded in the next call to // BlockingUpload, BeginUpload, or UploadToMemory. To upload more than one file, // call this method once for each file to be uploaded. void AddFileReference(const wchar_t *name, const wchar_t *filename); // Adds a custom HTTP request parameter to the upload. void AddParam(const wchar_t *name, const wchar_t *value); // Starts an asynchronous upload. Only one asynchronous upload may be in progress // at a time. To achieve multiple asynchronous uploads, use multiple instances of // the Chilkat Upload object. Each object instance is capable of managing a single // asynchronous upload. // // desc> When this method is called, a background thread is started and the // asynchronous upload runs in the background. The upload may be aborted at any // time by calling AbortUpload. The upload is completed (or failed) when // UploadInProgress becomes false. At that point, the UploadSuccess property may // be checked to determine success (true) or failure (false). // bool BeginUpload(void); // Uploads files to a web server using HTTP. The files to be uploaded are indicated // by calling AddFileReference once for each file (prior to calling this method). bool BlockingUpload(void); // Creates an asynchronous task to call the BlockingUpload method with the // arguments provided. // The caller is responsible for deleting the object returned by this method. CkTaskW *BlockingUploadAsync(void); // Clears the internal list of files created by calls to AddFileReference. void ClearFileReferences(void); // Clears the internal list of params created by calls to AddParam. void ClearParams(void); // Loads the caller of the task's async method. bool LoadTaskCaller(CkTaskW &task); // A convenience method for putting the calling process to sleep for N // milliseconds. It is provided here because some programming languages do not // provide this capability, and sleeping for short increments of time is helpful // when doing asynchronous uploads. void SleepMs(int millisec); // Writes the complete HTTP POST to memory. The POST contains the HTTP header, any // custom params added by calling AddParam, and each file to be uploaded. This is // helpful in debugging. It allows you to see the exact HTTP POST sent to the // server if BlockingUpload or BeginUpload is called. bool UploadToMemory(CkByteData &outData); // END PUBLIC INTERFACE }; #if !defined(__sun__) && !defined(__sun) #pragma pack (pop) #endif #endif