SFtp Delphi DLL Reference Documentation

SFtp

Current Version: 9.5.0.97

SFTP implementation for file transfer and remote file management over SSH.

Create/Dispose

var
myObject: HCkSFtp;

begin
myObject := CkSFtp_Create();

// ...

CkSFtp_Dispose(myObject);
end;
function CkSFtp_Create: HCkSFtp; stdcall;

Creates an instance of the HCkSFtp object and returns a handle (i.e. a Pointer). The handle is passed in the 1st argument for the functions listed on this page.

procedure CkSFtp_Dispose(handle: HCkSFtp); stdcall;

Objects created by calling CkSFtp_Create must be freed by calling this method. A memory leak occurs if a handle is not disposed by calling this function.

Properties

AbortCurrent
function CkSFtp_getAbortCurrent(objHandle: HCkSFtp): wordbool; stdcall;
procedure CkSFtp_putAbortCurrent(objHandle: HCkSFtp; newPropVal: wordbool); stdcall;
Introduced in version 9.5.0.58

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

top
AccumulateBuffer
procedure CkSFtp_getAccumulateBuffer(objHandle: HCkSFtp; outPropVal: HCkByteData); stdcall;

Contains the bytes downloaded from a remote file via the AccumulateBytes method call. Each call to AccumulateBytes appends to this buffer. To clear this buffer, call the ClearAccumulateBuffer method.

top
AuthFailReason
function CkSFtp_getAuthFailReason(objHandle: HCkSFtp): Integer; stdcall;
Introduced in version 9.5.0.52

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.

top
BandwidthThrottleDown
function CkSFtp_getBandwidthThrottleDown(objHandle: HCkSFtp): Integer; stdcall;
procedure CkSFtp_putBandwidthThrottleDown(objHandle: HCkSFtp; newPropVal: Integer); stdcall;
Introduced in version 9.5.0.49

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

top
BandwidthThrottleUp
function CkSFtp_getBandwidthThrottleUp(objHandle: HCkSFtp): Integer; stdcall;
procedure CkSFtp_putBandwidthThrottleUp(objHandle: HCkSFtp; newPropVal: Integer); stdcall;
Introduced in version 9.5.0.49

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

More Information and Examples
top
ClientIdentifier
procedure CkSFtp_getClientIdentifier(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putClientIdentifier(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__clientIdentifier(objHandle: HCkSFtp): PWideChar; stdcall;

The client-identifier string to be used when connecting to an SSH/SFTP server. Defaults to "SSH-2.0-PuTTY_Release_0.78". (This string is used to mimic PuTTY because some servers are known to disconnect from clients with unknown client identifiers.)

top
ClientIpAddress
procedure CkSFtp_getClientIpAddress(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putClientIpAddress(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__clientIpAddress(objHandle: HCkSFtp): PWideChar; stdcall;

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

top
ConnectTimeoutMs
function CkSFtp_getConnectTimeoutMs(objHandle: HCkSFtp): Integer; stdcall;
procedure CkSFtp_putConnectTimeoutMs(objHandle: HCkSFtp; newPropVal: Integer); stdcall;

Maximum number of milliseconds to wait when connecting to an SSH server.

To clarify: This property determines how long to wait for the SSH server to accept the TCP connection. Once the connection is made, it is the IdleTimeoutMs property that applies to receiving data and responses.

top
DebugLogFilePath
procedure CkSFtp_getDebugLogFilePath(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putDebugLogFilePath(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__debugLogFilePath(objHandle: HCkSFtp): PWideChar; stdcall;

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

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

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

top
DisconnectCode
function CkSFtp_getDisconnectCode(objHandle: HCkSFtp): Integer; stdcall;

If the SSH/SFTP 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

top
DisconnectReason
procedure CkSFtp_getDisconnectReason(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
function CkSFtp__disconnectReason(objHandle: HCkSFtp): PWideChar; stdcall;

If the SSH/SFTP server sent a DISCONNECT message when closing the connection, this property contains a descriptive string for the "reason code" as specified in RFC 4253.

top
EnableCache
function CkSFtp_getEnableCache(objHandle: HCkSFtp): wordbool; stdcall;
procedure CkSFtp_putEnableCache(objHandle: HCkSFtp; newPropVal: wordbool); stdcall;

Controls whether the component keeps an internal file size & attribute cache. The cache affects the following methods: GetFileSize32, GetFileSize64, GetFileSizeStr, GetFileCreateTime, GetFileLastAccess, GetFileLastModified, GetFileOwner, GetFileGroup, and GetFilePermissions.

The file attribute cache exists to minimize communications with the SFTP server. If the cache is enabled, then a request for any single attribute will cause all of the attributes to be cached. A subsequent request for a different attribute of the same file will be fulfilled from cache, eliminating the need for a message to be sent to the SFTP server.

Note: Caching only occurs when filenames are used, not handles.

top
EnableCompression
function CkSFtp_getEnableCompression(objHandle: HCkSFtp): wordbool; stdcall;
procedure CkSFtp_putEnableCompression(objHandle: HCkSFtp; newPropVal: wordbool); stdcall;
Introduced in version 9.5.0.56

Enables or disables the use of compression w/ the SSH connection. The default value is False.

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.

top
FilenameCharset
procedure CkSFtp_getFilenameCharset(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putFilenameCharset(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__filenameCharset(objHandle: HCkSFtp): PWideChar; stdcall;

Automatically set during the InitializeSftp method if the server sends a filename-charset name-value extension. Otherwise, may be set directly to the name of a charset, such as "utf-8", "iso-8859-1", "windows-1252", etc. ("ansi" is also a valid choice.) Incoming filenames are interpreted as utf-8 if no FilenameCharset is set. Outgoing filenames are sent using utf-8 by default. Otherwise, incoming and outgoing filenames use the charset specified by this property.

top
ForceCipher
procedure CkSFtp_getForceCipher(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putForceCipher(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__forceCipher(objHandle: HCkSFtp): PWideChar; stdcall;

Set to one of the following encryption algorithms to force that cipher to be used. By default, the component will automatically choose the first cipher supported by the server in the order listed here: "aes256-ctr", "aes128-ctr", "aes256-cbc", "aes128-cbc", "twofish256-cbc", "twofish128-cbc", "blowfish-cbc", "3des-cbc", "arcfour128", "arcfour256". (If blowfish is chosen, the encryption strength is 128 bits.)

Important: If this is property is set and the server does NOT support then encryption algorithm, then the Connect will fail.

top
ForceV3
function CkSFtp_getForceV3(objHandle: HCkSFtp): wordbool; stdcall;
procedure CkSFtp_putForceV3(objHandle: HCkSFtp; newPropVal: wordbool); stdcall;

If set to True, forces the client to choose version 3 of the SFTP protocol, even if the server supports a higher version. The default value of this property is True.

top
HeartbeatMs
function CkSFtp_getHeartbeatMs(objHandle: HCkSFtp): Integer; stdcall;
procedure CkSFtp_putHeartbeatMs(objHandle: HCkSFtp; newPropVal: Integer); stdcall;

This is the number of milliseconds between each AbortCheck event callback. The AbortCheck callback allows an application to abort any SFTP operation prior to completion. If HeartbeatMs is 0 (the default), no AbortCheck event callbacks will fire.

top
HostKeyAlg
procedure CkSFtp_getHostKeyAlg(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putHostKeyAlg(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__hostKeyAlg(objHandle: HCkSFtp): PWideChar; stdcall;

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.

top
HostKeyFingerprint
procedure CkSFtp_getHostKeyFingerprint(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
function CkSFtp__hostKeyFingerprint(objHandle: HCkSFtp): PWideChar; stdcall;

Returns the MD5 host key fingerprint of the server, which is automatically set after connecting to an SSH/SFTP server. Depending on the host key type, the format of the MD5 fingerprint looks like this:

ssh-rsa 2048 68:ff:d1:4e:6c:ff:d7:b0:d6:58:73:85:07:bc:2e:d5
ssh-dss 2048 68:ff:d1:4e:6c:ff:d7:b0:d6:58:73:85:07:bc:2e:d5
ssh-ed25519 68:ff:d1:4e:6c:ff:d7:b0:d6:58:73:85:07:bc:2e:d5
ecdsa-sha2-nistp256 256 a3:09:05:b5:81:79:5d:33:e1:1a:82:c7:cb:ba:93:ea

Note: To get the SHA256 host key fingerprint, use the GetHostKeyFP method (added in v9.5.0.92)

More Information and Examples
top
HttpProxyAuthMethod
procedure CkSFtp_getHttpProxyAuthMethod(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putHttpProxyAuthMethod(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__httpProxyAuthMethod(objHandle: HCkSFtp): PWideChar; stdcall;

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

top
HttpProxyDomain
procedure CkSFtp_getHttpProxyDomain(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putHttpProxyDomain(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__httpProxyDomain(objHandle: HCkSFtp): PWideChar; stdcall;

The NTLM authentication domain (optional) if NTLM authentication is used w/ the HTTP proxy.

top
HttpProxyHostname
procedure CkSFtp_getHttpProxyHostname(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putHttpProxyHostname(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__httpProxyHostname(objHandle: HCkSFtp): PWideChar; stdcall;

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

top
HttpProxyPassword
procedure CkSFtp_getHttpProxyPassword(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putHttpProxyPassword(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__httpProxyPassword(objHandle: HCkSFtp): PWideChar; stdcall;

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

top
HttpProxyPort
function CkSFtp_getHttpProxyPort(objHandle: HCkSFtp): Integer; stdcall;
procedure CkSFtp_putHttpProxyPort(objHandle: HCkSFtp; newPropVal: Integer); stdcall;

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

top
HttpProxyUsername
procedure CkSFtp_getHttpProxyUsername(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putHttpProxyUsername(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__httpProxyUsername(objHandle: HCkSFtp): PWideChar; stdcall;

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

top
IdleTimeoutMs
function CkSFtp_getIdleTimeoutMs(objHandle: HCkSFtp): Integer; stdcall;
procedure CkSFtp_putIdleTimeoutMs(objHandle: HCkSFtp; newPropVal: Integer); stdcall;

Causes SFTP operations to fail when progress for sending or receiving data halts for more than this number of milliseconds. Setting IdleTimeoutMs = 0 allows the application to wait indefinitely. The default value of this property is 30000 (which equals 30 seconds).

top
IncludeDotDirs
function CkSFtp_getIncludeDotDirs(objHandle: HCkSFtp): wordbool; stdcall;
procedure CkSFtp_putIncludeDotDirs(objHandle: HCkSFtp; newPropVal: wordbool); stdcall;

If True, then the ReadDir method will include the "." and ".." directories in its results. The default value of this property is False.

top
InitializeFailCode
function CkSFtp_getInitializeFailCode(objHandle: HCkSFtp): Integer; stdcall;

The InitializeSftp method call opens a channel for the SFTP session. If the 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

top
InitializeFailReason
procedure CkSFtp_getInitializeFailReason(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
function CkSFtp__initializeFailReason(objHandle: HCkSFtp): PWideChar; stdcall;

The InitializeSftp method call opens a channel for the SFTP session. If the request to open a channel fails, this property contains a description of the reason for failure. (It contains descriptive text matching the InitializeFailCode property.)

top
IsConnected
function CkSFtp_getIsConnected(objHandle: HCkSFtp): wordbool; stdcall;

Returns True if connected to the SSH server. Note: This does not mean authentication has happened or InitializeSftp has already succeeded. It only means that the connection has been established by calling Connect.

Understanding the IsConnected property: The IsConnected property is the last known state of the TCP connection (either connected or disconnected). This requires some explanation because most developer have incorrect assumptions about TCP connections.

  • If a TCP connection is established, and neither side is reading or writing the socket (i.e. both sides are doing nothing), then you can disconnect the network cable from the computer for any length of time, and then re-connect, and the TCP connection is not affected.
  • A TCP connection only becomes disconnected when an attempt is made to read/write while a network problem exists. If no attempts to read/write occur, a network problem may arise and then become resolved without affecting the TCP connection.
  • If the peer chooses to close its side of the TCP connection, your application won't magically know about it until you try to do something with the TCP socket (such as read or write).
  • A Chilkat API property (as opposed to a method) CANNOT and should not do something that would cause an application to timeout, hang, etc. Therefore, it is not appropriate for the IsConnected property to attempt any kind of socket operation (read/write/peek) on the socket. It simply returns the last known state of the connection. It may very well be that your network cable is unplugged and IsConnected returns True because technically, if neither peer is trying to read/write, the network cable could be plugged back in without affecting the connection. IsConnected could also return True if the peer has already closed its side of the connection, because the state of the connection is only updated after trying to read/write/peek.
  • To truly know the current connected state (as opposed to the last known connection state), your application should attempt a network operation that is appropriate to the protocol. For SFTP, an application could call SendIgnore, and then check IsConnected.

top
KeepSessionLog
function CkSFtp_getKeepSessionLog(objHandle: HCkSFtp): wordbool; stdcall;
procedure CkSFtp_putKeepSessionLog(objHandle: HCkSFtp; newPropVal: wordbool); stdcall;

Controls whether communications to/from the SFTP 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 SFTP activity transpires. The purpose of the KeepSessionLog / SessionLog properties is to help in debugging any future problems that may arise.

top
LastErrorHtml
procedure CkSFtp_getLastErrorHtml(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
function CkSFtp__lastErrorHtml(objHandle: HCkSFtp): PWideChar; stdcall;

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

top
LastErrorText
procedure CkSFtp_getLastErrorText(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
function CkSFtp__lastErrorText(objHandle: HCkSFtp): PWideChar; stdcall;

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

top
LastErrorXml
procedure CkSFtp_getLastErrorXml(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
function CkSFtp__lastErrorXml(objHandle: HCkSFtp): PWideChar; stdcall;

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

top
LastMethodSuccess
function CkSFtp_getLastMethodSuccess(objHandle: HCkSFtp): wordbool; stdcall;
procedure CkSFtp_putLastMethodSuccess(objHandle: HCkSFtp; newPropVal: wordbool); stdcall;

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

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

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

top
LastStatusCode
function CkSFtp_getLastStatusCode(objHandle: HCkSFtp): Integer; stdcall;
Introduced in version 9.5.0.85

Contains the numeric last status code received in an SSH_FXP_STATUS message received from the SFTP server. Status codes are defined in the SFTP protocol specification as follows:

(See https://tools.ietf.org/id/draft-ietf-secsh-filexfer-13.txt)

SSH_FX_OK                            0
SSH_FX_EOF                           1
SSH_FX_NO_SUCH_FILE                  2
SSH_FX_PERMISSION_DENIED             3
SSH_FX_FAILURE                       4
SSH_FX_BAD_MESSAGE                   5
SSH_FX_NO_CONNECTION                 6
SSH_FX_CONNECTION_LOST               7
SSH_FX_OP_UNSUPPORTED                8
SSH_FX_INVALID_HANDLE                9
SSH_FX_NO_SUCH_PATH                  10
SSH_FX_FILE_ALREADY_EXISTS           11
SSH_FX_WRITE_PROTECT                 12
SSH_FX_NO_MEDIA                      13
SSH_FX_NO_SPACE_ON_FILESYSTEM        14
SSH_FX_QUOTA_EXCEEDED                15
SSH_FX_UNKNOWN_PRINCIPAL             16
SSH_FX_LOCK_CONFLICT                 17
SSH_FX_DIR_NOT_EMPTY                 18
SSH_FX_NOT_A_DIRECTORY               19
SSH_FX_INVALID_FILENAME              20
SSH_FX_LINK_LOOP                     21
SSH_FX_CANNOT_DELETE                 22
SSH_FX_INVALID_PARAMETER             23
SSH_FX_FILE_IS_A_DIRECTORY           24
SSH_FX_BYTE_RANGE_LOCK_CONFLICT      25
SSH_FX_BYTE_RANGE_LOCK_REFUSED       26
SSH_FX_DELETE_PENDING                27
SSH_FX_FILE_CORRUPT                  28
SSH_FX_OWNER_INVALID                 29
SSH_FX_GROUP_INVALID                 30
SSH_FX_NO_MATCHING_BYTE_RANGE_LOCK       31

top
LastStatusMessage
procedure CkSFtp_getLastStatusMessage(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
function CkSFtp__lastStatusMessage(objHandle: HCkSFtp): PWideChar; stdcall;
Introduced in version 9.5.0.85

Contains the message text received in the last SSH_FXP_STATUS message received from the SFTP server. The actual text of the message can vary depending on the SFTP server implementation. The integer status code is available in the LastStatusCode property.

top
MaxPacketSize
function CkSFtp_getMaxPacketSize(objHandle: HCkSFtp): Integer; stdcall;
procedure CkSFtp_putMaxPacketSize(objHandle: HCkSFtp; newPropVal: Integer); stdcall;

The maximum packet length to be used in the underlying SSH transport protocol. The default value is 32768. (This should generally be left unchanged.)

top
PasswordChangeRequested
function CkSFtp_getPasswordChangeRequested(objHandle: HCkSFtp): wordbool; stdcall;

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|

top
PercentDoneScale
function CkSFtp_getPercentDoneScale(objHandle: HCkSFtp): Integer; stdcall;
procedure CkSFtp_putPercentDoneScale(objHandle: HCkSFtp; newPropVal: Integer); stdcall;
Introduced in version 9.5.0.49

This property is only valid in programming environment and languages that allow for event callbacks.

Sets the value to be defined as 100% complete for the purpose of PercentDone event callbacks. The defaut value of 100 means that at most 100 event PercentDone callbacks will occur in a method that (1) is event enabled and (2) is such that it is possible to measure progress as a percentage completed. This property may be set to larger numbers to get more fine-grained PercentDone callbacks. For example, setting this property equal to 1000 will provide callbacks with .1 percent granularity. For example, a value of 453 would indicate 45.3% competed. This property is clamped to a minimum value of 10, and a maximum value of 100000.

top
PreferIpv6
function CkSFtp_getPreferIpv6(objHandle: HCkSFtp): wordbool; stdcall;
procedure CkSFtp_putPreferIpv6(objHandle: HCkSFtp; newPropVal: wordbool); stdcall;

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.

top
PreserveDate
function CkSFtp_getPreserveDate(objHandle: HCkSFtp): wordbool; stdcall;
procedure CkSFtp_putPreserveDate(objHandle: HCkSFtp; newPropVal: wordbool); stdcall;

If True, then the file last-modified and create date/time will be preserved for downloaded and uploaded files. The default value is False.

Note: It does not apply to uploads or downloads where the remote file is opened to obtain a handle, the data is uploaded/downloaded, and then the handle is closed.

top
ProtocolVersion
function CkSFtp_getProtocolVersion(objHandle: HCkSFtp): Integer; stdcall;

The negotiated SFTP protocol version, which should be a value between 3 and 6 inclusive. When the InitializeSftp method is called, the Chilkat SFTP client sends it's highest supported protocol version to the server, and the server sends it's SFTP protocol version in response. The negotiated protocol (i.e. the protocol version used for the session) is the lower of the two numbers. If the SFTP server's protocol version is lower than 6, some file date/attributes are not supported because they are not supported by the earlier protocol version. These exceptions are noted throughout the reference documentation.

top
ReadDirMustMatch
procedure CkSFtp_getReadDirMustMatch(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putReadDirMustMatch(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__readDirMustMatch(objHandle: HCkSFtp): PWideChar; stdcall;
Introduced in version 9.5.0.53

Can contain a wildcarded list of file patterns separated by semicolons. For example, "*.xml; *.txt; *.csv". If set, the ReadDir method will only return files that match any one of these patterns.

top
ReadDirMustNotMatch
procedure CkSFtp_getReadDirMustNotMatch(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putReadDirMustNotMatch(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__readDirMustNotMatch(objHandle: HCkSFtp): PWideChar; stdcall;
Introduced in version 9.5.0.53

Can contain a wildcarded list of file patterns separated by semicolons. For example, "*.xml; *.txt; *.csv". If set, the ReadDir method will only return files that do not match any of these patterns.

top
ServerIdentifier
procedure CkSFtp_getServerIdentifier(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
function CkSFtp__serverIdentifier(objHandle: HCkSFtp): PWideChar; stdcall;
Introduced in version 9.5.0.71

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

top
SessionLog
procedure CkSFtp_getSessionLog(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
function CkSFtp__sessionLog(objHandle: HCkSFtp): PWideChar; stdcall;

Contains a log of the messages sent to/from the SFTP 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.

top
SocksHostname
procedure CkSFtp_getSocksHostname(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putSocksHostname(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__socksHostname(objHandle: HCkSFtp): PWideChar; stdcall;

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

top
SocksPassword
procedure CkSFtp_getSocksPassword(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putSocksPassword(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__socksPassword(objHandle: HCkSFtp): PWideChar; stdcall;

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

top
SocksPort
function CkSFtp_getSocksPort(objHandle: HCkSFtp): Integer; stdcall;
procedure CkSFtp_putSocksPort(objHandle: HCkSFtp; newPropVal: Integer); stdcall;

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

top
SocksUsername
procedure CkSFtp_getSocksUsername(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putSocksUsername(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__socksUsername(objHandle: HCkSFtp): PWideChar; stdcall;

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

top
SocksVersion
function CkSFtp_getSocksVersion(objHandle: HCkSFtp): Integer; stdcall;
procedure CkSFtp_putSocksVersion(objHandle: HCkSFtp; newPropVal: Integer); stdcall;

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.

top
SoRcvBuf
function CkSFtp_getSoRcvBuf(objHandle: HCkSFtp): Integer; stdcall;
procedure CkSFtp_putSoRcvBuf(objHandle: HCkSFtp; newPropVal: Integer); stdcall;

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.

top
SoSndBuf
function CkSFtp_getSoSndBuf(objHandle: HCkSFtp): Integer; stdcall;
procedure CkSFtp_putSoSndBuf(objHandle: HCkSFtp; newPropVal: Integer); stdcall;

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.

top
SyncCreateAllLocalDirs
function CkSFtp_getSyncCreateAllLocalDirs(objHandle: HCkSFtp): wordbool; stdcall;
procedure CkSFtp_putSyncCreateAllLocalDirs(objHandle: HCkSFtp; newPropVal: wordbool); stdcall;
Introduced in version 9.5.0.76

If True, then empty directories on the server are created locally when doing a download synchronization. If False, then only directories containing files that are downloaded are auto-created.

The default value of this property is True.

top
SyncDirectives
procedure CkSFtp_getSyncDirectives(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putSyncDirectives(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__syncDirectives(objHandle: HCkSFtp): PWideChar; stdcall;
Introduced in version 9.5.0.58

A property that can contain a list of comma-separated keywords to control certain aspects of an upload or download synchronization (for the SyncTreeUpload and SyncTreeDownload methods). At this time there is only one possible directive, but others may be added in the future.

Set this property to "UploadIgnoreLocalOpenFailures" to skip local files that cannot be opened. A common reason for this would be if another process on the system has the file open for exclusive access.

top
SyncedFiles
procedure CkSFtp_getSyncedFiles(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putSyncedFiles(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__syncedFiles(objHandle: HCkSFtp): PWideChar; stdcall;
Introduced in version 9.5.0.51

The paths of the files uploaded or downloaded in the last call to SyncTreeUpload or SyncTreeDownload. The paths are listed one per line. In both cases (for upload and download) each line contains the paths relative to the root synced directory.

Note: For SyncTreeDownload, some of entires can be the paths of local directories that were created. Local directory paths will be terminated with a "/" char to disinguish a directory from an actual file.

top
SyncMustMatch
procedure CkSFtp_getSyncMustMatch(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putSyncMustMatch(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__syncMustMatch(objHandle: HCkSFtp): PWideChar; stdcall;

Can contain a wildcarded list of file patterns separated by semicolons. For example, "*.xml; *.txt; *.csv". If set, the SyncTreeUpload and SyncTreeDownload methods will only transfer files that match any one of these patterns. This property only applies to files. It does not apply to sub-directory names when recursively traversing a directory tree.

top
SyncMustMatchDir
procedure CkSFtp_getSyncMustMatchDir(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putSyncMustMatchDir(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__syncMustMatchDir(objHandle: HCkSFtp): PWideChar; stdcall;
Introduced in version 9.5.0.76

Can contain a wildcarded list of file patterns separated by semicolons. For example, "xml; txt; data_*". If set, the SyncTreeUpload and SyncTreeDownload methods will only enter directories that match any one of these patterns.

top
SyncMustNotMatch
procedure CkSFtp_getSyncMustNotMatch(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putSyncMustNotMatch(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__syncMustNotMatch(objHandle: HCkSFtp): PWideChar; stdcall;

Can contain a wildcarded list of file patterns separated by semicolons. For example, "*.xml; *.txt; *.csv". If set, the SyncTreeUpload and SyncTreeDownload methods will not transfer files that match any one of these patterns. This property only applies to files. It does not apply to sub-directory names when recursively traversing a directory tree.

top
SyncMustNotMatchDir
procedure CkSFtp_getSyncMustNotMatchDir(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putSyncMustNotMatchDir(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__syncMustNotMatchDir(objHandle: HCkSFtp): PWideChar; stdcall;
Introduced in version 9.5.0.76

Can contain a wildcarded list of file patterns separated by semicolons. For example, "xml; txt; data_*". If set, the SyncTreeUpload and SyncTreeDownload methods will not enter directories that match any one of these patterns.

top
TcpNoDelay
function CkSFtp_getTcpNoDelay(objHandle: HCkSFtp): wordbool; stdcall;
procedure CkSFtp_putTcpNoDelay(objHandle: HCkSFtp; newPropVal: wordbool); stdcall;

This property controls the use of the internal TCP_NODELAY socket option (which disables the Nagle algorithm). The default value of this property is False. Setting this value to True disables the delay of sending successive small packets on the network.

top
UncommonOptions
procedure CkSFtp_getUncommonOptions(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putUncommonOptions(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__uncommonOptions(objHandle: HCkSFtp): PWideChar; stdcall;
Introduced in version 9.5.0.73

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:

  • ProtectFromVpn - Introduced in v9.5.0.80. On Android systems, will bypass any VPN that may be installed or active.
  • NoSyncDownloadEmptyFiles - Introduced in v9.5.0.80. Prevents empty files from being downloaded in SyncTreeDownload.
  • +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.

top
UploadChunkSize
function CkSFtp_getUploadChunkSize(objHandle: HCkSFtp): Integer; stdcall;
procedure CkSFtp_putUploadChunkSize(objHandle: HCkSFtp; newPropVal: Integer); stdcall;

The chunk size to use when uploading files via the UploadFile or UploadFileByName methods. The default value is 32000. If an upload fails because "WSAECONNABORTED An established connection was aborted by the software in your host machine.", then try setting this property to a smaller value, such as 4096. A smaller value will result in slower transfer rates, but may help avoid this problem.

top
UserAuthBanner
procedure CkSFtp_getUserAuthBanner(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
procedure CkSFtp_putUserAuthBanner(objHandle: HCkSFtp; newPropVal: PWideChar); stdcall;
function CkSFtp__userAuthBanner(objHandle: HCkSFtp): PWideChar; stdcall;
Introduced in version 9.5.0.88

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.

top
UtcMode
function CkSFtp_getUtcMode(objHandle: HCkSFtp): wordbool; stdcall;
procedure CkSFtp_putUtcMode(objHandle: HCkSFtp; newPropVal: wordbool); stdcall;

If True, then date/times are returned as UTC times. If False (the default) then date/times are returned as local times.

top
VerboseLogging
function CkSFtp_getVerboseLogging(objHandle: HCkSFtp): wordbool; stdcall;
procedure CkSFtp_putVerboseLogging(objHandle: HCkSFtp; newPropVal: wordbool); stdcall;

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.

top
Version
procedure CkSFtp_getVersion(objHandle: HCkSFtp; outPropVal: HCkString); stdcall;
function CkSFtp__version(objHandle: HCkSFtp): PWideChar; stdcall;

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

More Information and Examples
top
XferByteCount
function CkSFtp_getXferByteCount(objHandle: HCkSFtp): LongWord; stdcall;
Introduced in version 9.5.0.71

The current transfer byte count for an ongoing upload or download. Programs doing asynchronous uploads or downloads can read this property in real time during the upload. For SyncTreeUpload and SyncTreeDownload operations, this is the real-time cumulative number of bytes for all files uploaded or downloaded.

top
XferByteCount64
function CkSFtp_getXferByteCount64(objHandle: HCkSFtp): Int64; stdcall;
Introduced in version 9.5.0.71

The current transfer byte count for an ongoing upload or download. Programs doing asynchronous uploads or downloads can read this property in real time during the upload. For SyncTreeUpload and SyncTreeDownload operations, this is the real-time cumulative number of bytes for all files uploaded or downloaded.

top

Methods

AccumulateBytes
function CkSFtp_AccumulateBytes(objHandle: HCkSFtp;
    handle: PWideChar;
    maxBytes: Integer): Integer; stdcall;

Downloads bytes from an open file and appends them to the AccumulateBuffer. The handle is a file handle returned by the OpenFile method. The maxBytes is the maximum number of bytes to read. If the end-of-file is reached prior to reading the number of requested bytes, then fewer bytes may be returned.

Returns the number of bytes downloaded and appended to AccumulateBuffer. Returns -1 on error.

top
AccumulateBytesAsync (1)
function CkSFtp_AccumulateBytesAsync(objHandle: HCkSFtp;
    handle: PWideChar;
    maxBytes: Integer): HCkTask; stdcall;

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

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

Returns nil on failure

top
Add64
function CkSFtp_Add64(objHandle: HCkSFtp;
    n1: PWideChar;
    n2: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkSFtp__add64(objHandle: HCkSFtp;
    n1: PWideChar;
    n2: PWideChar): PWideChar; stdcall;

Convenience method for 64-bit addition. Allows for two 64-bit integers to be passed as decimal strings and returns the sum in a decimal sting.

Returns True for success, False for failure.

top
AuthenticatePk
function CkSFtp_AuthenticatePk(objHandle: HCkSFtp;
    username: PWideChar;
    privateKey: HCkSshKey): wordbool; stdcall;

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.

Returns True for success, False for failure.

top
AuthenticatePkAsync (1)
function CkSFtp_AuthenticatePkAsync(objHandle: HCkSFtp;
    username: PWideChar;
    privateKey: HCkSshKey): HCkTask; stdcall;

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

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

Returns nil on failure

top
AuthenticatePw
function CkSFtp_AuthenticatePw(objHandle: HCkSFtp;
    login: PWideChar;
    password: PWideChar): wordbool; stdcall;

Authenticates with the SSH server using a login and password.

An SFTP session always begins by first calling Connect to connect to the SSH server, then calling either AuthenticatePw or AuthenticatePk to login, and finally calling InitializeSftp.

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

Returns True for success, False for failure.

top
AuthenticatePwAsync (1)
function CkSFtp_AuthenticatePwAsync(objHandle: HCkSFtp;
    login: PWideChar;
    password: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
AuthenticatePwPk
function CkSFtp_AuthenticatePwPk(objHandle: HCkSFtp;
    username: PWideChar;
    password: PWideChar;
    privateKey: HCkSshKey): wordbool; stdcall;

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.

Returns True for success, False for failure.

More Information and Examples
top
AuthenticatePwPkAsync (1)
function CkSFtp_AuthenticatePwPkAsync(objHandle: HCkSFtp;
    username: PWideChar;
    password: PWideChar;
    privateKey: HCkSshKey): HCkTask; stdcall;

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

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

Returns nil on failure

top
AuthenticateSecPw
function CkSFtp_AuthenticateSecPw(objHandle: HCkSFtp;
    login: HCkSecureString;
    password: HCkSecureString): wordbool; stdcall;
Introduced in version 9.5.0.71

The same as AuthenticatePw, but the login and password are passed in secure string objects.

Returns True for success, False for failure.

More Information and Examples
top
AuthenticateSecPwAsync (1)
function CkSFtp_AuthenticateSecPwAsync(objHandle: HCkSFtp;
    login: HCkSecureString;
    password: HCkSecureString): HCkTask; stdcall;
Introduced in version 9.5.0.71

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

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

Returns nil on failure

top
AuthenticateSecPwPk
function CkSFtp_AuthenticateSecPwPk(objHandle: HCkSFtp;
    username: HCkSecureString;
    password: HCkSecureString;
    privateKey: HCkSshKey): wordbool; stdcall;
Introduced in version 9.5.0.71

The same as AuthenticatePwPk, but the login and password are passed in secure string objects.

Returns True for success, False for failure.

top
AuthenticateSecPwPkAsync (1)
function CkSFtp_AuthenticateSecPwPkAsync(objHandle: HCkSFtp;
    username: HCkSecureString;
    password: HCkSecureString;
    privateKey: HCkSshKey): HCkTask; stdcall;
Introduced in version 9.5.0.71

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

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

Returns nil on failure

top
ClearAccumulateBuffer
procedure CkSFtp_ClearAccumulateBuffer(objHandle: HCkSFtp) stdcall;

Clears the contents of the AccumulateBuffer property.

top
ClearCache
procedure CkSFtp_ClearCache(objHandle: HCkSFtp) stdcall;

Clears the internal file attribute cache. (Please refer to the EnableCache property for more information about the file attribute cache.)

top
ClearSessionLog
procedure CkSFtp_ClearSessionLog(objHandle: HCkSFtp) stdcall;

Clears the contents of the SessionLog property.

top
CloseHandle
function CkSFtp_CloseHandle(objHandle: HCkSFtp;
    handle: PWideChar): wordbool; stdcall;

Closes a file on the SSH/SFTP server. handle is a file handle returned from a previous call to OpenFile or OpenDir.

Returns True for success, False for failure.

More Information and Examples
top
CloseHandleAsync (1)
function CkSFtp_CloseHandleAsync(objHandle: HCkSFtp;
    handle: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
Connect
function CkSFtp_Connect(objHandle: HCkSFtp;
    domainName: PWideChar;
    port: Integer): wordbool; stdcall;

Connects to an SSH/SFTP server. The domainName may be a domain name or an IP address (example: 192.168.1.10). Both IPv4 and IPv6 addresses are supported. The port is typically 22, which is the standard port for SSH servers.

An SFTP session always begins by first calling Connect to connect to the SSH server, then calling either AuthenticatePw or AuthenticatePk to login, and finally calling InitializeSftp.

Important: When reporting problems, please send the full contents of the LastErrorText property to support@chilkatsoft.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.

The following algorithms are supported by Chilkat SSH/SFTP:

  • 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

Returns True for success, False for failure.

top
ConnectAsync (1)
function CkSFtp_ConnectAsync(objHandle: HCkSFtp;
    domainName: PWideChar;
    port: Integer): HCkTask; stdcall;

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

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

Returns nil on failure

top
ConnectThroughSsh
function CkSFtp_ConnectThroughSsh(objHandle: HCkSFtp;
    sshConn: HCkSsh;
    hostname: PWideChar;
    port: Integer): wordbool; stdcall;
Introduced in version 9.5.0.55

Connects to an SSH/SFTP server through an existing SSH connection. The sshConn 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 sshConn 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.

Returns True for success, False for failure.

More Information and Examples
top
ConnectThroughSshAsync (1)
function CkSFtp_ConnectThroughSshAsync(objHandle: HCkSFtp;
    sshConn: HCkSsh;
    hostname: PWideChar;
    port: Integer): HCkTask; stdcall;
Introduced in version 9.5.0.55

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

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

Returns nil on failure

top
ContinueKeyboardAuth
function CkSFtp_ContinueKeyboardAuth(objHandle: HCkSFtp;
    response: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkSFtp__continueKeyboardAuth(objHandle: HCkSFtp;
    response: PWideChar): PWideChar; stdcall;
Introduced in version 9.5.0.88

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.

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

If the interactive authentication completed with success or failure, the XML response will be:

<success>success_message</success>

or

<error>error_message</error>
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:
 	<infoRequest numPrompts="N">
	    <name>name_string</name>
	    <instruction>instruction_string</instruction>
	    <prompt1 echo="1_or_0">prompt_string</prompt1>
	    ...
	    <promptN echo="1_or_0">prompt_string</promptN>
	</infoRequest>

Returns True for success, False for failure.

top
ContinueKeyboardAuthAsync (1)
function CkSFtp_ContinueKeyboardAuthAsync(objHandle: HCkSFtp;
    response: PWideChar): HCkTask; stdcall;
Introduced in version 9.5.0.88

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

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

Returns nil on failure

top
CopyFileAttr
function CkSFtp_CopyFileAttr(objHandle: HCkSFtp;
    localFilename: PWideChar;
    remoteFilename: PWideChar;
    isHandle: wordbool): wordbool; stdcall;

Sets the date/time and other attributes of a remote file to be equal to that of a local file.

The attributes copied depend on the SFTP version of the server:

<b>SFTP v3 (and below)</b>
    Last-Modified Date/Time
    Last-Access Date/Time

<b>SFTP v4, v5</b>
    Last-Modified Date/Time
    Last-Access Date/Time
    Create Date/Time

<b>SFTP v6 (and above)</b>
    Last-Modified Date/Time
    Last-Access Date/Time
    Create Date/Time
    Read-Only Flag
    Hidden Flag
    Archive Flag
    Compressed Flag
    Encrypted Flag

Notes:
(1) The Last-Access date/time may or may not be set. Chilkat has found that the Last-Access time is set to the current date/time, which is probably a result of the operating system setting it based on when the SFTP server is touching the file.
(2) At the time of this writing, it is unknown whether the compressed/encryption settings for a local file are transferred to the remote file. For example, does the remote file become compressed and/or encrypted just by setting the flags? It may depend on the SFTP server and/or the remote filesystem.
(3) Dates/times are sent in GMT. SFTP servers should convert GMT times to local time zones.

Returns True for success, False for failure.

top
CopyFileAttrAsync (1)
function CkSFtp_CopyFileAttrAsync(objHandle: HCkSFtp;
    localFilename: PWideChar;
    remoteFilename: PWideChar;
    isHandle: wordbool): HCkTask; stdcall;

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

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

Returns nil on failure

top
CreateDir
function CkSFtp_CreateDir(objHandle: HCkSFtp;
    path: PWideChar): wordbool; stdcall;

Creates a directory on the SFTP server.

Returns True for success, False for failure.

top
CreateDirAsync (1)
function CkSFtp_CreateDirAsync(objHandle: HCkSFtp;
    path: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
Disconnect
procedure CkSFtp_Disconnect(objHandle: HCkSFtp) stdcall;

Disconnects from the SSH server.

top
DownloadBd
function CkSFtp_DownloadBd(objHandle: HCkSFtp;
    remoteFilePath: PWideChar;
    binData: HCkBinData): wordbool; stdcall;
Introduced in version 9.5.0.62

Downloads the contents of a remote file to a BinData object. (Appends to the BinData.)

Returns True for success, False for failure.

More Information and Examples
top
DownloadBdAsync (1)
function CkSFtp_DownloadBdAsync(objHandle: HCkSFtp;
    remoteFilePath: PWideChar;
    binData: HCkBinData): HCkTask; stdcall;
Introduced in version 9.5.0.62

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

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

Returns nil on failure

top
DownloadFile
function CkSFtp_DownloadFile(objHandle: HCkSFtp;
    handle: PWideChar;
    toFilename: PWideChar): wordbool; stdcall;

Downloads a file from the SSH server to the local filesystem. There are no limitations on file size and the data is streamed from SSH server to the local file. handle is a file handle returned by a previous call to OpenFile.

Returns True for success, False for failure.

top
DownloadFileAsync (1)
function CkSFtp_DownloadFileAsync(objHandle: HCkSFtp;
    handle: PWideChar;
    toFilename: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
DownloadFileByName
function CkSFtp_DownloadFileByName(objHandle: HCkSFtp;
    remoteFilePath: PWideChar;
    localFilePath: PWideChar): wordbool; stdcall;

Simplified method for downloading files.

The last-modified date/time is only preserved when the PreserveDate property is set to True. (The default value of PreserveDate is False.)

Important: If the remoteFilePath is an absolute path, then it is a path from the root of the server's filesystem. For example, "/home/joe/someFile.txt". Use a relative path to specify a directory relative to the $HOME directory of the SSH user account. For example, "./someFile.txt".

Returns True for success, False for failure.

top
DownloadFileByNameAsync (1)
function CkSFtp_DownloadFileByNameAsync(objHandle: HCkSFtp;
    remoteFilePath: PWideChar;
    localFilePath: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
DownloadSb
function CkSFtp_DownloadSb(objHandle: HCkSFtp;
    remoteFilePath: PWideChar;
    charset: PWideChar;
    sb: HCkStringBuilder): wordbool; stdcall;
Introduced in version 9.5.0.62

Downloads the contents of a remote file to a StringBuilder object. (Appends to the StringBuilder.)

Returns True for success, False for failure.

top
DownloadSbAsync (1)
function CkSFtp_DownloadSbAsync(objHandle: HCkSFtp;
    remoteFilePath: PWideChar;
    charset: PWideChar;
    sb: HCkStringBuilder): HCkTask; stdcall;
Introduced in version 9.5.0.62

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

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

Returns nil on failure

top
Eof
function CkSFtp_Eof(objHandle: HCkSFtp;
    handle: PWideChar): wordbool; stdcall;

Returns True if the last read operation for a handle reached the end of file. Otherwise returns False. If an invalid handle is passed, a value of True is returned.

top
FileExists
function CkSFtp_FileExists(objHandle: HCkSFtp;
    remotePath: PWideChar;
    followLinks: wordbool): Integer; stdcall;
Introduced in version 9.5.0.67

Returns a value to indicate whether the remote file exists or not. remotePath is the path of the remote file. If followLinks is True, then symbolic links will be followed on the server.

This method returns one of the following possible values:

  • -1: Unable to check. Examine the LastErrorText to determine the reason for failure.
  • 0: File does not exist.
  • 1: The regular file exists.
  • 2: It exists, but it is a directory.
  • 3: It exists, but it is a symlink (only possible if followLinks is False)
  • 4: It exists, but it is a special filesystem entry type.
  • 5: It exists, but it is an unkown filesystem entry type.
  • 6: It exists, but it is an socket filesystem entry type.
  • 7: It exists, but it is an char device entry type.
  • 8: It exists, but it is an block device entry type.
  • 9: It exists, but it is an FIFO entry type.

Note: The values greater than zero correspond to the possible values as specified in the SFTP protocol specification. A given value may not make sense on all operating systems.

More Information and Examples
top
FileExistsAsync (1)
function CkSFtp_FileExistsAsync(objHandle: HCkSFtp;
    remotePath: PWideChar;
    followLinks: wordbool): HCkTask; stdcall;
Introduced in version 9.5.0.67

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

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

Returns nil on failure

top
Fsync
function CkSFtp_Fsync(objHandle: HCkSFtp;
    handle: PWideChar): wordbool; stdcall;
Introduced in version 9.5.0.71

Causes the SFTP server to do an fsync on the open file. Specifically, this is directing the SFTP server to call fsync (https://linux.die.net/man/2/fsync) on the open file.

This method uses the fsync@openssh.com and only works for servers supporting the fsync@openssh.com extension.

Returns True for success, False for failure.

More Information and Examples
top
FsyncAsync (1)
function CkSFtp_FsyncAsync(objHandle: HCkSFtp;
    handle: PWideChar): HCkTask; stdcall;
Introduced in version 9.5.0.71

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

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

Returns nil on failure

top
GetFileCreateDt
function CkSFtp_GetFileCreateDt(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): HCkDateTime; stdcall;

Returns the create date/time for a file. pathOrHandle may be a remote filepath or an open handle string as returned by OpenFile. If pathOrHandle is a handle, then bIsHandle must be set to True, otherwise it should be False. If bFollowLinks is True, then symbolic links will be followed on the server.

Note: Servers running the SFTP v3 protocol or lower do not have the ability to return a file's creation date/time.

Returns nil on failure

top
GetFileCreateDtAsync (1) (2)
function CkSFtp_GetFileCreateDtAsync(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): HCkTask; stdcall;

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

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

Returns nil on failure

top
GetFileCreateTimeStr
function CkSFtp_GetFileCreateTimeStr(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool;
    outStr: HCkString): wordbool; stdcall;
function CkSFtp__getFileCreateTimeStr(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): PWideChar; stdcall;

The same as GetFileCreateTime, except the date/time is returned as an RFC822 formatted string.

Returns True for success, False for failure.

top
GetFileCreateTimeStrAsync (1)
function CkSFtp_GetFileCreateTimeStrAsync(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): HCkTask; stdcall;

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

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

Returns nil on failure

top
GetFileGroup
function CkSFtp_GetFileGroup(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool;
    outStr: HCkString): wordbool; stdcall;
function CkSFtp__getFileGroup(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): PWideChar; stdcall;

Returns the group of a file. pathOrHandle may be a remote filepath or an open handle string as returned by OpenFile. If pathOrHandle is a handle, then bIsHandle must be set to True, otherwise it should be False. If bFollowLinks is True, then symbolic links will be followed on the server.

Note: Servers running the SFTP v3 protocol or lower do not have the ability to return a file's group name. Instead, the decimal GID of the file is returned.

Returns True for success, False for failure.

top
GetFileGroupAsync (1)
function CkSFtp_GetFileGroupAsync(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): HCkTask; stdcall;

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

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

Returns nil on failure

top
GetFileLastAccessDt
function CkSFtp_GetFileLastAccessDt(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): HCkDateTime; stdcall;

Returns the last-access date/time for a file. pathOrHandle may be a remote filepath or an open handle string as returned by OpenFile. If pathOrHandle is a handle, then bIsHandle must be set to True, otherwise it should be False. If bFollowLinks is True, then symbolic links will be followed on the server.

Returns nil on failure

top
GetFileLastAccessDtAsync (1) (2)
function CkSFtp_GetFileLastAccessDtAsync(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): HCkTask; stdcall;

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

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

Returns nil on failure

top
GetFileLastAccessStr
function CkSFtp_GetFileLastAccessStr(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool;
    outStr: HCkString): wordbool; stdcall;
function CkSFtp__getFileLastAccessStr(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): PWideChar; stdcall;

The same as GetFileLastAccess, except the date/time is returned as an RFC822 formatted string.

Returns True for success, False for failure.

top
GetFileLastAccessStrAsync (1)
function CkSFtp_GetFileLastAccessStrAsync(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): HCkTask; stdcall;

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

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

Returns nil on failure

top
GetFileLastModifiedDt
function CkSFtp_GetFileLastModifiedDt(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): HCkDateTime; stdcall;

Returns the last-modified date/time for a file. pathOrHandle may be a remote filepath or an open handle string as returned by OpenFile. If pathOrHandle is a handle, then bIsHandle must be set to True, otherwise it should be False. If bFollowLinks is True, then symbolic links will be followed on the server.

Returns nil on failure

top
GetFileLastModifiedDtAsync (1) (2)
function CkSFtp_GetFileLastModifiedDtAsync(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): HCkTask; stdcall;

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

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

Returns nil on failure

top
GetFileLastModifiedStr
function CkSFtp_GetFileLastModifiedStr(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool;
    outStr: HCkString): wordbool; stdcall;
function CkSFtp__getFileLastModifiedStr(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): PWideChar; stdcall;

The same as GetFileLastModified, except the date/time is returned as an RFC822 formatted string.

Returns True for success, False for failure.

top
GetFileLastModifiedStrAsync (1)
function CkSFtp_GetFileLastModifiedStrAsync(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): HCkTask; stdcall;

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

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

Returns nil on failure

top
GetFileOwner
function CkSFtp_GetFileOwner(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool;
    outStr: HCkString): wordbool; stdcall;
function CkSFtp__getFileOwner(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): PWideChar; stdcall;

Returns the owner of a file. pathOrHandle may be a remote filepath or an open handle string as returned by OpenFile. If pathOrHandle is a handle, then bIsHandle must be set to True, otherwise it should be False. If bFollowLinks is True, then symbolic links will be followed on the server.

Note: Servers running the SFTP v3 protocol or lower do not have the ability to return a file's owner name. Instead, the decimal UID of the file is returned.

Returns True for success, False for failure.

top
GetFileOwnerAsync (1)
function CkSFtp_GetFileOwnerAsync(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): HCkTask; stdcall;

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

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

Returns nil on failure

top
GetFilePermissions
function CkSFtp_GetFilePermissions(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): Integer; stdcall;

Returns the access permisssions flags of a file. pathOrHandle may be a remote filepath or an open handle string as returned by OpenFile. If pathOrHandle is a handle, then bIsHandle must be set to True, otherwise it should be False. If bFollowLinks is True, then symbolic links will be followed on the server.

More Information and Examples
top
GetFilePermissionsAsync (1)
function CkSFtp_GetFilePermissionsAsync(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): HCkTask; stdcall;

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

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

Returns nil on failure

top
GetFileSize32
function CkSFtp_GetFileSize32(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): Integer; stdcall;

Returns the size in bytes of a file on the SSH server. If the file size exceeds what can be represented in 32-bits, a value of -1 is returned. pathOrHandle may be a remote filepath or an open handle string as returned by OpenFile. If pathOrHandle is a handle, then bIsHandle must be set to True, otherwise it should be False. If bFollowLinks is True, then symbolic links will be followed on the server.

top
GetFileSize32Async (1)
function CkSFtp_GetFileSize32Async(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): HCkTask; stdcall;

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

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

Returns nil on failure

top
GetFileSize64
function CkSFtp_GetFileSize64(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): Int64; stdcall;

Returns a 64-bit integer containing the size (in bytes) of a file on the SSH server. pathOrHandle may be a remote filepath or an open handle string as returned by OpenFile. If pathOrHandle is a handle, then bIsHandle must be set to True, otherwise it should be False. If bFollowLinks is True, then symbolic links will be followed on the server.

top
GetFileSize64Async (1)
function CkSFtp_GetFileSize64Async(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): HCkTask; stdcall;

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

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

Returns nil on failure

top
GetFileSizeStr
function CkSFtp_GetFileSizeStr(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool;
    outStr: HCkString): wordbool; stdcall;
function CkSFtp__getFileSizeStr(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): PWideChar; stdcall;

Returns the size in bytes (in decimal string form) of a file on the SSH server. pathOrHandle may be a remote filepath or an open handle string as returned by OpenFile. If pathOrHandle is a handle, then bIsHandle must be set to True, otherwise it should be False. If bFollowLinks is True, then symbolic links will be followed on the server.

Note: This method exists for environments that do not have 64-bit integer support. The Add64 method is provided for 64-bit addition, and other methods such as ReadFileBytes64s allow for 64-bit values to be passed as strings.

Returns True for success, False for failure.

top
GetFileSizeStrAsync (1)
function CkSFtp_GetFileSizeStrAsync(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bFollowLinks: wordbool;
    bIsHandle: wordbool): HCkTask; stdcall;

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

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

Returns nil on failure

top
GetHostKeyFP
function CkSFtp_GetHostKeyFP(objHandle: HCkSFtp;
    hashAlg: PWideChar;
    includeKeyType: wordbool;
    includeHashName: wordbool;
    outStr: HCkString): wordbool; stdcall;
function CkSFtp__getHostKeyFP(objHandle: HCkSFtp;
    hashAlg: PWideChar;
    includeKeyType: wordbool;
    includeHashName: wordbool): PWideChar; stdcall;
Introduced in version 9.5.0.92

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 True:
SHA256:L7sQgnpnoBwRoyIYXAFBs8SdSnwtyYmhXs1p/mQDK...
If includeKeyType is False and includeHashName is False:
L7sQgnpnoBwRoyIYXAFBs8SdSnwtyYmhXs1p/mQDK...

SSH host key types can be: ssh-rsa, ecdsa-*-* (such as ecdsa-sha2-nistp256), ssh-ed25519, and ssh-dss.

Returns True for success, False for failure.

More Information and Examples
top
HardLink
function CkSFtp_HardLink(objHandle: HCkSFtp;
    oldPath: PWideChar;
    newPath: PWideChar): wordbool; stdcall;
Introduced in version 9.5.0.71

Creates a hard link on the server using the hardlink@openssh.com extension. This only works for SFTP servers that support the hardlink@openssh.com extension.

Returns True for success, False for failure.

top
HardLinkAsync (1)
function CkSFtp_HardLinkAsync(objHandle: HCkSFtp;
    oldPath: PWideChar;
    newPath: PWideChar): HCkTask; stdcall;
Introduced in version 9.5.0.71

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

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

Returns nil on failure

top
InitializeSftp
function CkSFtp_InitializeSftp(objHandle: HCkSFtp): wordbool; stdcall;

Intializes the SFTP subsystem. This should be called after connecting and authenticating. An SFTP session always begins by first calling Connect to connect to the SSH server, then calling either AuthenticatePw or AuthenticatePk to login, and finally calling InitializeSftp.

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

If this method fails, the reason may be present in the InitializeFailCode and InitializeFailReason properties (assuming the failure occurred when trying to open the SFTP session channel).

Returns True for success, False for failure.

top
InitializeSftpAsync (1)
function CkSFtp_InitializeSftpAsync(objHandle: HCkSFtp): HCkTask; stdcall;

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

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

Returns nil on failure

top
LastJsonData
function CkSFtp_LastJsonData(objHandle: HCkSFtp): HCkJsonObject; stdcall;
Introduced in version 9.5.0.79

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.

Returns nil on failure

top
LastReadFailed
function CkSFtp_LastReadFailed(objHandle: HCkSFtp;
    handle: PWideChar): wordbool; stdcall;

Returns True if the last read on the specified handle failed. Otherwise returns False.

top
LastReadNumBytes
function CkSFtp_LastReadNumBytes(objHandle: HCkSFtp;
    handle: PWideChar): Integer; stdcall;

Returns the number of bytes received by the last read on a specified channel.

top
LoadTaskCaller
function CkSFtp_LoadTaskCaller(objHandle: HCkSFtp;
    task: HCkTask): wordbool; stdcall;
Introduced in version 9.5.0.80

Loads the caller of the task's async method.

Returns True for success, False for failure.

top
OpenDir
function CkSFtp_OpenDir(objHandle: HCkSFtp;
    path: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkSFtp__openDir(objHandle: HCkSFtp;
    path: PWideChar): PWideChar; stdcall;

Opens a directory for reading. To get a directory listing, first open the directory by calling this method, then call ReadDir to read the directory, and finally call CloseHandle to close the directory.

The SFTP protocol represents file names as strings. File names are assumed to use the slash ('/') character as a directory separator.

File names starting with a slash are "absolute", and are relative to the root of the file system. Names starting with any other character are relative to the user's default directory (home directory). Note that identifying the user is assumed to take place outside of this protocol.

Servers SHOULD interpret a path name component ".." as referring to the parent directory, and "." as referring to the current directory.

An empty path name is valid, and it refers to the user's default directory (usually the user's home directory).

Please note: This method does NOT "change" the remote working directory. It is only a method for opening a directory for the purpose of reading the directory listing.

SFTP is Secure File Transfer over SSH. It is not the FTP protocol. There is no similarity or relationship between FTP and SFTP. Therefore, concepts such as "current remote directory" that exist in FTP do not exist with SFTP. With the SFTP protocol, the current directory will always be the home directory of the user account used during SSH/SFTP authentication. You may pass relative or absolute directory/file paths. A relative path is always relative to the home directory of the SSH user account.

Returns True for success, False for failure.

top
OpenDirAsync (1)
function CkSFtp_OpenDirAsync(objHandle: HCkSFtp;
    path: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
OpenFile
function CkSFtp_OpenFile(objHandle: HCkSFtp;
    remotePath: PWideChar;
    access: PWideChar;
    createDisposition: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkSFtp__openFile(objHandle: HCkSFtp;
    remotePath: PWideChar;
    access: PWideChar;
    createDisposition: PWideChar): PWideChar; stdcall;

Opens or creates a file on the remote system. Returns a handle which may be passed to methods for reading and/or writing the file. The remotePath is the remote file path (the path to the file on the server). When the application is finished with the handle, it should call CloseHandle(remotePath).

Important: If the remotePath is an absolute path, then it is a path from the root of the server's filesystem. For example, "/home/joe/someFile.txt". Use a relative path to specify a directory relative to the $HOME directory of the SSH user account. For example, "./someFile.txt".

access should be one of the following strings: "readOnly", "writeOnly", or "readWrite".

createDisposition is a comma-separated list of keywords to provide more control over how the file is opened or created. One of the following keywords must be present: "createNew", "createTruncate", "openExisting", "openOrCreate", or "truncateExisting". All other keywords are optional. The list of keywords and their meanings are shown here:

createNew
A new file is created; if the file already exists the method fails.

createTruncate
A new file is created; if the file already exists, it is opened and truncated.

openExisting
An existing file is opened. If the file does not exist the method fails.

openOrCreate
If the file exists, it is opened. If the file does not exist, it is created.

truncateExisting
An existing file is opened and truncated. If the file does not exist the method fails.

appendData
Data is always written at the end of the file. Data is not required to be appended atomically. This means that if multiple writers attempt to append data simultaneously, data from the first may be lost.

appendDataAtomic
Data is always written at the end of the file. Data MUST be written atomically so that there is no chance that multiple appenders can collide and result in data being lost.
(Only supported in SFTP protocol versions 5 and later. See the note below.)

textMode
Indicates that the server should treat the file as text and convert it to the canonical newline convention in use. When a file is opened with this flag, data is always appended to the end of the file. Servers MUST process multiple, parallel reads and writes correctly in this mode.
(Only supported in SFTP protocol versions 5 and later. See the note below.)

blockRead
The server MUST guarantee that no other handle has been opened with read access, and that no other handle will be opened with read access until the client closes the handle. (This MUST apply both to other clients and to other processes on the server.) In a nutshell, this opens the file in non-sharing mode.
(Only supported in SFTP protocol versions 5 and later. See the note below.)

blockWrite
The server MUST guarantee that no other handle has been opened with write access, and that no other handle will be opened with write access until the client closes the handle. (This MUST apply both to other clients and to other processes on the server.) In a nutshell, this opens the file in non-sharing mode.
(Only supported in SFTP protocol versions 5 and later. See the note below.)

blockDelete
The server MUST guarantee that the file itself is not deleted in any other way until the client closes the handle. No other client or process is allowed to open the file with delete access.
(Only supported in SFTP protocol versions 5 and later. See the note below.)

blockAdvisory
If set, the above "block" modes are advisory. In advisory mode, only other accesses that specify a "block" mode need be considered when determining whether the "block" can be granted, and the server need not prevent I/O operations that violate the block mode. The server MAY perform mandatory locking even if the blockAdvisory flag is set.
(Only supported in SFTP protocol versions 5 and later. See the note below.)

noFollow
If the final component of the path is a symlink, then the open MUST fail.
(Only supported in SFTP protocol versions 5 and later. See the note below.)

deleteOnClose
The file should be deleted when the last handle to it is closed. (The last handle may not be an sftp-handle.) This MAY be emulated by a server if the OS doesn't support it by deleting the file when this handle is closed.
(Only supported in SFTP protocol versions 5 and later. See the note below.)

accessAuditAlarmInfo
The client wishes the server to enable any privileges or extra capabilities that the user may have in to allow the reading and writing of AUDIT or ALARM access control entries.
(Only supported in SFTP protocol versions 5 and later. See the note below.)

accessBackup
The client wishes the server to enable any privileges or extra capabilities that the user may have in order to bypass normal access checks for the purpose of backing up or restoring files.
(Only supported in SFTP protocol versions 5 and later. See the note below.)

backupStream
This flag indicates that the client wishes to read or write a backup stream. A backup stream is a system dependent structured data stream that encodes all the information that must be preserved in order to restore the file from backup medium. The only well defined use for backup stream data read in this fashion is to write it to the same server to a file also opened using the backupStream flag. However, if the server has a well defined backup stream format, there may be other uses for this data outside the scope of this protocol.
(Only supported in SFTP protocol versions 5 and later. See the note below.)

IMPORANT: If remotePath is a filename with no path, such as "test.txt", and the server responds with a "Folder not found" error, then try prepending "./" to the remotePath. For example, instead of passing "test.txt", try "./test.txt".

IMPORTANT note about createDisposition: Many of the options, such as textMode, are not implemented in the SFTP protocol versions 3 and 4. Only SFTP servers at protocol version 5 or later support these options. You can find out the protocol version of your server by examining the value of the ProtocolVersion property after calling InitializeSftp. Also, make sure the ForceV3 property is set to False (the default value is True)

Returns True for success, False for failure.

top
OpenFileAsync (1)
function CkSFtp_OpenFileAsync(objHandle: HCkSFtp;
    remotePath: PWideChar;
    access: PWideChar;
    createDisposition: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
ReadDir
function CkSFtp_ReadDir(objHandle: HCkSFtp;
    handle: PWideChar): HCkSFtpDir; stdcall;

Reads the contents of a directory and returns the directory listing (as an object). The handle returned by OpenDir should be passed to this method.

Returns nil on failure

More Information and Examples
top
ReadDirAsync (1) (2)
function CkSFtp_ReadDirAsync(objHandle: HCkSFtp;
    handle: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
ReadFileBd
function CkSFtp_ReadFileBd(objHandle: HCkSFtp;
    handle: PWideChar;
    numBytes: Integer;
    bd: HCkBinData): wordbool; stdcall;
Introduced in version 9.5.0.77

Reads file data from a remote file on the SSH server. The handle is a file handle returned by the OpenFile method. The numBytes is the maximum number of bytes to read. If the end-of-file is reached prior to reading the number of requested bytes, then fewer bytes may be returned. The received bytes are appended to the contents of bd.

To read an entire file, one may call ReadFileBd repeatedly until Eof(handle) returns True.

top
ReadFileBdAsync (1)
function CkSFtp_ReadFileBdAsync(objHandle: HCkSFtp;
    handle: PWideChar;
    numBytes: Integer;
    bd: HCkBinData): HCkTask; stdcall;
Introduced in version 9.5.0.77

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

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

Returns nil on failure

top
ReadFileBytes
function CkSFtp_ReadFileBytes(objHandle: HCkSFtp;
    handle: PWideChar;
    numBytes: Integer;
    outBytes: HCkByteData): wordbool; stdcall;

Reads file data from a remote file on the SSH server. The handle is a file handle returned by the OpenFile method. The numBytes is the maximum number of bytes to read. If the end-of-file is reached prior to reading the number of requested bytes, then fewer bytes may be returned.

To read an entire file, one may call ReadFileBytes repeatedly until Eof(handle) returns True.

Returns True for success, False for failure.

top
ReadFileBytesAsync (1)
function CkSFtp_ReadFileBytesAsync(objHandle: HCkSFtp;
    handle: PWideChar;
    numBytes: Integer): HCkTask; stdcall;

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

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

Returns nil on failure

top
ReadFileBytes32
function CkSFtp_ReadFileBytes32(objHandle: HCkSFtp;
    handle: PWideChar;
    offset: Integer;
    numBytes: Integer;
    outBytes: HCkByteData): wordbool; stdcall;

Reads file data from a remote file on the SSH server. The handle is a file handle returned by the OpenFile method. The offset is measured in bytes relative to the beginning of the file. (64-bit offsets are supported via the ReadFileBytes64 and ReadFileBytes64s methods.) The offset is ignored if the "textMode" flag was specified during the OpenFile. The numBytes is the maximum number of bytes to read. If the end-of-file is reached prior to reading the number of requested bytes, then fewer bytes may be returned.

Returns True for success, False for failure.

top
ReadFileBytes32Async (1)
function CkSFtp_ReadFileBytes32Async(objHandle: HCkSFtp;
    handle: PWideChar;
    offset: Integer;
    numBytes: Integer): HCkTask; stdcall;

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

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

Returns nil on failure

top
ReadFileBytes64
function CkSFtp_ReadFileBytes64(objHandle: HCkSFtp;
    handle: PWideChar;
    offset: Int64;
    numBytes: Integer;
    outBytes: HCkByteData): wordbool; stdcall;

Reads file data from a remote file on the SSH server. The handle is a file handle returned by the OpenFile method. The offset is a 64-bit integer measured in bytes relative to the beginning of the file. The offset is ignored if the "textMode" flag was specified during the OpenFile. The numBytes is the maximum number of bytes to read. If the end-of-file is reached prior to reading the number of requested bytes, then fewer bytes may be returned.

Returns True for success, False for failure.

top
ReadFileBytes64Async (1)
function CkSFtp_ReadFileBytes64Async(objHandle: HCkSFtp;
    handle: PWideChar;
    offset: Int64;
    numBytes: Integer): HCkTask; stdcall;

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

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

Returns nil on failure

top
ReadFileBytes64s
function CkSFtp_ReadFileBytes64s(objHandle: HCkSFtp;
    handle: PWideChar;
    offset: PWideChar;
    numBytes: Integer;
    outBytes: HCkByteData): wordbool; stdcall;

(This method exists for systems that do not support 64-bit integers. The 64-bit integer offset is passed as a decimal string instead.)

Reads file data from a remote file on the SSH server. The handle is a file handle returned by the OpenFile method. The offset is a 64-bit integer represented as a decimal string. It represents an offset in bytes from the beginning of the file. The offset is ignored if the "textMode" flag was specified during the OpenFile. The numBytes is the maximum number of bytes to read. If the end-of-file is reached prior to reading the number of requested bytes, then fewer bytes may be returned.

Returns True for success, False for failure.

top
ReadFileBytes64sAsync (1)
function CkSFtp_ReadFileBytes64sAsync(objHandle: HCkSFtp;
    handle: PWideChar;
    offset: PWideChar;
    numBytes: Integer): HCkTask; stdcall;

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

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

Returns nil on failure

top
ReadFileText
function CkSFtp_ReadFileText(objHandle: HCkSFtp;
    handle: PWideChar;
    numBytes: Integer;
    charset: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkSFtp__readFileText(objHandle: HCkSFtp;
    handle: PWideChar;
    numBytes: Integer;
    charset: PWideChar): PWideChar; stdcall;

This method is identical to ReadFileBytes except for one thing: The bytes are interpreted according to the specified charset (i.e. the character encoding) and returned as a string. A list of supported charset values may be found on this page: Supported Charsets.

Note: If the charset is an encoding where a single character might be represented in multiple bytes (such as utf-8, Shift_JIS, etc.) then there is a risk that the very last character may be partially read. This is because the method specifies the number of bytes to read, not the number of characters. This is never a problem with character encodings that use a single byte per character, such as all of the iso-8859-* encodings, or the Windows-* encodings.

To read an entire file, one may call ReadFileText repeatedly until Eof(handle) returns True.

Returns True for success, False for failure.

top
ReadFileTextAsync (1)
function CkSFtp_ReadFileTextAsync(objHandle: HCkSFtp;
    handle: PWideChar;
    numBytes: Integer;
    charset: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
ReadFileText32
function CkSFtp_ReadFileText32(objHandle: HCkSFtp;
    handle: PWideChar;
    offset: Integer;
    numBytes: Integer;
    charset: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkSFtp__readFileText32(objHandle: HCkSFtp;
    handle: PWideChar;
    offset: Integer;
    numBytes: Integer;
    charset: PWideChar): PWideChar; stdcall;

This method is identical to ReadFileBytes32 except for one thing: The bytes are interpreted according to the specified charset (i.e. the character encoding) and returned as a string. A list of supported charset values may be found on this page: Supported Charsets.

Note: If the charset is an encoding where a single character might be represented in multiple bytes (such as utf-8, Shift_JIS, etc.) then there is a risk that the very last character may be partially read. This is because the method specifies the number of bytes to read, not the number of characters. This is never a problem with character encodings that use a single byte per character, such as all of the iso-8859-* encodings, or the Windows-* encodings.

Returns True for success, False for failure.

top
ReadFileText32Async (1)
function CkSFtp_ReadFileText32Async(objHandle: HCkSFtp;
    handle: PWideChar;
    offset: Integer;
    numBytes: Integer;
    charset: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
ReadFileText64
function CkSFtp_ReadFileText64(objHandle: HCkSFtp;
    handle: PWideChar;
    offset: Int64;
    numBytes: Integer;
    charset: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkSFtp__readFileText64(objHandle: HCkSFtp;
    handle: PWideChar;
    offset: Int64;
    numBytes: Integer;
    charset: PWideChar): PWideChar; stdcall;

This method is identical to ReadFileBytes64 except for one thing: The bytes are interpreted according to the specified charset (i.e. the character encoding) and returned as a string. A list of supported charset values may be found on this page: Supported Charsets.

Note: If the charset is an encoding where a single character might be represented in multiple bytes (such as utf-8, Shift_JIS, etc.) then there is a risk that the very last character may be partially read. This is because the method specifies the number of bytes to read, not the number of characters. This is never a problem with character encodings that use a single byte per character, such as all of the iso-8859-* encodings, or the Windows-* encodings.

Returns True for success, False for failure.

top
ReadFileText64Async (1)
function CkSFtp_ReadFileText64Async(objHandle: HCkSFtp;
    handle: PWideChar;
    offset: Int64;
    numBytes: Integer;
    charset: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
ReadFileText64s
function CkSFtp_ReadFileText64s(objHandle: HCkSFtp;
    handle: PWideChar;
    offset: PWideChar;
    numBytes: Integer;
    charset: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkSFtp__readFileText64s(objHandle: HCkSFtp;
    handle: PWideChar;
    offset: PWideChar;
    numBytes: Integer;
    charset: PWideChar): PWideChar; stdcall;

This method is identical to ReadFileBytes64s except for one thing: The bytes are interpreted according to the specified charset (i.e. the character encoding) and returned as a string. A list of supported charset values may be found on this page: Supported Charsets.

Note: If the charset is an encoding where a single character might be represented in multiple bytes (such as utf-8, Shift_JIS, etc.) then there is a risk that the very last character may be partially read. This is because the method specifies the number of bytes to read, not the number of characters. This is never a problem with character encodings that use a single byte per character, such as all of the iso-8859-* encodings, or the Windows-* encodings.

Returns True for success, False for failure.

top
ReadFileText64sAsync (1)
function CkSFtp_ReadFileText64sAsync(objHandle: HCkSFtp;
    handle: PWideChar;
    offset: PWideChar;
    numBytes: Integer;
    charset: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
ReadLink
function CkSFtp_ReadLink(objHandle: HCkSFtp;
    path: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkSFtp__readLink(objHandle: HCkSFtp;
    path: PWideChar): PWideChar; stdcall;
Introduced in version 9.5.0.71

Returns the target of a symbolic link on the server. The path is the path of the symbolic link on the server.

Returns True for success, False for failure.

top
ReadLinkAsync (1)
function CkSFtp_ReadLinkAsync(objHandle: HCkSFtp;
    path: PWideChar): HCkTask; stdcall;
Introduced in version 9.5.0.71

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

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

Returns nil on failure

top
RealPath
function CkSFtp_RealPath(objHandle: HCkSFtp;
    originalPath: PWideChar;
    composePath: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkSFtp__realPath(objHandle: HCkSFtp;
    originalPath: PWideChar;
    composePath: PWideChar): PWideChar; stdcall;

This method can be used to have the server canonicalize any given path name to an absolute path. This is useful for converting path names containing ".." components or relative pathnames without a leading slash into absolute paths. The absolute path is returned by this method.

originalPath is the first component of the path which the client wishes resolved into a absolute canonical path. This may be the entire path.

The composePath is a path which the client wishes the server to compose with the original path to form the new path. This field is optional and may be set to a zero-length string.

The server will take the originalPath and apply the composePath as a modification to it. composePath may be relative to originalPath or may be an absolute path, in which case originalPath will be discarded. The composePath may be zero length.

Note: Servers running SFTP v4 and below do not support composePath.

Returns True for success, False for failure.

top
RealPathAsync (1)
function CkSFtp_RealPathAsync(objHandle: HCkSFtp;
    originalPath: PWideChar;
    composePath: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
RemoveDir
function CkSFtp_RemoveDir(objHandle: HCkSFtp;
    path: PWideChar): wordbool; stdcall;

Deletes a directory on the remote server. Most (if not all) SFTP servers require that the directorybe empty of files before it may be deleted.

Returns True for success, False for failure.

top
RemoveDirAsync (1)
function CkSFtp_RemoveDirAsync(objHandle: HCkSFtp;
    path: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
RemoveFile
function CkSFtp_RemoveFile(objHandle: HCkSFtp;
    filename: PWideChar): wordbool; stdcall;

Deletes a file on the SFTP server.

Returns True for success, False for failure.

More Information and Examples
top
RemoveFileAsync (1)
function CkSFtp_RemoveFileAsync(objHandle: HCkSFtp;
    filename: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
RenameFileOrDir
function CkSFtp_RenameFileOrDir(objHandle: HCkSFtp;
    oldPath: PWideChar;
    newPath: PWideChar): wordbool; stdcall;

Renames a file or directory on the SFTP server. This is the equivalent of moving a file. To move a file from one directory to another, call this method where oldPath is the path of the existing file, and newPath is the path where the file is to be moved. For example, rename a file from "someDirA/filename" to "someDirB/abc/xyz/filename".

Returns True for success, False for failure.

top
RenameFileOrDirAsync (1)
function CkSFtp_RenameFileOrDirAsync(objHandle: HCkSFtp;
    oldPath: PWideChar;
    newPath: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
ResumeDownloadFileByName
function CkSFtp_ResumeDownloadFileByName(objHandle: HCkSFtp;
    remoteFilePath: PWideChar;
    localFilePath: PWideChar): wordbool; stdcall;

Resumes an SFTP download. The size of the localFilePath is checked and the download begins at the appropriate position in the remoteFilePath. If localFilePath is empty or non-existent, then this method is identical to DownloadFileByName. If the localFilePath is already fully downloaded, then no additional data is downloaded and the method will return True.

Returns True for success, False for failure.

More Information and Examples
top
ResumeDownloadFileByNameAsync (1)
function CkSFtp_ResumeDownloadFileByNameAsync(objHandle: HCkSFtp;
    remoteFilePath: PWideChar;
    localFilePath: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
ResumeUploadFileByName
function CkSFtp_ResumeUploadFileByName(objHandle: HCkSFtp;
    remoteFilePath: PWideChar;
    localFilePath: PWideChar): wordbool; stdcall;

Resumes a file upload to the SFTP/SSH server. The size of the remoteFilePath is first checked to determine the starting offset for the upload. If remoteFilePath is empty or does not exist, this method is equivalent to UploadFileByName. If remoteFilePath is already fully uploaded (i.e. it's size is equal to localFilePath), then no additional bytes are uploaded and True is returned.

Returns True for success, False for failure.

More Information and Examples
top
ResumeUploadFileByNameAsync (1)
function CkSFtp_ResumeUploadFileByNameAsync(objHandle: HCkSFtp;
    remoteFilePath: PWideChar;
    localFilePath: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
SendIgnore
function CkSFtp_SendIgnore(objHandle: HCkSFtp): wordbool; stdcall;
Introduced in version 9.5.0.66

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 (i.e., you do not need to first open a channel prior to sending an IGNORE message).

Returns True for success, False for failure.

top
SendIgnoreAsync (1)
function CkSFtp_SendIgnoreAsync(objHandle: HCkSFtp): HCkTask; stdcall;
Introduced in version 9.5.0.66

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

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

Returns nil on failure

top
SetCreateDt
function CkSFtp_SetCreateDt(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    isHandle: wordbool;
    createDateTime: HCkDateTime): wordbool; stdcall;

Sets the create date/time for a file on the server. The pathOrHandle may be a filepath or the handle of a currently open file. isHandle should be set to True if the pathOrHandle is a handle, otherwise set isHandle to False.

Note: Servers running version 3 or lower of the SFTP protocol do not support setting the create date/time.

Returns True for success, False for failure.

top
SetCreateDtAsync (1)
function CkSFtp_SetCreateDtAsync(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    isHandle: wordbool;
    createDateTime: HCkDateTime): HCkTask; stdcall;

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

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

Returns nil on failure

top
SetCreateTimeStr
function CkSFtp_SetCreateTimeStr(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bIsHandle: wordbool;
    dateTimeStr: PWideChar): wordbool; stdcall;

The same as SetCreateTime, except the date/time is passed as an RFC822 formatted string.

Returns True for success, False for failure.

top
SetCreateTimeStrAsync (1)
function CkSFtp_SetCreateTimeStrAsync(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bIsHandle: wordbool;
    dateTimeStr: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
SetLastAccessDt
function CkSFtp_SetLastAccessDt(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    isHandle: wordbool;
    accessDateTime: HCkDateTime): wordbool; stdcall;

Sets the last-access date/time for a file on the server. The pathOrHandle may be a filepath or the handle of a currently open file. isHandle should be set to True if the pathOrHandle is a handle, otherwise set isHandle to False.

Returns True for success, False for failure.

top
SetLastAccessDtAsync (1)
function CkSFtp_SetLastAccessDtAsync(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    isHandle: wordbool;
    accessDateTime: HCkDateTime): HCkTask; stdcall;

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

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

Returns nil on failure

top
SetLastAccessTimeStr
function CkSFtp_SetLastAccessTimeStr(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bIsHandle: wordbool;
    dateTimeStr: PWideChar): wordbool; stdcall;

The same as SetLastAccessTime, except the date/time is passed as an RFC822 formatted string.

Returns True for success, False for failure.

top
SetLastAccessTimeStrAsync (1)
function CkSFtp_SetLastAccessTimeStrAsync(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bIsHandle: wordbool;
    dateTimeStr: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
SetLastModifiedDt
function CkSFtp_SetLastModifiedDt(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    isHandle: wordbool;
    modifiedDateTime: HCkDateTime): wordbool; stdcall;

Sets the last-modified date/time for a file on the server. The pathOrHandle may be a filepath or the handle of a currently open file. isHandle should be set to True if the pathOrHandle is a handle, otherwise set isHandle to False.

Returns True for success, False for failure.

top
SetLastModifiedDtAsync (1)
function CkSFtp_SetLastModifiedDtAsync(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    isHandle: wordbool;
    modifiedDateTime: HCkDateTime): HCkTask; stdcall;

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

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

Returns nil on failure

top
SetLastModifiedTimeStr
function CkSFtp_SetLastModifiedTimeStr(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bIsHandle: wordbool;
    dateTimeStr: PWideChar): wordbool; stdcall;

The same as SetLastModifiedTime, except the date/time is passed as an RFC822 formatted string.

Returns True for success, False for failure.

top
SetLastModifiedTimeStrAsync (1)
function CkSFtp_SetLastModifiedTimeStrAsync(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    bIsHandle: wordbool;
    dateTimeStr: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
SetOwnerAndGroup
function CkSFtp_SetOwnerAndGroup(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    isHandle: wordbool;
    owner: PWideChar;
    group: PWideChar): wordbool; stdcall;

Sets the owner and group for a file on the server. The pathOrHandle may be a filepath or the handle of a currently open file. isHandle should be set to True if the pathOrHandle is a handle, otherwise set isHandle to False.

Note: Servers running version 3 or lower of the SFTP protocol do not support setting the owner and group.

Returns True for success, False for failure.

top
SetOwnerAndGroupAsync (1)
function CkSFtp_SetOwnerAndGroupAsync(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    isHandle: wordbool;
    owner: PWideChar;
    group: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
SetPermissions
function CkSFtp_SetPermissions(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    isHandle: wordbool;
    permissions: Integer): wordbool; stdcall;

Sets the permissions for a file on the server. The pathOrHandle may be a filepath or the handle of a currently open file. isHandle should be set to True if the pathOrHandle is a handle, otherwise set isHandle to False.

Returns True for success, False for failure.

More Information and Examples
top
SetPermissionsAsync (1)
function CkSFtp_SetPermissionsAsync(objHandle: HCkSFtp;
    pathOrHandle: PWideChar;
    isHandle: wordbool;
    permissions: Integer): HCkTask; stdcall;

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

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

Returns nil on failure

top
StartKeyboardAuth
function CkSFtp_StartKeyboardAuth(objHandle: HCkSFtp;
    login: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkSFtp__startKeyboardAuth(objHandle: HCkSFtp;
    login: PWideChar): PWideChar; stdcall;
Introduced in version 9.5.0.88

Begins keyboard-interactive authentication with the SSH server. Returns an XML string providing the name, instruction, and prompts. The XML has the following format:

 	<infoRequest numPrompts="N">
	    <name>name_string</name>
	    <instruction>instruction_string</instruction>
	    <prompt1 echo="1_or_0">prompt_string</prompt1>
	    ...
	    <promptN echo="1_or_0">prompt_string</promptN>
	</infoRequest>

If the authentication immediately succeeds because no password is required, or immediately fails, the XML response can be:

<success>success_message</success>

or

<error>error_message</error>

Returns True for success, False for failure.

top
StartKeyboardAuthAsync (1)
function CkSFtp_StartKeyboardAuthAsync(objHandle: HCkSFtp;
    login: PWideChar): HCkTask; stdcall;
Introduced in version 9.5.0.88

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

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

Returns nil on failure

top
SymLink
function CkSFtp_SymLink(objHandle: HCkSFtp;
    oldPath: PWideChar;
    newPath: PWideChar): wordbool; stdcall;
Introduced in version 9.5.0.71

Create a symbolic link from oldpath to newpath on the server filesystem.

Returns True for success, False for failure.

More Information and Examples
top
SymLinkAsync (1)
function CkSFtp_SymLinkAsync(objHandle: HCkSFtp;
    oldPath: PWideChar;
    newPath: PWideChar): HCkTask; stdcall;
Introduced in version 9.5.0.71

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

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

Returns nil on failure

top
SyncTreeDownload
function CkSFtp_SyncTreeDownload(objHandle: HCkSFtp;
    remoteRoot: PWideChar;
    localRoot: PWideChar;
    mode: Integer;
    recurse: wordbool): wordbool; stdcall;

Downloads files from the SFTP server to a local directory tree. Synchronization modes include:

mode=0: Download all files
mode=1: Download all files that do not exist on the local filesystem.
mode=2: Download newer or non-existant files.
mode=3: Download only newer files. If a file does not already exist on the local filesystem, it is not downloaded from the server.
mode=5: Download only missing files or files with size differences.
mode=6: Same as mode 5, but also download newer files.
mode=99: Do not download files, but instead delete remote files that do not exist locally.

If recurse is False, then the remotel directory tree is not recursively descended.

Important: If the remoteRoot is an absolute path, then it is a path from the root of the server's filesystem. For example, "/home/joe/sourceDir". Use a relative path to specify a directory relative to the $HOME directory of the SSH user account. For example, "./sourceDir".

Note: After this method returns, the paths of the downloaded files are available in the SyncedFiles property.

Returns True for success, False for failure.

top
SyncTreeDownloadAsync (1)
function CkSFtp_SyncTreeDownloadAsync(objHandle: HCkSFtp;
    remoteRoot: PWideChar;
    localRoot: PWideChar;
    mode: Integer;
    recurse: wordbool): HCkTask; stdcall;

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

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

Returns nil on failure

top
SyncTreeUpload
function CkSFtp_SyncTreeUpload(objHandle: HCkSFtp;
    localBaseDir: PWideChar;
    remoteBaseDir: PWideChar;
    mode: Integer;
    bRecurse: wordbool): wordbool; stdcall;

Uploads a directory tree from the local filesystem to the SFTP server. Synchronization modes include:

mode=0: Upload all files
mode=1: Upload all files that do not exist on the server.
mode=2: Upload newer or non-existant files.
mode=3: Upload only newer files. If a file does not already exist on the server, it is not uploaded.
mode=4: transfer missing files or files with size differences.
mode=5: same as mode 4, but also newer files.

If bRecurse is False, then the local directory tree is not recursively descended.

Important: If the remoteBaseDir is an absolute path, then it is a path from the root of the server's filesystem. For example, "/home/joe/targetDir". Use a relative path to specify a directory relative to the $HOME directory of the SSH user account. For example, "./targetDir".

Note: After this method returns, the paths of the downloaded files are available in the SyncedFiles property.

Returns True for success, False for failure.

More Information and Examples
top
SyncTreeUploadAsync (1)
function CkSFtp_SyncTreeUploadAsync(objHandle: HCkSFtp;
    localBaseDir: PWideChar;
    remoteBaseDir: PWideChar;
    mode: Integer;
    bRecurse: wordbool): HCkTask; stdcall;

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

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

Returns nil on failure

top
UploadBd
function CkSFtp_UploadBd(objHandle: HCkSFtp;
    binData: HCkBinData;
    remoteFilePath: PWideChar): wordbool; stdcall;
Introduced in version 9.5.0.62

Uploads the contents of a BinData to a remote file.

Returns True for success, False for failure.

More Information and Examples
top
UploadBdAsync (1)
function CkSFtp_UploadBdAsync(objHandle: HCkSFtp;
    binData: HCkBinData;
    remoteFilePath: PWideChar): HCkTask; stdcall;
Introduced in version 9.5.0.62

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

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

Returns nil on failure

top
UploadFile
function CkSFtp_UploadFile(objHandle: HCkSFtp;
    handle: PWideChar;
    fromLocalFilePath: PWideChar): wordbool; stdcall;

Uploads a file from the local filesystem to the SFTP server. handle is a handle of a currently open file (obtained by calling the OpenFile method). fromLocalFilePath is the local file path of the file to be uploaded.

Returns True for success, False for failure.

More Information and Examples
top
UploadFileAsync (1)
function CkSFtp_UploadFileAsync(objHandle: HCkSFtp;
    handle: PWideChar;
    fromLocalFilePath: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
UploadFileByName
function CkSFtp_UploadFileByName(objHandle: HCkSFtp;
    remoteFilePath: PWideChar;
    localFilePath: PWideChar): wordbool; stdcall;

Simplified method for uploading a file to the SFTP/SSH server.

The last-modified date/time is only preserved if the PreserveDate property is set to True. This behavior of maintaining the last-mod date/time was introduced in v9.5.0.40.

Important: If the remoteFilePath is an absolute path, then it is a path from the root of the server's filesystem. For example, "/home/joe/someFile.txt". Use a relative path to specify a directory relative to the $HOME directory of the SSH user account. For example, "./someFile.txt".

Returns True for success, False for failure.

top
UploadFileByNameAsync (1)
function CkSFtp_UploadFileByNameAsync(objHandle: HCkSFtp;
    remoteFilePath: PWideChar;
    localFilePath: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
UploadSb
function CkSFtp_UploadSb(objHandle: HCkSFtp;
    sb: HCkStringBuilder;
    remoteFilePath: PWideChar;
    charset: PWideChar;
    includeBom: wordbool): wordbool; stdcall;
Introduced in version 9.5.0.62

Uploads the contents of a StringBuilder to a remote file.

Returns True for success, False for failure.

top
UploadSbAsync (1)
function CkSFtp_UploadSbAsync(objHandle: HCkSFtp;
    sb: HCkStringBuilder;
    remoteFilePath: PWideChar;
    charset: PWideChar;
    includeBom: wordbool): HCkTask; stdcall;
Introduced in version 9.5.0.62

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

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

Returns nil on failure

top
WriteFileBd
function CkSFtp_WriteFileBd(objHandle: HCkSFtp;
    handle: PWideChar;
    bd: HCkBinData): wordbool; stdcall;
Introduced in version 9.5.0.77

Appends the contents of bd to an open file. The handle is a file handle returned by the OpenFile method.

Returns True for success, False for failure.

More Information and Examples
top
WriteFileBdAsync (1)
function CkSFtp_WriteFileBdAsync(objHandle: HCkSFtp;
    handle: PWideChar;
    bd: HCkBinData): HCkTask; stdcall;
Introduced in version 9.5.0.77

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

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

Returns nil on failure

top
WriteFileBytes
function CkSFtp_WriteFileBytes(objHandle: HCkSFtp;
    handle: PWideChar;
    byteData: HCkByteData): wordbool; stdcall;

Appends byte data to an open file. The handle is a file handle returned by the OpenFile method.

Returns True for success, False for failure.

top
WriteFileBytesAsync (1)
function CkSFtp_WriteFileBytesAsync(objHandle: HCkSFtp;
    handle: PWideChar;
    byteData: HCkByteData): HCkTask; stdcall;

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

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

Returns nil on failure

top
WriteFileBytes32
function CkSFtp_WriteFileBytes32(objHandle: HCkSFtp;
    handle: PWideChar;
    offset: Integer;
    data: HCkByteData): wordbool; stdcall;

Writes data to an open file at a specific offset from the beginning of the file. The handle is a file handle returned by the OpenFile method. The offset is an offset from the beginning of the file.

Returns True for success, False for failure.

top
WriteFileBytes32Async (1)
function CkSFtp_WriteFileBytes32Async(objHandle: HCkSFtp;
    handle: PWideChar;
    offset: Integer;
    data: HCkByteData): HCkTask; stdcall;

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

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

Returns nil on failure

top
WriteFileBytes64
function CkSFtp_WriteFileBytes64(objHandle: HCkSFtp;
    handle: PWideChar;
    offset64: Int64;
    data: HCkByteData): wordbool; stdcall;

Writes data to an open file at a specific offset from the beginning of the file. The handle is a file handle returned by the OpenFile method. The offset64 is an offset from the beginning of the file.

Returns True for success, False for failure.

top
WriteFileBytes64Async (1)
function CkSFtp_WriteFileBytes64Async(objHandle: HCkSFtp;
    handle: PWideChar;
    offset64: Int64;
    data: HCkByteData): HCkTask; stdcall;

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

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

Returns nil on failure

top
WriteFileBytes64s
function CkSFtp_WriteFileBytes64s(objHandle: HCkSFtp;
    handle: PWideChar;
    offset64: PWideChar;
    data: HCkByteData): wordbool; stdcall;

Writes data to an open file at a specific offset from the beginning of the file. The handle is a file handle returned by the OpenFile method. The offset64 is an offset (in decimal string format) from the beginning of the file.

Returns True for success, False for failure.

top
WriteFileBytes64sAsync (1)
function CkSFtp_WriteFileBytes64sAsync(objHandle: HCkSFtp;
    handle: PWideChar;
    offset64: PWideChar;
    data: HCkByteData): HCkTask; stdcall;

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

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

Returns nil on failure

top
WriteFileText
function CkSFtp_WriteFileText(objHandle: HCkSFtp;
    handle: PWideChar;
    charset: PWideChar;
    textData: PWideChar): wordbool; stdcall;

Appends character data to an open file. The handle is a file handle returned by the OpenFile method. charset is a character encoding and is typically set to values such as "ansi", "utf-8", "windows-1252", etc. A list of supported character encodings is found on this page: Supported Charsets.

Note: It is necessary to specify the character encoding because in many programming languages, strings are represented as Unicode (2 bytes/char) and in most cases one does not wish to write Unicode chars to a text file (although it is possible by setting charset = "Unicode").

Returns True for success, False for failure.

top
WriteFileTextAsync (1)
function CkSFtp_WriteFileTextAsync(objHandle: HCkSFtp;
    handle: PWideChar;
    charset: PWideChar;
    textData: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
WriteFileText32
function CkSFtp_WriteFileText32(objHandle: HCkSFtp;
    handle: PWideChar;
    offset32: Integer;
    charset: PWideChar;
    textData: PWideChar): wordbool; stdcall;

Writes character data to an open file at a specific offset from the beginning of the file. The handle is a file handle returned by the OpenFile method. charset is a character encoding and is typically set to values such as "ansi", "utf-8", "windows-1252", etc. A list of supported character encodings is found on this page: Supported Charsets.

Returns True for success, False for failure.

top
WriteFileText32Async (1)
function CkSFtp_WriteFileText32Async(objHandle: HCkSFtp;
    handle: PWideChar;
    offset32: Integer;
    charset: PWideChar;
    textData: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
WriteFileText64
function CkSFtp_WriteFileText64(objHandle: HCkSFtp;
    handle: PWideChar;
    offset64: Int64;
    charset: PWideChar;
    textData: PWideChar): wordbool; stdcall;

Writes character data to an open file at a specific offset from the beginning of the file. The handle is a file handle returned by the OpenFile method. charset is a character encoding and is typically set to values such as "ansi", "utf-8", "windows-1252", etc. A list of supported character encodings is found on this page: Supported Charsets.

Returns True for success, False for failure.

top
WriteFileText64Async (1)
function CkSFtp_WriteFileText64Async(objHandle: HCkSFtp;
    handle: PWideChar;
    offset64: Int64;
    charset: PWideChar;
    textData: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top
WriteFileText64s
function CkSFtp_WriteFileText64s(objHandle: HCkSFtp;
    handle: PWideChar;
    offset64: PWideChar;
    charset: PWideChar;
    textData: PWideChar): wordbool; stdcall;

Writes character data to an open file at a specific offset from the beginning of the file. The handle is a file handle returned by the OpenFile method. The offset64 is an offset (in decimal string format) from the beginning of the file. charset is a character encoding and is typically set to values such as "ansi", "utf-8", "windows-1252", etc. A list of supported character encodings is found on this page: Supported Charsets.

Returns True for success, False for failure.

top
WriteFileText64sAsync (1)
function CkSFtp_WriteFileText64sAsync(objHandle: HCkSFtp;
    handle: PWideChar;
    offset64: PWideChar;
    charset: PWideChar;
    textData: PWideChar): HCkTask; stdcall;

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

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

Returns nil on failure

top

Events

Chilkat supports event callbacks for the Delphi DLL starting in version 9.5.0.82.

AbortCheck
function MyAbortCheck(): Integer; cdecl;
Introduced in version 9.5.0.82

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

More Information and Examples
top
PercentDone
function MyPercentDone(pctDone: Integer): Integer; cdecl;
Introduced in version 9.5.0.82

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

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

Return True to abort; return False to continue (not abort)

More Information and Examples
top
ProgressInfo
procedure MyProgressInfo(name: PWideChar; value: PWideChar) cdecl;
Introduced in version 9.5.0.82

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

More Information and Examples
top
TaskCompleted
procedure MyTaskCompleted(task: HCkTask) cdecl;
Introduced in version 9.5.0.82

Called in the background thread when an asynchronous task completes.

top