CkSocket C++ Reference Documentation

CkSocket

TCP socket component with SSL capability. Supports both asynchronous connect, accept, send, and read operations in all programming languages. The ActiveX and .NET socket components also include heartbeat, completion, and other events when blocking methods are called. DNS is supported in both synchronous and asynchronous modes. Supports the ability to abort all operations: connect, accept, send, receive, DNS lookups, etc. prior to completion.

Properties

bool get_AbortCurrent(void);
void put_AbortCurrent(bool newVal);

Introduced in version 9.5.0.58

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.)

int get_AcceptFailReason(void);

Introduced in version 9.5.0.50

If a AcceptNextConnection method fails, this property can be checked to determine the reason for failure.

Possible values are:

0 = Success
1 = An async operation is  in progress.
3 = An unspecified internal failure, perhaps out-of-memory, caused the failure.
5 = Timeout.  No connections were accepted in the amount of time alotted.
6 = The receive was aborted by the application in an event callback.
9 = An unspecified fatal socket error occurred (less common).
20 = Must first bind and listen on a port.
99 = The component is not unlocked.

Errors Relating to the SSL/TLS Handshake:
100 = TLS internal error.
102 = Unexpected handshake message.
109 = Failed to read handshake messages.
114 = Failed to send change cipher spec handshake message.
115 = Failed to send finished handshake message.
116 = Client's Finished message is invalid.
117 = Unable to agree on TLS protocol version.
118 = Unable to agree on a cipher spec.
119 = Failed to read the client's hello message.
120 = Failed to send handshake messages.
121 = Failed to process client cert message.
122 = Failed to process client cert URL message.
123 = Failed to process client key exchange message.
124 = Failed to process certificate verify message.

bool get_AsyncAcceptFinished(void);

This property is deprecated. It will be removed in a future version.

Set to true when an asynchronous accept operation completes. Once the asynchronous accept has finished, the success/failure is available in the AsyncAcceptSuccess boolean property.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

void get_AsyncAcceptLog(CkString &str);
const char *asyncAcceptLog(void);

This property is deprecated. It will be removed in a future version.

Contains the last-error information for an asynchronous accept operation.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

bool get_AsyncAcceptSuccess(void);

This property is deprecated. It will be removed in a future version.

Set to true when an asynchronous accept operation completes and is successful.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

bool get_AsyncConnectFinished(void);

This property is deprecated. It will be removed in a future version.

Set to true when an asynchronous connect operation completes. Once the asynchronous connect has finished, the success/failure is available in the AsyncConnectSuccess boolean property.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

void get_AsyncConnectLog(CkString &str);
const char *asyncConnectLog(void);

This property is deprecated. It will be removed in a future version.

Contains the last-error information for an asynchronous connect operation.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

bool get_AsyncConnectSuccess(void);

This property is deprecated. It will be removed in a future version.

Set to true when an asynchronous connect operation completes and is successful.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

bool get_AsyncDnsFinished(void);

This property is deprecated. It will be removed in a future version.

Set to true when an asynchronous DNS query completes. The success status is available in the AsyncDnsSuccess property.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

void get_AsyncDnsLog(CkString &str);
const char *asyncDnsLog(void);

This property is deprecated. It will be removed in a future version.

Contains the last-error information for an asynchronous DNS query.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

void get_AsyncDnsResult(CkString &str);
const char *asyncDnsResult(void);

This property is deprecated. It will be removed in a future version.

The IP address of the last asynchronous DNS query completed. The IP address is in nnn.nnn.nnn.nnn string form.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

bool get_AsyncDnsSuccess(void);

This property is deprecated. It will be removed in a future version.

Set to true when an asynchronous DNS query completes and is successful.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

void get_AsyncReceivedBytes(CkByteData &byteData);

This property is deprecated. It will be removed in a future version.

Contains the data received in an asynchronous receive operation (when receiving bytes asynchronously).

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

void get_AsyncReceivedString(CkString &str);
const char *asyncReceivedString(void);

This property is deprecated. It will be removed in a future version.

Contains the string received in an asynchronous receive operation (when receiving a string asynchronously).

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

bool get_AsyncReceiveFinished(void);

This property is deprecated. It will be removed in a future version.

Set to true when an asynchronous receive operation completes. Once the asynchronous receive has finished, the success/failure is available in the AsyncReceiveSuccess boolean property.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

void get_AsyncReceiveLog(CkString &str);
const char *asyncReceiveLog(void);

This property is deprecated. It will be removed in a future version.

Contains the last-error information for an asynchronous receive operation.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

bool get_AsyncReceiveSuccess(void);

This property is deprecated. It will be removed in a future version.

Set to true when an asynchronous receive operation completes and is successful.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

bool get_AsyncSendFinished(void);

This property is deprecated. It will be removed in a future version.

Set to true when an asynchronous send operation completes. Once the asynchronous send has finished, the success/failure is available in the AsyncSendSuccess boolean property.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

void get_AsyncSendLog(CkString &str);
const char *asyncSendLog(void);

This property is deprecated. It will be removed in a future version.

Contains the last-error information for an asynchronous send operation.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

bool get_AsyncSendSuccess(void);

This property is deprecated. It will be removed in a future version.

Set to true when an asynchronous send operation completes and is successful.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

int get_BandwidthThrottleDown(void);
void put_BandwidthThrottleDown(int newVal);

Introduced in version 9.5.0.49

If non-zero, limits (throttles) the receiving bandwidth to approximately this maximum number of bytes per second. The default value of this property is 0.

int get_BandwidthThrottleUp(void);
void put_BandwidthThrottleUp(int newVal);

Introduced in version 9.5.0.49

If non-zero, limits (throttles) the sending bandwidth to approximately this maximum number of bytes per second. The default value of this property is 0.

(C++) REST Upload Bandwidth Throttle

(MFC) REST Upload Bandwidth Throttle

bool get_BigEndian(void);
void put_BigEndian(bool newVal);

Applies to the SendCount and ReceiveCount methods. If BigEndian is set to true (the default) then the 4-byte count is in big endian format. Otherwise it is little endian.

void get_ClientIpAddress(CkString &str);
const char *clientIpAddress(void);
void put_ClientIpAddress(const char *ansiOrUtf8Str);

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".

Important Bind to Adapter Notes for Windows

int get_ClientPort(void);
void put_ClientPort(int newVal);

Normally left at the default value of 0, in which case a unique port is assigned with a value between 1024 and 5000. This property would only be changed if it is specifically required. For example, one customer's requirements are as follows:

"I have to connect to a Siemens PLC IP server on a technical network. This machine expects that I connect to its server from a specific IP address using a specific port otherwise the build in security disconnect the IP connection."

int get_ConnectFailReason(void);

If the Connect method fails, this property can be checked to determine the reason for failure.

Possible values are:

0 = success

Normal (non-SSL) sockets:
1 = empty hostname
2 = DNS lookup failed
3 = DNS timeout
4 = Aborted by application.
5 = Internal failure.
6 = Connect Timed Out
7 = Connect Rejected (or failed for some other reason)

SSL/TLS:
100 = TLS internal error.
101 = Failed to send client hello.
102 = Unexpected handshake message.
103 = Failed to read server hello.
104 = No server certificate.
105 = Unexpected TLS protocol version.
106 = Server certificate verify failed (the server certificate is expired or the cert's signature verification failed).
107 = Unacceptable TLS protocol version.
109 = Failed to read handshake messages.
110 = Failed to send client certificate handshake message.
111 = Failed to send client key exchange handshake message.
112 = Client certificate's private key not accessible.
113 = Failed to send client cert verify handshake message.
114 = Failed to send change cipher spec handshake message.
115 = Failed to send finished handshake message.
116 = Server's Finished message is invalid.

int get_DebugConnectDelayMs(void);
void put_DebugConnectDelayMs(int newVal);

Used to simulate a long wait when connecting to a remote server. If your application wishes to test for the handling of timeouts, you may set this value to a number of milliseconds greater than max-wait specified in the Connect method call. The default value is 0.

int get_DebugDnsDelayMs(void);
void put_DebugDnsDelayMs(int newVal);

Used to simulate a long wait when doing a DNS lookup. If your application wishes to test for the handling of timeouts, you may set this value to a number of milliseconds greater than max-wait specified in the DnsLookup method call. The default value is 0.

void get_DebugLogFilePath(CkString &str);
const char *debugLogFilePath(void);
void put_DebugLogFilePath(const char *ansiOrUtf8Str);

If set to a file path, causes each Chilkat method or property call to automatically append it's LastErrorText to the specified log file. The information is appended such that if a hang or crash occurs, it is possible to see the context in which the problem occurred, as well as a history of all Chilkat calls up to the point of the problem. The VerboseLogging property can be set to provide more detailed information.

This property is typically used for debugging the rare cases where a Chilkat method call hangs or generates an exception that halts program execution (i.e. crashes). A hang or crash should generally never happen. The typical causes of a hang are:

  1. a timeout related property was set to 0 to explicitly indicate that an infinite timeout is desired,
  2. the hang is actually a hang within an event callback (i.e. it is a hang within the application code), or
  3. there is an internal problem (bug) in the Chilkat code that causes the hang.

int get_ElapsedSeconds(void);

Contains the number of seconds since the last call to StartTiming, otherwise contains 0. (The StartTiming method and ElapsedSeconds property is provided for convenience.)

int get_HeartbeatMs(void);
void put_HeartbeatMs(int newVal);

The number of milliseconds between periodic heartbeat callbacks for blocking socket operations (connect, accept, dns query, send, receive). Set this to 0 to disable heartbeat events. The default value is 1000 (i.e. 1 heartbeat callback per second).

void get_HttpProxyAuthMethod(CkString &str);
const char *httpProxyAuthMethod(void);
void put_HttpProxyAuthMethod(const char *ansiOrUtf8Str);

If an HTTP proxy requiring authentication is to be used, set this property to the HTTP proxy authentication method name. Valid choices are "Basic" or "NTLM".

void get_HttpProxyDomain(CkString &str);
const char *httpProxyDomain(void);
void put_HttpProxyDomain(const char *ansiOrUtf8Str);

The NTLM authentication domain (optional) if NTLM authentication is used.

bool get_HttpProxyForHttp(void);
void put_HttpProxyForHttp(bool newVal);

Introduced in version 9.5.0.70

If this connection is effectively used to send HTTP requests, then set this property to true when using an HTTP proxy. The default value of this property is false.

void get_HttpProxyHostname(CkString &str);
const char *httpProxyHostname(void);
void put_HttpProxyHostname(const char *ansiOrUtf8Str);

If an HTTP proxy is to be used, set this property to the HTTP proxy hostname or IPv4 address (in dotted decimal notation).

void get_HttpProxyPassword(CkString &str);
const char *httpProxyPassword(void);
void put_HttpProxyPassword(const char *ansiOrUtf8Str);

If an HTTP proxy requiring authentication is to be used, set this property to the HTTP proxy password.

int get_HttpProxyPort(void);
void put_HttpProxyPort(int newVal);

If an HTTP proxy is to be used, set this property to the HTTP proxy port number. (Two commonly used HTTP proxy ports are 8080 and 3128.)

void get_HttpProxyUsername(CkString &str);
const char *httpProxyUsername(void);
void put_HttpProxyUsername(const char *ansiOrUtf8Str);

If an HTTP proxy requiring authentication is to be used, set this property to the HTTP proxy login name.

bool get_IsConnected(void);

Returns true if the socket is connected. Otherwise returns false.

bool get_KeepAlive(void);
void put_KeepAlive(bool newVal);

Introduced in version 9.5.0.49

Controls whether the SO_KEEPALIVE socket option is used for the underlying TCP/IP socket. The default value is true.

bool get_KeepSessionLog(void);
void put_KeepSessionLog(bool newVal);

Controls whether socket (or SSL) communications are logged to the SessionLog string property. To turn on session logging, set this property = true, otherwise set to false (which is the default value).

(C++) Demonstrates KeepSessionLog and SessionLog

(MFC) Demonstrates KeepSessionLog and SessionLog

void get_LastErrorHtml(CkString &str);
const char *lastErrorHtml(void);

Provides information in HTML format about the last method/property called. If a method call returns a value indicating failure, or behaves unexpectedly, examine this property to get more information.

void get_LastErrorText(CkString &str);
const char *lastErrorText(void);

Provides information in plain-text format about the last method/property called. If a method call returns a value indicating failure, or behaves unexpectedly, examine this property to get more information.

Concept of LastErrorText

LastErrorText Standard Information

void get_LastErrorXml(CkString &str);
const char *lastErrorXml(void);

Provides information in XML format about the last method/property called. If a method call returns a value indicating failure, or behaves unexpectedly, examine this property to get more information.

bool get_LastMethodFailed(void);

true if the last method called on this object failed. This provides an easier (less confusing) way of determining whether a method such as ReceiveBytes succeeded or failed.

bool get_LastMethodSuccess(void);
void put_LastMethodSuccess(bool newVal);

Introduced in version 9.5.0.52

Indicate whether the last method call succeeded or failed. A value of true indicates success, a value of false indicates failure. This property is automatically set for method calls. It is not modified by property accesses. The property is automatically set to indicate success for the following types of method calls:

  • Any method that returns a string.
  • Any method returning a Chilkat object, binary bytes, or a date/time.
  • Any method returning a standard boolean status value where success = true and failure = false.
  • Any method returning an integer where failure is defined by a return value less than zero.

Note: Methods that do not fit the above requirements will always set this property equal to true. For example, a method that returns no value (such as a "void" in C++) will technically always succeed.

bool get_ListenIpv6(void);
void put_ListenIpv6(bool newVal);

If set to true, then a socket that listens for incoming connections (via the BindAndList and AcceptNextConnection method calls) will use IPv6 and not IPv4. The default value is false for IPv4.

int get_ListenPort(void);

Introduced in version 9.5.0.59

The BindAndListen method will find a random unused port to listen on if you bind to port 0. This chosen listen port is available via this property.

(C++) Bind and Listen on a Randomly Selected Unused Port

(MFC) Bind and Listen on a Randomly Selected Unused Port

void get_LocalIpAddress(CkString &str);
const char *localIpAddress(void);

The local IP address for a bound or connected socket.

int get_LocalPort(void);

The local port for a bound or connected socket.

int get_MaxReadIdleMs(void);
void put_MaxReadIdleMs(int newVal);

The maximum number of milliseconds to wait on a socket read operation while no additional data is forthcoming. To wait indefinitely, set this property to 0. The default value is 0.

int get_MaxSendIdleMs(void);
void put_MaxSendIdleMs(int newVal);

The maximum number of milliseconds to wait for the socket to become writeable on a socket write operation. To wait indefinitely, set this property to 0. The default value is 0.

void get_MyIpAddress(CkString &str);
const char *myIpAddress(void);

The local IP address of the local computer. For multi-homed computers (i.e. computers with multiple IP adapters) this property returns the default IP address.

Note: This will be the internal IP address, not an external IP address. (For example, if your computer is on a LAN, it is likely to be an IP address beginning with "192.168.".

Important: Use LocalIpAddress and LocalIpPort to get the local IP/port for a bound or connected socket.

int get_NumReceivedClientCerts(void);

If the socket is the server-side of an SSL/TLS connection, the property represents the number of client-side certificates received during the SSL/TLS handshake (i.e. connection process). Each client-side cert may be retrieved by calling the GetReceivedClientCert method and passing an integer index value from 0 to N-1, where N is the number of client certs received.

Note: A client only sends a certificate if 2-way SSL/TLS is required. In other words, if the server demands a certificate from the client.

int get_NumSocketsInSet(void);

If this socket is a "socket set", then NumSocketsInSet returns the number of sockets contained in the set. A socket object can become a "socket set" by calling the TakeSocket method on one or more connected sockets. This makes it possible to select for reading on the set (i.e. wait for data to arrive from any one of multiple sockets). See the following methods and properties for more information: TakeSocket, SelectorIndex, SelectorReadIndex, SelectorWriteIndex, SelectForReading, SelectForWriting.

(C++) Socket Select for Reading

(MFC) Socket Select for Reading

int get_NumSslAcceptableClientCAs(void);

If connected as an SSL/TLS client to an SSL/TLS server where the server requires a client-side certificate for authentication, then this property contains the number of acceptable certificate authorities sent by the server during connection establishment handshake. The GetSslAcceptableClientCaDn method may be called to get the Distinguished Name (DN) of each acceptable CA.

int get_ObjectId(void);

Each socket object is assigned a unique object ID. This ID is passed in event callbacks to allow your application to associate the event with the socket object.

int get_PercentDoneScale(void);
void put_PercentDoneScale(int newVal);

Introduced in version 9.5.0.49

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.

bool get_PreferIpv6(void);
void put_PreferIpv6(bool 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.

int get_ReceivedCount(void);
void put_ReceivedCount(int newVal);

Any method that receives data will increase the value of this property by the number of bytes received. The application may reset this property to 0 at any point. It is provided as a way to keep count of the total number of bytes received on a socket connection, regardless of which method calls are used to receive the data.

Note: The ReceivedCount may be larger than the number of bytes returned by some methods. For methods such as ReceiveUntilMatch, the excess received on the socket (beyond the match), is buffered by Chilkat for subsequent method calls. The ReceivedCount is updated based on the actual number of bytes received on the underlying socket in real-time. (The ReceivedCount does not include the overhead bytes associated with the TLS and/or SSH protocols.

int get_ReceivedInt(void);
void put_ReceivedInt(int newVal);

Introduced in version 9.5.0.50

Contains the last integer received via a call to ReceiveByte, ReceiveInt16, or ReceiveInt32.

int get_ReceiveFailReason(void);

Introduced in version 9.5.0.49

If a Receive method fails, this property can be checked to determine the reason for failure.

Possible values are:

0 = Success
1 = An async receive operation is already in progress.
2 = The socket is not connected, such as if it was never connected, or if the connection was previously lost.
3 = An unspecified internal failure, perhaps out-of-memory, caused the failure.
4 = Invalid parameters were passed to the receive method call.
5 = Timeout.  Data stopped arriving for more than the amount of time specified by the MaxReadIdleMs property.
6 = The receive was aborted by the application in an event callback.
7 = The connection was lost -- the remote peer reset the connection. (The connection was forcibly closed by the peer.)
8 = An established connection was aborted by the software in your host machine. (See https://www.chilkatsoft.com/p/p_299.asp )
9 = An unspecified fatal socket error occurred (less common).
10 = The connection was closed by the peer.

int get_ReceivePacketSize(void);
void put_ReceivePacketSize(int newVal);

The number of bytes to receive at a time (internally). This setting has an effect on methods such as ReadBytes and ReadString where the number of bytes to read is not explicitly specified. The default value is 4096.

void get_RemoteIpAddress(CkString &str);
const char *remoteIpAddress(void);

When a socket is connected, the remote IP address of the connected peer is available in this property.

int get_RemotePort(void);

When a socket is connected, the remote port of the connected peer is available in this property.

bool get_RequireSslCertVerify(void);
void put_RequireSslCertVerify(bool newVal);

If true, then the SSL/TLS client will verify the server's SSL certificate. The certificate is expired, or if the cert's signature is invalid, the connection is not allowed. The default value of this property is false.

int get_SelectorIndex(void);
void put_SelectorIndex(int newVal);

If this socket contains a collection of connected sockets (i.e. it is a "socket set") then method calls and property gets/sets are routed to the contained socket indicated by this property. Indexing begins at 0. See the TakeSocket method and SelectForReading method for more information.

(C++) Socket Select for Reading

(MFC) Socket Select for Reading

int get_SelectorReadIndex(void);
void put_SelectorReadIndex(int newVal);

When SelectForReading returns a number greater than 0 indicating that 1 or more sockets are ready for reading, this property is used to select the socket in the "ready set" for reading. See the example below:

(C++) Socket Select for Reading

(MFC) Socket Select for Reading

int get_SelectorWriteIndex(void);
void put_SelectorWriteIndex(int newVal);

When SelectForWriting returns a number greater than 0 indicating that one or more sockets are ready for writing, this property is used to select the socket in the "ready set" for writing.

int get_SendFailReason(void);

Introduced in version 9.5.0.49

If a Send method fails, this property can be checked to determine the reason for failure.

Possible values are:

0 = Success
1 = An async receive operation is already in progress.
2 = The socket is not connected, such as if it was never connected, or if the connection was previously lost.
3 = An unspecified internal failure, perhaps out-of-memory, caused the failure.
4 = Invalid parameters were passed to the receive method call.
5 = Timeout.  Data stopped arriving for more than the amount of time specified by the MaxReadIdleMs property.
6 = The receive was aborted by the application in an event callback.
7 = The connection was lost -- the remote peer reset the connection. (The connection was forcibly closed by the peer.)
8 = An established connection was aborted by the software in your host machine. (See https://www.chilkatsoft.com/p/p_299.asp )
9 = An unspecified fatal socket error occurred (less common).
10 = The connection was closed by the peer.
11 = Decoding error (possible in SendString when coverting to the StringCharset, or in SendBytesENC).

int get_SendPacketSize(void);
void put_SendPacketSize(int newVal);

The number of bytes to send at a time (internally). This can also be though of as the "chunk size". If a large amount of data is to be sent, the data is sent in chunks equal to this size in bytes. The default value is 65535. (Note: This only applies to non-SSL/TLS connections. SSL and TLS have their own pre-defined packet sizes.)

void get_SessionLog(CkString &str);
const char *sessionLog(void);

Contains a log of the bytes sent and received on this socket. The KeepSessionLog property must be set to true for logging to occur.

(C++) Demonstrates KeepSessionLog and SessionLog

(MFC) Demonstrates KeepSessionLog and SessionLog

void get_SessionLogEncoding(CkString &str);
const char *sessionLogEncoding(void);
void put_SessionLogEncoding(const char *ansiOrUtf8Str);

Controls how the data is encoded in the SessionLog. Possible values are "esc" and "hex". The default value is "esc".

When set to "hex", the bytes are encoded as a hexidecimalized string. The "esc" encoding is a C-string like encoding, and is more compact than hex if most of the data to be logged is text. Printable us-ascii chars are unmodified. Common "C" control chars are represented as "\r", "\n", "\t", etc. Non-printable and byte values greater than 0x80 are escaped using a backslash and hex encoding: \xHH. Certain printable chars are backslashed: SPACE, double-quote, single-quote, etc.

(C++) Demonstrates KeepSessionLog and SessionLog

(MFC) Demonstrates KeepSessionLog and SessionLog

void get_SocksHostname(CkString &str);
const char *socksHostname(void);
void put_SocksHostname(const char *ansiOrUtf8Str);

The SOCKS4/SOCKS5 hostname or IPv4 address (in dotted decimal notation). This property is only used if the SocksVersion property is set to 4 or 5).

void get_SocksPassword(CkString &str);
const char *socksPassword(void);
void put_SocksPassword(const char *ansiOrUtf8Str);

The SOCKS5 password (if required). The SOCKS4 protocol does not include the use of a password, so this does not apply to SOCKS4.

int get_SocksPort(void);
void put_SocksPort(int newVal);

The SOCKS4/SOCKS5 proxy port. The default value is 1080. This property only applies if a SOCKS proxy is used (if the SocksVersion property is set to 4 or 5).

void get_SocksUsername(CkString &str);
const char *socksUsername(void);
void put_SocksUsername(const char *ansiOrUtf8Str);

The SOCKS4/SOCKS5 proxy username. This property is only used if the SocksVersion property is set to 4 or 5).

int get_SocksVersion(void);
void put_SocksVersion(int newVal);

SocksVersion May be set to one of the following integer values:

0 - No SOCKS proxy is used. This is the default.
4 - Connect via a SOCKS4 proxy.
5 - Connect via a SOCKS5 proxy.

int get_SoRcvBuf(void);
void put_SoRcvBuf(int newVal);

Sets the receive buffer size socket option. Normally, this property should be left unchanged. The default value is 4194304.

This property can be increased if download performance seems slow. It is recommended to be a multiple of 4096.

More Information about TCP performance and Buffer Sizes

bool get_SoReuseAddr(void);
void put_SoReuseAddr(bool newVal);

Sets the SO_REUSEADDR socket option for a socket that will bind to a port and listen for incoming connections. The default value is true, meaning that the SO_REUSEADDR socket option is set. If the socket option must be unset, set this property equal to false prior to calling BindAndListen or InitSslServer.

int get_SoSndBuf(void);
void put_SoSndBuf(int newVal);

Sets the send buffer size socket option. Normally, this property should be left unchanged. The default value is 262144.

This property can be increased if upload performance seems slow. It is recommended to be a multiple of 4096. Testing with sizes such as 512K and 1MB is reasonable.

More Information about TCP performance and Buffer Sizes

bool get_Ssl(void);
void put_Ssl(bool newVal);

Set this property to true if the socket requires an SSL connection. The default value is false.

void get_SslAllowedCiphers(CkString &str);
const char *sslAllowedCiphers(void);
void put_SslAllowedCiphers(const char *ansiOrUtf8Str);

Introduced in version 9.5.0.48

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_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_SslProtocol(CkString &str);
const char *sslProtocol(void);
void put_SslProtocol(const char *ansiOrUtf8Str);

Selects the secure protocol to be used for secure (SSL/TLS) connections. Possible values are:

default
TLS 1.2
TLS 1.1
TLS 1.0
SSL 3.0
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_StringCharset(CkString &str);
const char *stringCharset(void);
void put_StringCharset(const char *ansiOrUtf8Str);

A charset such as "utf-8", "windows-1252", "Shift_JIS", "iso-8859-1", etc. Methods for sending and receiving strings will use this charset as the encoding. Strings sent on the socket are first converted (if necessary) to this encoding. When reading, it is assumed that the bytes received are converted FROM this charset if necessary. This ONLY APPLIES TO THE SendString and ReceiveString methods. The default value is "ansi".

Chilkat Socket Programming: Important "Must Know" Concepts

bool get_TcpNoDelay(void);
void put_TcpNoDelay(bool newVal);

Controls whether the TCP_NODELAY socket option is used for the underlying TCP/IP socket. The default value is false. Setting the value to true disables the Nagle algorithm and allows for better performance when small amounts of data are sent on the socket connection.

void get_TlsCipherSuite(CkString &str);
const char *tlsCipherSuite(void);

Introduced in version 9.5.0.49

Contains the current or last negotiated TLS cipher suite. If no TLS connection has yet to be established, or if a connection as attempted and failed, then this will be empty. A sample cipher suite string looks like this: TLS_DHE_RSA_WITH_AES_256_CBC_SHA256.

void get_TlsPinSet(CkString &str);
const char *tlsPinSet(void);
void put_TlsPinSet(const char *ansiOrUtf8Str);

Introduced in version 9.5.0.55

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.

Encodings Supported by Chilkat

void get_TlsVersion(CkString &str);
const char *tlsVersion(void);

Introduced in version 9.5.0.49

Contains the current or last negotiated TLS protocol version. If no TLS connection has yet to be established, or if a connection as attempted and failed, then this will be empty. Possible values are "SSL 3.0", "TLS 1.0", "TLS 1.1", and "TLS 1.2".

void get_UserData(CkString &str);
const char *userData(void);
void put_UserData(const char *ansiOrUtf8Str);

Provides a way to store text data with the socket object. The UserData is purely for convenience and is not involved in the socket communications in any way. An application might use this property to keep extra information associated with the socket.

bool get_Utf8(void);
void put_Utf8(bool newVal);

When set to true, all "const char *" arguments are interpreted as utf-8 strings. If set to false (the default), then "const char *" arguments are interpreted as ANSI strings. Also, when set to true, and Chilkat method returning a "const char *" is returning the utf-8 representation. If set to false, all "const char *" return values are ANSI strings.

bool get_VerboseLogging(void);
void put_VerboseLogging(bool newVal);

If set to true, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. The default value is false. Verbose logging should only be used for debugging. The potentially large quantity of logged information may adversely affect peformance.

void get_Version(CkString &str);
const char *version(void);

Version of the component/library, such as "9.5.0.63"

Methods

CkSocket *AcceptNextConnection(int maxWaitMs);

Blocking call to accept the next incoming connection on the socket. maxWaitMs specifies the maximum time to wait (in milliseconds). Set this to 0 to wait indefinitely. If successful, a new socket object is returned.

Important: If accepting an SSL/TLS connection, the SSL handshake is part of the connection establishment process. This involves a few back-and-forth messages between the client and server to establish algorithms and a shared key to create the secure channel. The sending and receiving of these messages are governed by the MaxReadIdleMs and MaxSendIdleMs properties. If these properties are set to 0 (and this is the default unless changed by your application), then the AcceptNextConnection can hang indefinitely during the SSL handshake process. Make sure these properties are set to appropriate values before calling this method.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

CkTask *AcceptNextConnectionAsync(int maxWaitMs);

Creates an asynchronous task to call the AcceptNextConnection method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

(C++) How to Return an Object from an Async Task

(MFC) How to Return an Object from an Async Task

bool AddSslAcceptableClientCaDn(const char *certAuthDN);

If this object is a server-side socket accepting SSL/TLS connections, and wishes to require a client-side certificate for authentication, then it should make one or more calls to this method to identify the CA's it will accept for client-side certificates.

If no CA DN's are added by this method, then client certificates from any root CA are accepted.

Important: If calling this method, it must be called before calling InitSslServer.

Returns true for success, false for failure.

(C++) Accept TLS Connection with Client Authentication

(MFC) Accept TLS Connection with Client Authentication

void AsyncAcceptAbort(void);

This method is deprecated. It will be removed in a future version.

Call this to abort an asynchronous socket connect that is running in a background thread. Asynchronous connects are initiated by calling AsyncAcceptStart.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

CkSocket *AsyncAcceptSocket(void);

This method is deprecated. It will be removed in a future version.

Returns the socket object for the connection accepted asynchronously in a background thread (via AsyncAcceptStart). The connected socket can only be retrieved once. A subsequent call to AsyncAcceptSocket will return a NULL reference until another connection is accepted asynchronously.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

bool AsyncAcceptStart(int maxWaitMs);

This method is deprecated. It will be removed in a future version.

Initiates a background thread to wait for and accept the next incoming TCP connection. The method will fail if an asynchronous operation is already in progress. The timeout (in milliseconds) is passed in maxWaitMs. To wait indefinitely, set maxWaitMs to 0. Asynchronous accept operations can be aborted by calling AsyncAcceptAbort. When the async accept operation completes, the AsyncAcceptFinished property will become true. If the accept was successful, the AsyncAcceptSuccess property is set to true and the connected socket can be retrieved via the AsyncAcceptSocket method. A debug log is available in the AsyncAcceptLog property.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

Returns true for success, false for failure.

void AsyncConnectAbort(void);

This method is deprecated. It will be removed in a future version.

Aborts an asynchronous connect operation running in a background thread (started by calling AsyncConnectStart).

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

bool AsyncConnectStart(const char *hostname, int port, bool ssl, int maxWaitMs);

This method is deprecated. It will be removed in a future version.

Initiates a background thread to establish a TCP connection with a remote host:port. The method will fail if an asynchronous operation is already in progress, or if the timeout expired. The timeout (in milliseconds) is passed in maxWaitMs. To wait indefinitely, set maxWaitMs to 0. Set ssl = true to esablish an SSL connection. Asynchronous connect operations can be aborted by calling AsyncConnectAbort. When the async connect operation completes, the AsyncConnectFinished property will become true. If the connect was successful, the AsyncConnectSuccess property is set to true. A debug log is available in the AsyncConnectLog property.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

Returns true for success, false for failure.

void AsyncDnsAbort(void);

This method is deprecated. It will be removed in a future version.

Aborts an asynchronous DNS lookup running in a background thread (started via the AsyncDnsStart method).

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

bool AsyncDnsStart(const char *hostname, int maxWaitMs);

This method is deprecated. It will be removed in a future version.

Initiates a background thread to do a DNS query (i.e. to resolve a hostname to an IP address). The method will fail if an asynchronous operation is already in progress, or if the timeout expired. The timeout (in milliseconds) is passed in maxWaitMs. To wait indefinitely, set maxWaitMs to 0. Asynchronous DNS lookups can be aborted by calling AsyncDnsAbort. When the async DNS operation completes, the AsyncDnsFinished property will become true. If the DNS query was successful, the AsyncDnsSuccess property is set to true. A debug log is available in the AsyncDnsLog property. Finally, the DNS query result (i.e. IP address) is available in nnn.nnn.nnn.nnn string form in the AsyncDnsResult property.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

Returns true for success, false for failure.

void AsyncReceiveAbort(void);

This method is deprecated. It will be removed in a future version.

Aborts an asynchronous receive running in a background thread (started via one of the AsyncReceive* methods).

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

bool AsyncReceiveBytes(void);

This method is deprecated. It will be removed in a future version.

Initiates a background thread to receive bytes on an already-connected socket (ssl or non-ssl).

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

Returns true for success, false for failure.

bool AsyncReceiveBytesN(unsigned long numBytes);

This method is deprecated. It will be removed in a future version.

Initiates a background thread to receive exactly numBytes bytes on an already-connected socket (ssl or non-ssl).

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

Returns true for success, false for failure.

bool AsyncReceiveString(void);

This method is deprecated. It will be removed in a future version.

Initiates a background thread to receive text on an already-connected socket (ssl or non-ssl). The component interprets the received bytes according to the charset specified in the StringCharset property.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

Returns true for success, false for failure.

bool AsyncReceiveToCRLF(void);

This method is deprecated. It will be removed in a future version.

Initiates a background thread to receive text on an already-connected socket (ssl or non-ssl). The asynchronous receive does not complete until a CRLF is received. The component interprets the received bytes according to the charset specified in the StringCharset property.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

Returns true for success, false for failure.

bool AsyncReceiveUntilMatch(const char *matchStr);

This method is deprecated. It will be removed in a future version.

Initiates a background thread to receive text on an already-connected socket (ssl or non-ssl). The asynchronous receive does not complete until the exact string specified by matchStr is received. The component interprets the received bytes according to the charset specified in the StringCharset property.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

Returns true for success, false for failure.

void AsyncSendAbort(void);

This method is deprecated. It will be removed in a future version.

Aborts an asynchronous send running in a background thread (started via one of the AsyncSend* methods).

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

bool AsyncSendByteData(CkByteData &data);

This method is deprecated. It will be removed in a future version.

Initiates a background thread to send bytes on an already-connected socket (SSL/TLS or unencrypted). This method is redundant and identical to SendBytes.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

Returns true for success, false for failure.

bool AsyncSendBytes(CkByteData &byteData);

This method is deprecated. It will be removed in a future version.

Initiates a background thread to send bytes on an already-connected socket (ssl or non-ssl).

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

Returns true for success, false for failure.

bool AsyncSendString(const char *stringToSend);

This method is deprecated. It will be removed in a future version.

Initiates a background thread to send text on an already-connected socket (ssl or non-ssl). Before sending, the stringToSend is first converted (if necessary) to the charset specified by the StringCharset property.

This functionality is replaced by the new model for asynchronous programming introduced in Chilkat v9.5.0.52. Applications should use the new model, which is identified by methods having names ending with "Async" and return a task object.

Returns true for success, false for failure.

bool BindAndListen(int port, int backLog);

Binds a TCP socket to a port and configures it to listen for incoming connections. The size of the backlog is passed in backLog. The backLog is necessary when multiple connections arrive at the same time, or close enough in time such that they cannot be serviced immediately. (A typical value to use for backLog is 5.) This method should be called once prior to receiving incoming connection requests via the AcceptNextConnection or AsyncAcceptStart methods.

Note:This method will find a random unused port to listen on if you bind to port 0. The chosen port is available via the read-only ListenPort property after this method returns successful.

To bind and listen using IPv6, set the ListenIpv6 property = true prior to calling this method.

What is a reasonable value for backLog? The answer depends on how many simultaneous incoming connections could be expected, and how quickly your application can process an incoming connection and then return to accept the next connection.

Returns true for success, false for failure.

(C++) Bind and Listen on a Randomly Selected Unused Port

(MFC) Bind and Listen on a Randomly Selected Unused Port

CkTask *BindAndListenAsync(int port, int backLog);

Creates an asynchronous task to call the BindAndListen method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

int BindAndListenPortRange(int beginPort, int endPort, int backLog);

Introduced in version 9.5.0.69

Binds a TCP socket to an unused port within a port range (beginPort to endPort) and configures it to listen for incoming connections. The size of the backlog is passed in endPort. The endPort is necessary when multiple connections arrive at the same time, or close enough in time such that they cannot be serviced immediately. (A typical value to use for endPort is 5.) This method should be called once prior to receiving incoming connection requests via the AcceptNextConnection method.

To bind and listen using IPv6, set the ListenIpv6 property = true prior to calling this method.

Returns the port number that was bound, or -1 if no port was available or if it failed for some other reason.

CkTask *BindAndListenPortRangeAsync(int beginPort, int endPort, int backLog);

Introduced in version 9.5.0.69

Creates an asynchronous task to call the BindAndListenPortRange method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool BuildHttpGetRequest(const char *url, CkString &outStr);
const char *buildHttpGetRequest(const char *url);

Introduced in version 9.5.0.35

Convenience method for building a simple HTTP GET request from a URL.

Returns true for success, false for failure.

int CheckWriteable(int maxWaitMs);

Determines if the socket is writeable. Returns one of the following integer values:

1: If the socket is connected and ready for writing.
0: If a timeout occurred or if the application aborted the method during an event callback.
-1: The socket is not connected.

A maxWaitMs value of 0 indicates a poll.

CkTask *CheckWriteableAsync(int maxWaitMs);

Creates an asynchronous task to call the CheckWriteable method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

void ClearSessionLog(void);

Clears the contents of the SessionLog property.

CkSocket *CloneSocket(void);

Introduced in version 9.5.0.47

Creates a copy that shares the same underlying TCP (or SSL/TLS) connection. This allows for simultaneous reading/writing by different threads on the socket. When using asynchronous reading/writing, it is not necessary to clone the socket. However, if separate background threads are making synchronous calls to read/write, then one thread may use the original socket, and the other should use a clone.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

Simultaneous Reading/Writing a Socket from Different Threads

(C++) Bidirectional Sockets (TLS or non-TLS, simultaneous reading and writing a connection)

(MFC) Bidirectional Sockets (TLS or non-TLS, simultaneous reading and writing a connection)

bool Close(int maxWaitMs);

Cleanly terminates and closes a TCP, TLS, or SSH channel connection. The maxWaitMs applies to SSL/TLS connections because there is a handshake that occurs during secure channel shutdown.

CkTask *CloseAsync(int maxWaitMs);

Creates an asynchronous task to call the Close method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool Connect(const char *hostname, int port, bool ssl, int maxWaitMs);

Establishes a secure SSL/TLS or a plain non-secure TCP connection with a remote host:port. This is a blocking call. The maximum wait time (in milliseconds) is passed in maxWaitMs. This is the amount of time the app is willing to wait for the TCP connection to be accepted.

To establish an SSL/TLS connection, set ssl = true, otherwise set ssl = false for a normal TCP connection. Note: The timeouts that apply to the internal SSL/TLS handshaking messages are the MaxReadIdleMs and MaxSendIdleMs properties.

Note: Connections do not automatically close because of inactivity. A connection will remain open indefinitely even if there is no activity.

Important: All TCP-based Internet communications, regardless of the protocol (such as HTTP, FTP, SSH, IMAP, POP3, SMTP, etc.), and regardless of SSL/TLS, begin with establishing a TCP connection to a remote host:port. External security-related infrastructure such as software firewalls (Windows Firewall), hardware firewalls, anti-virus, at either source or destination (or both) can block the connection. If the connection fails, make sure to check all potential external causes of blockage.

Question: How do I Choose the TLS version, such as 1.2? Answer: The client does not specifically choose the TLS version. In the TLS handshake (which is what occurs internally in this method), the client tells the server the version of the TLS protocol it wishes to use, which should be the highest version is supports. In this case, (at the time of this writing on 22-June-2017) it is TLS 1.2. The server then chooses the TLS version that will actually be used. In most cases it will be TLS 1.2. The client can then choose to accept or reject the connection based on the TLS version chosen by the server. By default, Chilkat will reject anything lower than SSL 3.0 (i.e. SSL 2.0 or lower is rejected). The SslProtocol property can be set to change what is accepted by Chilkat. For example, it can be set to "TLS 1.0 or higher".

Returns true for success, false for failure.

Chilkat Socket Programming: Important "Must Know" Concepts

(C++) Socket Connect Failure Cases

(MFC) Socket Connect Failure Cases

CkTask *ConnectAsync(const char *hostname, int port, bool ssl, int maxWaitMs);

Creates an asynchronous task to call the Connect method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

Chilkat C# Async Sockets Example on GitHub

bool ConvertFromSsl(void);

Closes the secure (TLS/SSL) channel leaving the socket in a connected state where data sent and received is unencrypted.

Returns true for success, false for failure.

CkTask *ConvertFromSslAsync(void);

Creates an asynchronous task to call the ConvertFromSsl method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool ConvertToSsl(void);

Converts a non-SSL/TLS connected socket to a secure channel using TLS/SSL.

Returns true for success, false for failure.

CkTask *ConvertToSslAsync(void);

Creates an asynchronous task to call the ConvertToSsl method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

void DnsCacheClear(void);

Introduced in version 9.5.0.38

Clears the Chilkat-wide in-memory hostname-to-IP address DNS cache. Chilkat automatically maintains this in-memory cache to prevent redundant DNS lookups. If the TTL on the DNS A records being accessed are short and/or these DNS records change frequently, then this method can be called clear the internal cache. Note: The DNS cache is used/shared among all Chilkat objects in a program, and clearing the cache affects all Chilkat objects.

bool DnsLookup(const char *hostname, int maxWaitMs, CkString &outStr);
const char *dnsLookup(const char *hostname, int maxWaitMs);

Performs a DNS query to resolve a hostname to an IP address. The IP address is returned if successful. The maximum time to wait (in milliseconds) is passed in maxWaitMs. To wait indefinitely, set maxWaitMs = 0.

Returns true for success, false for failure.

(C++) DNS Lookup

(MFC) DNS Lookup

CkTask *DnsLookupAsync(const char *hostname, int maxWaitMs);

Creates an asynchronous task to call the DnsLookup method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

CkCert *GetMyCert(void);

Returns the digital certificate to be used for SSL connections. This method would only be called by an SSL server application. The SSL certificate is initially specified by calling InitSslServer.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

CkCert *GetReceivedClientCert(int index);

Returns the Nth client certificate received during an SSL/TLS handshake. This method only applies to the server-side of an SSL/TLS connection. The 1st client certificate is at index 0. The NumReceivedClientCerts property indicates the number of client certificates received during the SSL/TLS connection establishment.

Client certificates are customarily only sent when the server demands client-side authentication, as in 2-way SSL/TLS. This method provides the ability for the server to access and examine the client-side certs immediately after a connection is established. (Of course, if the client-side certs are inadequate for authentication, then the application can choose to immediately disconnect.)

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

bool GetSslAcceptableClientCaDn(int index, CkString &outStr);
const char *getSslAcceptableClientCaDn(int index);

If connected as an SSL/TLS client to an SSL/TLS server where the server requires a client-side certificate for authentication, then the NumSslAcceptableClientCAs property contains the number of acceptable certificate authorities sent by the server during connection establishment handshake. This method may be called to get the Distinguished Name (DN) of each acceptable CA. The index should range from 0 to NumSslAcceptableClientCAs - 1.

Returns true for success, false for failure.

CkCert *GetSslServerCert(void);

Returns the SSL server's digital certificate. This method would only be called by the client-side of an SSL connection. It returns the certificate of the remote SSL server for the current SSL connection. If the socket is not connected, or is not connected via SSL, then a NULL reference is returned.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) Get TLS Server's SPKI Fingerprint

(MFC) Get TLS Server's SPKI Fingerprint

bool InitSslServer(CkCert &cert);

SSL Server applications should call this method with the SSL server certificate to be used for SSL connections. It should be called prior to accepting connections. This method has an intended side-effect: If not already connected, then the Ssl property is set to true.

Returns true for success, false for failure.

(C++) SSL Server Example

(MFC) SSL Server Example

bool IsUnlocked(void);

Returns true if the component is unlocked.

bool LoadTaskResult(CkTask &task);

Introduced in version 9.5.0.52

Loads the socket object from a completed asynchronous task.

Returns true for success, false for failure.

bool PollDataAvailable(void);

Check to see if data is available for reading on the socket. Returns true if data is waiting and false if no data is waiting to be read.

CkTask *PollDataAvailableAsync(void);

Creates an asynchronous task to call the PollDataAvailable method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool ReceiveBd(CkBinData &binData);

Introduced in version 9.5.0.65

Receives as much data as is immediately available on a connected TCP socket and appends the incoming data to binData. If no data is immediately available, it waits up to MaxReadIdleMs milliseconds for data to arrive.

Returns true for success, false for failure.

CkTask *ReceiveBdAsync(CkBinData &binData);

Introduced in version 9.5.0.65

Creates an asynchronous task to call the ReceiveBd method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool ReceiveBdN(unsigned long numBytes, CkBinData &binData);

Introduced in version 9.5.0.65

Reads exactly numBytes bytes from the connection. This method blocks until numBytes bytes are read or the read times out. The timeout is specified by the MaxReadIdleMs property (in milliseconds).

Returns true for success, false for failure.

CkTask *ReceiveBdNAsync(unsigned long numBytes, CkBinData &binData);

Introduced in version 9.5.0.65

Creates an asynchronous task to call the ReceiveBdN method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool ReceiveByte(bool bUnsigned);

Introduced in version 9.5.0.50

Receives a single byte. The received byte will be available in the ReceivedInt property. If bUnsigned is true, then a value from 0 to 255 is returned in ReceivedInt. If bUnsigned is false, then a value from -128 to +127 is returned.

Returns true for success, false for failure.

CkTask *ReceiveByteAsync(bool bUnsigned);

Introduced in version 9.5.0.50

Creates an asynchronous task to call the ReceiveByte method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool ReceiveBytes(CkByteData &outData);

Receives as much data as is immediately available on a connected TCP socket. If no data is immediately available, it waits up to MaxReadIdleMs milliseconds for data to arrive.

Returns true for success, false for failure.

Chilkat Socket Programming: Important "Must Know" Concepts

CkTask *ReceiveBytesAsync(void);

Creates an asynchronous task to call the ReceiveBytes method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool ReceiveBytesENC(const char *encodingAlg, CkString &outStr);
const char *receiveBytesENC(const char *encodingAlg);

The same as ReceiveBytes, except the bytes are returned in encoded string form according to encodingAlg. The encodingAlg can be "Base64", "modBase64", "Base32", "UU", "QP" (for quoted-printable), "URL" (for url-encoding), "Hex", "Q", "B", "url_oath", "url_rfc1738", "url_rfc2396", or "url_rfc3986".

Returns true for success, false for failure.

CkTask *ReceiveBytesENCAsync(const char *encodingAlg);

Creates an asynchronous task to call the ReceiveBytesENC method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool ReceiveBytesN(unsigned long numBytes, CkByteData &outData);

Reads exactly numBytes bytes from a connected SSL or non-SSL socket. This method blocks until numBytes bytes are read or the read times out. The timeout is specified by the MaxReadIdleMs property (in milliseconds).

Returns true for success, false for failure.

CkTask *ReceiveBytesNAsync(unsigned long numBytes);

Creates an asynchronous task to call the ReceiveBytesN method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

Chilkat C# Async Sockets Example on GitHub

bool ReceiveBytesToFile(const char *appendFilename);

Receives as much data as is immediately available on a connected TCP socket. If no data is immediately available, it waits up to MaxReadIdleMs milliseconds for data to arrive.

The received data is appended to the file specified by appendFilename.

Returns true for success, false for failure.

CkTask *ReceiveBytesToFileAsync(const char *appendFilename);

Creates an asynchronous task to call the ReceiveBytesToFile method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

int ReceiveCount(void);

Receives a 4-byte signed integer and returns the value received. Returns -1 on error.

CkTask *ReceiveCountAsync(void);

Creates an asynchronous task to call the ReceiveCount method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool ReceiveInt16(bool bigEndian, bool bUnsigned);

Introduced in version 9.5.0.50

Receives a 16-bit integer (2 bytes). The received integer will be available in the ReceivedInt property. Set bigEndian equal to true if the incoming 16-bit integer is in big-endian byte order. Otherwise set bigEndian equal to false for receving a little-endian integer. If bUnsigned is true, the ReceivedInt will range from 0 to 65,535. If bUnsigned is false, the ReceivedInt will range from -32,768 through 32,767.

Returns true for success, false for failure.

CkTask *ReceiveInt16Async(bool bigEndian, bool bUnsigned);

Introduced in version 9.5.0.50

Creates an asynchronous task to call the ReceiveInt16 method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool ReceiveInt32(bool bigEndian);

Introduced in version 9.5.0.50

Receives a 32-bit integer (4 bytes). The received integer will be available in the ReceivedInt property. Set bigEndian equal to true if the incoming 32-bit integer is in big-endian byte order. Otherwise set bigEndian equal to false for receving a little-endian integer.

Returns true for success, false for failure.

(C++) TCP Socket through SSH Tunnel (Port Forwarding)

(MFC) TCP Socket through SSH Tunnel (Port Forwarding)

(C++) Get Current Date/Time from NIST Time Server

(MFC) Get Current Date/Time from NIST Time Server

CkTask *ReceiveInt32Async(bool bigEndian);

Introduced in version 9.5.0.50

Creates an asynchronous task to call the ReceiveInt32 method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool ReceiveNBytesENC(unsigned long numBytes, const char *encodingAlg, CkString &outStr);
const char *receiveNBytesENC(unsigned long numBytes, const char *encodingAlg);

The same as ReceiveBytesN, except the bytes are returned in encoded string form using the encoding specified by numBytes. The numBytes can be "Base64", "modBase64", "Base32", "UU", "QP" (for quoted-printable), "URL" (for url-encoding), "Hex", "Q", "B", "url_oath", "url_rfc1738", "url_rfc2396", or "url_rfc3986".

Returns true for success, false for failure.

CkTask *ReceiveNBytesENCAsync(unsigned long numBytes, const char *encodingAlg);

Creates an asynchronous task to call the ReceiveNBytesENC method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool ReceiveSb(CkStringBuilder &sb);

Introduced in version 9.5.0.65

Receives as much data as is immediately available on the connection. If no data is immediately available, it waits up to MaxReadIdleMs milliseconds for data to arrive. The incoming bytes are interpreted according to the StringCharset property and appended to sb.

Returns true for success, false for failure.

CkTask *ReceiveSbAsync(CkStringBuilder &sb);

Introduced in version 9.5.0.65

Creates an asynchronous task to call the ReceiveSb method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool ReceiveString(CkString &outStr);
const char *receiveString(void);

Receives as much data as is immediately available on a TCP/IP or SSL socket. If no data is immediately available, it waits up to MaxReadIdleMs milliseconds for data to arrive. The incoming bytes are interpreted according to the StringCharset property and returned as a string.

Returns true for success, false for failure.

Chilkat Socket Programming: Important "Must Know" Concepts

(C++) Example Code: Receiving a String

(MFC) Example Code: Receiving a String

CkTask *ReceiveStringAsync(void);

Creates an asynchronous task to call the ReceiveString method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool ReceiveStringMaxN(int maxByteCount, CkString &outStr);
const char *receiveStringMaxN(int maxByteCount);

Same as ReceiveString, but limits the amount of data returned to a maximum of maxByteCount bytes.

(Receives as much data as is immediately available on the TCP/IP or SSL socket. If no data is immediately available, it waits up to MaxReadIdleMs milliseconds for data to arrive. The incoming bytes are interpreted according to the StringCharset property and returned as a string.)

Returns true for success, false for failure.

CkTask *ReceiveStringMaxNAsync(int maxByteCount);

Creates an asynchronous task to call the ReceiveStringMaxN method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool ReceiveStringUntilByte(int lookForByte, CkString &outStr);
const char *receiveStringUntilByte(int lookForByte);

Receives bytes on a connected SSL or non-SSL socket until a specific 1-byte value is read. Returns a string containing all the bytes up to but excluding the lookForByte.

Returns true for success, false for failure.

CkTask *ReceiveStringUntilByteAsync(int lookForByte);

Creates an asynchronous task to call the ReceiveStringUntilByte method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool ReceiveToCRLF(CkString &outStr);
const char *receiveToCRLF(void);

Reads text from the connected TCP/IP or SSL socket until a CRLF is received. Returns the text up to and including the CRLF. The incoming bytes are interpreted according to the charset specified by the StringCharset property.

Returns true for success, false for failure.

(C++) Receive Text until CRLF

(MFC) Receive Text until CRLF

(C++) TLS Connection within SSH Tunnel (Port Forwarding)

(MFC) TLS Connection within SSH Tunnel (Port Forwarding)

CkTask *ReceiveToCRLFAsync(void);

Creates an asynchronous task to call the ReceiveToCRLF method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool ReceiveUntilByte(int lookForByte, CkByteData &outBytes);

Receives bytes on the TCP/IP or SSL socket until a specific 1-byte value is read. Returns all the bytes up to and including the lookForByte.

Returns true for success, false for failure.

CkTask *ReceiveUntilByteAsync(int lookForByte);

Creates an asynchronous task to call the ReceiveUntilByte method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool ReceiveUntilMatch(const char *matchStr, CkString &outStr);
const char *receiveUntilMatch(const char *matchStr);

Reads text from the connected TCP/IP or SSL socket until a matching string (matchStr) is received. Returns the text up to and including the matching string. As an example, to one might read the header of an HTTP request or a MIME message by reading up to the first double CRLF ("\r\n\r\n"). The incoming bytes are interpreted according to the charset specified by the StringCharset property.

Returns true for success, false for failure.

(C++) SSL Client Example

(MFC) SSL Client Example

(C++) Receive Text until CRLF

(MFC) Receive Text until CRLF

(C++) Bidirectional Sockets (TLS or non-TLS, simultaneous reading and writing a connection)

(MFC) Bidirectional Sockets (TLS or non-TLS, simultaneous reading and writing a connection)

CkTask *ReceiveUntilMatchAsync(const char *matchStr);

Creates an asynchronous task to call the ReceiveUntilMatch method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

Chilkat C# Async Sockets Example on GitHub

bool SaveLastError(const char *path);

Saves the last-error information (the contents of LastErrorXml) to an XML formatted file.

Returns true for success, false for failure.

int SelectForReading(int timeoutMs);

Wait for data to arrive on this socket, or any of the contained sockets if the caller is a "socket set". (see the example at the link below for more detailed information) Waits a maximum of timeoutMs milliseconds. If maxWaitMs = 0, then it is effectively a poll. Returns the number of sockets with data available for reading. If no sockets have data available for reading, then a value of 0 is returned. A value of -1 indicates an error condition. Note: when the remote peer (in this case the web server) disconnects, the socket will appear as if it has data available. A "ready" socket is one where either data is available for reading or the socket has become disconnected.

If the peer closed the connection, it will not be discovered until an attempt is made to read the socket. If the read fails, then the IsConnected property may be checked to see if the connection was closed.

(C++) Socket Select for Reading

(MFC) Socket Select for Reading

CkTask *SelectForReadingAsync(int timeoutMs);

Creates an asynchronous task to call the SelectForReading method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

int SelectForWriting(int timeoutMs);

Waits until it is known that data can be written to one or more sockets without it blocking.

Socket writes are typically buffered by the operating system. When an application writes data to a socket, the operating system appends it to the socket's outgoing send buffers and returns immediately. However, if the OS send buffers become filled up (because the sender is sending data faster than the remote receiver can read it), then a socket write can block (until outgoing send buffer space becomes available).

Waits a maximum of timeoutMs milliseconds. If maxWaitMs = 0, then it is effectively a poll. Returns the number of sockets such that data can be written without blocking. A value of -1 indicates an error condition.

CkTask *SelectForWritingAsync(int timeoutMs);

Creates an asynchronous task to call the SelectForWriting method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool SendBd(CkBinData &binData, unsigned long offset, unsigned long numBytes);

Introduced in version 9.5.0.65

Sends bytes from binData over a connected SSL or non-SSL socket. If transmission halts for more than MaxSendIdleMs milliseconds, the send is aborted. This is a blocking (synchronous) method. It returns only after the bytes have been sent.

Set offset and/or numBytes to non-zero values to send a portion of the binData. If offset and numBytes are both 0, then the entire binData is sent. If offset is non-zero and numBytes is zero, then the bytes starting at offset until the end are sent.

Returns true for success, false for failure.

CkTask *SendBdAsync(CkBinData &binData, unsigned long offset, unsigned long numBytes);

Introduced in version 9.5.0.65

Creates an asynchronous task to call the SendBd method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool SendByte(int value);

Introduced in version 9.5.0.50

Sends a single byte. The integer must have a value from 0 to 255.

Returns true for success, false for failure.

CkTask *SendByteAsync(int value);

Introduced in version 9.5.0.50

Creates an asynchronous task to call the SendByte method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool SendBytes(CkByteData &data);

Sends bytes over a connected SSL or non-SSL socket. If transmission halts for more than MaxSendIdleMs milliseconds, the send is aborted. This is a blocking (synchronous) method. It returns only after the bytes have been sent.

Returns true for success, false for failure.

Chilkat Socket Programming: Important "Must Know" Concepts

CkTask *SendBytesAsync(CkByteData &data);

Creates an asynchronous task to call the SendBytes method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool SendBytesENC(const char *encodedBytes, const char *encodingAlg);

The same as SendBytes, except the bytes are provided in encoded string form as specified by encodingAlg. The encodingAlg can be "Base64", "modBase64", "Base32", "Base58", "UU", "QP" (for quoted-printable), "URL" (for url-encoding), "Hex", "Q", "B", "url_oauth", "url_rfc1738", "url_rfc2396", and "url_rfc3986".

CkTask *SendBytesENCAsync(const char *encodedBytes, const char *encodingAlg);

Creates an asynchronous task to call the SendBytesENC method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool SendCount(int byteCount);

Sends a 4-byte signed integer on the connection. The receiver may call ReceiveCount to receive the integer. The SendCount and ReceiveCount methods are handy for sending byte counts prior to sending data. The sender would send a count followed by the data, and the receiver would receive the count first, and then knows how many data bytes it should expect to receive.

Returns true for success, false for failure.

CkTask *SendCountAsync(int byteCount);

Creates an asynchronous task to call the SendCount method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool SendInt16(int value, bool bigEndian);

Introduced in version 9.5.0.50

Sends a 16-bit integer (2 bytes). Set bigEndian equal to true to send the integer in big-endian byte order (this is the standard network byte order). Otherwise set bigEndian equal to false to send in little-endian byte order.

Returns true for success, false for failure.

CkTask *SendInt16Async(int value, bool bigEndian);

Introduced in version 9.5.0.50

Creates an asynchronous task to call the SendInt16 method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool SendInt32(int value, bool bigEndian);

Introduced in version 9.5.0.50

Sends a 32-bit integer (4 bytes). Set bigEndian equal to true to send the integer in big-endian byte order (this is the standard network byte order). Otherwise set bigEndian equal to false to send in little-endian byte order.

Returns true for success, false for failure.

CkTask *SendInt32Async(int value, bool bigEndian);

Introduced in version 9.5.0.50

Creates an asynchronous task to call the SendInt32 method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool SendSb(CkStringBuilder &sb);

Introduced in version 9.5.0.65

Sends the contents of sb over the connection. If transmission halts for more than MaxSendIdleMs milliseconds, the send is aborted. The string is sent in the charset encoding specified by the StringCharset property.

This is a blocking (synchronous) method. It returns after the string has been sent.

Returns true for success, false for failure.

CkTask *SendSbAsync(CkStringBuilder &sb);

Introduced in version 9.5.0.65

Creates an asynchronous task to call the SendSb method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool SendString(const char *stringToSend);

Sends a string over a connected SSL or non-SSL (TCP/IP) socket. If transmission halts for more than MaxSendIdleMs milliseconds, the send is aborted. The string is sent in the charset encoding specified by the StringCharset property.

This is a blocking (synchronous) method. It returns after the string has been sent.

Returns true for success, false for failure.

(C++) SSL Client Example

(MFC) SSL Client Example

(C++) Bidirectional Sockets (TLS or non-TLS, simultaneous reading and writing a connection)

(MFC) Bidirectional Sockets (TLS or non-TLS, simultaneous reading and writing a connection)

CkTask *SendStringAsync(const char *stringToSend);

Creates an asynchronous task to call the SendString method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

Chilkat C# Async Sockets Example on GitHub

bool SendWakeOnLan(const char *macAddress, int port, const char *ipBroadcastAddr);

Introduced in version 9.5.0.69

Sends a "Wake on Lan" magic packet to a computer. A Wake on Lan is a way to power on a computer remotely by sending a data packet known as a magic packet. For this to work, the network card must have enabled the feature: “Power on Lan” or “Power on PCI Device“, which is done by accessing the BIOS of the machine.

The macAddress is the MAC address (in hex) of the computer to wake. A MAC address should be 6 bytes in length. For example, "000102030405". The port is the port which should be 7 or 9. (Port number 9 is more commonly used.) The ipBroadcastAddr is the broadcast address of your network, which usually ends with *.255. For example: "192.168.1.255".

Your application does not call Connect prior to calling SendWakeOnLan. To use this method, it's just a matter of instantiating an instance of this socket object and then call SendWakeOnLan.

Returns true for success, false for failure.

For more information about Wake-on-LAN

bool SetSslClientCert(CkCert &cert);

A client-side certificate for SSL/TLS connections is optional. It should be used only if the server demands it. This method allows the certificate to be specified using a certificate object.

Returns true for success, false for failure.

bool SetSslClientCertPem(const char *pemDataOrFilename, const char *pemPassword);

A client-side certificate for SSL/TLS connections is optional. It should be used only if the server demands it. This method allows the certificate to be specified using a PEM file.

Returns true for success, false for failure.

How to Create a PEM that Contains Certificates and a Private Key

bool SetSslClientCertPfx(const char *pfxFilename, const char *pfxPassword);

A client-side certificate for SSL/TLS connections is optional. It should be used only if the server demands it. This method allows the certificate to be specified using a PFX file.

Returns true for success, false for failure.

void SleepMs(int millisec);

Convenience method to force the calling thread to sleep for a number of milliseconds.

bool SshAuthenticatePk(const char *sshLogin, CkSshKey &privateKey);

Introduced in version 9.5.0.50

Authenticates with the SSH server using public-key authentication. The corresponding public key must have been installed on the SSH server for the sshLogin. Authentication will succeed if the matching privateKey is provided.

Important: When reporting problems, please send the full contents of the LastErrorText property to support@chilkatsoft.com.

Returns true for success, false for failure.

CkTask *SshAuthenticatePkAsync(const char *sshLogin, CkSshKey &privateKey);

Introduced in version 9.5.0.50

Creates an asynchronous task to call the SshAuthenticatePk method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool SshAuthenticatePw(const char *sshLogin, const char *sshPassword);

Introduced in version 9.5.0.50

Authenticates with the SSH server using a sshLogin and sshPassword. This method is only used for SSH tunneling. The tunnel is established by calling SshOpenTunnel, then (if necessary) authenticated by calling SshAuthenticatePw or SshAuthenticatePk.

Returns true for success, false for failure.

CkTask *SshAuthenticatePwAsync(const char *sshLogin, const char *sshPassword);

Introduced in version 9.5.0.50

Creates an asynchronous task to call the SshAuthenticatePw method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool SshCloseTunnel(void);

Introduced in version 9.5.0.50

Closes the SSH tunnel previously opened by SshOpenTunnel.

Returns true for success, false for failure.

CkTask *SshCloseTunnelAsync(void);

Introduced in version 9.5.0.50

Creates an asynchronous task to call the SshCloseTunnel method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

CkSocket *SshOpenChannel(const char *hostname, int port, bool ssl, int maxWaitMs);

Introduced in version 9.5.0.50

Opens a new channel within an SSH tunnel. Returns the socket that is connected to the destination host:port through the SSH tunnel via port forwarding. If ssl is true, the connection is TLS (i.e. TLS inside the SSH tunnel). Returns the socket object that is the port-forwarded tunneled connection. Any number of channels may be opened within a single SSH tunnel, and may be port-forwarded to different remote host:port endpoints.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) TCP Socket through SSH Tunnel (Port Forwarding)

(MFC) TCP Socket through SSH Tunnel (Port Forwarding)

(C++) TLS Connection within SSH Tunnel (Port Forwarding)

(MFC) TLS Connection within SSH Tunnel (Port Forwarding)

CkTask *SshOpenChannelAsync(const char *hostname, int port, bool ssl, int maxWaitMs);

Introduced in version 9.5.0.50

Creates an asynchronous task to call the SshOpenChannel method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

(C++) How to Return an Object from an Async Task

(MFC) How to Return an Object from an Async Task

bool SshOpenTunnel(const char *sshHostname, int sshPort);

Introduced in version 9.5.0.50

Connects to an SSH server and creates a tunnel for port forwarding. The sshHostname is the hostname (or IP address) of the SSH server. The sshPort is typically 22, which is the standard SSH port number.

An SSH tunneling (port forwarding) session always begins by first calling SshOpenTunnel to connect to the SSH server, followed by calling either SshAuthenticatePw or SshAuthenticatePk to authenticate. A program would then call SshOpenChannel to connect to the destination server (via the SSH tunnel). Any number of channels can be opened over the same SSH tunnel.

Returns true for success, false for failure.

(C++) TCP Socket through SSH Tunnel (Port Forwarding)

(MFC) TCP Socket through SSH Tunnel (Port Forwarding)

(C++) TLS Connection within SSH Tunnel (Port Forwarding)

(MFC) TLS Connection within SSH Tunnel (Port Forwarding)

CkTask *SshOpenTunnelAsync(const char *sshHostname, int sshPort);

Introduced in version 9.5.0.50

Creates an asynchronous task to call the SshOpenTunnel method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

void StartTiming(void);

Used in combination with the ElapsedSeconds property, which will contain the number of seconds since the last call to this method. (The StartTiming method and ElapsedSeconds property is provided for convenience.)

bool TakeSocket(CkSocket &sock);

Takes ownership of the sock. sock is added to the internal set of connected sockets. The caller object is now effectively a "socket set", i.e. a collection of connected sockets. Method calls are routed to the internal sockets based on the value of the SelectorIndex property. For example, if SelectorIndex equals 2, then a call to SendBytes is actually a call to SendBytes on the 3rd socket in the set. (Indexing begins at 0.) Likewise, getting and setting properties are also routed to the contained socket based on SelectorIndex. It is possible to wait on a set of sockets for data to arrive on any of them by calling SelectForReading. See the example link below.

Returns true for success, false for failure.

(C++) Socket Select for Reading

(MFC) Socket Select for Reading

bool TlsRenegotiate(void);

Introduced in version 9.5.0.55

Initiates a renegotiation of the TLS security parameters. This sends a ClientHello to re-do the TLS handshake to establish new TLS security params.

Returns true for success, false for failure.

CkTask *TlsRenegotiateAsync(void);

Introduced in version 9.5.0.55

Creates an asynchronous task to call the TlsRenegotiate method with the arguments provided. (Async methods are available starting in Chilkat v9.5.0.52.)

Note: Async method event callbacks happen in the background thread. Accessing and updating UI elements existing in the main thread may require special considerations.

Note: The application is responsible for deleting (via the C++ delete operator) the object returned by this method.

Returns NULL on failure

(C++) How to Run an Asynchronous Task

(MFC) How to Run an Asynchronous Task

bool UnlockComponent(const char *unlockCode);

Unlocks the component allowing for the full functionality to be used. An arbitrary string can be passed to initiate a fully-functional 30-day trial.

Returns true for success, false for failure.

Diagnosing UnlockComponent Problems

UnlockComponent LastErrorText shows exact string passed to it.

Verify UnlockComponent Success w/ Purchased Unlock Code

LastErrorText Standard Information

bool UseSsh(CkSsh &ssh);

Introduced in version 9.5.0.55

Uses an existing SSH tunnel for the connection. This is an alternative way of establishing a socket connection through an SSH tunnel. There are four ways of running a TCP or SSL/TLS connection through an SSH tunnel:

  1. UseSsh
    1. Establish the SSH connection and authenticate using the Chilkat SSH object.
    2. Call UseSsh to indicate that the connections should be made through the SSH tunnel.
    3. Call the Connect method to establish the TCP or SSL/TLS connection with a destination host:port. The connection is not direct, but will instead be routed through the SSH tunnel and then port-forwarded (from the SSH server) to the destination host:port. (Had UseSsh not been called, the connection would be direct.)
  2. SshOpenTunnel
    1. Call the Socket object's SshOpenTunnel method to connect to an SSH server.
    2. Call SshAuthenticatePw to authenticate with the SSH server.
    3. Instead of calling Connect to connect with the destination host:port, the SshOpenChannel method is called to connect via port-forwarding through the SSH tunnel.
  3. SshTunnel object with dynamic port forwarding
    1. The Chilkat SSH Tunnel object is utilized to run in a background thread. It connects and authenticates with an SSH server, and then listens at a port chosen by the application, and behaves as a SOCKS5 proxy server.
    2. The Socket object sets the SOCKS5 proxy host:port to localhost:<port>,
    3. The Socket's Connect method is called to connect via the SSH Tunnel. The connection is routed through the SSH tunnel via dynamic port forwarding.
    4. Once the background SSH Tunnel thread is running, it can handle any number of incoming connections from the foreground thread, other threads, or even other programs that are local or remote. Each incoming connection is routed via dynamic port forwarding to it's chosen destnation host:port on it's own logical SSH channel.
  4. SshTunnel object with hard-coded port forwarding
    1. The Chilkat SSH Tunnel object is utilized to run in a background thread. It connects and authenticates with an SSH server, and then listens at a port chosen by the application. It does not behave as a SOCKS5 proxy server, but instead has a hard-coded destination host:port.
    2. The Socket's Connect method is called to connect to localhost:<port>. The connection is automatically port-forwarded through the SSH tunnel to the hard-coded destination host:port.
In all cases, the SSH tunnels can hold both unencrypted TCP connections and SSL/TLS connections.

Returns true for success, false for failure.

(C++) TCP or TLS over Multiple Hop SSH to Remote Server

(MFC) TCP or TLS over Multiple Hop SSH to Remote Server

Events

To implement an event callback, your application would define and implement a class that inherits from CkBaseProgress. Your application can implement methods to override some or all of the default/empty method implementations of the CkBaseProgress base class.

For example:

  CkSocket socket;

  MySocketProgress callbackObj;

  socket.put_EventCallbackObject(&callbackObj);

MySocketProgress example:

#include "CkBaseProgress.h"

class MySocketProgress : public CkBaseProgress {

  public:
    MySocketProgress();
    virtual ~MySocketProgress();

    void AbortCheck(bool  *abort);

    void BinaryData(const void *data, unsigned int length);

    void PercentDone(int pctDone, bool  *abort);

    void ProgressInfo(const char *name, const char *value);

    void TaskCompleted(CkTask &task);

    void TextData(const char *data);

};

void AbortCheck(bool *abort);

Provides the opportunity for a method call to be aborted. The AbortCheck event is fired periodically based on the value of the HeartbeatMs property. If HeartbeatMs is 0, then no AbortCheck events will fire. As an example, to fire 5 AbortCheck events per second, set the HeartbeatMs property equal to 200.

void BinaryData(const void *data, unsigned int length);

Binary data provided by certain methods.

void PercentDone(int pctDone, bool *abort);

Provides the percentage completed for any method that involves network communications or time-consuming processing (assuming it is a method where a percentage completion can be measured). This event is only fired when it is possible to know a percentage completion, and when it makes sense to express the operation as a percentage completed. The pctDone argument will have a value from 1 to 100. For operations (Chilkat method calls) that complete very quickly, the number of PercentDone callbacks will vary, but the final callback should have a value of 100. For long running operations, no more than one callback per percentage point will occur (for example: 1, 2, 3, ... 98, 99, 100).

The PercentDone callback counts as an AbortCheck event. For method calls that complete quickly such that PercentDone events fire, it may be that AbortCheck events don't fire because the opportunity to abort is already provided in the PercentDone callback. For time consuming operations, where the amount of time between PercentDone callbacks are long, AbortCheck callbacks may be used to allow for the operation to be aborted in a more responsive manner.

The abort output argument provides a means for aborting the operation. Setting it to true will cause the method to abort and return a failed status (or whatever return value indicates failure).

void ProgressInfo(const char *name, const char *value);

A general name/value event that provides information about what is happening during a method call. To find out what information is available, write code to handle this event and log the name/value pairs. Most are self-explanatory.

void TaskCompleted(CkTask &task);

Called in the background thread when an asynchronous task completes.

void TextData(const char *data);

Text data provided by certain methods.