CkSsh

Set to true to request that the currently running Chilkat operation abort. This applies to synchronous and asynchronous methods that may block on network or lengthy processing.

When the abort is observed, Chilkat resets the property to false. If no operation is running, it is reset when the next method begins. A synchronous call may be aborted by setting this property from another thread.

Contains an authentication failure code after AuthenticatePw, AuthenticatePk, or AuthenticatePwPk fails.

Controls whether caret notation is converted to ASCII control characters in strings passed to SendReqExec and ChannelSendString. The default is false.

Caret  Dec  Hex  Name  Description
^@       0   00   NUL   Null
^A       1   01   SOH   Start of Heading
^B       2   02   STX   Start of Text
^C       3   03   ETX   End of Text
^D       4   04   EOT   End of Transmission
^E       5   05   ENQ   Enquiry
^F       6   06   ACK   Acknowledge
^G       7   07   BEL   Bell
^H       8   08   BS    Backspace
^I       9   09   HT    Horizontal Tab
^J      10   0A   LF    Line Feed
^K      11   0B   VT    Vertical Tab
^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

Contains the SSH channel-open failure code when a request to open a channel is rejected. The values are defined by RFC 4254.

Contains the descriptive text associated with ChannelOpenFailCode after a channel-open request fails.

Specifies the SSH client-identification string sent when a connection is established. The default is SSH-2.0-Chilkat_ followed by the Chilkat version, for example SSH-2.0-Chilkat_11.6.0.

This property is normally left unset. Set it only when the computer has multiple network interfaces or multiple local IP addresses and the application needs to use a specific one.

The value may be a numeric IPv4 or IPv6 address. Do not specify a domain name. When this property is empty, Chilkat and the operating system automatically select the appropriate local address.

The specified address must be available on the local computer and must be compatible with the address family used for the connection. If the address is invalid or unavailable, the connection fails.

This setting applies to all connection paths, including direct SSH connections, HTTP and SOCKS proxy connections, ConnectThroughSsh, and multi-hop SSH connections.

This property is normally left at its default value of 0. In this case, the operating system automatically chooses an unused local port from its ephemeral-port range. Applications should set a specific local port only when a remote system or network policy requires the connection to originate from that port.

When set to a nonzero value, Chilkat requests that exact local port. The connection fails if the port is already in use or is otherwise unavailable. A specifically chosen port might also be temporarily unavailable for reuse after a connection closes because of operating-system TCP connection management. These port-reuse concerns do not normally apply when this property remains 0.

This property applies to all connection paths, including direct SSH connections, HTTP and SOCKS proxy connections, ConnectThroughSsh, and multi-hop SSH connections.

Starting in Chilkat v11.6.0, assigned values must be in the range 0 through 65535. If a negative value or a value greater than 65535 is assigned, it is ignored and the existing property value remains unchanged.

Specifies the maximum number of milliseconds to wait for the remote endpoint to accept the TCP connection.

When a proxy is used, this timeout applies to establishing the TCP connection to the proxy. It does not include the HTTP CONNECT exchange, proxy authentication, or SSH protocol negotiation.

If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. This logging helps identify the context and history of Chilkat calls leading up to any crash or hang, aiding in debugging.

Enabling the VerboseLogging property provides more detailed information. This property is mainly used for debugging rare instances where a Chilkat method call causes a hang or crash, which should generally not happen.

Possible causes of hangs include:

• A timeout property set to 0, indicating an infinite timeout.
• A hang occurring within an event callback in the application code.
• An internal bug in the Chilkat code causing the hang.

Contains the reason code from an SSH DISCONNECT message received from the server. The values are defined by RFC 4253.

When connection establishment fails, this property is cleared and does not retain a code from an earlier connection.

Contains the descriptive text sent with the server’s SSH DISCONNECT message. See DisconnectCode for the corresponding RFC 4253 reason code.

When connection establishment fails, this property is cleared and does not retain text from an earlier connection.

Controls whether SSH compression may be negotiated. The default is true, meaning compression is used when the server supports it.

Enables automatic resolution of secret specification strings from secure operating-system storage. The default is false.

When true, supported password properties and authentication methods may receive a value beginning with !! instead of a literal credential. Chilkat resolves the secret from Windows Credential Manager on Windows or Apple Keychain on macOS.

Secret specification format:

!![appName|]service[|domain]|username

This feature applies to HttpProxyPassword, SocksPassword, AuthenticatePw, and AuthenticatePwPk.

Restricts SSH cipher negotiation to one cipher or a comma-separated preference list. Leave this property empty to let Chilkat choose the first mutually supported cipher from its normal preference order.

Specifies the preferred host-key algorithm used during SSH connection establishment. The default is DSS; set it to RSA only when required for compatibility with a particular server.

Contains the server host-key fingerprint after a successful connection. A typical value is:

ssh-rsa 1024 68:ff:d1:4e:6c:ff:d7:b0:d6:58:73:85:07:bc:2e:d5

This property is nonempty only while a valid SSH connection exists. It is empty when no valid connection exists, including after a failed connection attempt.

Use GetHostKeyFP when a specific hash algorithm or output format is required.

Specifies the authentication method used by an HTTP proxy. Matching is case-insensitive.

Basic and NTLM are the supported methods. Chilkat automatically handles a 407 Proxy Authentication Required response and performs the required authentication exchange.

NTLMv2 is used unless NTLMv1 is explicitly selected by setting Global.DefaultNtlmVersion to 1.

Specifies the optional Windows domain used for NTLM authentication with an HTTP proxy.

The value is the legacy Windows NetBIOS domain name. It is not a DNS domain name and is not the workstation name. This property is ignored unless NTLM proxy authentication is used.

Specifies the hostname or numeric IP address of an HTTP proxy.

Chilkat uses the HTTP CONNECT method to establish the SSH tunnel through the proxy. The TCP connection to the proxy is not itself protected by TLS for this SSH use case.

The HTTP proxy is used only when SocksVersion is 0, this property is nonempty, and HttpProxyPort is nonzero. A configured SOCKS proxy takes precedence. These settings apply to both Connect and ConnectThroughSsh.

Specifies the password used to authenticate with an HTTP proxy.

If the proxy requires authentication and this property is empty, the connection fails.

Specifies the HTTP proxy port.

An HTTP proxy is used only when SocksVersion is 0, HttpProxyHostname is nonempty, and this property is nonzero. A configured SOCKS proxy takes precedence.

Specifies the username used to authenticate with an HTTP proxy.

If the proxy requires authentication and this property is empty, the connection fails.

Specifies the maximum time, in milliseconds, that an SSH operation may remain without send or receive progress. The operation fails when no progress occurs for longer than this interval.

The default is 0, which allows an indefinite wait.

Indicates Chilkat’s last known connection state. It becomes true after Connect successfully establishes the secure SSH transport. A failed Connect always leaves this property equal to false. It also becomes false after Disconnect or when another method detects that the connection has been lost.

Controls whether SSH protocol traffic is accumulated in SessionLog. The default is false.

Provides HTML-formatted information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.

Provides plain text information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.

Provides XML-formatted information about the last called method or property. If a method call fails or behaves unexpectedly, check this property for details. Note that information is available regardless of the method call's success.

Indicates the success or failure of the most recent method call: true means success, false means failure. This property remains unchanged by property setters or getters. This method is present to address challenges in checking for null or Nothing returns in certain programming languages. Note: This property does not apply to methods that return integer values or to boolean-returning methods where the boolean does not indicate success or failure.

Specifies the maximum SSH channel packet size advertised in the SSH_MSG_CHANNEL_OPEN message. The default is 8192.

For high-volume transfers, a value such as 32768 may improve performance.

Returns the number of channels currently open in this SSH session.

Indicates that the server rejected password authentication because it requires the user to change the password. This property is set by AuthenticatePw and AuthenticatePwPk.

When true, call the authentication method again and pass both passwords in this form:

|oldPassword|newPassword|

Controls which address family is selected when DNS resolution for a hostname returns both an IPv4 address and an IPv6 address.

• When false (the default), Chilkat selects the IPv4 address when one is available.
• When true, Chilkat selects the IPv6 address when one is available.

This property expresses a preference; it does not prohibit use of the other address family when the preferred family is unavailable.

Specifies the maximum total time, in milliseconds, allowed for a read operation, even while data continues to arrive. The default is 0, meaning no total read-time limit.

Specifies the character encoding used for command text sent by SendReqExec, QuickCommand, and QuickCmdSend. The default is ANSI; utf-8 is a common alternative.

Contains the SSH server-identification string received during connection establishment. For example:

SSH-2.0-OpenSSH_7.2p2 Ubuntu-4ubuntu2.2

If connection establishment fails, this property is cleared, even if the server identifier was received earlier during the failed attempt. It does not retain a value from a previous connection.

Contains the in-memory SSH session log. Enable logging by setting KeepSessionLog to true.

Specifies the SOCKS proxy hostname or IPv4 address. This property is used only when SocksVersion is 4 or 5.

Specifies the SOCKS5 password when proxy authentication is required. SOCKS4 does not define password authentication, so this property is ignored for SOCKS4.

Specifies the SOCKS proxy port. The default is 1080. This property is used only when SocksVersion is 4 or 5.

Specifies the SOCKS proxy username. This property is used only when SocksVersion is 4 or 5.

Selects whether and how a SOCKS proxy is used.

These proxy settings apply to both Connect and ConnectThroughSsh.

Specifies the socket receive-buffer size. The default is 4194304 bytes. Normally this property should remain unchanged.

When download throughput is unexpectedly low, testing a larger value may help. Values should generally be multiples of 4096.

When a proxy is used, this setting applies to the TCP connection made to the proxy.

Specifies the socket send-buffer size. The default is 262144 bytes. Normally this property should remain unchanged.

When upload throughput is unexpectedly low, testing values such as 524288 or 1048576 may help. Values should generally be multiples of 4096.

When a proxy is used, this setting applies to the TCP connection made to the proxy.

Controls whether stderr is merged into the normal channel receive buffer. The default is true.

When true, retrieve combined stdout and stderr with GetReceivedData, GetReceivedDataN, GetReceivedText, or GetReceivedTextS. When false, retrieve stderr separately with GetReceivedStderr or GetReceivedStderrText.

Controls whether terminal color escape sequences are removed from received text. The default is true. Set to false when the application needs the original terminal formatting codes.

Controls the TCP_NODELAY setting for the underlying TCP connection. The default is true, which disables the Nagle algorithm and generally improves responsiveness when many small messages are exchanged.

When a proxy is used, this setting applies to the TCP connection made to the proxy.

Provides comma-separated compatibility and security options for uncommon SSH scenarios. The default is an empty string, which is appropriate for most applications.

Contains a user-authentication banner received from the server during keyboard-interactive authentication. Check this property after calling StartKeyboardAuth and display it to the user when appropriate.

When set to true, all string arguments and return values are interpreted as UTF-8 strings. When set to false, they are interpreted as ANSI strings.

In Chilkat v11.0.0 and later, the default value is true. Before v11.0.0, it was false.

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

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

Authenticates the connected SSH session using public-key authentication. username identifies the server account, and privateKey supplies the matching private key. The corresponding public key must already be authorized for username on the server.

Returns true for success, false for failure.

Creates an asynchronous task to call the AuthenticatePk method with the arguments provided.

Returns nil on failure

Authenticates the connected SSH session using the login in login and the password in password.

A typical sequence is Connect followed by one authentication method. If the server requests a password change, see PasswordChangeRequested.

Returns true for success, false for failure.

Creates an asynchronous task to call the AuthenticatePw method with the arguments provided.

Returns nil on failure

Authenticates with a server that requires both a password and a private key. username is the username, password is the password, and privateKey is the private key.

Returns true for success, false for failure.

Creates an asynchronous task to call the AuthenticatePwPk method with the arguments provided.

Returns nil on failure

Performs the same password authentication as AuthenticatePw, but receives the login and password in SecureString objects.

Returns true for success, false for failure.

Creates an asynchronous task to call the AuthenticateSecPw method with the arguments provided.

Returns nil on failure

Performs the same combined password/private-key authentication as AuthenticatePwPk, but receives the username and password in SecureString objects.

Returns true for success, false for failure.

Creates an asynchronous task to call the AuthenticateSecPwPk method with the arguments provided.

Returns nil on failure

Returns true when the channel identified by channelNum is currently open; otherwise returns false.

Polls the open channel in channelNum for incoming data, waiting at most pollTimeoutMs milliseconds. Data received by this method is placed in the channel’s internal receive buffer.

Creates an asynchronous task to call the ChannelPoll method with the arguments provided.

Returns nil on failure

Reads incoming data from the open channel in channelNum. The first wait is limited by IdleTimeoutMs. Received bytes are accumulated in the channel’s internal receive buffer.

Creates an asynchronous task to call the ChannelRead method with the arguments provided.

Returns nil on failure

Reads the channel in channelNum and continues reading until no additional data arrives for pollTimeoutMs milliseconds. The first wait uses IdleTimeoutMs; after data begins arriving, each subsequent wait uses pollTimeoutMs.

Creates an asynchronous task to call the ChannelReadAndPoll method with the arguments provided.

Returns nil on failure

Works like ChannelReadAndPoll, but also returns as soon as the total available received data exceeds maxNumBytes bytes.

Creates an asynchronous task to call the ChannelReadAndPoll2 method with the arguments provided.

Returns nil on failure

Returns true if an SSH CLOSE message has been received for the channel in channelNum. After CLOSE, the channel is closed in both directions and no more data should be sent.

Returns true if an SSH EOF message has been received for the channel in channelNum. EOF means the server will send no more data, but the client may still send data until the channel is closed.

Returns true if the server has supplied an exit-status value for the channel in channelNum. When true, call GetChannelExitStatus.

Receives data on the channel in channelNum until the server closes the channel. On success, use GetReceivedNumBytes to inspect the buffered byte count and a GetReceived* method to retrieve the data.

Returns true for success, false for failure.

Creates an asynchronous task to call the ChannelReceiveToClose method with the arguments provided.

Returns nil on failure

Receives text on the channel in channelNum until the accumulated text matches the wildcard pattern in matchPattern. For example, *Hello World* waits until that text appears. charset specifies the character encoding, and caseSensitive controls case sensitivity.

The method may read beyond the matched text. Use GetReceivedTextS with the matching substring to remove and return only the text through the match.

Returns true for success, false for failure.

Creates an asynchronous task to call the ChannelReceiveUntilMatch method with the arguments provided.

Returns nil on failure

Works like ChannelReceiveUntilMatch, but returns when any pattern contained in the StringArray passed in matchPatterns is matched. charset specifies the character encoding, and caseSensitive controls case sensitivity.

Returns true for success, false for failure.

Creates an asynchronous task to call the ChannelReceiveUntilMatchN method with the arguments provided.

Returns nil on failure

Releases Chilkat’s internal resources for the channel in channelNum after it has been closed. Channels are released automatically when the Ssh object is disposed, so this method is normally needed only by long-running applications that open and close very large numbers of channels.

Sends an SSH CLOSE message for the channel in channelNum, closing the channel in both directions.

Returns true for success, false for failure.

Creates an asynchronous task to call the ChannelSendClose method with the arguments provided.

Returns nil on failure

Sends an SSH EOF message on the channel in channelNum. After EOF is sent, no additional data may be sent on that channel, although data may still be received until the channel closes.

Returns true for success, false for failure.

Creates an asynchronous task to call the ChannelSendEof method with the arguments provided.

Returns nil on failure

Encodes the text in textData using the character set named by charset, then sends the resulting bytes on the channel in channelNum.

See Supported Charsets. When CaretControl is true, caret sequences are translated to control characters before sending.

Returns true for success, false for failure.

Creates an asynchronous task to call the ChannelSendString method with the arguments provided.

Returns nil on failure

Actively checks whether the underlying TCP socket is still connected to the SSH server. Unlike IsConnected, this method performs a connection check rather than returning only the last known state.

Clears all TTY mode settings previously added with SetTtyMode. The next SendReqPty request will not include those cleared modes.

Establishes an SSH connection to domainName on the TCP port specified by port. The domainName may be a DNS hostname or a numeric IPv4 or IPv6 address.

Proxy selection: If SocksVersion is 4 or 5, Chilkat connects through the configured SOCKS proxy. Otherwise, if HttpProxyHostname is nonempty and HttpProxyPort is nonzero, Chilkat connects through the HTTP proxy. If neither condition applies, Chilkat connects directly to the SSH server.

If this method is called while the object is already connected, Chilkat first disconnects the existing session and then establishes a new connection. This occurs even when connecting again to the same server. The existing connection and its channels are replaced.

The same Ssh object may be reused after Disconnect or after a failed connection attempt. A failed call always leaves IsConnected equal to false. Connection-related property settings remain in effect across disconnects and subsequent connection attempts.

Supported negotiation algorithms include:

Returns true for success, false for failure.

Creates an asynchronous task to call the Connect method with the arguments provided.

Returns nil on failure

Connects to another SSH server through the already connected and authenticated Ssh object in ssh. hostname and port identify the destination host and port.

application  →  first SSH server  →  destination SSH server

After this method succeeds, authenticate separately with the destination server by calling one of its Authenticate* methods.

The proxy properties on this object also apply to this connection. SOCKS takes precedence over HTTP proxy settings, using the same selection rules as Connect.

Returns true for success, false for failure.

Creates an asynchronous task to call the ConnectThroughSsh method with the arguments provided.

Returns nil on failure

Continues keyboard-interactive authentication by submitting the response in response. For a single prompt, response may be the response text. When the preceding information request contains multiple prompts, supply an XML response:

<response>
  <response1>response to first prompt</response1>
  <response2>response to second prompt</response2>
  ...
</response>

The returned XML has one of three forms: authentication success, authentication failure, or another information request containing additional prompts.

<success>success message</success>

<error>error message</error>

<infoRequest numPrompts="N">
  <name>name</name>
  <instruction>instructions</instruction>
  <prompt1 echo="1_or_0">prompt text</prompt1>
  ...
</infoRequest>

Returns true for success, false for failure.

Creates an asynchronous task to call the ContinueKeyboardAuth method with the arguments provided.

Returns nil on failure

Closes the current SSH connection and releases all open channels associated with the session.

The Ssh object remains reusable. Connection-related property settings are not reset and remain in effect for subsequent calls to Connect. Every newly established connection begins unauthenticated, even if the object authenticated a previous session.

Queries the connected server for its supported user-authentication methods and returns a comma-separated string such as publickey,password,keyboard-interactive.

Returns true for success, false for failure.

Creates an asynchronous task to call the GetAuthMethods method with the arguments provided.

Returns nil on failure

Returns the exit-status value received for the channel in channelNum. Call this method only after ChannelReceivedExitStatus returns true.

Returns the channel number for the open channel at zero-based index index. Use NumOpenChannels to determine the valid index range. Returns -1 when index is out of range.

Returns the type of the open channel at zero-based index index. Possible values include session, x11, forwarded-tcpip, and direct-tcpip.

Returns true for success, false for failure.

Returns the connected server’s host-key fingerprint. hashAlg specifies the hash algorithm, such as SHA256, SHA384, SHA512, SHA1, MD5, or a SHA-3 variant. includeKeyType controls whether the host-key type is included; includeHashName controls whether the hash name is included.

Possible host-key types include ssh-rsa, ECDSA types such as ecdsa-sha2-nistp256, ssh-ed25519, and ssh-dss.

Returns true for success, false for failure.

Copies structured diagnostic information from the most recently called method into the JsonObject in json. Many methods do not produce additional JSON details; in those cases the object may contain little or no information.

Returns the number of bytes currently available in the receive buffer for the channel in channelNum. Retrieve the bytes with GetReceivedData, GetReceivedDataN, or a text-retrieval method.

Decodes and returns all text currently accumulated in the stderr buffer for the channel in channelNum, using the character set in charset. The stderr buffer is cleared after the text is returned.

See Supported Charsets.

Returns true for success, false for failure.

Decodes and returns all text currently accumulated in the receive buffer for the channel in channelNum, using the character set in charset. The receive buffer is cleared after the text is returned.

See Supported Charsets.

Returns true for success, false for failure.

Decodes text in the channel receive buffer and returns only the portion through the first occurrence of substr, inclusive. charset specifies the character set.

The returned portion is removed from the buffer. If substr is not found, an empty string is returned and the buffer is left unchanged.

Returns true for success, false for failure.

Loads into this object the caller state associated with the asynchronous method represented by task. This is used by generated asynchronous wrappers to recover the object that initiated the task.

Returns true for success, false for failure.

Requests a custom SSH channel whose application-defined channel type is supplied in channelType. On success, returns the channel number used by subsequent channel methods; returns -1 on failure.

Creates an asynchronous task to call the OpenCustomChannel method with the arguments provided.

Returns nil on failure

Opens a direct-tcpip channel through the SSH server to the target host in targetHostname and port in targetPort. Bytes sent with ChannelSend* methods are forwarded to the target; data received from the target is read with ChannelRead* or ChannelReceive* methods.

Returns the new channel number on success, or -1 on failure.

Creates an asynchronous task to call the OpenDirectTcpIpChannel method with the arguments provided.

Returns nil on failure

Opens a new SSH session channel. Session channels are used for command execution, shells, PTY requests, environment variables, and related SSH connection-protocol requests.

1. Connect
2. Authenticate
3. OpenSessionChannel
4. SendReqExec or SendReqShell

Returns the new channel number on success, or -1 on failure.

Creates an asynchronous task to call the OpenSessionChannel method with the arguments provided.

Returns nil on failure

Returns the text currently buffered for the channel in channelNum, decoded using charset, without removing it from the receive buffer.

Returns true for success, false for failure.

Waits up to pollTimeoutMs milliseconds for any command previously started by QuickCmdSend to complete.

Creates an asynchronous task to call the QuickCmdCheck method with the arguments provided.

Returns nil on failure

Starts a remote command and immediately returns its channel number, allowing multiple commands to run concurrently. Internally, this method opens a session channel and sends an exec request.

command is the command. ReqExecCharset controls its encoding. Returns -1 on failure.

Creates an asynchronous task to call the QuickCmdSend method with the arguments provided.

Returns nil on failure

Executes one remote command and returns its complete output as text. Internally, this method opens a session channel, sends an exec request, receives until the channel closes, and decodes the buffered output.

command is the command. charset specifies the output character set, such as utf-8 or ansi. ReqExecCharset controls the encoding used to send the command.

Returns true for success, false for failure.

Creates an asynchronous task to call the QuickCommand method with the arguments provided.

Returns nil on failure

Starts a remote shell using the simplified sequence OpenSessionChannel → SendReqPty → SendReqShell. Returns the shell channel number on success, or -1 on failure.

Creates an asynchronous task to call the QuickShell method with the arguments provided.

Returns nil on failure

Initiates SSH key re-exchange and waits for it to complete. Either client or server may initiate rekeying at any time.

RFC 4253 recommends changing keys after approximately one gigabyte of transferred data or one hour of connection time, whichever occurs first. In normal use, servers initiate rekeying as needed and Chilkat handles it transparently.

Returns true for success, false for failure.

Creates an asynchronous task to call the ReKey method with the arguments provided.

Returns nil on failure

Sends an SSH IGNORE message. The server does not reply, but a successful send helps verify that the connection is still writable. No channel is required.

Returns true for success, false for failure.

Creates an asynchronous task to call the SendIgnore method with the arguments provided.

Returns nil on failure

Requests execution of the command line in commandLine on the session channel in channelNum. commandLine should contain the complete command and its arguments.

This starts a noninteractive command, not a persistent shell. ReqExecCharset controls the encoding of the command text.

Returns true for success, false for failure.

Creates an asynchronous task to call the SendReqExec method with the arguments provided.

Returns nil on failure

Requests a pseudo-terminal for the session channel in channelNum. termType specifies the terminal type. For character-oriented terminals such as vt100, set widthInChars and heightInChars to the character dimensions and typically set widthInPixels and heightInPixels to 0. For pixel-oriented terminals such as xterm, provide pixel dimensions in widthInPixels and heightInPixels.

1. Connect
2. Authenticate
3. OpenSessionChannel
4. SendReqPty, if required
5. SendReqShell

Returns true for success, false for failure.

Creates an asynchronous task to call the SendReqPty method with the arguments provided.

Returns nil on failure

Requests that the server set the environment variable named by name to the value in value for the session channel in channelNum. The server may accept or reject environment-variable requests according to its configuration.

Returns true for success, false for failure.

Creates an asynchronous task to call the SendReqSetEnv method with the arguments provided.

Returns nil on failure

Starts an interactive shell on the open session channel in channelNum. Some servers require a PTY request first; in that case call SendReqPty before this method.

After the shell starts, send commands with ChannelSendString. Include the line ending expected by the remote shell, commonly CRLF.

Returns true for success, false for failure.

Creates an asynchronous task to call the SendReqShell method with the arguments provided.

Returns nil on failure

Requests delivery of the signal named by signalName to the remote process running on the channel in channelNum. Supported signal names are:

ABRT  ALRM  FPE  HUP  ILL  INT  KILL
PIPE  QUIT  SEGV TERM USR1 USR2

These are Unix-style signals and are relevant when the SSH server and remote process support them.

Returns true for success, false for failure.

Creates an asynchronous task to call the SendReqSignal method with the arguments provided.

Returns nil on failure

Requests the predefined subsystem named by subsystemName on the session channel in channelNum. For example, SFTP clients start the sftp subsystem.

Returns true for success, false for failure.

Creates an asynchronous task to call the SendReqSubsystem method with the arguments provided.

Returns nil on failure

Notifies the server that the client-side terminal size changed for the channel in channelNum. widthInChars and heightInRows specify the character dimensions; pixWidth and pixHeight specify the pixel dimensions.

Creates an asynchronous task to call the SendReqWindowChange method with the arguments provided.

Returns nil on failure

Sends an SSH X11-forwarding request on the session channel in channelNum. singleConnection controls whether forwarding is limited to a single connection; authProt through screenNum provide the X11 authentication protocol, cookie, and screen number.

Creates an asynchronous task to call the SendReqX11Forwarding method with the arguments provided.

Returns nil on failure

Deprecated for practical use. This method should not be used.

Creates an asynchronous task to call the SendReqXonXoff method with the arguments provided.

Returns nil on failure

Applies an explicit allow-list of SSH negotiation algorithms supplied in json. Use this method before Connect when security policy or server compatibility requires precise control over accepted host-key, key-exchange, cipher, MAC, or compression algorithms.

Returns true for success, false for failure.

Adds or updates one TTY mode to be included in a later SendReqPty request. ttyName is the mode name and ttyValue is its integer value, commonly 0 or 1. Call this method once for each mode to set.

Supported mode 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

Begins keyboard-interactive authentication for the login in login. The returned XML describes the server’s prompts and whether each response should be echoed.

<infoRequest numPrompts="N">
  <name>name</name>
  <instruction>instructions</instruction>
  <prompt1 echo="1_or_0">prompt text</prompt1>
  ...
</infoRequest>

If authentication immediately succeeds or fails, the returned XML instead has one of these forms:

<success>success message</success>

<error>error message</error>

Submit responses with ContinueKeyboardAuth.

Returns true for success, false for failure.

Creates an asynchronous task to call the StartKeyboardAuth method with the arguments provided.

Returns nil on failure

Waits up to pollTimeoutMs milliseconds for an incoming SSH message on any channel. Pass 0 to poll without waiting.

Creates an asynchronous task to call the WaitForChannelMessage method with the arguments provided.

Returns nil on failure

Sends the bytes in byteData on the channel identified by channelNum.

Returns true for success, false for failure.

Creates an asynchronous task to call the ChannelSendData method with the arguments provided.

Returns nil on failure

Appends all bytes currently accumulated in the receive buffer for the channel in channelNum to the BinData object in bd, then clears the channel receive buffer.

Returns true for success, false for failure.

Returns all bytes currently accumulated in the receive buffer for the channel in channelNum, then clears that buffer.

Returns true for success, false for failure.

Returns and removes at most maxNumBytes bytes from the receive buffer for the channel in channelNum. Any remaining bytes stay buffered for a later call.

Returns true for success, false for failure.

Returns all bytes currently accumulated in the stderr buffer for the channel in channelNum, then clears that stderr buffer.

Returns true for success, false for failure.

Deprecated. Use GetLastJsonData instead.

For methods that provide structured diagnostic details, returns a JsonObject describing what occurred during the most recent operation. Many methods do not produce additional JSON data.

Returns nil on failure