// CkSshW.h: interface for the CkSshW class.
//
//////////////////////////////////////////////////////////////////////

// This header is generated for Chilkat 11.3.0

#ifndef _CkSshW_H
#define _CkSshW_H
	
#include "chilkatDefs.h"
#include "CkString.h"
#include "CkClassWithCallbacksW.h"

class CkSshKeyW;
class CkTaskW;
class CkSecureStringW;
class CkStringArrayW;
class CkByteData;
class CkJsonObjectW;
class CkBaseProgressW;



#if !defined(__sun__) && !defined(__sun)
#pragma pack (push, 8)
#endif
 

// CLASS: CkSshW
class CK_VISIBLE_PUBLIC CkSshW  : public CkClassWithCallbacksW
{
	private:
	bool m_cbOwned;

	private:
	
	// Don't allow assignment or copying these objects.
	CkSshW(const CkSshW &);
	CkSshW &operator=(const CkSshW &);

    public:
	CkSshW(void);
	virtual ~CkSshW(void);

	

	static CkSshW *createNew(void);
	

	CkSshW(bool bCallbackOwned);
	static CkSshW *createNew(bool bCallbackOwned);

	
	void CK_VISIBLE_PRIVATE inject(void *impl);

	// May be called when finished with the object to free/dispose of any
	// internal resources held by the object. 
	void dispose(void);

	CkBaseProgressW *get_EventCallbackObject(void) const;
	void put_EventCallbackObject(CkBaseProgressW *progress);


	// BEGIN PUBLIC INTERFACE

	// ----------------------
	// Properties
	// ----------------------
	// When set to true, causes the currently running method to abort. Methods that
	// always finish quickly (i.e.have no length file operations or network
	// communications) are not affected. If no method is running, then this property is
	// automatically reset to false when the next method is called. When the abort
	// occurs, this property is reset to false. Both synchronous and asynchronous
	// method calls can be aborted. (A synchronous method call could be aborted by
	// setting this property from a separate thread.)
	bool get_AbortCurrent(void);
	// When set to true, causes the currently running method to abort. Methods that
	// always finish quickly (i.e.have no length file operations or network
	// communications) are not affected. If no method is running, then this property is
	// automatically reset to false when the next method is called. When the abort
	// occurs, this property is reset to false. Both synchronous and asynchronous
	// method calls can be aborted. (A synchronous method call could be aborted by
	// setting this property from a separate thread.)
	void put_AbortCurrent(bool newVal);

	// Set to one of the following values if a call to AuthenticatePw, AuthenticatePk,
	// or AuthenticatePwPk returns a failed status.
	//     * 1: Transport failure. This is a failure to communicate with the server
	//     (i.e. the connection was lost, or a read or write failed or timed out).
	//     * 2: Invalid key for public key authentication. The key was not a valid
	//     format, not a valid key, not a private key, or not the right type of key.
	//     * 3: No matching authentication methods were available.
	//     * 4: SSH authentication protocol error - an unexpected or invalid message
	//     was received.
	//     * 5: The incorrect password or private key was provided.
	//     * 6: Already authenticated. The SSH session is already authenticated.
	//     * 7: Password change request: The server requires the password to be
	//     changed.
	int get_AuthFailReason(void);

	// Controls whether the caret character '^' is interpreted as indicating a control
	// character. The default value of this property is false. If set to true, then
	// the following sequences are interpreted as control characters in any string
	// passed to SendReqExec or ChannelSendString.^@ 	00 	00 	NUL  	Null
	// ^A 	01 	01 	SOH  	Start of Heading
	// ^B 	02 	02 	STX  	Start of Text
	// ^C 	03 	03 	ETX  	End of Text
	// ^D 	04 	04 	EOT  	End of Transmission
	// ^E 	05 	05 	ENQ  	Enquiry
	// ^F 	06 	06 	ACK  	Acknowledge
	// ^G 	07 	07 	BEL  	Bell
	// ^H 	08 	08 	BS  	Backspace
	// ^I 	09 	09 	HT  	Character Tabulation, Horizontal Tabulation
	// ^J 	10 	0A 	LF  	Line Feed
	// ^K 	11 	0B 	VT  	Line Tabulation, Vertical Tabulation
	// ^L 	12 	0C 	FF  	Form Feed
	// ^M 	13 	0D 	CR  	Carriage Return
	// ^N 	14 	0E 	SO  	Shift Out
	// ^O 	15 	0F 	SI  	Shift In
	// ^P 	16 	10 	DLE  	Data Link Escape
	// ^Q 	17 	11 	DC1  	Device Control One (XON)
	// ^R 	18 	12 	DC2  	Device Control Two
	// ^S 	19 	13 	DC3  	Device Control Three (XOFF)
	// ^T 	20 	14 	DC4  	Device Control Four
	// ^U 	21 	15 	NAK  	Negative Acknowledge
	// ^V 	22 	16 	SYN  	Synchronous Idle
	// ^W 	23 	17 	ETB  	End of Transmission Block
	// ^X 	24 	18 	CAN  	Cancel
	// ^Y 	25 	19 	EM  	End of medium
	// ^Z 	26 	1A 	SUB  	Substitute
	// ^[ 	27 	1B 	ESC  	Escape
	// ^\ 	28 	1C 	FS  	File Separator
	// ^] 	29 	1D 	GS  	Group Separator
	// ^^ 	30 	1E 	RS  	Record Separator
	// ^_ 	31 	1F 	US  	Unit Separator
	// ^? 	127 	7F 	DEL  	Delete
	bool get_CaretControl(void);
	// Controls whether the caret character '^' is interpreted as indicating a control
	// character. The default value of this property is false. If set to true, then
	// the following sequences are interpreted as control characters in any string
	// passed to SendReqExec or ChannelSendString.^@ 	00 	00 	NUL  	Null
	// ^A 	01 	01 	SOH  	Start of Heading
	// ^B 	02 	02 	STX  	Start of Text
	// ^C 	03 	03 	ETX  	End of Text
	// ^D 	04 	04 	EOT  	End of Transmission
	// ^E 	05 	05 	ENQ  	Enquiry
	// ^F 	06 	06 	ACK  	Acknowledge
	// ^G 	07 	07 	BEL  	Bell
	// ^H 	08 	08 	BS  	Backspace
	// ^I 	09 	09 	HT  	Character Tabulation, Horizontal Tabulation
	// ^J 	10 	0A 	LF  	Line Feed
	// ^K 	11 	0B 	VT  	Line Tabulation, Vertical Tabulation
	// ^L 	12 	0C 	FF  	Form Feed
	// ^M 	13 	0D 	CR  	Carriage Return
	// ^N 	14 	0E 	SO  	Shift Out
	// ^O 	15 	0F 	SI  	Shift In
	// ^P 	16 	10 	DLE  	Data Link Escape
	// ^Q 	17 	11 	DC1  	Device Control One (XON)
	// ^R 	18 	12 	DC2  	Device Control Two
	// ^S 	19 	13 	DC3  	Device Control Three (XOFF)
	// ^T 	20 	14 	DC4  	Device Control Four
	// ^U 	21 	15 	NAK  	Negative Acknowledge
	// ^V 	22 	16 	SYN  	Synchronous Idle
	// ^W 	23 	17 	ETB  	End of Transmission Block
	// ^X 	24 	18 	CAN  	Cancel
	// ^Y 	25 	19 	EM  	End of medium
	// ^Z 	26 	1A 	SUB  	Substitute
	// ^[ 	27 	1B 	ESC  	Escape
	// ^\ 	28 	1C 	FS  	File Separator
	// ^] 	29 	1D 	GS  	Group Separator
	// ^^ 	30 	1E 	RS  	Record Separator
	// ^_ 	31 	1F 	US  	Unit Separator
	// ^? 	127 	7F 	DEL  	Delete
	void put_CaretControl(bool newVal);

	// If a request to open a channel fails, this property contains a code that
	// identifies the reason for failure. The reason codes are defined in RFC 4254 and
	// are reproduced here:             Symbolic name                           reason code
	//              -------------                           -----------
	//             SSH_OPEN_ADMINISTRATIVELY_PROHIBITED          1
	//             SSH_OPEN_CONNECT_FAILED                       2
	//             SSH_OPEN_UNKNOWN_CHANNEL_TYPE                 3
	//             SSH_OPEN_RESOURCE_SHORTAGE                    4
	int get_ChannelOpenFailCode(void);

	// The descriptive text corresponding to the ChannelOpenFailCode property.
	void get_ChannelOpenFailReason(CkString &str);
	// The descriptive text corresponding to the ChannelOpenFailCode property.
	const wchar_t *channelOpenFailReason(void);

	// The client-identifier string to be used when connecting to an SSH/SFTP server.
	// Starting in Chilkat v9.5.0.99, the default is SSH-2.0-Chilkat_ + the Chilkat
	// version number, such as SSH-2.0-Chilkat_9.5.0.99 .
	// 
	// Note: The client identifier should always begin with SSH-2.0- . SSH servers may
	// disconnect if it does not.
	// 
	void get_ClientIdentifier(CkString &str);
	// The client-identifier string to be used when connecting to an SSH/SFTP server.
	// Starting in Chilkat v9.5.0.99, the default is SSH-2.0-Chilkat_ + the Chilkat
	// version number, such as SSH-2.0-Chilkat_9.5.0.99 .
	// 
	// Note: The client identifier should always begin with SSH-2.0- . SSH servers may
	// disconnect if it does not.
	// 
	const wchar_t *clientIdentifier(void);
	// The client-identifier string to be used when connecting to an SSH/SFTP server.
	// Starting in Chilkat v9.5.0.99, the default is SSH-2.0-Chilkat_ + the Chilkat
	// version number, such as SSH-2.0-Chilkat_9.5.0.99 .
	// 
	// Note: The client identifier should always begin with SSH-2.0- . SSH servers may
	// disconnect if it does not.
	// 
	void put_ClientIdentifier(const wchar_t *newVal);

	// The IP address to use for computers with multiple network interfaces or IP
	// addresses. For computers with a single network interface (i.e. most computers),
	// this property should not be set. For multihoming computers, the default IP
	// address is automatically used if this property is not set.
	// 
	// The IP address is a string such as in dotted notation using numbers, not domain
	// names, such as 165.164.55.124 .
	// 
	void get_ClientIpAddress(CkString &str);
	// The IP address to use for computers with multiple network interfaces or IP
	// addresses. For computers with a single network interface (i.e. most computers),
	// this property should not be set. For multihoming computers, the default IP
	// address is automatically used if this property is not set.
	// 
	// The IP address is a string such as in dotted notation using numbers, not domain
	// names, such as 165.164.55.124 .
	// 
	const wchar_t *clientIpAddress(void);
	// The IP address to use for computers with multiple network interfaces or IP
	// addresses. For computers with a single network interface (i.e. most computers),
	// this property should not be set. For multihoming computers, the default IP
	// address is automatically used if this property is not set.
	// 
	// The IP address is a string such as in dotted notation using numbers, not domain
	// names, such as 165.164.55.124 .
	// 
	void put_ClientIpAddress(const wchar_t *newVal);

	// 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_ClientPort(void);
	// 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."
	// 
	void put_ClientPort(int newVal);

	// Maximum number of milliseconds to wait when connecting to an SSH server.
	int get_ConnectTimeoutMs(void);
	// Maximum number of milliseconds to wait when connecting to an SSH server.
	void put_ConnectTimeoutMs(int newVal);

	// If the SSH server sent a DISCONNECT message when closing the connection, this
	// property contains the reason code as specified in RFC 4253:           Symbolic name                                reason code
	//            -------------                                -----------
	//       SSH_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT             1
	//       SSH_DISCONNECT_PROTOCOL_ERROR                          2
	//       SSH_DISCONNECT_KEY_EXCHANGE_FAILED                     3
	//       SSH_DISCONNECT_RESERVED                                4
	//       SSH_DISCONNECT_MAC_ERROR                               5
	//       SSH_DISCONNECT_COMPRESSION_ERROR                       6
	//       SSH_DISCONNECT_SERVICE_NOT_AVAILABLE                   7
	//       SSH_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED          8
	//       SSH_DISCONNECT_HOST_KEY_NOT_VERIFIABLE                 9
	//       SSH_DISCONNECT_CONNECTION_LOST                        10
	//       SSH_DISCONNECT_BY_APPLICATION                         11
	//       SSH_DISCONNECT_TOO_MANY_CONNECTIONS                   12
	//       SSH_DISCONNECT_AUTH_CANCELLED_BY_USER                 13
	//       SSH_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE         14
	//       SSH_DISCONNECT_ILLEGAL_USER_NAME                      15
	int get_DisconnectCode(void);

	// If the SSH/ server sent a DISCONNECT message when closing the connection, this
	// property contains a descriptive string for the reason code as specified in RFC
	// 4253.
	void get_DisconnectReason(CkString &str);
	// If the SSH/ server sent a DISCONNECT message when closing the connection, this
	// property contains a descriptive string for the reason code as specified in RFC
	// 4253.
	const wchar_t *disconnectReason(void);

	// Enables or disables the use of compression w/ the SSH connection. The default
	// value is true, meaning that compression is used if the server supports it.
	// 
	// Some older SSH servers have been found that claim to support compression, but
	// actually fail when compression is used. PuTTY does not enable compression by
	// default. If trouble is encountered where the SSH server disconnects immediately
	// after the connection is seemingly established (i.e. during authentication), then
	// check to see if disabling compression resolves the problem.
	// 
	bool get_EnableCompression(void);
	// Enables or disables the use of compression w/ the SSH connection. The default
	// value is true, meaning that compression is used if the server supports it.
	// 
	// Some older SSH servers have been found that claim to support compression, but
	// actually fail when compression is used. PuTTY does not enable compression by
	// default. If trouble is encountered where the SSH server disconnects immediately
	// after the connection is seemingly established (i.e. during authentication), then
	// check to see if disabling compression resolves the problem.
	// 
	void put_EnableCompression(bool newVal);

	// Allows for the application to specify an encryption algorithm (cipher) or a
	// comma-separated list of algorithms that are acceptable. If this property is set,
	// then the SSH connection will use one of the specified ciphers.
	// 
	// Possible algorithms are:
	//     * chacha20-poly1305@openssh.com
	//     * aes128-ctr
	//     * aes256-ctr
	//     * aes192-ctr
	//     * aes128-cbc
	//     * aes256-cbc
	//     * aes192-cbc
	//     * aes128-gcm@openssh.com
	//     * aes256-gcm@openssh.com
	//     * twofish256-cbc
	//     * twofish128-cbc
	//     * blowfish-cbc
	//     * 3des-cbc
	//     * arcfour128
	//     * arcfour256
	// 
	// This property is empty by default, which means the encryption chosen will be the
	// 1st on the above list (in the order listed above) that is also implemented by
	// the server.
	// 
	// Note: The cipher(s) must be specified using the exact spelling in lowercase as
	// shown above.
	// 
	// Important: If this is property is set and the server does NOT support then
	// encryption algorithm, then the Connect will fail.
	// 
	void get_ForceCipher(CkString &str);
	// Allows for the application to specify an encryption algorithm (cipher) or a
	// comma-separated list of algorithms that are acceptable. If this property is set,
	// then the SSH connection will use one of the specified ciphers.
	// 
	// Possible algorithms are:
	//     * chacha20-poly1305@openssh.com
	//     * aes128-ctr
	//     * aes256-ctr
	//     * aes192-ctr
	//     * aes128-cbc
	//     * aes256-cbc
	//     * aes192-cbc
	//     * aes128-gcm@openssh.com
	//     * aes256-gcm@openssh.com
	//     * twofish256-cbc
	//     * twofish128-cbc
	//     * blowfish-cbc
	//     * 3des-cbc
	//     * arcfour128
	//     * arcfour256
	// 
	// This property is empty by default, which means the encryption chosen will be the
	// 1st on the above list (in the order listed above) that is also implemented by
	// the server.
	// 
	// Note: The cipher(s) must be specified using the exact spelling in lowercase as
	// shown above.
	// 
	// Important: If this is property is set and the server does NOT support then
	// encryption algorithm, then the Connect will fail.
	// 
	const wchar_t *forceCipher(void);
	// Allows for the application to specify an encryption algorithm (cipher) or a
	// comma-separated list of algorithms that are acceptable. If this property is set,
	// then the SSH connection will use one of the specified ciphers.
	// 
	// Possible algorithms are:
	//     * chacha20-poly1305@openssh.com
	//     * aes128-ctr
	//     * aes256-ctr
	//     * aes192-ctr
	//     * aes128-cbc
	//     * aes256-cbc
	//     * aes192-cbc
	//     * aes128-gcm@openssh.com
	//     * aes256-gcm@openssh.com
	//     * twofish256-cbc
	//     * twofish128-cbc
	//     * blowfish-cbc
	//     * 3des-cbc
	//     * arcfour128
	//     * arcfour256
	// 
	// This property is empty by default, which means the encryption chosen will be the
	// 1st on the above list (in the order listed above) that is also implemented by
	// the server.
	// 
	// Note: The cipher(s) must be specified using the exact spelling in lowercase as
	// shown above.
	// 
	// Important: If this is property is set and the server does NOT support then
	// encryption algorithm, then the Connect will fail.
	// 
	void put_ForceCipher(const wchar_t *newVal);

	// The interval in milliseconds between each AbortCheck event callback, which
	// enables an application to abort certain method calls before they complete. By
	// default, HeartbeatMs is set to 0 , meaning no AbortCheck event callbacks will
	// trigger.
	// 
	// References:
	// 1: #AbortCheck
	int get_HeartbeatMs(void);
	// The interval in milliseconds between each AbortCheck event callback, which
	// enables an application to abort certain method calls before they complete. By
	// default, HeartbeatMs is set to 0 , meaning no AbortCheck event callbacks will
	// trigger.
	// 
	// References:
	// 1: #AbortCheck
	void put_HeartbeatMs(int newVal);

	// Indicates the preferred host key algorithm to be used in establishing the SSH
	// secure connection. The default is DSS . It may be changed to RSA if needed.
	// Chilkat recommends not changing this unless a problem warrants the change.
	void get_HostKeyAlg(CkString &str);
	// Indicates the preferred host key algorithm to be used in establishing the SSH
	// secure connection. The default is DSS . It may be changed to RSA if needed.
	// Chilkat recommends not changing this unless a problem warrants the change.
	const wchar_t *hostKeyAlg(void);
	// Indicates the preferred host key algorithm to be used in establishing the SSH
	// secure connection. The default is DSS . It may be changed to RSA if needed.
	// Chilkat recommends not changing this unless a problem warrants the change.
	void put_HostKeyAlg(const wchar_t *newVal);

	// Set after connecting to an SSH server. The format of the fingerprint looks like
	// this: ssh-rsa 1024 68:ff:d1:4e:6c:ff:d7:b0:d6:58:73:85:07:bc:2e:d5
	void get_HostKeyFingerprint(CkString &str);
	// Set after connecting to an SSH server. The format of the fingerprint looks like
	// this: ssh-rsa 1024 68:ff:d1:4e:6c:ff:d7:b0:d6:58:73:85:07:bc:2e:d5
	const wchar_t *hostKeyFingerprint(void);

	// 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_HttpProxyAuthMethod(CkString &str);
	// 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 .
	const wchar_t *httpProxyAuthMethod(void);
	// 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 put_HttpProxyAuthMethod(const wchar_t *newVal);

	// The NTLM authentication domain (optional) if NTLM authentication is used w/ the
	// HTTP proxy.
	void get_HttpProxyDomain(CkString &str);
	// The NTLM authentication domain (optional) if NTLM authentication is used w/ the
	// HTTP proxy.
	const wchar_t *httpProxyDomain(void);
	// The NTLM authentication domain (optional) if NTLM authentication is used w/ the
	// HTTP proxy.
	void put_HttpProxyDomain(const wchar_t *newVal);

	// 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_HttpProxyHostname(CkString &str);
	// If an HTTP proxy is to be used, set this property to the HTTP proxy hostname or
	// IPv4 address (in dotted decimal notation).
	const wchar_t *httpProxyHostname(void);
	// If an HTTP proxy is to be used, set this property to the HTTP proxy hostname or
	// IPv4 address (in dotted decimal notation).
	void put_HttpProxyHostname(const wchar_t *newVal);

	// If an HTTP proxy requiring authentication is to be used, set this property to
	// the HTTP proxy password.
	void get_HttpProxyPassword(CkString &str);
	// If an HTTP proxy requiring authentication is to be used, set this property to
	// the HTTP proxy password.
	const wchar_t *httpProxyPassword(void);
	// If an HTTP proxy requiring authentication is to be used, set this property to
	// the HTTP proxy password.
	void put_HttpProxyPassword(const wchar_t *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.)
	int get_HttpProxyPort(void);
	// 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 put_HttpProxyPort(int newVal);

	// If an HTTP proxy requiring authentication is to be used, set this property to
	// the HTTP proxy login name.
	void get_HttpProxyUsername(CkString &str);
	// If an HTTP proxy requiring authentication is to be used, set this property to
	// the HTTP proxy login name.
	const wchar_t *httpProxyUsername(void);
	// If an HTTP proxy requiring authentication is to be used, set this property to
	// the HTTP proxy login name.
	void put_HttpProxyUsername(const wchar_t *newVal);

	// Causes SSH operations to fail when progress for sending or receiving data halts
	// for more than this number of milliseconds. Setting IdleTimeoutMs = 0 (the
	// default) allows the application to wait indefinitely.
	int get_IdleTimeoutMs(void);
	// Causes SSH operations to fail when progress for sending or receiving data halts
	// for more than this number of milliseconds. Setting IdleTimeoutMs = 0 (the
	// default) allows the application to wait indefinitely.
	void put_IdleTimeoutMs(int newVal);

	// Returns true if the last known state of the connection with the SSH server is
	// connected .
	// 
	// Note: The IsConnected property is set to true after successfully completing
	// the Connect method call. The IsConnected property will only be set to false by
	// calling Disconnect, or by the failure of another method call such that the
	// disconnection is detected.
	// 
	// If the last communications with the SSH server was successful and then a long
	// time passes with no communications, and the server disconnects because of
	// inactivity, then IsConnected will still indicate true. A better way of testing
	// the connection is to call SendIgnore after checking to see if IsConnected is
	// true. (If IsConnected is false, then there is surely no connection.)
	// 
	bool get_IsConnected(void);

	// Controls whether communications to/from the SSH server are saved to the
	// SessionLog property. The default value is false. If this property is set to
	// true, the contents of the SessionLog property will continuously grow as SSH
	// activity transpires. The purpose of the KeepSessionLog / SessionLog properties
	// is to help in debugging any future problems that may arise.
	bool get_KeepSessionLog(void);
	// Controls whether communications to/from the SSH server are saved to the
	// SessionLog property. The default value is false. If this property is set to
	// true, the contents of the SessionLog property will continuously grow as SSH
	// activity transpires. The purpose of the KeepSessionLog / SessionLog properties
	// is to help in debugging any future problems that may arise.
	void put_KeepSessionLog(bool newVal);

	// The maximum packet length to be used in the SSH transport protocol. The default
	// value is 8192.
	// 
	// Note: If a large amount of data is to be flowing to/from the SSH server, then
	// setting the MaxPacketSize equal to 32768 may improve performance. For those
	// familiar with the inner workings of the SSH protocol, this is the maximum packet
	// size value that is sent in the SSH_MSG_CHANNEL_OPEN message as defined in RFC
	// 4254.
	// 
	int get_MaxPacketSize(void);
	// The maximum packet length to be used in the SSH transport protocol. The default
	// value is 8192.
	// 
	// Note: If a large amount of data is to be flowing to/from the SSH server, then
	// setting the MaxPacketSize equal to 32768 may improve performance. For those
	// familiar with the inner workings of the SSH protocol, this is the maximum packet
	// size value that is sent in the SSH_MSG_CHANNEL_OPEN message as defined in RFC
	// 4254.
	// 
	void put_MaxPacketSize(int newVal);

	// The number of currently open channels.
	int get_NumOpenChannels(void);

	// Set by the AuthenticatePw and AuthenticatePwPk methods. If the authenticate
	// method returns a failed status, and this property is set to true, then it
	// indicates the server requested a password change. In this case, re-call the
	// authenticate method, but provide both the old and new passwords in the following
	// format, where vertical bar characters encapsulate the old and new passwords:
	// 
	//     |oldPassword|newPassword|
	// 
	bool get_PasswordChangeRequested(void);

	// If true, then use IPv6 over IPv4 when both are supported for a particular
	// domain. The default value of this property is false, which will choose IPv4
	// over IPv6.
	bool get_PreferIpv6(void);
	// If true, then use IPv6 over IPv4 when both are supported for a particular
	// domain. The default value of this property is false, which will choose IPv4
	// over IPv6.
	void put_PreferIpv6(bool newVal);

	// The maximum amount of time to allow for reading messages/data from the SSH
	// server. This is different from the IdleTimeoutMs property. The IdleTimeoutMs is
	// the maximum amount of time to wait while no incoming data is arriving. The
	// ReadTimeoutMs is the maximum amount of time to allow for reading data even if
	// data is continuing to arrive. The default value of 0 indicates an infinite
	// timeout value.
	int get_ReadTimeoutMs(void);
	// The maximum amount of time to allow for reading messages/data from the SSH
	// server. This is different from the IdleTimeoutMs property. The IdleTimeoutMs is
	// the maximum amount of time to wait while no incoming data is arriving. The
	// ReadTimeoutMs is the maximum amount of time to allow for reading data even if
	// data is continuing to arrive. The default value of 0 indicates an infinite
	// timeout value.
	void put_ReadTimeoutMs(int newVal);

	// Indicates the charset to be used for the command sent via the SendReqExec
	// method. The default is ANSI . A likely alternate value would be utf-8 .
	void get_ReqExecCharset(CkString &str);
	// Indicates the charset to be used for the command sent via the SendReqExec
	// method. The default is ANSI . A likely alternate value would be utf-8 .
	const wchar_t *reqExecCharset(void);
	// Indicates the charset to be used for the command sent via the SendReqExec
	// method. The default is ANSI . A likely alternate value would be utf-8 .
	void put_ReqExecCharset(const wchar_t *newVal);

	// The server-identifier string received from the server during connection
	// establishment. For example, a typical value would be similar to
	// SSH-2.0-OpenSSH_7.2p2 Ubuntu-4ubuntu2.2 .
	void get_ServerIdentifier(CkString &str);
	// The server-identifier string received from the server during connection
	// establishment. For example, a typical value would be similar to
	// SSH-2.0-OpenSSH_7.2p2 Ubuntu-4ubuntu2.2 .
	const wchar_t *serverIdentifier(void);

	// Contains a log of the messages sent to/from the SSH server. To enable session
	// logging, set the KeepSessionLog property = true. Note: This property is not a
	// filename -- it is a string property that contains the session log data.
	void get_SessionLog(CkString &str);
	// Contains a log of the messages sent to/from the SSH server. To enable session
	// logging, set the KeepSessionLog property = true. Note: This property is not a
	// filename -- it is a string property that contains the session log data.
	const wchar_t *sessionLog(void);

	// 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_SocksHostname(CkString &str);
	// 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).
	const wchar_t *socksHostname(void);
	// 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 put_SocksHostname(const wchar_t *newVal);

	// The SOCKS5 password (if required). The SOCKS4 protocol does not include the use
	// of a password, so this does not apply to SOCKS4.
	void get_SocksPassword(CkString &str);
	// The SOCKS5 password (if required). The SOCKS4 protocol does not include the use
	// of a password, so this does not apply to SOCKS4.
	const wchar_t *socksPassword(void);
	// The SOCKS5 password (if required). The SOCKS4 protocol does not include the use
	// of a password, so this does not apply to SOCKS4.
	void put_SocksPassword(const wchar_t *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).
	int get_SocksPort(void);
	// 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 put_SocksPort(int newVal);

	// The SOCKS4/SOCKS5 proxy username. This property is only used if the SocksVersion
	// property is set to 4 or 5).
	void get_SocksUsername(CkString &str);
	// The SOCKS4/SOCKS5 proxy username. This property is only used if the SocksVersion
	// property is set to 4 or 5).
	const wchar_t *socksUsername(void);
	// The SOCKS4/SOCKS5 proxy username. This property is only used if the SocksVersion
	// property is set to 4 or 5).
	void put_SocksUsername(const wchar_t *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_SocksVersion(void);
	// 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.
	// 
	void put_SocksVersion(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.
	// 
	int get_SoRcvBuf(void);
	// 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.
	// 
	void put_SoRcvBuf(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.
	// 
	int get_SoSndBuf(void);
	// 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.
	// 
	void put_SoSndBuf(int newVal);

	// If true, then stderr is redirected to stdout. In this case, channel output for
	// both stdout and stderr is combined and retrievable via the following methods:
	// GetReceivedData, GetReceivedDataN, GetReceivedText, GetReceivedTextS. If this
	// property is false, then stderr is available separately via the
	// GetReceivedStderr method.
	// 
	// The default value of this property is true.
	// 
	// Note: Most SSH servers do not send stderr output as extended data packets as
	// specified in RFC 4254. The SessionLog may be examined to see if any
	// CHANNEL_EXTENDED_DATA messages exist. If not, then all of the output (stdout +
	// stderr) was sent via CHANNEL_DATA messages, and therefore it is not possible to
	// differentiate stderr output from stdout. In summary: This feature will not work
	// for most SSH servers.
	// 
	bool get_StderrToStdout(void);
	// If true, then stderr is redirected to stdout. In this case, channel output for
	// both stdout and stderr is combined and retrievable via the following methods:
	// GetReceivedData, GetReceivedDataN, GetReceivedText, GetReceivedTextS. If this
	// property is false, then stderr is available separately via the
	// GetReceivedStderr method.
	// 
	// The default value of this property is true.
	// 
	// Note: Most SSH servers do not send stderr output as extended data packets as
	// specified in RFC 4254. The SessionLog may be examined to see if any
	// CHANNEL_EXTENDED_DATA messages exist. If not, then all of the output (stdout +
	// stderr) was sent via CHANNEL_DATA messages, and therefore it is not possible to
	// differentiate stderr output from stdout. In summary: This feature will not work
	// for most SSH servers.
	// 
	void put_StderrToStdout(bool newVal);

	// If true, then terminal color codes are stripped from the received text. The
	// default value of this property is true. (Color codes are non-printable escape
	// sequences that provide information about color for text in a terminal.)
	bool get_StripColorCodes(void);
	// If true, then terminal color codes are stripped from the received text. The
	// default value of this property is true. (Color codes are non-printable escape
	// sequences that provide information about color for text in a terminal.)
	void put_StripColorCodes(bool newVal);

	// Controls whether the TCP_NODELAY socket option is used for the underlying TCP/IP
	// socket. The default value is true. This disables the Nagle algorithm and
	// allows for better performance when small amounts of data are sent to/from the
	// SSH server.
	bool get_TcpNoDelay(void);
	// Controls whether the TCP_NODELAY socket option is used for the underlying TCP/IP
	// socket. The default value is true. This disables the Nagle algorithm and
	// allows for better performance when small amounts of data are sent to/from the
	// SSH server.
	void put_TcpNoDelay(bool newVal);

	// This is a catch-all property to be used for uncommon needs. This property
	// defaults to the empty string, and should typically remain empty.
	// 
	// Can be set to a list of the following comma separated keywords:
	//     * ForceUserAuthRsaSha1 - Introduced in v9.5.0.98. When doing public-key
	//     authentication, forces rsa-sha1 to be used for the userauth algorithm even if
	//     the server supports rsa-sha2-256, rsa-sha2-512, but still requires SHA1 for the
	//     userauth algorithm. Make sure to set this option before connecting to the
	//     server.
	//     * no-weak-mac-algs - Introduced in v9.5.0.98. Removes all weaker MAC
	//     algorithms from the list offered to the SSH server when negotiating the
	//     connection parameters during a Connect. Specifically, removes hmac-sha1-96,
	//     hmac-sha1, hmac-md5, and hmac-ripemd160. Note: Stronger algorithms such as
	//     hmac-sha2-256, hmac-sha2-512, etc., will already be automatically chosen because
	//     they are given higher preference. The only way a weaker algorithm is chosen is
	//     if the SSH server ONLY supports weaker algorithms. This option would only be set
	//     if you explicitly want to avoid connecting to older SSH servers, or servers
	//     configured in some unusual way where only weaker algorithms are supported on the
	//     server (which is rare).
	//     * ProtectFromVpn - Introduced in v9.5.0.80. On Android systems, will bypass
	//     any VPN that may be installed or active.
	//     * +ssh-hmac-etm - Introduced in v9.5.0.97. Version 9.5.0.97 disabled the
	//     *-etm MAC algorithms to mitigate the Terrapin attack. Use this keyword to
	//     include the etm MAC algorithms.
	//     * +chacha20-poly1305@openssh.com - Introduced in v9.5.0.97. To mitigate the
	//     Terrapin attack, chacha20-poly1305@openssh.com is no longer included by default.
	//     It can be re-added by adding this keyword.
	// 
	void get_UncommonOptions(CkString &str);
	// This is a catch-all property to be used for uncommon needs. This property
	// defaults to the empty string, and should typically remain empty.
	// 
	// Can be set to a list of the following comma separated keywords:
	//     * ForceUserAuthRsaSha1 - Introduced in v9.5.0.98. When doing public-key
	//     authentication, forces rsa-sha1 to be used for the userauth algorithm even if
	//     the server supports rsa-sha2-256, rsa-sha2-512, but still requires SHA1 for the
	//     userauth algorithm. Make sure to set this option before connecting to the
	//     server.
	//     * no-weak-mac-algs - Introduced in v9.5.0.98. Removes all weaker MAC
	//     algorithms from the list offered to the SSH server when negotiating the
	//     connection parameters during a Connect. Specifically, removes hmac-sha1-96,
	//     hmac-sha1, hmac-md5, and hmac-ripemd160. Note: Stronger algorithms such as
	//     hmac-sha2-256, hmac-sha2-512, etc., will already be automatically chosen because
	//     they are given higher preference. The only way a weaker algorithm is chosen is
	//     if the SSH server ONLY supports weaker algorithms. This option would only be set
	//     if you explicitly want to avoid connecting to older SSH servers, or servers
	//     configured in some unusual way where only weaker algorithms are supported on the
	//     server (which is rare).
	//     * ProtectFromVpn - Introduced in v9.5.0.80. On Android systems, will bypass
	//     any VPN that may be installed or active.
	//     * +ssh-hmac-etm - Introduced in v9.5.0.97. Version 9.5.0.97 disabled the
	//     *-etm MAC algorithms to mitigate the Terrapin attack. Use this keyword to
	//     include the etm MAC algorithms.
	//     * +chacha20-poly1305@openssh.com - Introduced in v9.5.0.97. To mitigate the
	//     Terrapin attack, chacha20-poly1305@openssh.com is no longer included by default.
	//     It can be re-added by adding this keyword.
	// 
	const wchar_t *uncommonOptions(void);
	// This is a catch-all property to be used for uncommon needs. This property
	// defaults to the empty string, and should typically remain empty.
	// 
	// Can be set to a list of the following comma separated keywords:
	//     * ForceUserAuthRsaSha1 - Introduced in v9.5.0.98. When doing public-key
	//     authentication, forces rsa-sha1 to be used for the userauth algorithm even if
	//     the server supports rsa-sha2-256, rsa-sha2-512, but still requires SHA1 for the
	//     userauth algorithm. Make sure to set this option before connecting to the
	//     server.
	//     * no-weak-mac-algs - Introduced in v9.5.0.98. Removes all weaker MAC
	//     algorithms from the list offered to the SSH server when negotiating the
	//     connection parameters during a Connect. Specifically, removes hmac-sha1-96,
	//     hmac-sha1, hmac-md5, and hmac-ripemd160. Note: Stronger algorithms such as
	//     hmac-sha2-256, hmac-sha2-512, etc., will already be automatically chosen because
	//     they are given higher preference. The only way a weaker algorithm is chosen is
	//     if the SSH server ONLY supports weaker algorithms. This option would only be set
	//     if you explicitly want to avoid connecting to older SSH servers, or servers
	//     configured in some unusual way where only weaker algorithms are supported on the
	//     server (which is rare).
	//     * ProtectFromVpn - Introduced in v9.5.0.80. On Android systems, will bypass
	//     any VPN that may be installed or active.
	//     * +ssh-hmac-etm - Introduced in v9.5.0.97. Version 9.5.0.97 disabled the
	//     *-etm MAC algorithms to mitigate the Terrapin attack. Use this keyword to
	//     include the etm MAC algorithms.
	//     * +chacha20-poly1305@openssh.com - Introduced in v9.5.0.97. To mitigate the
	//     Terrapin attack, chacha20-poly1305@openssh.com is no longer included by default.
	//     It can be re-added by adding this keyword.
	// 
	void put_UncommonOptions(const wchar_t *newVal);

	// If a user authentication banner message is received during authentication, it
	// will be made available here. An application can check to see if this property
	// contains a banner string after calling StartKeyboardAuth. It is only possible
	// for an application to display this message if it is doing keyboard-interactive
	// authentication via the StartKeyboardAuth and ContinueKeyboardAuth methods.
	void get_UserAuthBanner(CkString &str);
	// If a user authentication banner message is received during authentication, it
	// will be made available here. An application can check to see if this property
	// contains a banner string after calling StartKeyboardAuth. It is only possible
	// for an application to display this message if it is doing keyboard-interactive
	// authentication via the StartKeyboardAuth and ContinueKeyboardAuth methods.
	const wchar_t *userAuthBanner(void);
	// If a user authentication banner message is received during authentication, it
	// will be made available here. An application can check to see if this property
	// contains a banner string after calling StartKeyboardAuth. It is only possible
	// for an application to display this message if it is doing keyboard-interactive
	// authentication via the StartKeyboardAuth and ContinueKeyboardAuth methods.
	void put_UserAuthBanner(const wchar_t *newVal);



	// ----------------------
	// Methods
	// ----------------------
	// Authenticates with the SSH server using public-key authentication. The
	// corresponding public key must have been installed on the SSH server for the
	// username. 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.
	// 
	bool AuthenticatePk(const wchar_t *username, CkSshKeyW &privateKey);

	// Creates an asynchronous task to call the AuthenticatePk method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *AuthenticatePkAsync(const wchar_t *username, CkSshKeyW &privateKey);

	// Authenticates with the SSH server using a login and password.
	// 
	// An SSH session always begins by first calling Connect to connect to the SSH
	// server, and then calling either AuthenticatePw or AuthenticatePk to login.
	// 
	// Important: When reporting problems, please send the full contents of the
	// LastErrorText property to support@chilkatsoft.com.
	// Note: To learn about how to handle password change requests, see the
	// PasswordChangeRequested property (above).
	// 
	bool AuthenticatePw(const wchar_t *login, const wchar_t *password);

	// Creates an asynchronous task to call the AuthenticatePw method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *AuthenticatePwAsync(const wchar_t *login, const wchar_t *password);

	// Authentication for SSH servers that require both a password and private key.
	// (Most SSH servers are configured to require one or the other, but not both.)
	// 
	// Important: When reporting problems, please send the full contents of the
	// LastErrorText property to support@chilkatsoft.com.
	// 
	bool AuthenticatePwPk(const wchar_t *username, const wchar_t *password, CkSshKeyW &privateKey);

	// Creates an asynchronous task to call the AuthenticatePwPk method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *AuthenticatePwPkAsync(const wchar_t *username, const wchar_t *password, CkSshKeyW &privateKey);

	// The same as AuthenticatePw, except the login and passwords strings are passed in
	// secure string objects.
	bool AuthenticateSecPw(CkSecureStringW &login, CkSecureStringW &password);

	// Creates an asynchronous task to call the AuthenticateSecPw method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *AuthenticateSecPwAsync(CkSecureStringW &login, CkSecureStringW &password);

	// The same as AuthenticatePwPk, except the login and passwords strings are passed
	// in secure string objects.
	bool AuthenticateSecPwPk(CkSecureStringW &username, CkSecureStringW &password, CkSshKeyW &privateKey);

	// Creates an asynchronous task to call the AuthenticateSecPwPk method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *AuthenticateSecPwPkAsync(CkSecureStringW &username, CkSecureStringW &password, CkSshKeyW &privateKey);

	// Returns true if the channel indicated by channelNum is open. Otherwise returns
	// false.
	bool ChannelIsOpen(int channelNum);

	// Polls for incoming data on an open channel. This method will read a channel,
	// waiting at most pollTimeoutMs milliseconds for data to arrive. Return values are as
	// follows:
	// 
	// -1 -- Error. Check the IsConnected property to see if the connection to the SSH
	// server is still valid. Also, call ChannelIsOpen to see if the channel remains
	// open. The LastErrorText property will contain more detailed information
	// regarding the error.
	// 
	// -2 -- No additional data was received prior to the poll timeout.
	// 
	// >0 -- Additional data was received and the return value indicates how many bytes
	// are available to be picked up . Methods that read data on a channel do not
	// return the received data directly. Instead, they return an integer to indicate
	// how many bytes are available to be picked up . An application picks up the
	// available data by calling GetReceivedData or GetReceivedText.
	// 
	// =0 -- A zero can be returned if the channel EOF has already been received, or if
	// the channel had already been closed.
	// 
	int ChannelPoll(int channelNum, int pollTimeoutMs);

	// Creates an asynchronous task to call the ChannelPoll method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *ChannelPollAsync(int channelNum, int pollTimeoutMs);

	// Reads incoming data on an open channel. This method will read a channel, waiting
	// at most IdleTimeoutMs milliseconds for data to arrive. Return values are as
	// follows:
	// 
	// -1 -- Error. Check the IsConnected property to see if the connection to the SSH
	// server is still valid. Also, call ChannelIsOpen to see if the channel remains
	// open. The LastErrorText property will contain more detailed information
	// regarding the error.
	// 
	// -2 -- No additional data was received prior to the IdleTimeoutMs timeout.
	// 
	// >0 -- Additional data was received and the return value indicates how many bytes
	// are available to be picked up . Methods that read data on a channel do not
	// return the received data directly. Instead, they return an integer to indicate
	// how many bytes are available to be picked up . An application picks up the
	// available data by calling GetReceivedData or GetReceivedText.
	// 
	// =0 -- A zero can be returned if the channel EOF has already been received, or if
	// the channel had already been closed.
	// 
	int ChannelRead(int channelNum);

	// Creates an asynchronous task to call the ChannelRead method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *ChannelReadAsync(int channelNum);

	// Reads incoming data on an open channel and continues reading until no data
	// arrives for pollTimeoutMs milliseconds. The first read will wait a max of IdleTimeoutMs
	// milliseconds before timing out. Subsequent reads wait a max of pollTimeoutMs milliseconds
	// before timing out.
	// 
	// The idea behind ChannelReadAndPoll is to capture the output of a shell command.
	// One might imagine the typical sequence of events when executing a shell command
	// to be like this: (1) client sends command to server, (2) server executes the
	// command (i.e. it's computing...), potentially taking some amount of time, (3)
	// output is streamed back to the client. It makes sense for the client to wait a
	// longer period of time for the first data to arrive, but once it begins arriving,
	// the timeout can be shortened. This is exactly what ChannelReadAndPoll does --
	// the first timeout is controlled by the IdleTimeoutMs property, while the
	// subsequent reads (once output starts flowing) is controlled by pollTimeoutMs.
	// 
	// Return values are as follows:
	// -1 -- Error. Check the IsConnected property to see if the connection to the SSH
	// server is still valid. Also, call ChannelIsOpen to see if the channel remains
	// open. The LastErrorText property will contain more detailed information
	// regarding the error.
	// 
	// -2 -- No additional data was received prior to the IdleTimeoutMs timeout.
	// 
	// >0 -- Additional data was received and the return value indicates how many bytes
	// are available to be picked up . Methods that read data on a channel do not
	// return the received data directly. Instead, they return an integer to indicate
	// how many bytes are available to be picked up . An application picks up the
	// available data by calling GetReceivedData or GetReceivedText.
	// 
	// =0 -- A zero can be returned if the channel EOF has already been received, or if
	// the channel had already been closed.
	// 
	int ChannelReadAndPoll(int channelNum, int pollTimeoutMs);

	// Creates an asynchronous task to call the ChannelReadAndPoll method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *ChannelReadAndPollAsync(int channelNum, int pollTimeoutMs);

	// The same as ChannelReadAndPoll, except this method will return as soon as maxNumBytes
	// is exceeded.
	int ChannelReadAndPoll2(int channelNum, int pollTimeoutMs, int maxNumBytes);

	// Creates an asynchronous task to call the ChannelReadAndPoll2 method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *ChannelReadAndPoll2Async(int channelNum, int pollTimeoutMs, int maxNumBytes);

	// true if a CLOSE message has been received on the channel indicated by channelNum.
	// When a CLOSE is received, no subsequent data should be sent in either direction
	// -- the channel is closed in both directions.
	bool ChannelReceivedClose(int channelNum);

	// true if an EOF message has been received on the channel indicated by channelNum.
	// When an EOF is received, no more data will be forthcoming on the channel.
	// However, data may still be sent in the opposite direction.
	bool ChannelReceivedEof(int channelNum);

	// true if an exit status code was received on the channel. Otherwise false.
	bool ChannelReceivedExitStatus(int channelNum);

	// Reads incoming data on an open channel until the channel is closed by the
	// server. If successful, the number of bytes available to be picked up can be
	// determined by calling GetReceivedNumBytes. The received data may be retrieved by
	// calling GetReceivedData or GetReceivedText.
	bool ChannelReceiveToClose(int channelNum);

	// Creates an asynchronous task to call the ChannelReceiveToClose method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *ChannelReceiveToCloseAsync(int channelNum);

	// Reads incoming text data on an open channel until the received data matches the
	// matchPattern. For example, to receive data until the string Hello World arrives, set
	// matchPattern equal to *Hello World* . charset indicates the character encoding of the text
	// being received ( iso-8859-1 for example). caseSensitive may be set to true for case
	// sensitive matching, or false for case insensitive matching.
	// 
	// Returns true if text data matching matchPattern was received and is available to be
	// picked up by calling GetReceivedText (or GetReceivedTextS). IMPORTANT: This
	// method may read beyond the matching text. Call GetReceivedTextS to extract only
	// the data up-to and including the matching text.
	// 
	// Important Notes:
	//     * It's wise to set the ReadTimeoutMs property to a non-zero value to prevent
	//     an infinite wait if the matchPattern never arrives.
	//     * If using a shell session and SendReqPty was called, set the termType =
	//     dumb . If terminal control codes get mixed into the output stream, it could
	//     disrupt matching.
	//     * Be aware of the StderrToStdout property setting. The default value is
	//     true, which means that stderr is mixed with stdout in the output stream. This
	//     could disrupt matching. Set StderrToStdout to false to prevent this possibility.
	// 
	bool ChannelReceiveUntilMatch(int channelNum, const wchar_t *matchPattern, const wchar_t *charset, bool caseSensitive);

	// Creates an asynchronous task to call the ChannelReceiveUntilMatch method with
	// the arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *ChannelReceiveUntilMatchAsync(int channelNum, const wchar_t *matchPattern, const wchar_t *charset, bool caseSensitive);

	// The same as ChannelReceiveUntilMatch except that the method returns when any one
	// of the match patterns specified in matchPatterns are received on the channel.
	// 
	// Important: It's wise to set the ReadTimeoutMs property to a non-zero value to
	// prevent an infinite wait if of the matchPatterns ever arrives.
	// 
	bool ChannelReceiveUntilMatchN(int channelNum, CkStringArrayW &matchPatterns, const wchar_t *charset, bool caseSensitive);

	// Creates an asynchronous task to call the ChannelReceiveUntilMatchN method with
	// the arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *ChannelReceiveUntilMatchNAsync(int channelNum, CkStringArrayW &matchPatterns, const wchar_t *charset, bool caseSensitive);

	// Releases the internal memory resources for a channel previously opened by
	// OpenSessionChannel, OpenCustomChannel, or OpenDirectTcpIpChannel. It is not
	// absolutely necessary to call this method because the internal memory resources
	// for all channels are automatically released when the SSH object instance is
	// deleted/disposed. This method becomes necessary only when an extremely large
	// number of channels within the same SSH object instance are opened, used, and
	// closed over a long period of time.
	void ChannelRelease(int channelNum);

	// Sends a CLOSE message to the server for the channel indicated by channelNum. This
	// closes both directions of the bidirectional channel.
	bool ChannelSendClose(int channelNum);

	// Creates an asynchronous task to call the ChannelSendClose method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *ChannelSendCloseAsync(int channelNum);

	// Sends byte data on the channel indicated by channelNum.
	bool ChannelSendData(int channelNum, CkByteData &byteData);

	// Creates an asynchronous task to call the ChannelSendData method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *ChannelSendDataAsync(int channelNum, CkByteData &byteData);

	// Sends an EOF for the channel indicated by channelNum. Once an EOF is sent, no
	// additional data may be sent on the channel. However, the channel remains open
	// and additional data may still be received from the server.
	bool ChannelSendEof(int channelNum);

	// Creates an asynchronous task to call the ChannelSendEof method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *ChannelSendEofAsync(int channelNum);

	// Sends character data on the channel indicated by channelNum. The text is converted to
	// the charset indicated by charset prior to being sent. A list of supported charset
	// values may be found on this page: Supported Charsets.
	// 
	// References:
	// 1: https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp
	bool ChannelSendString(int channelNum, const wchar_t *textData, const wchar_t *charset);

	// Creates an asynchronous task to call the ChannelSendString method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *ChannelSendStringAsync(int channelNum, const wchar_t *textData, const wchar_t *charset);

	// Returns true if the underlying TCP socket is connected to the SSH server.
	bool CheckConnection(void);

	// Clears the collection of TTY modes that are sent with the SendReqPty method.
	void ClearTtyModes(void);

	// Connects to the SSH server at domainName:port
	// 
	// The domainName may be a domain name or an IPv4 or IPv6 address in string format.
	// 
	// Internally, the following SSH connection protocol algorithms are supported:
	//     * Hostkey:
	//         1. ssh-ed25519
	//         2. rsa-sha2-256
	//         3. rsa-sha2-512
	//         4. ecdsa-sha2-nistp256
	//         5. ecdsa-sha2-nistp384
	//         6. ecdsa-sha2-nistp521
	//         7. ssh-rsa
	//         8. ssh-dss
	//     * Key Exchange:
	//         1. curve25519-sha256
	//         2. curve25519-sha256@libssh.org
	//         3. ecdh-sha2-nistp256
	//         4. ecdh-sha2-nistp384
	//         5. ecdh-sha2-nistp521
	//         6. diffie-hellman-group14-sha256
	//         7. diffie-hellman-group1-sha1
	//         8. diffie-hellman-group14-sha1
	//         9. diffie-hellman-group16-sha512
	//         10. diffie-hellman-group18-sha512
	//         11. diffie-hellman-group-exchange-sha256
	//         12. diffie-hellman-group-exchange-sha1
	//     * Ciphers:
	//         1. aes128-ctr
	//         2. aes256-ctr
	//         3. aes192-ctr
	//         4. aes128-cbc
	//         5. aes256-cbc
	//         6. aes192-cbc
	//         7. aes128-gcm@openssh.com
	//         8. aes256-gcm@openssh.com
	//         9. twofish256-cbc
	//         10. twofish128-cbc
	//         11. blowfish-cbc
	//         12. (also chacha20-poly1305@openssh.com if explicitly allowed by the
	//         application)
	//     * MAC Algorithms:
	//         1. hmac-sha2-256
	//         2. hmac-sha2-512
	//         3. hmac-sha1
	//         4. hmac-ripemd160
	//         5. hmac-sha1-96
	//         6. hmac-md5
	//         7. (also the following etm algorithms if explicitly allowed)
	//         8. hmac-sha1-etm@openssh.com
	//         9. hmac-sha2-256-etm@openssh.com
	//         10. hmac-sha2-512-etm@openssh.com
	//     * Compression:
	//         1. none
	//         2. zlib
	//         3. zlib@openssh.com
	// 
	// 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.
	// 
	bool Connect(const wchar_t *domainName, int port);

	// Creates an asynchronous task to call the Connect method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *ConnectAsync(const wchar_t *domainName, int port);

	// Connects to an SSH server through an existing SSH connection. The ssh is an
	// existing connected and authenticated SSH object. The connection to hostname:port is
	// made through the existing SSH connection via port-forwarding. If successful, the
	// connection is as follows: application => ServerSSH1 => ServerSSH2. (where
	// ServerSSH1 is the ssh and ServerSSH2 is the SSH server at hostname:port) Once
	// connected in this way, all communications are routed through ServerSSH1 to
	// ServerSSH2. This includes authentication -- which means the application must
	// still call one of the Authenticate* methods to authenticate with ServerSSH2.
	bool ConnectThroughSsh(CkSshW &ssh, const wchar_t *hostname, int port);

	// Creates an asynchronous task to call the ConnectThroughSsh method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *ConnectThroughSshAsync(CkSshW &ssh, const wchar_t *hostname, int port);

	// Continues keyboard-interactive authentication with the SSH server. The response is
	// typically the password. If multiple responses are required (because there were
	// multiple prompts in the infoRequest XML returned by StartKeyboardAuth), then the
	// response should be formatted as XML (as shown below) otherwise the response simply
	// contains the single response string._LT_response_GT_
	//     _LT_response1_GT_response to first prompt_LT_/response1_GT_
	//     _LT_response2_GT_response to second prompt_LT_/response2_GT_
	//     ...
	//     _LT_responseN_GT_response to Nth prompt_LT_/responseN_GT_
	// _LT_/response_GT_
	// 
	// If the interactive authentication completed with success or failure, the XML
	// response will be:_LT_success_GT_success_message_LT_/success_GT_
	// 
	// or
	// 
	// _LT_error_GT_error_message_LT_/error_GT_
	// If additional steps are required to complete the interactive authentication,
	// then an XML string that provides the name, instruction, and prompts is returned.
	// The XML has the following format: 	_LT_infoRequest numPrompts="N"_GT_
	// 	    _LT_name_GT_name_string_LT_/name_GT_
	// 	    _LT_instruction_GT_instruction_string_LT_/instruction_GT_
	// 	    _LT_prompt1 echo="1_or_0"_GT_prompt_string_LT_/prompt1_GT_
	// 	    ...
	// 	    _LT_promptN echo="1_or_0"_GT_prompt_string_LT_/promptN_GT_
	// 	_LT_/infoRequest_GT_
	// 
	bool ContinueKeyboardAuth(const wchar_t *response, CkString &outStr);
	// Continues keyboard-interactive authentication with the SSH server. The response is
	// typically the password. If multiple responses are required (because there were
	// multiple prompts in the infoRequest XML returned by StartKeyboardAuth), then the
	// response should be formatted as XML (as shown below) otherwise the response simply
	// contains the single response string._LT_response_GT_
	//     _LT_response1_GT_response to first prompt_LT_/response1_GT_
	//     _LT_response2_GT_response to second prompt_LT_/response2_GT_
	//     ...
	//     _LT_responseN_GT_response to Nth prompt_LT_/responseN_GT_
	// _LT_/response_GT_
	// 
	// If the interactive authentication completed with success or failure, the XML
	// response will be:_LT_success_GT_success_message_LT_/success_GT_
	// 
	// or
	// 
	// _LT_error_GT_error_message_LT_/error_GT_
	// If additional steps are required to complete the interactive authentication,
	// then an XML string that provides the name, instruction, and prompts is returned.
	// The XML has the following format: 	_LT_infoRequest numPrompts="N"_GT_
	// 	    _LT_name_GT_name_string_LT_/name_GT_
	// 	    _LT_instruction_GT_instruction_string_LT_/instruction_GT_
	// 	    _LT_prompt1 echo="1_or_0"_GT_prompt_string_LT_/prompt1_GT_
	// 	    ...
	// 	    _LT_promptN echo="1_or_0"_GT_prompt_string_LT_/promptN_GT_
	// 	_LT_/infoRequest_GT_
	// 
	const wchar_t *continueKeyboardAuth(const wchar_t *response);

	// Creates an asynchronous task to call the ContinueKeyboardAuth method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *ContinueKeyboardAuthAsync(const wchar_t *response);

	// Disconnects from the SSH server.
	void Disconnect(void);

	// Queries the SSH server to find out which authentication methods it supports.
	// Returns a string such as publickey,password,keyboard-interactive .
	// 
	// This method should be called after connecting, but prior to authenticating. The
	// method intentionally disconnects from the server after getting the
	// authentication methods. An application may then connect again and authentication
	// with a chosen method. (In most cases, an application knows in advance the type
	// of authentication to be used, and this method is never called.)
	// 
	bool GetAuthMethods(CkString &outStr);
	// Queries the SSH server to find out which authentication methods it supports.
	// Returns a string such as publickey,password,keyboard-interactive .
	// 
	// This method should be called after connecting, but prior to authenticating. The
	// method intentionally disconnects from the server after getting the
	// authentication methods. An application may then connect again and authentication
	// with a chosen method. (In most cases, an application knows in advance the type
	// of authentication to be used, and this method is never called.)
	// 
	const wchar_t *getAuthMethods(void);
	// Queries the SSH server to find out which authentication methods it supports.
	// Returns a string such as publickey,password,keyboard-interactive .
	// 
	// This method should be called after connecting, but prior to authenticating. The
	// method intentionally disconnects from the server after getting the
	// authentication methods. An application may then connect again and authentication
	// with a chosen method. (In most cases, an application knows in advance the type
	// of authentication to be used, and this method is never called.)
	// 
	const wchar_t *authMethods(void);

	// Creates an asynchronous task to call the GetAuthMethods method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *GetAuthMethodsAsync(void);

	// Returns the exit status code for a channel. This method should only be called if
	// an exit status has been received. You may check to see if the exit status was
	// received by calling ChannelReceivedExitStatus.
	int GetChannelExitStatus(int channelNum);

	// Returns the channel number for the Nth open channel. Indexing begins at 0, and
	// the number of currently open channels is indicated by the NumOpenChannels
	// property. Returns -1 if the index is out of range.
	int GetChannelNumber(int index);

	// Returns a string describing the channel type for the Nth open channel. Channel
	// types are: session , x11 , forwarded-tcpip , and direct-tcpip .
	bool GetChannelType(int index, CkString &outStr);
	// Returns a string describing the channel type for the Nth open channel. Channel
	// types are: session , x11 , forwarded-tcpip , and direct-tcpip .
	const wchar_t *getChannelType(int index);
	// Returns a string describing the channel type for the Nth open channel. Channel
	// types are: session , x11 , forwarded-tcpip , and direct-tcpip .
	const wchar_t *channelType(int index);

	// Returns the host key fingerprint of the server, which is automatically set after
	// connecting to an SSH/SFTP server. The hashAlg can be any hash algorithm supported
	// by Chilkat, such as SHA256 , SHA384 , SHA512 , SHA1 , MD5 , SHA3-224 , SHA3-256
	// , SHA3-384 , SHA3-512 , etc.
	// 
	// If both includeKeyType and includeHashName are true, then the fingerprint string is formatted like
	// this:ssh-rsa SHA256:L7sQgnpnoBwRoyIYXAFBs8SdSnwtyYmhXs1p/mQDK...
	// If includeKeyType is true and includeHashName is false:ssh-rsa L7sQgnpnoBwRoyIYXAFBs8SdSnwtyYmhXs1p/mQDK...
	// If includeKeyType is false:and includeHashName is trueSHA256:L7sQgnpnoBwRoyIYXAFBs8SdSnwtyYmhXs1p/mQDK...
	// If includeKeyType is false:and includeHashName is false:andL7sQgnpnoBwRoyIYXAFBs8SdSnwtyYmhXs1p/mQDK...
	//  
	// 
	// SSH host key types can be: ssh-rsa, ecdsa-*-* (such as ecdsa-sha2-nistp256),
	// ssh-ed25519, and ssh-dss.
	// 
	bool GetHostKeyFP(const wchar_t *hashAlg, bool includeKeyType, bool includeHashName, CkString &outStr);
	// Returns the host key fingerprint of the server, which is automatically set after
	// connecting to an SSH/SFTP server. The hashAlg can be any hash algorithm supported
	// by Chilkat, such as SHA256 , SHA384 , SHA512 , SHA1 , MD5 , SHA3-224 , SHA3-256
	// , SHA3-384 , SHA3-512 , etc.
	// 
	// If both includeKeyType and includeHashName are true, then the fingerprint string is formatted like
	// this:ssh-rsa SHA256:L7sQgnpnoBwRoyIYXAFBs8SdSnwtyYmhXs1p/mQDK...
	// If includeKeyType is true and includeHashName is false:ssh-rsa L7sQgnpnoBwRoyIYXAFBs8SdSnwtyYmhXs1p/mQDK...
	// If includeKeyType is false:and includeHashName is trueSHA256:L7sQgnpnoBwRoyIYXAFBs8SdSnwtyYmhXs1p/mQDK...
	// If includeKeyType is false:and includeHashName is false:andL7sQgnpnoBwRoyIYXAFBs8SdSnwtyYmhXs1p/mQDK...
	//  
	// 
	// SSH host key types can be: ssh-rsa, ecdsa-*-* (such as ecdsa-sha2-nistp256),
	// ssh-ed25519, and ssh-dss.
	// 
	const wchar_t *getHostKeyFP(const wchar_t *hashAlg, bool includeKeyType, bool includeHashName);
	// Returns the host key fingerprint of the server, which is automatically set after
	// connecting to an SSH/SFTP server. The hashAlg can be any hash algorithm supported
	// by Chilkat, such as SHA256 , SHA384 , SHA512 , SHA1 , MD5 , SHA3-224 , SHA3-256
	// , SHA3-384 , SHA3-512 , etc.
	// 
	// If both includeKeyType and includeHashName are true, then the fingerprint string is formatted like
	// this:ssh-rsa SHA256:L7sQgnpnoBwRoyIYXAFBs8SdSnwtyYmhXs1p/mQDK...
	// If includeKeyType is true and includeHashName is false:ssh-rsa L7sQgnpnoBwRoyIYXAFBs8SdSnwtyYmhXs1p/mQDK...
	// If includeKeyType is false:and includeHashName is trueSHA256:L7sQgnpnoBwRoyIYXAFBs8SdSnwtyYmhXs1p/mQDK...
	// If includeKeyType is false:and includeHashName is false:andL7sQgnpnoBwRoyIYXAFBs8SdSnwtyYmhXs1p/mQDK...
	//  
	// 
	// SSH host key types can be: ssh-rsa, ecdsa-*-* (such as ecdsa-sha2-nistp256),
	// ssh-ed25519, and ssh-dss.
	// 
	const wchar_t *hostKeyFP(const wchar_t *hashAlg, bool includeKeyType, bool includeHashName);

	// Provides information about what transpired in the last method called. For many
	// methods, there is no information. For some methods, details about what
	// transpired can be obtained via LastJsonData.
	void GetLastJsonData(CkJsonObjectW &json);

	// Returns the accumulated data received on the channel indicated by channelNum and
	// clears the channel's internal receive buffer.
	bool GetReceivedData(int channelNum, CkByteData &outBytes);

	// Same as GetReceivedData, but a maximum of maxNumBytes bytes is returned.
	bool GetReceivedDataN(int channelNum, int maxNumBytes, CkByteData &outBytes);

	// Returns the number of bytes available in the internal receive buffer for the
	// specified channelNum. The received data may be retrieved by calling GetReceivedData or
	// GetReceivedText.
	int GetReceivedNumBytes(int channelNum);

	// Returns the accumulated stderr bytes received on the channel indicated by channelNum
	// and clears the channel's internal stderr receive buffer.
	// 
	// Note: If the StderrToStdout property is set to true, then stderr is
	// automatically redirected to stdout. This is the default behavior. The following
	// methods can be called to retrieve the channel's stdout: GetReceivedData,
	// GetReceivedDataN, GetReceivedText, and GetReceivedTextS.
	// 
	bool GetReceivedStderr(int channelNum, CkByteData &outBytes);

	// Returns the accumulated stderr text received on the channel indicated by channelNum
	// and clears the channel's internal receive buffer. The charset indicates the charset
	// of the character data in the internal receive buffer. A list of supported
	// charset values may be found on this page: Supported Charsets.
	// 
	// References:
	// 1: https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp
	bool GetReceivedStderrText(int channelNum, const wchar_t *charset, CkString &outStr);
	// Returns the accumulated stderr text received on the channel indicated by channelNum
	// and clears the channel's internal receive buffer. The charset indicates the charset
	// of the character data in the internal receive buffer. A list of supported
	// charset values may be found on this page: Supported Charsets.
	// 
	// References:
	// 1: https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp
	const wchar_t *getReceivedStderrText(int channelNum, const wchar_t *charset);
	// Returns the accumulated stderr text received on the channel indicated by channelNum
	// and clears the channel's internal receive buffer. The charset indicates the charset
	// of the character data in the internal receive buffer. A list of supported
	// charset values may be found on this page: Supported Charsets.
	// 
	// References:
	// 1: https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp
	const wchar_t *receivedStderrText(int channelNum, const wchar_t *charset);

	// Returns the accumulated text received on the channel indicated by channelNum and
	// clears the channel's internal receive buffer. The charset indicates the charset of
	// the character data in the internal receive buffer. A list of supported charset
	// values may be found on this page: Supported Charsets.
	// 
	// References:
	// 1: https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp
	bool GetReceivedText(int channelNum, const wchar_t *charset, CkString &outStr);
	// Returns the accumulated text received on the channel indicated by channelNum and
	// clears the channel's internal receive buffer. The charset indicates the charset of
	// the character data in the internal receive buffer. A list of supported charset
	// values may be found on this page: Supported Charsets.
	// 
	// References:
	// 1: https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp
	const wchar_t *getReceivedText(int channelNum, const wchar_t *charset);
	// Returns the accumulated text received on the channel indicated by channelNum and
	// clears the channel's internal receive buffer. The charset indicates the charset of
	// the character data in the internal receive buffer. A list of supported charset
	// values may be found on this page: Supported Charsets.
	// 
	// References:
	// 1: https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp
	const wchar_t *receivedText(int channelNum, const wchar_t *charset);

	// The same as GetReceivedText, except only the text up to and including substr is
	// returned. The text returned is removed from the internal receive buffer. If the
	// substr was not found in the internal receive buffer, an empty string is returned
	// and the internal receive buffer is not modified.
	bool GetReceivedTextS(int channelNum, const wchar_t *substr, const wchar_t *charset, CkString &outStr);
	// The same as GetReceivedText, except only the text up to and including substr is
	// returned. The text returned is removed from the internal receive buffer. If the
	// substr was not found in the internal receive buffer, an empty string is returned
	// and the internal receive buffer is not modified.
	const wchar_t *getReceivedTextS(int channelNum, const wchar_t *substr, const wchar_t *charset);
	// The same as GetReceivedText, except only the text up to and including substr is
	// returned. The text returned is removed from the internal receive buffer. If the
	// substr was not found in the internal receive buffer, an empty string is returned
	// and the internal receive buffer is not modified.
	const wchar_t *receivedTextS(int channelNum, const wchar_t *substr, const wchar_t *charset);

	// This method is deprecated. Call GetLastJsonData instead.
	// 
	// Provides information about what transpired in the last method called. For many
	// methods, there is no information. For some methods, details about what
	// transpired can be obtained via LastJsonData.
	// 
	// The caller is responsible for deleting the object returned by this method.
	CkJsonObjectW *LastJsonData(void);

	// Loads the caller of the task's async method.
	bool LoadTaskCaller(CkTaskW &task);

	// Opens a custom channel with a custom server that uses the SSH protocol. The channelType
	// is application-defined.
	// 
	// If successful, the channel number is returned. This is the number that should be
	// passed to any method requiring a channel number. A -1 is returned upon failure.
	// 
	int OpenCustomChannel(const wchar_t *channelType);

	// Creates an asynchronous task to call the OpenCustomChannel method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *OpenCustomChannelAsync(const wchar_t *channelType);

	// Open a direct-tcpip channel for port forwarding. Data sent on the channel via
	// ChannelSend* methods is sent to the SSH server and then forwarded to targetHostname:targetPort.
	// The SSH server automatically forwards data received from targetHostname:targetPort to the SSH
	// client. Therefore, calling ChannelRead* and ChannelReceive* methods is
	// equivalent to reading directly from targetHostname:targetPort.
	// 
	// If successful, the channel number is returned. This is the number that should be
	// passed to any method requiring a channel number. A -1 is returned upon failure.
	// 
	int OpenDirectTcpIpChannel(const wchar_t *targetHostname, int targetPort);

	// Creates an asynchronous task to call the OpenDirectTcpIpChannel method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *OpenDirectTcpIpChannelAsync(const wchar_t *targetHostname, int targetPort);

	// Opens a new session channel. Almost everything you will do with the Chilkat SSH
	// component will involve opening a session channel. The normal sequence of
	// operation is typically this: 1) Connect to the SSH server. 2) Authenticate. 3)
	// Open a session channel. 4) do something on the channel such as opening a shell,
	// execute a command, etc.
	// 
	// If successful, the channel number is returned. This is the number that should be
	// passed to any method requiring a channel number. A -1 is returned upon failure.
	// 
	int OpenSessionChannel(void);

	// Creates an asynchronous task to call the OpenSessionChannel method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *OpenSessionChannelAsync(void);

	// This is the same as GetReceivedText, except the internal receive buffer is not
	// cleared.
	bool PeekReceivedText(int channelNum, const wchar_t *charset, CkString &outStr);
	// This is the same as GetReceivedText, except the internal receive buffer is not
	// cleared.
	const wchar_t *peekReceivedText(int channelNum, const wchar_t *charset);

	// Returns a channel number for a completed command that was previously sent via
	// QuickCmdSend. Returns -1 if no commands have yet completed. The pollTimeoutMs indicates
	// how long to wait (in milliseconds) for any command in progress (on any channel)
	// to complete before returning -1.
	// 
	// Returns -2 if an error occurred (for example, if the connection to the SSH
	// server was lost while checking for responses).
	// 
	int QuickCmdCheck(int pollTimeoutMs);

	// Creates an asynchronous task to call the QuickCmdCheck method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *QuickCmdCheckAsync(int pollTimeoutMs);

	// Sends a command and returns the channel number for the command that has started.
	// This is the equivalent of calling OpenSessionChannel, followed by SendReqExec. A
	// value of -1 is returned on failure.
	// 
	// The ReqExecCharset property controls the charset used for the command that is
	// sent.
	// 
	// Important: When reporting problems, please send the full contents of the
	// LastErrorText property to support@chilkatsoft.com.
	// 
	int QuickCmdSend(const wchar_t *command);

	// Creates an asynchronous task to call the QuickCmdSend method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *QuickCmdSendAsync(const wchar_t *command);

	// Simplified method for executing a remote command and getting the complete
	// output. This is the equivalent of calling OpenSessionChannel, followed by
	// SendReqExec, then ChannelReceiveToClose, and finally GetReceivedText.
	// 
	// The charset indicates the charset of the command's output (such as utf-8 or ansi ).
	// A list of supported charset values may be found on this page: Supported
	// Charsets.
	// 
	// The ReqExecCharset property controls the charset used for the command that is
	// sent.
	// 
	// Important: When reporting problems, please send the full contents of the
	// LastErrorText property to support@chilkatsoft.com.
	// 
	// 
	// References:
	// 1: https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp
	bool QuickCommand(const wchar_t *command, const wchar_t *charset, CkString &outStr);
	// Simplified method for executing a remote command and getting the complete
	// output. This is the equivalent of calling OpenSessionChannel, followed by
	// SendReqExec, then ChannelReceiveToClose, and finally GetReceivedText.
	// 
	// The charset indicates the charset of the command's output (such as utf-8 or ansi ).
	// A list of supported charset values may be found on this page: Supported
	// Charsets.
	// 
	// The ReqExecCharset property controls the charset used for the command that is
	// sent.
	// 
	// Important: When reporting problems, please send the full contents of the
	// LastErrorText property to support@chilkatsoft.com.
	// 
	// 
	// References:
	// 1: https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp
	const wchar_t *quickCommand(const wchar_t *command, const wchar_t *charset);

	// Creates an asynchronous task to call the QuickCommand method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *QuickCommandAsync(const wchar_t *command, const wchar_t *charset);

	// Simplified method for starting a remote shell session. It is the equivalent of
	// calling OpenSessionChannel, followed by SendReqPty, and finally SendReqShell.
	// 
	// Returns the SSH channel number for the session, or -1 if not successful.
	// 
	// Important: When reporting problems, please send the full contents of the
	// LastErrorText property to support@chilkatsoft.com.
	// 
	int QuickShell(void);

	// Creates an asynchronous task to call the QuickShell method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *QuickShellAsync(void);

	// Initiates a re-key with the SSH server. The ReKey method does not return until
	// the key re-exchange is complete.
	// 
	// RFC 4253 (the SSH Transport Layer Protocol) recommends that keys be changed
	// after each gigabyte of transmitted data or after each hour of connection time,
	// whichever comes sooner. Key re-exchange is a public-key operation and requires a
	// fair amount of processing power and should not be performed too often. Either
	// side (client or server) may initiate a key re-exchange at any time.
	// 
	// In most cases, a server will automatically initiate key re-exchange whenever it
	// deems necessary, and the Chilkat SSH component handles these transparently. For
	// example, if the Chilkat SSH component receives a re-key message from the server
	// while in the process of receiving data on a channel, it will automatically
	// handle the key re-exchange and the application will not even realize that an
	// underlying key re-exchange occurred.
	// 
	bool ReKey(void);

	// Creates an asynchronous task to call the ReKey method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *ReKeyAsync(void);

	// Sends an IGNORE message to the SSH server. This is one way of verifying that the
	// connection to the SSH server is open and valid. The SSH server does not respond
	// to an IGNORE message. It simply ignores it. IGNORE messages are not associated
	// with a channel (in other words, you do not need to first open a channel prior to
	// sending an IGNORE message).
	bool SendIgnore(void);

	// Creates an asynchronous task to call the SendIgnore method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SendIgnoreAsync(void);

	// Initiates execution of a command on the channel specified by channelNum. The commandLine
	// contains the full command line including any command-line parameters (just as
	// you would type the command at a shell prompt).
	// 
	// This is the equivalent of running a command on a remote server via the rexec
	// command. See rexec command. It is not a shell session.
	// 
	// Important: A channel only exists for a single request. You may not call
	// SendReqExec multiple times on the same open channel. The reason is that the SSH
	// server automatically closes the channel at the end of the exec. The solution is
	// to call OpenSessionChannel to get a new channel, and then call SendReqExec using
	// the new channel. It is OK to have more than one channel open simultaneously.
	// 
	// Charset: The ReqExecCharset property has been added in version 9.5.0.47. This
	// can be set to control the character encoding of the command sent to the server.
	// The default is ANSI. A likely alternative value is utf-8 .
	// 
	// 
	// References:
	// 1: https://linux.die.net/man/1/rexec
	bool SendReqExec(int channelNum, const wchar_t *commandLine);

	// Creates an asynchronous task to call the SendReqExec method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SendReqExecAsync(int channelNum, const wchar_t *commandLine);

	// Requests a pseudo-terminal for a session channel. If the termType is a character
	// oriented terminal ( vt100 for example), then widthInChars and heightInChars would be set to
	// non-zero values, while widthInPixels and heightInPixels may be set to 0. If termType is pixel-oriented,
	// such as xterm , the reverse is true (i.e. set widthInPixels and heightInPixels, but set widthInChars and
	// heightInChars equal to 0).
	// 
	// In most cases, you probably don't even want terminal emulation. In that case,
	// try setting termType = dumb . Terminal emulation causes terminal escape sequences to
	// be included with shell command output. A dumb terminal should have no escape
	// sequences.
	// 
	// Some SSH servers allow a shell to be started (via the SendReqShell method)
	// without the need to first request a pseudo-terminal. The normal sequence for
	// starting a remote shell is as follows:1) Connect
	// 2) Authenticate
	// 3) OpenSessionChannel
	// 4) Request a PTY via this method if necessary.
	// 5) Start a shell by calling SendReqShell
	// 
	bool SendReqPty(int channelNum, const wchar_t *termType, int widthInChars, int heightInChars, int widthInPixels, int heightInPixels);

	// Creates an asynchronous task to call the SendReqPty method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SendReqPtyAsync(int channelNum, const wchar_t *termType, int widthInChars, int heightInChars, int widthInPixels, int heightInPixels);

	// Sets an environment variable in the remote shell.
	bool SendReqSetEnv(int channelNum, const wchar_t *name, const wchar_t *value);

	// Creates an asynchronous task to call the SendReqSetEnv method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SendReqSetEnvAsync(int channelNum, const wchar_t *name, const wchar_t *value);

	// Starts a shell on an open session channel. Some SSH servers require that a PTY
	// (pseudo-terminal) first be requested prior to starting a shell. In that case,
	// call SendReqPty prior to calling this method. Once a shell is started, commands
	// may be sent by calling ChannelSendString. (Don't forget to terminate commands
	// with a CRLF).
	bool SendReqShell(int channelNum);

	// Creates an asynchronous task to call the SendReqShell method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SendReqShellAsync(int channelNum);

	// Delivers a signal to the remote process/service. signalName is one of the following:
	// ABRT, ALRM, FPE, HUP, ILL, INT, KILL, PIPE, QUIT, SEGV, TERM, USR1, USR2.
	// (Obviously, these are UNIX signals, so the remote SSH server would need to be a
	// Unix/Linux system.)
	bool SendReqSignal(int channelNum, const wchar_t *signalName);

	// Creates an asynchronous task to call the SendReqSignal method with the arguments
	// provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SendReqSignalAsync(int channelNum, const wchar_t *signalName);

	// Executes a pre-defined subsystem. The SFTP protocol (Secure File Transfer
	// Protocol) is started by the Chilkat SFTP component by starting the sftp
	// subsystem.
	bool SendReqSubsystem(int channelNum, const wchar_t *subsystemName);

	// Creates an asynchronous task to call the SendReqSubsystem method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SendReqSubsystemAsync(int channelNum, const wchar_t *subsystemName);

	// When the client-side window (terminal) size changes, this message may be sent to
	// the server to inform it of the new size.
	bool SendReqWindowChange(int channelNum, int widthInChars, int heightInRows, int pixWidth, int pixHeight);

	// Creates an asynchronous task to call the SendReqWindowChange method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SendReqWindowChangeAsync(int channelNum, int widthInChars, int heightInRows, int pixWidth, int pixHeight);

	// Allows the client to send an X11 forwarding request to the server. Chilkat only
	// provides this functionality because it is a message defined in the SSH
	// connection protocol. Chilkat has no advice for when or why it would be needed.
	bool SendReqX11Forwarding(int channelNum, bool singleConnection, const wchar_t *authProt, const wchar_t *authCookie, int screenNum);

	// Creates an asynchronous task to call the SendReqX11Forwarding method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SendReqX11ForwardingAsync(int channelNum, bool singleConnection, const wchar_t *authProt, const wchar_t *authCookie, int screenNum);

	// This method should be ignored and not used.
	bool SendReqXonXoff(int channelNum, bool clientCanDo);

	// Creates an asynchronous task to call the SendReqXonXoff method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *SendReqXonXoffAsync(int channelNum, bool clientCanDo);

	// Provides a way to specific the exact set of algorithms allowed for the
	// connection.
	bool SetAllowedAlgorithms(CkJsonObjectW &json);

	// Sets a TTY mode that is included in the SendReqPty method call. Most commonly,
	// it is not necessary to call this method at all. Chilkat has no recommendations
	// or expertise as to why or when a particular mode might be useful. This
	// capability is provided because it is defined in the SSH connection protocol
	// specification.
	// 
	// This method can be called multiple times to set many terminal mode flags (one
	// per call).
	// 
	// The ttyValue is an integer, typically 0 or 1. Valid ttyName flag names include: VINTR,
	// VQUIT, VERASE, VKILL, VEOF, VEOL, VEOL2, VSTART, VSTOP, VSUSP, VDSUSP, VREPRINT,
	// VWERASE, VLNEXT, VFLUSH, VSWTCH, VSTATUS, VDISCARD, IGNPAR, PARMRK, INPCK,
	// ISTRIP, INLCR, IGNCR, ICRNL, IUCLC, IXON, IXANY, IXOFF, IMAXBEL, ISIG, ICANON,
	// XCASE, ECHO, ECHOE, ECHOK, ECHONL, NOFLSH, TOSTOP, IEXTEN, ECHOCTL, ECHOKE,
	// PENDIN, OPOST, OLCUC, ONLCR, OCRNL, ONOCR, ONLRET, CS7, CS8, PARENB, PARODD,
	// TTY_OP_ISPEED, TTY_OP_OSPEED
	// 
	bool SetTtyMode(const wchar_t *ttyName, int ttyValue);

	// Begins keyboard-interactive authentication with the SSH server. Returns an XML
	// string providing the name, instruction, and prompts. The XML has the following
	// format: 	_LT_infoRequest numPrompts="N"_GT_
	// 	    _LT_name_GT_name_string_LT_/name_GT_
	// 	    _LT_instruction_GT_instruction_string_LT_/instruction_GT_
	// 	    _LT_prompt1 echo="1_or_0"_GT_prompt_string_LT_/prompt1_GT_
	// 	    ...
	// 	    _LT_promptN echo="1_or_0"_GT_prompt_string_LT_/promptN_GT_
	// 	_LT_/infoRequest_GT_
	// 
	// If the authentication immediately succeeds because no password is required, or
	// immediately fails, the XML response can be:_LT_success_GT_success_message_LT_/success_GT_
	// 
	// or
	// 
	// _LT_error_GT_error_message_LT_/error_GT_
	// 
	bool StartKeyboardAuth(const wchar_t *login, CkString &outStr);
	// Begins keyboard-interactive authentication with the SSH server. Returns an XML
	// string providing the name, instruction, and prompts. The XML has the following
	// format: 	_LT_infoRequest numPrompts="N"_GT_
	// 	    _LT_name_GT_name_string_LT_/name_GT_
	// 	    _LT_instruction_GT_instruction_string_LT_/instruction_GT_
	// 	    _LT_prompt1 echo="1_or_0"_GT_prompt_string_LT_/prompt1_GT_
	// 	    ...
	// 	    _LT_promptN echo="1_or_0"_GT_prompt_string_LT_/promptN_GT_
	// 	_LT_/infoRequest_GT_
	// 
	// If the authentication immediately succeeds because no password is required, or
	// immediately fails, the XML response can be:_LT_success_GT_success_message_LT_/success_GT_
	// 
	// or
	// 
	// _LT_error_GT_error_message_LT_/error_GT_
	// 
	const wchar_t *startKeyboardAuth(const wchar_t *login);

	// Creates an asynchronous task to call the StartKeyboardAuth method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *StartKeyboardAuthAsync(const wchar_t *login);

	// The pollTimeoutMs is the number of milliseconds to wait. To poll, pass a value of 0 in
	// pollTimeoutMs. Waits for an incoming message on any channel. This includes data, EOF,
	// CLOSE, etc. If a message arrives in the alotted time, the channel number is
	// returned. A value of -1 is returned for a timeout, and -2 for any other errors
	// such as if the connection is lost.
	// 
	// Note: If a channel number is returned, the message must still be read by calling
	// a method such as ChannelRead, ChannelReceiveUntilMatch, etc. Once the message is
	// actually received, it may be collected by calling GetReceivedText,
	// GetReceivedData, etc.
	// 
	int WaitForChannelMessage(int pollTimeoutMs);

	// Creates an asynchronous task to call the WaitForChannelMessage method with the
	// arguments provided.
	// The caller is responsible for deleting the object returned by this method.
	CkTaskW *WaitForChannelMessageAsync(int pollTimeoutMs);





	// END PUBLIC INTERFACE


};
#if !defined(__sun__) && !defined(__sun)
#pragma pack (pop)
#endif
	
#endif
