---
product: Chilkat
product_version: 11.7.0
language: wc
language_label: Unicode C
class: SFtp
license: bundle
deprecated: false
reference_html: https://www.chilkatsoft.com/refdoc/wc_CkSFtpWRef.html
---
# Chilkat SFtp — Unicode C — v11.7.0

> Chilkat 11.7.0 · language=wc · class=SFtp
> Other versions: replace `11.7.0` in this URL. Other languages: `https://www.chilkatsoft.com/ai-docs/v/11.7.0/<lang>/classes/SFtp.md`.
> Language-wide rules (install, unlock, error model, strings/bytes): `https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/guide.md`.

## Purpose

**Transfer, list, manage, and synchronize files over SFTP.**

`Chilkat.SFtp` is Chilkat's main class for secure file transfer over SSH. It provides SSH connection and authentication, SFTP subsystem initialization, uploads, downloads, directory listings, remote file management, file attributes, handle-based file access, recursive synchronization, bandwidth throttling, proxy support, host key fingerprinting, SSH algorithm controls, and detailed diagnostics.

**SSH + SFTP setup**

Connect to an SSH server, authenticate with password or key-based credentials, then initialize the SFTP subsystem before file operations.

**Upload and download**

Transfer files using simple path-based APIs, in-memory data, streams, or handle-based methods when lower-level control is needed.

**Directory and file management**

List directories, create and remove folders, rename files, delete files, inspect attributes, and work with remote paths.

**Sync-tree operations**

Upload or download directory trees and synchronize local and remote folder structures.

**Security controls**

Verify host keys, control accepted SSH algorithms, use private keys, and configure proxy or network settings when required.

**Diagnostics and reliability**

Use detailed error text, session logs, progress callbacks, bandwidth limits, and timeout settings to troubleshoot real-world server behavior.

**Common pattern:** Connect, authenticate, initialize SFTP, perform file operations using remote paths or handles, close any open handles, and disconnect. Use handle-based APIs for precise control, and synchronization methods for recursive folder transfers.

For an extended overview, see [SFtp Class Overview](https://www.chilkatsoft.com/sftp_class_overview.asp).

## Object creation, unlocking and error handling

**Create/Dispose**

```c
HCkSFtpW instance = CkSFtpW_Create();
// ...
CkSFtpW_Dispose(instance);
```

`HCkSFtpW CkSFtpW_Create(void);`

Creates an instance of the HCkSFtpW object and returns a handle ("void \*" pointer). The handle is passed in the 1st argument for the functions listed on this page.

`void CkSFtpW_Dispose(HCkSFtpW handle);`

Objects created by calling CkSFtpW_Create must be freed by calling this method. A memory leak occurs if a handle is not disposed by calling this function. Also, any handle returned by a Chilkat "C" function must also be freed by the application by calling the appropriate Dispose method, such as CkSFtpW_Dispose.

Call `Global.UnlockBundle` once at the start of the program, before using this or any other Chilkat class. Any string unlocks a fully functional 30-day trial; a purchased unlock code is used in production. See `guide.md` for the exact code in Unicode C.

## Members common to every Chilkat class

Documented once per language in `common-members.md`; listed here so this page is self-contained.

| Property | Signature | Access | Meaning |
|---|---|---|---|
| `DebugLogFilePath` | `void CkSFtpW_getDebugLogFilePath(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putDebugLogFilePath(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_debugLogFilePath(HCkSFtpW cHandle);` | read/write | If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. |
| `LastErrorHtml` | `void CkSFtpW_getLastErrorHtml(HCkSFtpW cHandle, HCkString retval); const wchar_t *CkSFtpW_lastErrorHtml(HCkSFtpW cHandle);` | read-only | Provides HTML-formatted information about the last called method or property. |
| `LastErrorText` | `void CkSFtpW_getLastErrorText(HCkSFtpW cHandle, HCkString retval); const wchar_t *CkSFtpW_lastErrorText(HCkSFtpW cHandle);` | read-only | Provides plain text information about the last called method or property. |
| `LastErrorXml` | `void CkSFtpW_getLastErrorXml(HCkSFtpW cHandle, HCkString retval); const wchar_t *CkSFtpW_lastErrorXml(HCkSFtpW cHandle);` | read-only | Provides XML-formatted information about the last called method or property. |
| `LastMethodSuccess` | `BOOL CkSFtpW_getLastMethodSuccess(HCkSFtpW cHandle); void CkSFtpW_putLastMethodSuccess(HCkSFtpW cHandle, BOOL newVal);` | read/write | Indicates the success or failure of the most recent method call: `TRUE` means success, `FALSE` means failure. |
| `VerboseLogging` | `BOOL CkSFtpW_getVerboseLogging(HCkSFtpW cHandle); void CkSFtpW_putVerboseLogging(HCkSFtpW cHandle, BOOL newVal);` | read/write | If set to `TRUE`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. |
| `Version` | `void CkSFtpW_getVersion(HCkSFtpW cHandle, HCkString retval); const wchar_t *CkSFtpW_version(HCkSFtpW cHandle);` | read-only | Version of the component/library, such as "10.1.0" |

## Member index

| Member | Kind | Signature |
|---|---|---|
| `AbortCurrent` | property, read/write | `BOOL CkSFtpW_getAbortCurrent(HCkSFtpW cHandle); void CkSFtpW_putAbortCurrent(HCkSFtpW cHandle, BOOL newVal);` |
| `AuthFailReason` | property, read-only | `int CkSFtpW_getAuthFailReason(HCkSFtpW cHandle);` |
| `BandwidthThrottleDown` | property, read/write | `int CkSFtpW_getBandwidthThrottleDown(HCkSFtpW cHandle); void CkSFtpW_putBandwidthThrottleDown(HCkSFtpW cHandle, int newVal);` |
| `BandwidthThrottleUp` | property, read/write | `int CkSFtpW_getBandwidthThrottleUp(HCkSFtpW cHandle); void CkSFtpW_putBandwidthThrottleUp(HCkSFtpW cHandle, int newVal);` |
| `ClientIdentifier` | property, read/write | `void CkSFtpW_getClientIdentifier(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putClientIdentifier(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_clientIdentifier(HCkSFtpW cHandle);` |
| `ClientIpAddress` | property, read/write | `void CkSFtpW_getClientIpAddress(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putClientIpAddress(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_clientIpAddress(HCkSFtpW cHandle);` |
| `ConnectTimeoutMs` | property, read/write | `int CkSFtpW_getConnectTimeoutMs(HCkSFtpW cHandle); void CkSFtpW_putConnectTimeoutMs(HCkSFtpW cHandle, int newVal);` |
| `DisconnectCode` | property, read-only | `int CkSFtpW_getDisconnectCode(HCkSFtpW cHandle);` |
| `DisconnectReason` | property, read-only | `void CkSFtpW_getDisconnectReason(HCkSFtpW cHandle, HCkString retval); const wchar_t *CkSFtpW_disconnectReason(HCkSFtpW cHandle);` |
| `EnableCache` | property, read/write | `BOOL CkSFtpW_getEnableCache(HCkSFtpW cHandle); void CkSFtpW_putEnableCache(HCkSFtpW cHandle, BOOL newVal);` |
| `EnableCompression` | property, read/write | `BOOL CkSFtpW_getEnableCompression(HCkSFtpW cHandle); void CkSFtpW_putEnableCompression(HCkSFtpW cHandle, BOOL newVal);` |
| `EnableSecrets` | property, read/write | `BOOL CkSFtpW_getEnableSecrets(HCkSFtpW cHandle); void CkSFtpW_putEnableSecrets(HCkSFtpW cHandle, BOOL newVal);` |
| `FilenameCharset` | property, read/write | `void CkSFtpW_getFilenameCharset(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putFilenameCharset(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_filenameCharset(HCkSFtpW cHandle);` |
| `ForceCipher` | property, read/write | `void CkSFtpW_getForceCipher(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putForceCipher(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_forceCipher(HCkSFtpW cHandle);` |
| `ForceV3` | property, read/write | `BOOL CkSFtpW_getForceV3(HCkSFtpW cHandle); void CkSFtpW_putForceV3(HCkSFtpW cHandle, BOOL newVal);` |
| `HeartbeatMs` | property, read/write | `int CkSFtpW_getHeartbeatMs(HCkSFtpW cHandle); void CkSFtpW_putHeartbeatMs(HCkSFtpW cHandle, int newVal);` |
| `HostKeyAlg` | property, read/write | `void CkSFtpW_getHostKeyAlg(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putHostKeyAlg(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_hostKeyAlg(HCkSFtpW cHandle);` |
| `HostKeyFingerprint` | property, read-only | `void CkSFtpW_getHostKeyFingerprint(HCkSFtpW cHandle, HCkString retval); const wchar_t *CkSFtpW_hostKeyFingerprint(HCkSFtpW cHandle);` |
| `HttpProxyAuthMethod` | property, read/write | `void CkSFtpW_getHttpProxyAuthMethod(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putHttpProxyAuthMethod(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_httpProxyAuthMethod(HCkSFtpW cHandle);` |
| `HttpProxyDomain` | property, read/write | `void CkSFtpW_getHttpProxyDomain(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putHttpProxyDomain(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_httpProxyDomain(HCkSFtpW cHandle);` |
| `HttpProxyHostname` | property, read/write | `void CkSFtpW_getHttpProxyHostname(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putHttpProxyHostname(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_httpProxyHostname(HCkSFtpW cHandle);` |
| `HttpProxyPassword` | property, read/write | `void CkSFtpW_getHttpProxyPassword(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putHttpProxyPassword(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_httpProxyPassword(HCkSFtpW cHandle);` |
| `HttpProxyPort` | property, read/write | `int CkSFtpW_getHttpProxyPort(HCkSFtpW cHandle); void CkSFtpW_putHttpProxyPort(HCkSFtpW cHandle, int newVal);` |
| `HttpProxyUsername` | property, read/write | `void CkSFtpW_getHttpProxyUsername(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putHttpProxyUsername(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_httpProxyUsername(HCkSFtpW cHandle);` |
| `IdleTimeoutMs` | property, read/write | `int CkSFtpW_getIdleTimeoutMs(HCkSFtpW cHandle); void CkSFtpW_putIdleTimeoutMs(HCkSFtpW cHandle, int newVal);` |
| `IncludeDotDirs` | property, read/write | `BOOL CkSFtpW_getIncludeDotDirs(HCkSFtpW cHandle); void CkSFtpW_putIncludeDotDirs(HCkSFtpW cHandle, BOOL newVal);` |
| `InitializeFailCode` | property, read-only | `int CkSFtpW_getInitializeFailCode(HCkSFtpW cHandle);` |
| `InitializeFailReason` | property, read-only | `void CkSFtpW_getInitializeFailReason(HCkSFtpW cHandle, HCkString retval); const wchar_t *CkSFtpW_initializeFailReason(HCkSFtpW cHandle);` |
| `IsConnected` | property, read-only | `BOOL CkSFtpW_getIsConnected(HCkSFtpW cHandle);` |
| `KeepSessionLog` | property, read/write | `BOOL CkSFtpW_getKeepSessionLog(HCkSFtpW cHandle); void CkSFtpW_putKeepSessionLog(HCkSFtpW cHandle, BOOL newVal);` |
| `LastStatusCode` | property, read-only | `int CkSFtpW_getLastStatusCode(HCkSFtpW cHandle);` |
| `LastStatusMessage` | property, read-only | `void CkSFtpW_getLastStatusMessage(HCkSFtpW cHandle, HCkString retval); const wchar_t *CkSFtpW_lastStatusMessage(HCkSFtpW cHandle);` |
| `MaxPacketSize` | property, read/write | `int CkSFtpW_getMaxPacketSize(HCkSFtpW cHandle); void CkSFtpW_putMaxPacketSize(HCkSFtpW cHandle, int newVal);` |
| `PasswordChangeRequested` | property, read-only | `BOOL CkSFtpW_getPasswordChangeRequested(HCkSFtpW cHandle);` |
| `PercentDoneScale` | property, read/write | `int CkSFtpW_getPercentDoneScale(HCkSFtpW cHandle); void CkSFtpW_putPercentDoneScale(HCkSFtpW cHandle, int newVal);` |
| `PreferIpv6` | property, read/write | `BOOL CkSFtpW_getPreferIpv6(HCkSFtpW cHandle); void CkSFtpW_putPreferIpv6(HCkSFtpW cHandle, BOOL newVal);` |
| `PreserveDate` | property, read/write | `BOOL CkSFtpW_getPreserveDate(HCkSFtpW cHandle); void CkSFtpW_putPreserveDate(HCkSFtpW cHandle, BOOL newVal);` |
| `ProtocolVersion` | property, read-only | `int CkSFtpW_getProtocolVersion(HCkSFtpW cHandle);` |
| `ReadDirMustMatch` | property, read/write | `void CkSFtpW_getReadDirMustMatch(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putReadDirMustMatch(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_readDirMustMatch(HCkSFtpW cHandle);` |
| `ReadDirMustNotMatch` | property, read/write | `void CkSFtpW_getReadDirMustNotMatch(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putReadDirMustNotMatch(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_readDirMustNotMatch(HCkSFtpW cHandle);` |
| `ServerIdentifier` | property, read-only | `void CkSFtpW_getServerIdentifier(HCkSFtpW cHandle, HCkString retval); const wchar_t *CkSFtpW_serverIdentifier(HCkSFtpW cHandle);` |
| `SessionLog` | property, read-only | `void CkSFtpW_getSessionLog(HCkSFtpW cHandle, HCkString retval); const wchar_t *CkSFtpW_sessionLog(HCkSFtpW cHandle);` |
| `SocksHostname` | property, read/write | `void CkSFtpW_getSocksHostname(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putSocksHostname(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_socksHostname(HCkSFtpW cHandle);` |
| `SocksPassword` | property, read/write | `void CkSFtpW_getSocksPassword(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putSocksPassword(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_socksPassword(HCkSFtpW cHandle);` |
| `SocksPort` | property, read/write | `int CkSFtpW_getSocksPort(HCkSFtpW cHandle); void CkSFtpW_putSocksPort(HCkSFtpW cHandle, int newVal);` |
| `SocksUsername` | property, read/write | `void CkSFtpW_getSocksUsername(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putSocksUsername(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_socksUsername(HCkSFtpW cHandle);` |
| `SocksVersion` | property, read/write | `int CkSFtpW_getSocksVersion(HCkSFtpW cHandle); void CkSFtpW_putSocksVersion(HCkSFtpW cHandle, int newVal);` |
| `SoRcvBuf` | property, read/write | `int CkSFtpW_getSoRcvBuf(HCkSFtpW cHandle); void CkSFtpW_putSoRcvBuf(HCkSFtpW cHandle, int newVal);` |
| `SoSndBuf` | property, read/write | `int CkSFtpW_getSoSndBuf(HCkSFtpW cHandle); void CkSFtpW_putSoSndBuf(HCkSFtpW cHandle, int newVal);` |
| `SyncCreateAllLocalDirs` | property, read/write | `BOOL CkSFtpW_getSyncCreateAllLocalDirs(HCkSFtpW cHandle); void CkSFtpW_putSyncCreateAllLocalDirs(HCkSFtpW cHandle, BOOL newVal);` |
| `SyncDirectives` | property, read/write | `void CkSFtpW_getSyncDirectives(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putSyncDirectives(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_syncDirectives(HCkSFtpW cHandle);` |
| `SyncMustMatch` | property, read/write | `void CkSFtpW_getSyncMustMatch(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putSyncMustMatch(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_syncMustMatch(HCkSFtpW cHandle);` |
| `SyncMustMatchDir` | property, read/write | `void CkSFtpW_getSyncMustMatchDir(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putSyncMustMatchDir(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_syncMustMatchDir(HCkSFtpW cHandle);` |
| `SyncMustNotMatch` | property, read/write | `void CkSFtpW_getSyncMustNotMatch(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putSyncMustNotMatch(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_syncMustNotMatch(HCkSFtpW cHandle);` |
| `SyncMustNotMatchDir` | property, read/write | `void CkSFtpW_getSyncMustNotMatchDir(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putSyncMustNotMatchDir(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_syncMustNotMatchDir(HCkSFtpW cHandle);` |
| `TcpNoDelay` | property, read/write | `BOOL CkSFtpW_getTcpNoDelay(HCkSFtpW cHandle); void CkSFtpW_putTcpNoDelay(HCkSFtpW cHandle, BOOL newVal);` |
| `UncommonOptions` | property, read/write | `void CkSFtpW_getUncommonOptions(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putUncommonOptions(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_uncommonOptions(HCkSFtpW cHandle);` |
| `UploadChunkSize` | property, read/write | `int CkSFtpW_getUploadChunkSize(HCkSFtpW cHandle); void CkSFtpW_putUploadChunkSize(HCkSFtpW cHandle, int newVal);` |
| `UserAuthBanner` | property, read/write | `void CkSFtpW_getUserAuthBanner(HCkSFtpW cHandle, HCkString retval); void CkSFtpW_putUserAuthBanner(HCkSFtpW cHandle, const wchar_t *newVal); const wchar_t *CkSFtpW_userAuthBanner(HCkSFtpW cHandle);` |
| `UtcMode` | property, read/write | `BOOL CkSFtpW_getUtcMode(HCkSFtpW cHandle); void CkSFtpW_putUtcMode(HCkSFtpW cHandle, BOOL newVal);` |
| `XferByteCount` | property, read-only | `unsigned long CkSFtpW_getXferByteCount(HCkSFtpW cHandle);` |
| `XferByteCount64` | property, read-only | `__int64 CkSFtpW_getXferByteCount64(HCkSFtpW cHandle);` |
| `AuthenticatePk` | method | `BOOL CkSFtpW_AuthenticatePk(HCkSFtpW cHandle, const wchar_t *username, HCkSshKeyW privateKey);` |
| `AuthenticatePw` | method | `BOOL CkSFtpW_AuthenticatePw(HCkSFtpW cHandle, const wchar_t *login, const wchar_t *password);` |
| `AuthenticatePwPk` | method | `BOOL CkSFtpW_AuthenticatePwPk(HCkSFtpW cHandle, const wchar_t *username, const wchar_t *password, HCkSshKeyW privateKey);` |
| `AuthenticateSecPw` | method | `BOOL CkSFtpW_AuthenticateSecPw(HCkSFtpW cHandle, HCkSecureStringW login, HCkSecureStringW password);` |
| `AuthenticateSecPwPk` | method | `BOOL CkSFtpW_AuthenticateSecPwPk(HCkSFtpW cHandle, HCkSecureStringW username, HCkSecureStringW password, HCkSshKeyW privateKey);` |
| `ClearCache` | method | `void CkSFtpW_ClearCache(HCkSFtpW cHandle);` |
| `ClearSessionLog` | method | `void CkSFtpW_ClearSessionLog(HCkSFtpW cHandle);` |
| `CloseHandle` | method | `BOOL CkSFtpW_CloseHandle(HCkSFtpW cHandle, const wchar_t *handle);` |
| `Connect` | method | `BOOL CkSFtpW_Connect(HCkSFtpW cHandle, const wchar_t *domainName, int port);` |
| `ConnectThroughSsh` | method | `BOOL CkSFtpW_ConnectThroughSsh(HCkSFtpW cHandle, HCkSshW sshConn, const wchar_t *hostname, int port);` |
| `ContinueKeyboardAuth` | method | `BOOL CkSFtpW_ContinueKeyboardAuth(HCkSFtpW cHandle, const wchar_t *response, const wchar_t *outStr); const wchar_t *CkSFtpW_continueKeyboardAuth(HCkSFtpW cHandle, const wchar_t *response);` |
| `CopyFileAttr` | method | `BOOL CkSFtpW_CopyFileAttr(HCkSFtpW cHandle, const wchar_t *localFilename, const wchar_t *remoteFilename, BOOL isHandle);` |
| `CreateDir` | method | `BOOL CkSFtpW_CreateDir(HCkSFtpW cHandle, const wchar_t *path);` |
| `Disconnect` | method | `void CkSFtpW_Disconnect(HCkSFtpW cHandle);` |
| `DownloadBd` | method | `BOOL CkSFtpW_DownloadBd(HCkSFtpW cHandle, const wchar_t *remoteFilePath, HCkBinDataW binData);` |
| `DownloadFile` | method | `BOOL CkSFtpW_DownloadFile(HCkSFtpW cHandle, const wchar_t *handle, const wchar_t *toFilename);` |
| `DownloadFileByName` | method | `BOOL CkSFtpW_DownloadFileByName(HCkSFtpW cHandle, const wchar_t *remoteFilePath, const wchar_t *localFilePath);` |
| `DownloadSb` | method | `BOOL CkSFtpW_DownloadSb(HCkSFtpW cHandle, const wchar_t *remoteFilePath, const wchar_t *charset, HCkStringBuilderW sb);` |
| `Eof` | method | `BOOL CkSFtpW_Eof(HCkSFtpW cHandle, const wchar_t *handle);` |
| `FileExists` | method | `int CkSFtpW_FileExists(HCkSFtpW cHandle, const wchar_t *remotePath, BOOL followLinks);` |
| `Fsync` | method | `BOOL CkSFtpW_Fsync(HCkSFtpW cHandle, const wchar_t *handle);` |
| `GetFileCreateTimeStr` | method | `BOOL CkSFtpW_GetFileCreateTimeStr(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle, const wchar_t *outStr); const wchar_t *CkSFtpW_getFileCreateTimeStr(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);` |
| `GetFileGroup` | method | `BOOL CkSFtpW_GetFileGroup(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle, const wchar_t *outStr); const wchar_t *CkSFtpW_getFileGroup(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);` |
| `GetFileLastAccessStr` | method | `BOOL CkSFtpW_GetFileLastAccessStr(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle, const wchar_t *outStr); const wchar_t *CkSFtpW_getFileLastAccessStr(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);` |
| `GetFileLastModifiedStr` | method | `BOOL CkSFtpW_GetFileLastModifiedStr(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle, const wchar_t *outStr); const wchar_t *CkSFtpW_getFileLastModifiedStr(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);` |
| `GetFileOwner` | method | `BOOL CkSFtpW_GetFileOwner(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle, const wchar_t *outStr); const wchar_t *CkSFtpW_getFileOwner(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);` |
| `GetFilePermissions` | method | `int CkSFtpW_GetFilePermissions(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);` |
| `GetFileSize32` | method | `int CkSFtpW_GetFileSize32(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);` |
| `GetFileSize64` | method | `__int64 CkSFtpW_GetFileSize64(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);` |
| `GetFileSizeStr` | method | `BOOL CkSFtpW_GetFileSizeStr(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle, const wchar_t *outStr); const wchar_t *CkSFtpW_getFileSizeStr(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);` |
| `GetHostKeyFP` | method | `BOOL CkSFtpW_GetHostKeyFP(HCkSFtpW cHandle, const wchar_t *hashAlg, BOOL includeKeyType, BOOL includeHashName, const wchar_t *outStr); const wchar_t *CkSFtpW_getHostKeyFP(HCkSFtpW cHandle, const wchar_t *hashAlg, BOOL includeKeyType, BOOL includeHashName);` |
| `GetLastJsonData` | method | `void CkSFtpW_GetLastJsonData(HCkSFtpW cHandle, HCkJsonObjectW json);` |
| `GetSyncedFiles` | method | `void CkSFtpW_GetSyncedFiles(HCkSFtpW cHandle, HCkStringTableW strTab);` |
| `HardLink` | method | `BOOL CkSFtpW_HardLink(HCkSFtpW cHandle, const wchar_t *oldPath, const wchar_t *newPath);` |
| `InitializeSftp` | method | `BOOL CkSFtpW_InitializeSftp(HCkSFtpW cHandle);` |
| `LastReadFailed` | method | `BOOL CkSFtpW_LastReadFailed(HCkSFtpW cHandle, const wchar_t *handle);` |
| `LastReadNumBytes` | method | `int CkSFtpW_LastReadNumBytes(HCkSFtpW cHandle, const wchar_t *handle);` |
| `LoadTaskCaller` | method | `BOOL CkSFtpW_LoadTaskCaller(HCkSFtpW cHandle, HCkTaskW task);` |
| `OpenDir` | method | `BOOL CkSFtpW_OpenDir(HCkSFtpW cHandle, const wchar_t *path, const wchar_t *outStr); const wchar_t *CkSFtpW_openDir(HCkSFtpW cHandle, const wchar_t *path);` |
| `OpenFile` | method | `BOOL CkSFtpW_OpenFile(HCkSFtpW cHandle, const wchar_t *remotePath, const wchar_t *access, const wchar_t *createDisposition, const wchar_t *outStr); const wchar_t *CkSFtpW_openFile(HCkSFtpW cHandle, const wchar_t *remotePath, const wchar_t *access, const wchar_t *createDisposition);` |
| `ReadDirListing` | method | `BOOL CkSFtpW_ReadDirListing(HCkSFtpW cHandle, const wchar_t *handle, HCkSFtpDirW dirObj);` |
| `ReadFileBd` | method | `BOOL CkSFtpW_ReadFileBd(HCkSFtpW cHandle, const wchar_t *handle, int numBytes, HCkBinDataW bd);` |
| `ReadFileText` | method | `BOOL CkSFtpW_ReadFileText(HCkSFtpW cHandle, const wchar_t *handle, int numBytes, const wchar_t *charset, const wchar_t *outStr); const wchar_t *CkSFtpW_readFileText(HCkSFtpW cHandle, const wchar_t *handle, int numBytes, const wchar_t *charset);` |
| `ReadFileText32` | method | `BOOL CkSFtpW_ReadFileText32(HCkSFtpW cHandle, const wchar_t *handle, int offset, int numBytes, const wchar_t *charset, const wchar_t *outStr); const wchar_t *CkSFtpW_readFileText32(HCkSFtpW cHandle, const wchar_t *handle, int offset, int numBytes, const wchar_t *charset);` |
| `ReadFileText64` | method | `BOOL CkSFtpW_ReadFileText64(HCkSFtpW cHandle, const wchar_t *handle, __int64 offset, int numBytes, const wchar_t *charset, const wchar_t *outStr); const wchar_t *CkSFtpW_readFileText64(HCkSFtpW cHandle, const wchar_t *handle, __int64 offset, int numBytes, const wchar_t *charset);` |
| `ReadFileText64s` | method | `BOOL CkSFtpW_ReadFileText64s(HCkSFtpW cHandle, const wchar_t *handle, const wchar_t *offset, int numBytes, const wchar_t *charset, const wchar_t *outStr); const wchar_t *CkSFtpW_readFileText64s(HCkSFtpW cHandle, const wchar_t *handle, const wchar_t *offset, int numBytes, const wchar_t *charset);` |
| `ReadLink` | method | `BOOL CkSFtpW_ReadLink(HCkSFtpW cHandle, const wchar_t *path, const wchar_t *outStr); const wchar_t *CkSFtpW_readLink(HCkSFtpW cHandle, const wchar_t *path);` |
| `RealPath` | method | `BOOL CkSFtpW_RealPath(HCkSFtpW cHandle, const wchar_t *originalPath, const wchar_t *composePath, const wchar_t *outStr); const wchar_t *CkSFtpW_realPath(HCkSFtpW cHandle, const wchar_t *originalPath, const wchar_t *composePath);` |
| `RemoveDir` | method | `BOOL CkSFtpW_RemoveDir(HCkSFtpW cHandle, const wchar_t *path);` |
| `RemoveFile` | method | `BOOL CkSFtpW_RemoveFile(HCkSFtpW cHandle, const wchar_t *filename);` |
| `RenameFileOrDir` | method | `BOOL CkSFtpW_RenameFileOrDir(HCkSFtpW cHandle, const wchar_t *oldPath, const wchar_t *newPath);` |
| `ResumeDownloadFileByName` | method | `BOOL CkSFtpW_ResumeDownloadFileByName(HCkSFtpW cHandle, const wchar_t *remoteFilePath, const wchar_t *localFilePath);` |
| `ResumeUploadFileByName` | method | `BOOL CkSFtpW_ResumeUploadFileByName(HCkSFtpW cHandle, const wchar_t *remoteFilePath, const wchar_t *localFilePath);` |
| `SendIgnore` | method | `BOOL CkSFtpW_SendIgnore(HCkSFtpW cHandle);` |
| `SetAllowedAlgorithms` | method | `BOOL CkSFtpW_SetAllowedAlgorithms(HCkSFtpW cHandle, HCkJsonObjectW json);` |
| `SetCreateDt` | method | `BOOL CkSFtpW_SetCreateDt(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL isHandle, HCkDateTimeW createDateTime);` |
| `SetCreateTimeStr` | method | `BOOL CkSFtpW_SetCreateTimeStr(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bIsHandle, const wchar_t *dateTimeStr);` |
| `SetLastAccessDt` | method | `BOOL CkSFtpW_SetLastAccessDt(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL isHandle, HCkDateTimeW accessDateTime);` |
| `SetLastAccessTimeStr` | method | `BOOL CkSFtpW_SetLastAccessTimeStr(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bIsHandle, const wchar_t *dateTimeStr);` |
| `SetLastModifiedDt` | method | `BOOL CkSFtpW_SetLastModifiedDt(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL isHandle, HCkDateTimeW modifiedDateTime);` |
| `SetLastModifiedTimeStr` | method | `BOOL CkSFtpW_SetLastModifiedTimeStr(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bIsHandle, const wchar_t *dateTimeStr);` |
| `SetOwnerAndGroup` | method | `BOOL CkSFtpW_SetOwnerAndGroup(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL isHandle, const wchar_t *owner, const wchar_t *group);` |
| `SetPermissions` | method | `BOOL CkSFtpW_SetPermissions(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL isHandle, int permissions);` |
| `StartKeyboardAuth` | method | `BOOL CkSFtpW_StartKeyboardAuth(HCkSFtpW cHandle, const wchar_t *login, const wchar_t *outStr); const wchar_t *CkSFtpW_startKeyboardAuth(HCkSFtpW cHandle, const wchar_t *login);` |
| `SymLink` | method | `BOOL CkSFtpW_SymLink(HCkSFtpW cHandle, const wchar_t *oldPath, const wchar_t *newPath);` |
| `SyncTreeDownload` | method | `BOOL CkSFtpW_SyncTreeDownload(HCkSFtpW cHandle, const wchar_t *remoteRoot, const wchar_t *localRoot, int mode, BOOL recurse);` |
| `SyncTreeUpload` | method | `BOOL CkSFtpW_SyncTreeUpload(HCkSFtpW cHandle, const wchar_t *localBaseDir, const wchar_t *remoteBaseDir, int mode, BOOL bRecurse);` |
| `UploadBd` | method | `BOOL CkSFtpW_UploadBd(HCkSFtpW cHandle, HCkBinDataW binData, const wchar_t *remoteFilePath);` |
| `UploadFile` | method | `BOOL CkSFtpW_UploadFile(HCkSFtpW cHandle, const wchar_t *handle, const wchar_t *fromLocalFilePath);` |
| `UploadFileByName` | method | `BOOL CkSFtpW_UploadFileByName(HCkSFtpW cHandle, const wchar_t *remoteFilePath, const wchar_t *localFilePath);` |
| `UploadSb` | method | `BOOL CkSFtpW_UploadSb(HCkSFtpW cHandle, HCkStringBuilderW sb, const wchar_t *remoteFilePath, const wchar_t *charset, BOOL includeBom);` |
| `WriteFileBd` | method | `BOOL CkSFtpW_WriteFileBd(HCkSFtpW cHandle, const wchar_t *handle, HCkBinDataW bd);` |
| `WriteFileText` | method | `BOOL CkSFtpW_WriteFileText(HCkSFtpW cHandle, const wchar_t *handle, const wchar_t *charset, const wchar_t *textData);` |
| `WriteFileText32` | method | `BOOL CkSFtpW_WriteFileText32(HCkSFtpW cHandle, const wchar_t *handle, int offset32, const wchar_t *charset, const wchar_t *textData);` |
| `WriteFileText64` | method | `BOOL CkSFtpW_WriteFileText64(HCkSFtpW cHandle, const wchar_t *handle, __int64 offset64, const wchar_t *charset, const wchar_t *textData);` |
| `WriteFileText64s` | method | `BOOL CkSFtpW_WriteFileText64s(HCkSFtpW cHandle, const wchar_t *handle, const wchar_t *offset64, const wchar_t *charset, const wchar_t *textData);` |

Deprecated members are listed at the end of this file with their replacements; do not use them in new code.

## Properties

### SFtp.AbortCurrent

`Chilkat 11.7.0 · wc · SFtp · AbortCurrent · property · read/write · since 9.5.0.58`

```c
BOOL CkSFtpW_getAbortCurrent(HCkSFtpW cHandle);
void CkSFtpW_putAbortCurrent(HCkSFtpW cHandle, BOOL newVal);
```

Set to `TRUE` to request that the currently running Chilkat operation abort. Both synchronous and asynchronous operations can be canceled; a synchronous call may be interrupted by setting this property from another thread.

When the abort is observed, the current method returns failure and Chilkat resets this property to `FALSE`. If no method is running, it is reset when the next method begins.

### SFtp.AuthFailReason

`Chilkat 11.7.0 · wc · SFtp · AuthFailReason · property · read-only · since 9.5.0.52`

```c
int CkSFtpW_getAuthFailReason(HCkSFtpW cHandle);
```

Contains the result code from the most recent call to `AuthenticatePw`, `AuthenticatePk`, `AuthenticatePwPk`, or a corresponding secure-string authentication method.

| Value | Meaning |
| :--- | :--- |
| `1` | Transport failure: communication was lost, or a network read or write failed or timed out. |
| `2` | Invalid private key: the key format, key type, or key contents are not suitable for public-key authentication. |
| `3` | No mutually supported authentication method is available. |
| `4` | SSH authentication protocol error: an unexpected or invalid message was received. |
| `5` | The server rejected the supplied password or private key. |
| `6` | The SSH session is already authenticated. |
| `7` | The server requires a password change. See `PasswordChangeRequested`. |

Read this property immediately after an authentication method fails. Also inspect `LastErrorText` for detailed diagnostics.

**Lifetime:** A later successful authentication does not necessarily reset this value. Consult it only immediately after an authentication method returns `FALSE`; do not use an older value to describe the current session.

### SFtp.BandwidthThrottleDown

`Chilkat 11.7.0 · wc · SFtp · BandwidthThrottleDown · property · read/write · since 9.5.0.49`

```c
int CkSFtpW_getBandwidthThrottleDown(HCkSFtpW cHandle);
void CkSFtpW_putBandwidthThrottleDown(HCkSFtpW cHandle, int newVal);
```

Specifies the approximate maximum download rate, in bytes per second. The default is `0`, which disables download throttling.

Bandwidth throttling is approximate. Actual throughput can vary because of network latency, SSH framing, buffering, and server behavior.

### SFtp.BandwidthThrottleUp

`Chilkat 11.7.0 · wc · SFtp · BandwidthThrottleUp · property · read/write · since 9.5.0.49`

```c
int CkSFtpW_getBandwidthThrottleUp(HCkSFtpW cHandle);
void CkSFtpW_putBandwidthThrottleUp(HCkSFtpW cHandle, int newVal);
```

Specifies the approximate maximum upload rate, in bytes per second. The default is `0`, which disables upload throttling.

Bandwidth throttling is approximate. Actual throughput can vary because of network latency, SSH framing, buffering, and server behavior.

### SFtp.ClientIdentifier

`Chilkat 11.7.0 · wc · SFtp · ClientIdentifier · property · read/write`

```c
void CkSFtpW_getClientIdentifier(HCkSFtpW cHandle, HCkString retval);
void CkSFtpW_putClientIdentifier(HCkSFtpW cHandle, const wchar_t *newVal);
const wchar_t *CkSFtpW_clientIdentifier(HCkSFtpW cHandle);
```

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

The value should begin with `SSH-2.0-`. A server may disconnect if the identification string is invalid.

### SFtp.ClientIpAddress

`Chilkat 11.7.0 · wc · SFtp · ClientIpAddress · property · read/write`

```c
void CkSFtpW_getClientIpAddress(HCkSFtpW cHandle, HCkString retval);
void CkSFtpW_putClientIpAddress(HCkSFtpW cHandle, const wchar_t *newVal);
const wchar_t *CkSFtpW_clientIpAddress(HCkSFtpW cHandle);
```

**This property is normally left unset.** Set it only on a multihomed computer when the application must bind the outgoing connection to a specific local network interface.

Specify a numeric IPv4 or IPv6 address, not a hostname. When the property is empty, the operating system automatically chooses the local address.

### SFtp.ConnectTimeoutMs

`Chilkat 11.7.0 · wc · SFtp · ConnectTimeoutMs · property · read/write`

```c
int CkSFtpW_getConnectTimeoutMs(HCkSFtpW cHandle);
void CkSFtpW_putConnectTimeoutMs(HCkSFtpW cHandle, int newVal);
```

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

This setting covers TCP connection establishment. After the socket is connected, receive and transfer inactivity are governed by `IdleTimeoutMs` and method-specific timeouts.

### SFtp.DisconnectCode

`Chilkat 11.7.0 · wc · SFtp · DisconnectCode · property · read-only`

```c
int CkSFtpW_getDisconnectCode(HCkSFtpW cHandle);
```

Contains the RFC 4253 reason code from the most recent SSH `DISCONNECT` message received from the server. A value of `0` means no server-provided disconnect code is available.

| Code | Symbolic name |
| :--- | :--- |
| `1` | `SSH_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT` |
| `2` | `SSH_DISCONNECT_PROTOCOL_ERROR` |
| `3` | `SSH_DISCONNECT_KEY_EXCHANGE_FAILED` |
| `4` | `SSH_DISCONNECT_RESERVED` |
| `5` | `SSH_DISCONNECT_MAC_ERROR` |
| `6` | `SSH_DISCONNECT_COMPRESSION_ERROR` |
| `7` | `SSH_DISCONNECT_SERVICE_NOT_AVAILABLE` |
| `8` | `SSH_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED` |
| `9` | `SSH_DISCONNECT_HOST_KEY_NOT_VERIFIABLE` |
| `10` | `SSH_DISCONNECT_CONNECTION_LOST` |
| `11` | `SSH_DISCONNECT_BY_APPLICATION` |
| `12` | `SSH_DISCONNECT_TOO_MANY_CONNECTIONS` |
| `13` | `SSH_DISCONNECT_AUTH_CANCELLED_BY_USER` |
| `14` | `SSH_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE` |
| `15` | `SSH_DISCONNECT_ILLEGAL_USER_NAME` |

See `DisconnectReason` for the server-provided descriptive text.

### SFtp.DisconnectReason

`Chilkat 11.7.0 · wc · SFtp · DisconnectReason · property · read-only`

```c
void CkSFtpW_getDisconnectReason(HCkSFtpW cHandle, HCkString retval);
const wchar_t *CkSFtpW_disconnectReason(HCkSFtpW cHandle);
```

Contains the descriptive text sent with the most recent server SSH `DISCONNECT` message. See `DisconnectCode` for the corresponding RFC 4253 reason code.

The text is supplied by the server and can be empty or generic. An ordinary TCP loss or a local disconnect does not necessarily produce an SSH disconnect reason.

### SFtp.EnableCache

`Chilkat 11.7.0 · wc · SFtp · EnableCache · property · read/write`

```c
BOOL CkSFtpW_getEnableCache(HCkSFtpW cHandle);
void CkSFtpW_putEnableCache(HCkSFtpW cHandle, BOOL newVal);
```

Controls whether Chilkat caches remote file sizes and attributes requested by `GetFileSize32`, `GetFileSize64`, `GetFileSizeStr`, `GetFileCreateTimeStr`, `GetFileLastAccessStr`, `GetFileLastModifiedStr`, `GetFileOwner`, `GetFileGroup`, `GetFilePermissions`. The default is `FALSE`.

When enabled, requesting one attribute by filename causes the complete attribute set for that file to be cached. Later attribute requests for the same filename can be satisfied without another server round trip.

Caching applies only when a remote path is used, not when an open handle is used. Call `ClearCache` when remote metadata may have changed.

### SFtp.EnableCompression

`Chilkat 11.7.0 · wc · SFtp · EnableCompression · property · read/write · since 9.5.0.56`

```c
BOOL CkSFtpW_getEnableCompression(HCkSFtpW cHandle);
void CkSFtpW_putEnableCompression(HCkSFtpW cHandle, BOOL newVal);
```

Controls whether SSH compression may be negotiated. The default is `FALSE`.

Some older servers advertise compression but fail when it is enabled. If the server disconnects during or immediately after connection or authentication, try leaving this property `FALSE`.

### SFtp.EnableSecrets

`Chilkat 11.7.0 · wc · SFtp · EnableSecrets · property · read/write · since 11.5.0`

```c
BOOL CkSFtpW_getEnableSecrets(HCkSFtpW cHandle);
void CkSFtpW_putEnableSecrets(HCkSFtpW cHandle, BOOL newVal);
```

**Full documentation for this property (same in every language):** [More Detailed Information About EnableSecrets](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/secret_specification_strings.md)

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

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

Secret specification format:

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

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

### SFtp.FilenameCharset

`Chilkat 11.7.0 · wc · SFtp · FilenameCharset · property · read/write`

```c
void CkSFtpW_getFilenameCharset(HCkSFtpW cHandle, HCkString retval);
void CkSFtpW_putFilenameCharset(HCkSFtpW cHandle, const wchar_t *newVal);
const wchar_t *CkSFtpW_filenameCharset(HCkSFtpW cHandle);
```

Specifies the character encoding used for SFTP filenames. During `InitializeSftp`, Chilkat automatically sets this property when the server supplies a `filename-charset` extension.

When the property is empty, incoming and outgoing filenames use UTF-8. Otherwise, Chilkat uses the specified charset, such as `utf-8`, `iso-8859-1`, or `windows-1252`.

Use an explicit charset only when required by the server. UTF-8 is the normal SFTP filename encoding.

### SFtp.ForceCipher

`Chilkat 11.7.0 · wc · SFtp · ForceCipher · property · read/write`

```c
void CkSFtpW_getForceCipher(HCkSFtpW cHandle, HCkString retval);
void CkSFtpW_putForceCipher(HCkSFtpW cHandle, const wchar_t *newVal);
const wchar_t *CkSFtpW_forceCipher(HCkSFtpW cHandle);
```

Restricts SSH cipher negotiation to a single cipher. Leave this property empty to use Chilkat's normal preference order. For broader algorithm control, use `SetAllowedAlgorithms`.

| Cipher name | Family |
| :--- | :--- |
| `chacha20-poly1305@openssh.com` | ChaCha20-Poly1305 authenticated encryption |
| `aes128-ctr, aes192-ctr, aes256-ctr` | AES in CTR mode |
| `aes128-cbc, aes192-cbc, aes256-cbc` | AES in CBC mode |
| `aes128-gcm@openssh.com, aes256-gcm@openssh.com` | AES-GCM authenticated encryption |
| `twofish128-cbc, twofish256-cbc` | Twofish in CBC mode |
| `blowfish-cbc` | Blowfish in CBC mode |

If the server does not support the selected cipher, `Connect` fails.

### SFtp.ForceV3

`Chilkat 11.7.0 · wc · SFtp · ForceV3 · property · read/write`

```c
BOOL CkSFtpW_getForceV3(HCkSFtpW cHandle);
void CkSFtpW_putForceV3(HCkSFtpW cHandle, BOOL newVal);
```

Controls SFTP protocol-version negotiation. The default is `TRUE`, which forces use of SFTP v3 even when the server supports a newer version.

Set this property to `FALSE` before `InitializeSftp` when the application needs features introduced in SFTP v4, v5, or v6. After initialization, read `ProtocolVersion` to determine the negotiated version.

### SFtp.HeartbeatMs

`Chilkat 11.7.0 · wc · SFtp · HeartbeatMs · property · read/write`

```c
int CkSFtpW_getHeartbeatMs(HCkSFtpW cHandle);
void CkSFtpW_putHeartbeatMs(HCkSFtpW cHandle, int newVal);
```

**Full documentation for this property (same in every language):** [Event Callback Examples](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/event_callback_examples.md)

Specifies the interval, in milliseconds, between `AbortCheck` event callbacks during operations that support progress events. The default is `0`, which disables periodic callbacks.

### SFtp.HostKeyAlg

`Chilkat 11.7.0 · wc · SFtp · HostKeyAlg · property · read/write`

```c
void CkSFtpW_getHostKeyAlg(HCkSFtpW cHandle, HCkString retval);
void CkSFtpW_putHostKeyAlg(HCkSFtpW cHandle, const wchar_t *newVal);
const wchar_t *CkSFtpW_hostKeyAlg(HCkSFtpW cHandle);
```

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

Normally this property should be left unchanged.

### SFtp.HostKeyFingerprint

`Chilkat 11.7.0 · wc · SFtp · HostKeyFingerprint · property · read-only`

```c
void CkSFtpW_getHostKeyFingerprint(HCkSFtpW cHandle, HCkString retval);
const wchar_t *CkSFtpW_hostKeyFingerprint(HCkSFtpW cHandle);
```

Contains the connected server's host-key fingerprint in Chilkat's legacy MD5 format. The value is set after a successful SSH connection.

```
ssh-rsa 2048 68:ff:d1:4e:6c:ff:d7:b0:d6:58:73:85:07:bc:2e:d5
ssh-ed25519 256 c8:73:22:c7:82:aa:09:f1:1c:4e:99:8a:a0:62:a7:87
```

For new applications, use `GetHostKeyFP` with `SHA256`. Compare the fingerprint with a value obtained from a trusted source before sending credentials.

The value is cleared by `Disconnect`. Obtain and validate it while the SSH connection is active.

### SFtp.HttpProxyAuthMethod

`Chilkat 11.7.0 · wc · SFtp · HttpProxyAuthMethod · property · read/write`

```c
void CkSFtpW_getHttpProxyAuthMethod(HCkSFtpW cHandle, HCkString retval);
void CkSFtpW_putHttpProxyAuthMethod(HCkSFtpW cHandle, const wchar_t *newVal);
const wchar_t *CkSFtpW_httpProxyAuthMethod(HCkSFtpW cHandle);
```

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

| Value | Behavior |
| :--- | :--- |
| *empty* | Automatically negotiate a supported method. |
| `Basic` | Use HTTP Basic authentication. |
| `NTLM` | Use NTLM authentication. |

### SFtp.HttpProxyDomain

`Chilkat 11.7.0 · wc · SFtp · HttpProxyDomain · property · read/write`

```c
void CkSFtpW_getHttpProxyDomain(HCkSFtpW cHandle, HCkString retval);
void CkSFtpW_putHttpProxyDomain(HCkSFtpW cHandle, const wchar_t *newVal);
const wchar_t *CkSFtpW_httpProxyDomain(HCkSFtpW cHandle);
```

Specifies the optional Windows domain used for NTLM authentication with an HTTP proxy. This property is ignored for Basic authentication.

### SFtp.HttpProxyHostname

`Chilkat 11.7.0 · wc · SFtp · HttpProxyHostname · property · read/write`

```c
void CkSFtpW_getHttpProxyHostname(HCkSFtpW cHandle, HCkString retval);
void CkSFtpW_putHttpProxyHostname(HCkSFtpW cHandle, const wchar_t *newVal);
const wchar_t *CkSFtpW_httpProxyHostname(HCkSFtpW cHandle);
```

Specifies the hostname or numeric IP address of an HTTP proxy used to establish the SSH connection.

Set this property together with `HttpProxyPort`. A configured SOCKS proxy takes precedence when `SocksVersion` is `4` or `5`.

### SFtp.HttpProxyPassword

`Chilkat 11.7.0 · wc · SFtp · HttpProxyPassword · property · read/write`

```c
void CkSFtpW_getHttpProxyPassword(HCkSFtpW cHandle, HCkString retval);
void CkSFtpW_putHttpProxyPassword(HCkSFtpW cHandle, const wchar_t *newVal);
const wchar_t *CkSFtpW_httpProxyPassword(HCkSFtpW cHandle);
```

Specifies the password used to authenticate with an HTTP proxy.

### SFtp.HttpProxyPort

`Chilkat 11.7.0 · wc · SFtp · HttpProxyPort · property · read/write`

```c
int CkSFtpW_getHttpProxyPort(HCkSFtpW cHandle);
void CkSFtpW_putHttpProxyPort(HCkSFtpW cHandle, int newVal);
```

Specifies the HTTP proxy port. Common values include `8080` and `3128`.

The proxy is used when `HttpProxyHostname` is nonempty, this property is nonzero, and `SocksVersion` is `0`.

### SFtp.HttpProxyUsername

`Chilkat 11.7.0 · wc · SFtp · HttpProxyUsername · property · read/write`

```c
void CkSFtpW_getHttpProxyUsername(HCkSFtpW cHandle, HCkString retval);
void CkSFtpW_putHttpProxyUsername(HCkSFtpW cHandle, const wchar_t *newVal);
const wchar_t *CkSFtpW_httpProxyUsername(HCkSFtpW cHandle);
```

Specifies the username used to authenticate with an HTTP proxy.

### SFtp.IdleTimeoutMs

`Chilkat 11.7.0 · wc · SFtp · IdleTimeoutMs · property · read/write`

```c
int CkSFtpW_getIdleTimeoutMs(HCkSFtpW cHandle);
void CkSFtpW_putIdleTimeoutMs(HCkSFtpW cHandle, int newVal);
```

Specifies the maximum period, in milliseconds, during which an SFTP operation may make no progress while sending or receiving data. The default is `30000` (30 seconds).

Set this property to `0` to allow an operation to wait indefinitely.

### SFtp.IncludeDotDirs

`Chilkat 11.7.0 · wc · SFtp · IncludeDotDirs · property · read/write`

```c
BOOL CkSFtpW_getIncludeDotDirs(HCkSFtpW cHandle);
void CkSFtpW_putIncludeDotDirs(HCkSFtpW cHandle, BOOL newVal);
```

Controls whether `ReadDir` and `ReadDirListing` include the special `.` and `..` directory entries. The default is `FALSE`.

This property controls only the special directory entries `.` and `..`. It does not exclude ordinary hidden filenames such as `.gitignore` or `.profile`.

### SFtp.InitializeFailCode

`Chilkat 11.7.0 · wc · SFtp · InitializeFailCode · property · read-only`

```c
int CkSFtpW_getInitializeFailCode(HCkSFtpW cHandle);
```

Contains the RFC 4254 channel-open failure code when `InitializeSftp` cannot open the SFTP session channel. The initial value is `0`.

| Code | Symbolic name |
| :--- | :--- |
| `1` | `SSH_OPEN_ADMINISTRATIVELY_PROHIBITED` |
| `2` | `SSH_OPEN_CONNECT_FAILED` |
| `3` | `SSH_OPEN_UNKNOWN_CHANNEL_TYPE` |
| `4` | `SSH_OPEN_RESOURCE_SHORTAGE` |

### SFtp.InitializeFailReason

`Chilkat 11.7.0 · wc · SFtp · InitializeFailReason · property · read-only`

```c
void CkSFtpW_getInitializeFailReason(HCkSFtpW cHandle, HCkString retval);
const wchar_t *CkSFtpW_initializeFailReason(HCkSFtpW cHandle);
```

Contains the descriptive text associated with `InitializeFailCode` when `InitializeSftp` cannot open the SFTP session channel. The text is supplied by the server and may be empty or generic.

### SFtp.IsConnected

`Chilkat 11.7.0 · wc · SFtp · IsConnected · property · read-only`

```c
BOOL CkSFtpW_getIsConnected(HCkSFtpW cHandle);
```

Returns `TRUE` when Chilkat's last known state indicates that the underlying SSH transport is connected. This means `Connect` succeeded; it does not mean authentication or `InitializeSftp` has completed.

This property is passive and does not perform network I/O. A silent network failure or a peer close may remain undetected until an operation reads from or writes to the socket.

To actively test whether the connection is still writable, call `SendIgnore` and check its return value. The server does not reply to an SSH `IGNORE` message.

### SFtp.KeepSessionLog

`Chilkat 11.7.0 · wc · SFtp · KeepSessionLog · property · read/write`

```c
BOOL CkSFtpW_getKeepSessionLog(HCkSFtpW cHandle);
void CkSFtpW_putKeepSessionLog(HCkSFtpW cHandle, BOOL newVal);
```

Controls whether SSH and SFTP protocol traffic is accumulated in `SessionLog`. The default is `FALSE`.

Session logging is intended for diagnostics and grows as activity continues. Disable it when no longer needed and treat the resulting log as potentially sensitive.

### SFtp.LastStatusCode

`Chilkat 11.7.0 · wc · SFtp · LastStatusCode · property · read-only · since 9.5.0.85`

```c
int CkSFtpW_getLastStatusCode(HCkSFtpW cHandle);
```

Contains the numeric code from the most recently received SFTP `SSH_FXP_STATUS` response. This is not necessarily the status of the most recently called method. Methods that return a handle, attributes, or data can complete without receiving a new status response, leaving an older value unchanged. A successful method can therefore leave a previous nonzero status code in this property.

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

See `LastStatusMessage` for the server-provided message text.

Use each method's documented return value as the primary success test. Read this property immediately after a relevant SFTP failure when the server status provides additional detail.

### SFtp.LastStatusMessage

`Chilkat 11.7.0 · wc · SFtp · LastStatusMessage · property · read-only · since 9.5.0.85`

```c
void CkSFtpW_getLastStatusMessage(HCkSFtpW cHandle, HCkString retval);
const wchar_t *CkSFtpW_lastStatusMessage(HCkSFtpW cHandle);
```

Contains the message text from the most recently received SFTP `SSH_FXP_STATUS` response. The wording is server-dependent.

This property can remain unchanged across later successful methods that do not receive a new status response. See `LastStatusCode` for the numeric code.

### SFtp.MaxPacketSize

`Chilkat 11.7.0 · wc · SFtp · MaxPacketSize · property · read/write`

```c
int CkSFtpW_getMaxPacketSize(HCkSFtpW cHandle);
void CkSFtpW_putMaxPacketSize(HCkSFtpW cHandle, int newVal);
```

Specifies the maximum packet length used by the underlying SSH transport. The default is `32768` bytes.

Normally this property should remain unchanged.

### SFtp.PasswordChangeRequested

`Chilkat 11.7.0 · wc · SFtp · PasswordChangeRequested · property · read-only`

```c
BOOL CkSFtpW_getPasswordChangeRequested(HCkSFtpW cHandle);
```

Indicates that the server rejected password authentication because the account password must be changed. This property is set by `AuthenticatePw` and `AuthenticatePwPk`.

When `TRUE`, call the authentication method again and pass the old and new passwords in this form:

```
|oldPassword|newPassword|
```

### SFtp.PercentDoneScale

`Chilkat 11.7.0 · wc · SFtp · PercentDoneScale · property · read/write · since 9.5.0.49`

```c
int CkSFtpW_getPercentDoneScale(HCkSFtpW cHandle);
void CkSFtpW_putPercentDoneScale(HCkSFtpW cHandle, int newVal);
```

Specifies the value representing 100% completion in `PercentDone` event callbacks. The default is `100`.

For example, a scale of `1000` provides 0.1% granularity, so a callback value of `453` represents 45.3% complete. Values are clamped to the range `10` through `100000`.

This property applies only in environments that support event callbacks and only to operations for which progress can be measured.

### SFtp.PreferIpv6

`Chilkat 11.7.0 · wc · SFtp · PreferIpv6 · property · read/write`

```c
BOOL CkSFtpW_getPreferIpv6(HCkSFtpW cHandle);
void CkSFtpW_putPreferIpv6(HCkSFtpW cHandle, BOOL newVal);
```

Controls the preferred address family when DNS resolution returns both IPv4 and IPv6 addresses. The default is `FALSE`, which prefers IPv4. Set it to `TRUE` to prefer IPv6.

### SFtp.PreserveDate

`Chilkat 11.7.0 · wc · SFtp · PreserveDate · property · read/write`

```c
BOOL CkSFtpW_getPreserveDate(HCkSFtpW cHandle);
void CkSFtpW_putPreserveDate(HCkSFtpW cHandle, BOOL newVal);
```

Controls whether path-based upload and download methods preserve source timestamps on the destination. The default is `FALSE`.

Last-modified time is preserved when supported by the negotiated SFTP version and destination filesystem. SFTP v3 represents these times with whole-second precision and does not provide a creation-time attribute; creation-time preservation requires a later protocol version and server support.

This property does not apply to low-level transfers performed by opening a remote handle, reading or writing the data, and then closing the handle.

### SFtp.ProtocolVersion

`Chilkat 11.7.0 · wc · SFtp · ProtocolVersion · property · read-only`

```c
int CkSFtpW_getProtocolVersion(HCkSFtpW cHandle);
```

Contains the SFTP protocol version negotiated by `InitializeSftp`, normally a value from `3` through `6`.

Chilkat and the server exchange their highest supported versions, and the session uses the lower compatible version. Features unavailable in older versions are identified throughout this reference documentation.

The initial value is `0`. After a successful initialization, the negotiated value can remain populated after `Disconnect` and during a later connection before SFTP is initialized again. Do not use this property alone to determine whether an SFTP channel is currently open.

### SFtp.ReadDirMustMatch

`Chilkat 11.7.0 · wc · SFtp · ReadDirMustMatch · property · read/write · since 9.5.0.53`

```c
void CkSFtpW_getReadDirMustMatch(HCkSFtpW cHandle, HCkString retval);
void CkSFtpW_putReadDirMustMatch(HCkSFtpW cHandle, const wchar_t *newVal);
const wchar_t *CkSFtpW_readDirMustMatch(HCkSFtpW cHandle);
```

Specifies a semicolon-separated list of filename patterns. When nonempty, `ReadDir` and `ReadDirListing` include only entries matching at least one pattern.

- `*` matches zero or more characters.
- Matching is case-insensitive.
- `?` and bracket expressions such as `[0-9]` are not wildcard operators.
- Surrounding whitespace and empty entries between semicolons are ignored.

```
*.xml; *.txt; *.csv
```

### SFtp.ReadDirMustNotMatch

`Chilkat 11.7.0 · wc · SFtp · ReadDirMustNotMatch · property · read/write · since 9.5.0.53`

```c
void CkSFtpW_getReadDirMustNotMatch(HCkSFtpW cHandle, HCkString retval);
void CkSFtpW_putReadDirMustNotMatch(HCkSFtpW cHandle, const wchar_t *newVal);
const wchar_t *CkSFtpW_readDirMustNotMatch(HCkSFtpW cHandle);
```

Specifies a semicolon-separated list of filename patterns. When nonempty, `ReadDir` and `ReadDirListing` exclude entries matching any pattern. Exclusion is applied after `ReadDirMustMatch`.

- `*` matches zero or more characters.
- Matching is case-insensitive.
- `?` and bracket expressions such as `[0-9]` are not wildcard operators.
- Surrounding whitespace and empty entries between semicolons are ignored.

```
*.tmp; *.bak; *.log
```

### SFtp.ServerIdentifier

`Chilkat 11.7.0 · wc · SFtp · ServerIdentifier · property · read-only · since 9.5.0.71`

```c
void CkSFtpW_getServerIdentifier(HCkSFtpW cHandle, HCkString retval);
const wchar_t *CkSFtpW_serverIdentifier(HCkSFtpW cHandle);
```

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

```
SSH-2.0-OpenSSH_8.9p1 Ubuntu-3ubuntu0.16
```

The last received identifier can remain populated after `Disconnect`. Use `IsConnected` to determine whether the SSH transport is currently connected.

### SFtp.SessionLog

`Chilkat 11.7.0 · wc · SFtp · SessionLog · property · read-only`

```c
void CkSFtpW_getSessionLog(HCkSFtpW cHandle, HCkString retval);
const wchar_t *CkSFtpW_sessionLog(HCkSFtpW cHandle);
```

Contains the in-memory SSH/SFTP protocol log. Enable logging by setting `KeepSessionLog` to `TRUE`.

This property contains log text, not a file path. Call `ClearSessionLog` to clear it.

### SFtp.SocksHostname

`Chilkat 11.7.0 · wc · SFtp · SocksHostname · property · read/write`

```c
void CkSFtpW_getSocksHostname(HCkSFtpW cHandle, HCkString retval);
void CkSFtpW_putSocksHostname(HCkSFtpW cHandle, const wchar_t *newVal);
const wchar_t *CkSFtpW_socksHostname(HCkSFtpW cHandle);
```

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

### SFtp.SocksPassword

`Chilkat 11.7.0 · wc · SFtp · SocksPassword · property · read/write`

```c
void CkSFtpW_getSocksPassword(HCkSFtpW cHandle, HCkString retval);
void CkSFtpW_putSocksPassword(HCkSFtpW cHandle, const wchar_t *newVal);
const wchar_t *CkSFtpW_socksPassword(HCkSFtpW cHandle);
```

Specifies the SOCKS5 password when username/password authentication is required. SOCKS4 does not use a password, so this property is ignored when `SocksVersion` is `4`.

### SFtp.SocksPort

`Chilkat 11.7.0 · wc · SFtp · SocksPort · property · read/write`

```c
int CkSFtpW_getSocksPort(HCkSFtpW cHandle);
void CkSFtpW_putSocksPort(HCkSFtpW cHandle, int newVal);
```

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

### SFtp.SocksUsername

`Chilkat 11.7.0 · wc · SFtp · SocksUsername · property · read/write`

```c
void CkSFtpW_getSocksUsername(HCkSFtpW cHandle, HCkString retval);
void CkSFtpW_putSocksUsername(HCkSFtpW cHandle, const wchar_t *newVal);
const wchar_t *CkSFtpW_socksUsername(HCkSFtpW cHandle);
```

Specifies the SOCKS proxy username. For SOCKS4 it is sent as the user ID; for SOCKS5 it is used with `SocksPassword` for username/password authentication.

### SFtp.SocksVersion

`Chilkat 11.7.0 · wc · SFtp · SocksVersion · property · read/write`

```c
int CkSFtpW_getSocksVersion(HCkSFtpW cHandle);
void CkSFtpW_putSocksVersion(HCkSFtpW cHandle, int newVal);
```

Selects whether and how a SOCKS proxy is used.

| Value | Behavior |
| :--- | :--- |
| `0` | Do not use a SOCKS proxy. This is the default. |
| `4` | Connect through a SOCKS4 proxy. |
| `5` | Connect through a SOCKS5 proxy. |

### SFtp.SoRcvBuf

`Chilkat 11.7.0 · wc · SFtp · SoRcvBuf · property · read/write`

```c
int CkSFtpW_getSoRcvBuf(HCkSFtpW cHandle);
void CkSFtpW_putSoRcvBuf(HCkSFtpW cHandle, int newVal);
```

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

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

See also:

- [More Information about TCP performance and Buffer Sizes](http://www.cknotes.com/?p=446)

### SFtp.SoSndBuf

`Chilkat 11.7.0 · wc · SFtp · SoSndBuf · property · read/write`

```c
int CkSFtpW_getSoSndBuf(HCkSFtpW cHandle);
void CkSFtpW_putSoSndBuf(HCkSFtpW cHandle, int newVal);
```

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

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

See also:

- [More Information about TCP performance and Buffer Sizes](http://www.cknotes.com/?p=446)

### SFtp.SyncCreateAllLocalDirs

`Chilkat 11.7.0 · wc · SFtp · SyncCreateAllLocalDirs · property · read/write · since 9.5.0.76`

```c
BOOL CkSFtpW_getSyncCreateAllLocalDirs(HCkSFtpW cHandle);
void CkSFtpW_putSyncCreateAllLocalDirs(HCkSFtpW cHandle, BOOL newVal);
```

Controls whether `SyncTreeDownload` creates empty remote directories locally. The default is `TRUE`.

When `FALSE`, a local directory is created only when it is needed to contain a downloaded file.

When `TRUE`, an empty remote directory is created locally even when no file beneath it is downloaded.

### SFtp.SyncDirectives

`Chilkat 11.7.0 · wc · SFtp · SyncDirectives · property · read/write · since 9.5.0.58`

```c
void CkSFtpW_getSyncDirectives(HCkSFtpW cHandle, HCkString retval);
void CkSFtpW_putSyncDirectives(HCkSFtpW cHandle, const wchar_t *newVal);
const wchar_t *CkSFtpW_syncDirectives(HCkSFtpW cHandle);
```

Specifies comma-separated directives that modify `SyncTreeUpload` or `SyncTreeDownload`. The default is an empty string.

| Directive | Effect |
| :--- | :--- |
| `UploadIgnoreLocalOpenFailures` | During upload synchronization, skip local files that cannot be opened, such as files held with exclusive access by another process. |

### SFtp.SyncMustMatch

`Chilkat 11.7.0 · wc · SFtp · SyncMustMatch · property · read/write`

```c
void CkSFtpW_getSyncMustMatch(HCkSFtpW cHandle, HCkString retval);
void CkSFtpW_putSyncMustMatch(HCkSFtpW cHandle, const wchar_t *newVal);
const wchar_t *CkSFtpW_syncMustMatch(HCkSFtpW cHandle);
```

Specifies a semicolon-separated list of wildcard filename patterns. `SyncTreeUpload` and `SyncTreeDownload` transfer only files matching at least one pattern.

This filter applies to filenames, not directory names encountered while recursively traversing a tree.

```
*.xml;*.txt;*.csv
```

Use `*` to match zero or more characters. Separate multiple patterns with semicolons.

### SFtp.SyncMustMatchDir

`Chilkat 11.7.0 · wc · SFtp · SyncMustMatchDir · property · read/write · since 9.5.0.76`

```c
void CkSFtpW_getSyncMustMatchDir(HCkSFtpW cHandle, HCkString retval);
void CkSFtpW_putSyncMustMatchDir(HCkSFtpW cHandle, const wchar_t *newVal);
const wchar_t *CkSFtpW_syncMustMatchDir(HCkSFtpW cHandle);
```

Specifies a semicolon-separated list of wildcard directory-name patterns. `SyncTreeUpload` and `SyncTreeDownload` enter only directories matching at least one pattern.

```
xml;txt;data_*
```

Use `*` to match zero or more characters. Separate multiple patterns with semicolons.

### SFtp.SyncMustNotMatch

`Chilkat 11.7.0 · wc · SFtp · SyncMustNotMatch · property · read/write`

```c
void CkSFtpW_getSyncMustNotMatch(HCkSFtpW cHandle, HCkString retval);
void CkSFtpW_putSyncMustNotMatch(HCkSFtpW cHandle, const wchar_t *newVal);
const wchar_t *CkSFtpW_syncMustNotMatch(HCkSFtpW cHandle);
```

Specifies a semicolon-separated list of wildcard filename patterns. `SyncTreeUpload` and `SyncTreeDownload` skip files matching any pattern.

This filter applies to filenames, not directory names encountered while recursively traversing a tree.

```
*.tmp;*.bak;*.log
```

Use `*` to match zero or more characters. Separate multiple patterns with semicolons.

### SFtp.SyncMustNotMatchDir

`Chilkat 11.7.0 · wc · SFtp · SyncMustNotMatchDir · property · read/write · since 9.5.0.76`

```c
void CkSFtpW_getSyncMustNotMatchDir(HCkSFtpW cHandle, HCkString retval);
void CkSFtpW_putSyncMustNotMatchDir(HCkSFtpW cHandle, const wchar_t *newVal);
const wchar_t *CkSFtpW_syncMustNotMatchDir(HCkSFtpW cHandle);
```

Specifies a semicolon-separated list of wildcard directory-name patterns. `SyncTreeUpload` and `SyncTreeDownload` skip directories matching any pattern.

```
temp;cache;archive_*
```

Use `*` to match zero or more characters. Separate multiple patterns with semicolons.

### SFtp.TcpNoDelay

`Chilkat 11.7.0 · wc · SFtp · TcpNoDelay · property · read/write`

```c
BOOL CkSFtpW_getTcpNoDelay(HCkSFtpW cHandle);
void CkSFtpW_putTcpNoDelay(HCkSFtpW cHandle, BOOL newVal);
```

Controls the `TCP_NODELAY` socket option. The default is `FALSE`. Set it to `TRUE` to disable the Nagle algorithm and reduce delays when many small packets are sent.

### SFtp.UncommonOptions

`Chilkat 11.7.0 · wc · SFtp · UncommonOptions · property · read/write · since 9.5.0.73`

```c
void CkSFtpW_getUncommonOptions(HCkSFtpW cHandle, HCkString retval);
void CkSFtpW_putUncommonOptions(HCkSFtpW cHandle, const wchar_t *newVal);
const wchar_t *CkSFtpW_uncommonOptions(HCkSFtpW cHandle);
```

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

| Keyword | Effect |
| :--- | :--- |
| `ForceUserAuthRsaSha1` | Force legacy `ssh-rsa`/SHA-1 signatures for RSA user authentication. Set before connecting. |
| `ProtectFromVpn` | On Android, bypass an installed or active VPN. |
| `NoSyncDownloadEmptyFiles` | Prevent empty files from being downloaded by `SyncTreeDownload`. |
| `no-weak-mac-algs` | Remove weaker SHA-1, MD5, and RIPEMD-160 MAC algorithms from the offered list. |
| `+ssh-hmac-etm` | Re-enable OpenSSH Encrypt-then-MAC algorithms disabled by default as a Terrapin mitigation. |
| `+chacha20-poly1305@openssh.com` | Re-enable `chacha20-poly1305@openssh.com`, disabled by default as a Terrapin mitigation. |

### SFtp.UploadChunkSize

`Chilkat 11.7.0 · wc · SFtp · UploadChunkSize · property · read/write`

```c
int CkSFtpW_getUploadChunkSize(HCkSFtpW cHandle);
void CkSFtpW_putUploadChunkSize(HCkSFtpW cHandle, int newVal);
```

Specifies the chunk size, in bytes, used by `UploadFile` and `UploadFileByName`. The default is `32000`.

If an upload fails because the local operating system aborts the connection, try a smaller value such as `4096`. Smaller chunks can reduce throughput.

### SFtp.UserAuthBanner

`Chilkat 11.7.0 · wc · SFtp · UserAuthBanner · property · read/write · since 9.5.0.88`

```c
void CkSFtpW_getUserAuthBanner(HCkSFtpW cHandle, HCkString retval);
void CkSFtpW_putUserAuthBanner(HCkSFtpW cHandle, const wchar_t *newVal);
const wchar_t *CkSFtpW_userAuthBanner(HCkSFtpW cHandle);
```

Contains a user-authentication banner received from the server. Check this property after `StartKeyboardAuth` or another authentication attempt and display it to the user when appropriate.

When no banner is available, the property returns an empty string.

### SFtp.UtcMode

`Chilkat 11.7.0 · wc · SFtp · UtcMode · property · read/write`

```c
BOOL CkSFtpW_getUtcMode(HCkSFtpW cHandle);
void CkSFtpW_putUtcMode(HCkSFtpW cHandle, BOOL newVal);
```

Controls the time zone used by date/time getters. When `TRUE`, returned values are expressed in UTC. When `FALSE` (the default), returned values are converted to the local time zone.

```
UtcMode = FALSE: Fri, 21 Nov 1997 09:55:06 -0600
UtcMode = TRUE:  Fri, 21 Nov 1997 15:55:06 GMT
```

### SFtp.XferByteCount

`Chilkat 11.7.0 · wc · SFtp · XferByteCount · property · read-only · since 9.5.0.71`

```c
unsigned long CkSFtpW_getXferByteCount(HCkSFtpW cHandle);
```

Contains the current transfer byte count for an upload or download in progress. An application can read this property while an asynchronous transfer is running.

For `SyncTreeUpload` and `SyncTreeDownload`, the value is cumulative across all files processed by the operation. Use `XferByteCount64` when a 64-bit count is required.

### SFtp.XferByteCount64

`Chilkat 11.7.0 · wc · SFtp · XferByteCount64 · property · read-only · since 9.5.0.71`

```c
__int64 CkSFtpW_getXferByteCount64(HCkSFtpW cHandle);
```

Contains the current 64-bit transfer byte count for an upload or download in progress. An application can read this property while an asynchronous transfer is running.

For `SyncTreeUpload` and `SyncTreeDownload`, the value is cumulative across all files processed by the operation.

## Methods

### SFtp.AuthenticatePk

`Chilkat 11.7.0 · wc · SFtp · AuthenticatePk · method`

```c
BOOL CkSFtpW_AuthenticatePk(HCkSFtpW cHandle, const wchar_t *username, HCkSshKeyW privateKey);
```

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

Call `Connect` first. After a failure, inspect `AuthFailReason` and `LastErrorText`.

Returns TRUE for success, FALSE for failure.

Async variant: `AuthenticatePkAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.AuthenticatePw

`Chilkat 11.7.0 · wc · SFtp · AuthenticatePw · method`

```c
BOOL CkSFtpW_AuthenticatePw(HCkSFtpW cHandle, const wchar_t *login, const wchar_t *password);
```

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

```
1. Connect
2. AuthenticatePw or AuthenticatePk
3. InitializeSftp
```

If the server requests a password change, see `PasswordChangeRequested`. After a failure, inspect `AuthFailReason` and `LastErrorText`.

A rejected password does not necessarily close the SSH connection. The application may retry authentication on the same connected session. After a later success, an older `AuthFailReason` value can remain populated.

Returns TRUE for success, FALSE for failure.

Async variant: `AuthenticatePwAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.AuthenticatePwPk

`Chilkat 11.7.0 · wc · SFtp · AuthenticatePwPk · method`

```c
BOOL CkSFtpW_AuthenticatePwPk(HCkSFtpW cHandle, const wchar_t *username, const wchar_t *password, HCkSshKeyW privateKey);
```

Authenticates with a server that requires both a password and a private key. `username` identifies the account, `password` supplies the password, and `privateKey` supplies the private key.

Most servers require either password or public-key authentication rather than both. After a failure, inspect `AuthFailReason` and `LastErrorText`.

Returns TRUE for success, FALSE for failure.

Async variant: `AuthenticatePwPkAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.AuthenticateSecPw

`Chilkat 11.7.0 · wc · SFtp · AuthenticateSecPw · method · since 9.5.0.71`

```c
BOOL CkSFtpW_AuthenticateSecPw(HCkSFtpW cHandle, HCkSecureStringW login, HCkSecureStringW password);
```

Works like `AuthenticatePw`, but receives `login` and `password` in `SecureString` objects.

Returns TRUE for success, FALSE for failure.

Async variant: `AuthenticateSecPwAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.AuthenticateSecPwPk

`Chilkat 11.7.0 · wc · SFtp · AuthenticateSecPwPk · method · since 9.5.0.71`

```c
BOOL CkSFtpW_AuthenticateSecPwPk(HCkSFtpW cHandle, HCkSecureStringW username, HCkSecureStringW password, HCkSshKeyW privateKey);
```

Works like `AuthenticatePwPk`, but receives `username` and `password` in `SecureString` objects. `privateKey` supplies the private key.

Returns TRUE for success, FALSE for failure.

Async variant: `AuthenticateSecPwPkAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.ClearCache

`Chilkat 11.7.0 · wc · SFtp · ClearCache · method`

```c
void CkSFtpW_ClearCache(HCkSFtpW cHandle);
```

Clears the internal remote file-attribute cache used when `EnableCache` is `TRUE`.

### SFtp.ClearSessionLog

`Chilkat 11.7.0 · wc · SFtp · ClearSessionLog · method`

```c
void CkSFtpW_ClearSessionLog(HCkSFtpW cHandle);
```

Clears the in-memory text stored in `SessionLog`.

### SFtp.CloseHandle

`Chilkat 11.7.0 · wc · SFtp · CloseHandle · method`

```c
BOOL CkSFtpW_CloseHandle(HCkSFtpW cHandle, const wchar_t *handle);
```

Closes the remote file or directory handle specified by `handle`. The handle must have been returned by `OpenFile` or `OpenDir`.

Handles are specific to one initialized SFTP session. Close each handle exactly once. Closing an empty, invalid, or already-closed handle returns `FALSE`. A handle must never be reused after disconnecting or replacing the connection.

Returns TRUE for success, FALSE for failure.

Async variant: `CloseHandleAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.Connect

`Chilkat 11.7.0 · wc · SFtp · Connect · method`

```c
BOOL CkSFtpW_Connect(HCkSFtpW cHandle, const wchar_t *domainName, int port);
```

Establishes an SSH connection to `domainName` on TCP port `port`. The host may be a DNS name or numeric IPv4 or IPv6 address; SSH servers commonly listen on port `22`.

A successful connection establishes the SSH transport only. Next call an authentication method, then call `InitializeSftp`.

```
1. Connect
2. AuthenticatePw, AuthenticatePk, or another authentication method
3. InitializeSftp
4. Perform SFTP operations
```

**Supported negotiation algorithms include:**

| Category | Algorithms |
| :--- | :--- |
| Host key | `ssh-ed25519`, `rsa-sha2-256`, `rsa-sha2-512`, `ecdsa-sha2-nistp256`, `ecdsa-sha2-nistp384`, `ecdsa-sha2-nistp521`, `ssh-rsa`, `ssh-dss` |
| Key exchange | `curve25519-sha256`, `curve25519-sha256@libssh.org`, NIST ECDH, Diffie-Hellman group 1/14/16/18, and group-exchange SHA-1/SHA-256 |
| Ciphers | AES CTR/CBC/GCM, Twofish CBC, Blowfish CBC, and optionally `chacha20-poly1305@openssh.com` |
| MAC | SHA-2, SHA-1, RIPEMD-160, MD5, and optionally OpenSSH Encrypt-then-MAC variants |
| Compression | `none`, `zlib`, and `zlib@openssh.com` |

Connection failures can occur before SSH negotiation because of firewalls, endpoint security, routing, network ACLs, proxy configuration, or server policy.

**Calling while connected:** A new successful `Connect` replaces the existing SSH connection. The previous SFTP subsystem and all handles from it are no longer usable. Authenticate and call `InitializeSftp` for the new connection.

Returns TRUE for success, FALSE for failure.

Async variant: `ConnectAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.ConnectThroughSsh

`Chilkat 11.7.0 · wc · SFtp · ConnectThroughSsh · method · since 9.5.0.55`

```c
BOOL CkSFtpW_ConnectThroughSsh(HCkSFtpW cHandle, HCkSshW sshConn, const wchar_t *hostname, int port);
```

Connects to `hostname` on `port` through the already connected and authenticated `Ssh` object in `sshConn`.

```
application  →  first SSH server  →  destination SSH/SFTP server
```

After this method succeeds, authenticate separately with the destination server and call `InitializeSftp`. All destination traffic is carried through the first SSH connection.

Returns TRUE for success, FALSE for failure.

Async variant: `ConnectThroughSshAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.ContinueKeyboardAuth

`Chilkat 11.7.0 · wc · SFtp · ContinueKeyboardAuth · method · since 9.5.0.88`

```c
BOOL CkSFtpW_ContinueKeyboardAuth(HCkSFtpW cHandle, const wchar_t *response, const wchar_t *outStr);
const wchar_t *CkSFtpW_continueKeyboardAuth(HCkSFtpW cHandle, const wchar_t *response);
```

Continues keyboard-interactive authentication by submitting `response` for the prompts returned by `StartKeyboardAuth`.

For a single prompt, pass the response text directly. For multiple prompts, pass XML in this form:

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

The returned XML indicates authentication success, authentication failure, or another `infoRequest` containing additional prompts.

```
<success>success message</success>

<error>error message</error>
```

Returns TRUE for success, FALSE for failure.

Async variant: `ContinueKeyboardAuthAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.CopyFileAttr

`Chilkat 11.7.0 · wc · SFtp · CopyFileAttr · method`

```c
BOOL CkSFtpW_CopyFileAttr(HCkSFtpW cHandle, const wchar_t *localFilename, const wchar_t *remoteFilename, BOOL isHandle);
```

Copies supported timestamps and attributes from the local file at `localFilename` to the remote item identified by `remoteFilename`.

Set `isHandle` to `TRUE` when `remoteFilename` contains an open SFTP handle; otherwise set it to `FALSE` for a remote path.

| Negotiated SFTP version | Attributes copied |
| :--- | :--- |
| SFTP v3 and earlier | Last-modified time and last-access time |
| SFTP v4 and v5 | Last-modified time, last-access time, and creation time |
| SFTP v6 and later | The preceding timestamps plus read-only, hidden, archive, compressed, and encrypted flags |

The remote server and filesystem determine whether all requested attributes can be applied. Last-access time may change when the server accesses the file, and compressed or encrypted flags may not have the same effect on every server.

Returns TRUE for success, FALSE for failure.

Async variant: `CopyFileAttrAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.CreateDir

`Chilkat 11.7.0 · wc · SFtp · CreateDir · method`

```c
BOOL CkSFtpW_CreateDir(HCkSFtpW cHandle, const wchar_t *path);
```

Creates the remote directory specified by `path`. Parent directories are not necessarily created automatically.

Returns TRUE for success, FALSE for failure.

Async variant: `CreateDirAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.Disconnect

`Chilkat 11.7.0 · wc · SFtp · Disconnect · method`

```c
void CkSFtpW_Disconnect(HCkSFtpW cHandle);
```

Closes the current SSH/SFTP connection. All remote file and directory handles from that session become invalid and must not be reused.

The object remains reusable. A later session must call `Connect`, authenticate again, and call `InitializeSftp` before performing SFTP operations.

Some properties retain values from the previous session after disconnect, including the negotiated protocol version, server identifier, and last SFTP status. Treat these as historical values rather than evidence of a live session.

### SFtp.DownloadBd

`Chilkat 11.7.0 · wc · SFtp · DownloadBd · method · since 9.5.0.62`

```c
BOOL CkSFtpW_DownloadBd(HCkSFtpW cHandle, const wchar_t *remoteFilePath, HCkBinDataW binData);
```

Downloads the remote file at `remoteFilePath` and appends its bytes to `binData`.

Existing data in `binData` is preserved. Clear it first when replacement rather than append behavior is required.

Returns TRUE for success, FALSE for failure.

Async variant: `DownloadBdAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.DownloadFile

`Chilkat 11.7.0 · wc · SFtp · DownloadFile · method`

```c
BOOL CkSFtpW_DownloadFile(HCkSFtpW cHandle, const wchar_t *handle, const wchar_t *toFilename);
```

Streams the remote file identified by `handle` to the local filesystem path `toFilename`. The handle must have been returned by `OpenFile`.

The transfer is streamed and is not limited by available memory. Close the remote handle when the download is complete.

This method downloads the entire remote file beginning at byte offset `0`. It does not begin at the handle's current sequential read position.

Returns TRUE for success, FALSE for failure.

Async variant: `DownloadFileAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.DownloadFileByName

`Chilkat 11.7.0 · wc · SFtp · DownloadFileByName · method`

```c
BOOL CkSFtpW_DownloadFileByName(HCkSFtpW cHandle, const wchar_t *remoteFilePath, const wchar_t *localFilePath);
```

Downloads the remote file at `remoteFilePath` to the local filesystem path `localFilePath`.

When `PreserveDate` is `TRUE`, Chilkat preserves the remote file's last-modified time.

An absolute remote path begins with `/` and is relative to the server filesystem root. A relative path is interpreted relative to the authenticated user's home directory.

If the local destination file exists, it is truncated before the download.

Returns TRUE for success, FALSE for failure.

Async variant: `DownloadFileByNameAsync` — same arguments, returns a `Task` (see Async variants below).

See also:

- [Understanding SFTP Absolute FilePaths](http://www.cknotes.com/?p=135)

### SFtp.DownloadSb

`Chilkat 11.7.0 · wc · SFtp · DownloadSb · method · since 9.5.0.62`

```c
BOOL CkSFtpW_DownloadSb(HCkSFtpW cHandle, const wchar_t *remoteFilePath, const wchar_t *charset, HCkStringBuilderW sb);
```

Downloads the remote file at `remoteFilePath`, decodes it using `charset`, and appends the text to `sb`.

Existing text in `sb` is preserved. Clear it first when replacement rather than append behavior is required.

Returns TRUE for success, FALSE for failure.

Async variant: `DownloadSbAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.Eof

`Chilkat 11.7.0 · wc · SFtp · Eof · method`

```c
BOOL CkSFtpW_Eof(HCkSFtpW cHandle, const wchar_t *handle);
```

Returns `TRUE` when the most recent read for `handle` received the SFTP end-of-file status.

Reading exactly through the final byte does not set EOF immediately. The next read returns successfully with zero bytes, sets `LastStatusCode` to `SSH_FX_EOF`, and causes this method to return `TRUE`.

An empty, malformed, or already-closed handle can also cause this method to return `TRUE`. Use `LastReadFailed` and the read method's result to distinguish a normal EOF from a handle or read failure.

### SFtp.FileExists

`Chilkat 11.7.0 · wc · SFtp · FileExists · method · since 9.5.0.67`

```c
int CkSFtpW_FileExists(HCkSFtpW cHandle, const wchar_t *remotePath, BOOL followLinks);
```

Checks the remote item at `remotePath`. When `followLinks` is `TRUE`, a symbolic link is followed and the target type is returned.

| Return value | Meaning |
| :--- | :--- |
| `-1` | Unable to determine the result. Inspect `LastErrorText`. |
| `0` | The path does not exist. |
| `1` | A regular file exists. |
| `2` | A directory exists. |
| `3` | A symbolic link exists. This is possible only when `followLinks` is `FALSE`. |
| `4` | A special filesystem entry exists. |
| `5` | An entry of unknown type exists. |
| `6` | A socket exists. |
| `7` | A character device exists. |
| `8` | A block device exists. |
| `9` | A FIFO exists. |

Positive values correspond to SFTP filesystem entry types. Some types are platform-dependent.

For a dangling symbolic link, `followLinks = FALSE` returns `3` for the link itself, while `followLinks = TRUE` returns `0` because the target does not exist.

Async variant: `FileExistsAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.Fsync

`Chilkat 11.7.0 · wc · SFtp · Fsync · method · since 9.5.0.71`

```c
BOOL CkSFtpW_Fsync(HCkSFtpW cHandle, const wchar_t *handle);
```

Requests that the server flush pending data for the open file identified by `handle` to stable storage.

This method uses the OpenSSH `fsync@openssh.com` extension and succeeds only when the server supports that extension.

Returns TRUE for success, FALSE for failure.

Async variant: `FsyncAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.GetFileCreateTimeStr

`Chilkat 11.7.0 · wc · SFtp · GetFileCreateTimeStr · method`

```c
BOOL CkSFtpW_GetFileCreateTimeStr(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle, const wchar_t *outStr);
const wchar_t *CkSFtpW_getFileCreateTimeStr(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);
```

Returns the remote file's creation date and time. `pathOrHandle` may contain a remote path or a handle returned by `OpenFile`. Set `bIsHandle` to `TRUE` for a handle and `FALSE` for a path.

When `bFollowLinks` is `TRUE`, the server follows a symbolic link and returns metadata for its target.

SFTP v3 and earlier do not provide a file creation time.

The result is an RFC 822 formatted string, for example `Fri, 21 Nov 1997 09:55:06 -0600`.

Returns TRUE for success, FALSE for failure.

Async variant: `GetFileCreateTimeStrAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.GetFileGroup

`Chilkat 11.7.0 · wc · SFtp · GetFileGroup · method`

```c
BOOL CkSFtpW_GetFileGroup(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle, const wchar_t *outStr);
const wchar_t *CkSFtpW_getFileGroup(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);
```

Returns the remote file's group ownership. `pathOrHandle` may contain a remote path or a handle returned by `OpenFile`. Set `bIsHandle` to `TRUE` for a handle and `FALSE` for a path.

When `bFollowLinks` is `TRUE`, the server follows a symbolic link and returns metadata for its target.

With SFTP v3 and earlier, the result is the decimal numeric GID because textual group names are not supported.

Returns TRUE for success, FALSE for failure.

Async variant: `GetFileGroupAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.GetFileLastAccessStr

`Chilkat 11.7.0 · wc · SFtp · GetFileLastAccessStr · method`

```c
BOOL CkSFtpW_GetFileLastAccessStr(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle, const wchar_t *outStr);
const wchar_t *CkSFtpW_getFileLastAccessStr(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);
```

Returns the remote file's last-access date and time. `pathOrHandle` may contain a remote path or a handle returned by `OpenFile`. Set `bIsHandle` to `TRUE` for a handle and `FALSE` for a path.

When `bFollowLinks` is `TRUE`, the server follows a symbolic link and returns metadata for its target.

The result is an RFC 822 formatted string, for example `Fri, 21 Nov 1997 09:55:06 -0600`.

Returns TRUE for success, FALSE for failure.

Async variant: `GetFileLastAccessStrAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.GetFileLastModifiedStr

`Chilkat 11.7.0 · wc · SFtp · GetFileLastModifiedStr · method`

```c
BOOL CkSFtpW_GetFileLastModifiedStr(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle, const wchar_t *outStr);
const wchar_t *CkSFtpW_getFileLastModifiedStr(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);
```

Returns the remote file's last-modified date and time. `pathOrHandle` may contain a remote path or a handle returned by `OpenFile`. Set `bIsHandle` to `TRUE` for a handle and `FALSE` for a path.

When `bFollowLinks` is `TRUE`, the server follows a symbolic link and returns metadata for its target.

The result is an RFC 822 formatted string, for example `Fri, 21 Nov 1997 09:55:06 -0600`.

Returns TRUE for success, FALSE for failure.

Async variant: `GetFileLastModifiedStrAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.GetFileOwner

`Chilkat 11.7.0 · wc · SFtp · GetFileOwner · method`

```c
BOOL CkSFtpW_GetFileOwner(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle, const wchar_t *outStr);
const wchar_t *CkSFtpW_getFileOwner(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);
```

Returns the remote file's owner. `pathOrHandle` may contain a remote path or a handle returned by `OpenFile`. Set `bIsHandle` to `TRUE` for a handle and `FALSE` for a path.

When `bFollowLinks` is `TRUE`, the server follows a symbolic link and returns metadata for its target.

With SFTP v3 and earlier, the result is the decimal numeric UID because textual owner names are not supported.

Returns TRUE for success, FALSE for failure.

Async variant: `GetFileOwnerAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.GetFilePermissions

`Chilkat 11.7.0 · wc · SFtp · GetFilePermissions · method`

```c
int CkSFtpW_GetFilePermissions(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);
```

Returns the remote item's complete POSIX mode value. `pathOrHandle` may contain a remote path or a handle returned by `OpenFile`. Set `bIsHandle` to `TRUE` for a handle and `FALSE` for a path. When `bFollowLinks` is `TRUE`, the server follows a symbolic link and returns metadata for its target.

The returned integer includes both the file-type bits and permission bits. For example:

```
Regular file, mode 0664: octal 0100664, decimal 33204
Regular file, mode 0600: octal 0100600, decimal 33152
Regular file, mode 0644: octal 0100644, decimal 33188
```

Mask with octal `07777` to obtain permission and special bits, or `0777` for only the traditional owner/group/other read, write, and execute bits. See `SetPermissions` to change the permissions.

Async variant: `GetFilePermissionsAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.GetFileSize32

`Chilkat 11.7.0 · wc · SFtp · GetFileSize32 · method`

```c
int CkSFtpW_GetFileSize32(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);
```

Returns the remote file's size in bytes as a 32-bit integer. `pathOrHandle` may contain a remote path or a handle returned by `OpenFile`. Set `bIsHandle` to `TRUE` for a handle and `FALSE` for a path.

When `bFollowLinks` is `TRUE`, the server follows a symbolic link and returns metadata for its target.

Returns `-1` when the size cannot be represented as a 32-bit integer. Use `GetFileSize64` or `GetFileSizeStr` for large files.

Async variant: `GetFileSize32Async` — same arguments, returns a `Task` (see Async variants below).

### SFtp.GetFileSize64

`Chilkat 11.7.0 · wc · SFtp · GetFileSize64 · method`

```c
__int64 CkSFtpW_GetFileSize64(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);
```

Returns the remote file's size in bytes as a 64-bit integer. `pathOrHandle` may contain a remote path or a handle returned by `OpenFile`. Set `bIsHandle` to `TRUE` for a handle and `FALSE` for a path.

When `bFollowLinks` is `TRUE`, the server follows a symbolic link and returns metadata for its target.

Async variant: `GetFileSize64Async` — same arguments, returns a `Task` (see Async variants below).

### SFtp.GetFileSizeStr

`Chilkat 11.7.0 · wc · SFtp · GetFileSizeStr · method`

```c
BOOL CkSFtpW_GetFileSizeStr(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle, const wchar_t *outStr);
const wchar_t *CkSFtpW_getFileSizeStr(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);
```

Returns the remote file's size in bytes as a decimal string. `pathOrHandle` may contain a remote path or a handle returned by `OpenFile`. Set `bIsHandle` to `TRUE` for a handle and `FALSE` for a path.

When `bFollowLinks` is `TRUE`, the server follows a symbolic link and returns metadata for its target.

Returns TRUE for success, FALSE for failure.

Async variant: `GetFileSizeStrAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.GetHostKeyFP

`Chilkat 11.7.0 · wc · SFtp · GetHostKeyFP · method · since 9.5.0.92`

```c
BOOL CkSFtpW_GetHostKeyFP(HCkSFtpW cHandle, const wchar_t *hashAlg, BOOL includeKeyType, BOOL includeHashName, const wchar_t *outStr);
const wchar_t *CkSFtpW_getHostKeyFP(HCkSFtpW cHandle, const wchar_t *hashAlg, BOOL includeKeyType, BOOL includeHashName);
```

Returns the connected server's host-key fingerprint using `hashAlg`. Common choices include `SHA256`, `SHA384`, `SHA512`, `SHA1`, and `MD5`.

| includeKeyType | includeHashName | Example format |
| :--- | :--- | :--- |
| `TRUE` | `TRUE` | `ssh-rsa SHA256:L7sQgnpnoBwRoyIYXAFBs8SdSnwtyYmhXs1p/mQDK...` |
| `TRUE` | `FALSE` | `ssh-rsa L7sQgnpnoBwRoyIYXAFBs8SdSnwtyYmhXs1p/mQDK...` |
| `FALSE` | `TRUE` | `SHA256:L7sQgnpnoBwRoyIYXAFBs8SdSnwtyYmhXs1p/mQDK...` |
| `FALSE` | `FALSE` | `L7sQgnpnoBwRoyIYXAFBs8SdSnwtyYmhXs1p/mQDK...` |

For server identity verification, compare a SHA-256 fingerprint with a value obtained from a trusted source before sending credentials.

Returns TRUE for success, FALSE for failure.

### SFtp.GetLastJsonData

`Chilkat 11.7.0 · wc · SFtp · GetLastJsonData · method · since 11.0.0`

```c
void CkSFtpW_GetLastJsonData(HCkSFtpW cHandle, HCkJsonObjectW json);
```

Populates `json` with supplemental details produced by the most recent method when such details are available. Many methods do not produce additional JSON information.

### SFtp.GetSyncedFiles

`Chilkat 11.7.0 · wc · SFtp · GetSyncedFiles · method · since 10.0.0`

```c
void CkSFtpW_GetSyncedFiles(HCkSFtpW cHandle, HCkStringTableW strTab);
```

Appends to `strTab` the relative paths processed by the most recent `SyncTreeUpload` or `SyncTreeDownload` operation.

For downloads, entries can include local directories that were created. Directory paths end with `/` so they can be distinguished from file paths.

Existing entries in `strTab` are preserved.

Clear `strTab` first when only the latest synchronization results are wanted. Downloaded directory entries are reported with a trailing `/`; uploaded directory entries are reported without one.

### SFtp.HardLink

`Chilkat 11.7.0 · wc · SFtp · HardLink · method · since 9.5.0.71`

```c
BOOL CkSFtpW_HardLink(HCkSFtpW cHandle, const wchar_t *oldPath, const wchar_t *newPath);
```

Creates a hard link from `newPath` to the existing remote file at `oldPath`.

This method uses the OpenSSH `hardlink@openssh.com` extension and succeeds only when the server supports that extension.

A successful hard link refers to the same underlying file. Modifying the existing file through either path changes the content observed through the other path.

Returns TRUE for success, FALSE for failure.

Async variant: `HardLinkAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.InitializeSftp

`Chilkat 11.7.0 · wc · SFtp · InitializeSftp · method`

```c
BOOL CkSFtpW_InitializeSftp(HCkSFtpW cHandle);
```

Opens the SFTP subsystem and negotiates the SFTP protocol version. Call this method after connecting and authenticating.

```
1. Connect
2. AuthenticatePw, AuthenticatePk, or another authentication method
3. InitializeSftp
```

After success, read `ProtocolVersion` to determine the negotiated SFTP version.

If opening the SFTP channel fails, inspect `InitializeFailCode`, `InitializeFailReason`, and `LastErrorText`.

Call this method only once for a given SSH connection. A second call on the same connection returns `FALSE`. After disconnecting or replacing the connection, authenticate the new connection and call this method again.

Returns TRUE for success, FALSE for failure.

Async variant: `InitializeSftpAsync` — same arguments, returns a `Task` (see Async variants below).

See also:

- [Error Explained: Received FAILURE response to subsystem request.](http://www.cknotes.com/?p=250)

### SFtp.LastReadFailed

`Chilkat 11.7.0 · wc · SFtp · LastReadFailed · method`

```c
BOOL CkSFtpW_LastReadFailed(HCkSFtpW cHandle, const wchar_t *handle);
```

Returns `TRUE` if the most recent read associated with `handle` failed; otherwise returns `FALSE`.

A normal end-of-file is not a read failure: the EOF read succeeds, returns zero bytes, and this method returns `FALSE`. For an empty, malformed, or already-closed handle, this method returns `TRUE`.

### SFtp.LastReadNumBytes

`Chilkat 11.7.0 · wc · SFtp · LastReadNumBytes · method`

```c
int CkSFtpW_LastReadNumBytes(HCkSFtpW cHandle, const wchar_t *handle);
```

Returns the number of bytes received by the most recent read associated with `handle`.

The initial value for a newly opened handle is `0`. A normal EOF read and a failed read report `0`.

### SFtp.LoadTaskCaller

`Chilkat 11.7.0 · wc · SFtp · LoadTaskCaller · method · since 9.5.0.80`

```c
BOOL CkSFtpW_LoadTaskCaller(HCkSFtpW cHandle, HCkTaskW task);
```

Loads this object from the caller state associated with the completed asynchronous `task`.

Use the same object type that originally started the asynchronous operation.

Returns TRUE for success, FALSE for failure.

### SFtp.OpenDir

`Chilkat 11.7.0 · wc · SFtp · OpenDir · method`

```c
BOOL CkSFtpW_OpenDir(HCkSFtpW cHandle, const wchar_t *path, const wchar_t *outStr);
const wchar_t *CkSFtpW_openDir(HCkSFtpW cHandle, const wchar_t *path);
```

Opens the remote directory specified by `path` and returns a handle for reading its entries.

```
handle = OpenDir(path)
ReadDirListing(handle, dirObj)
CloseHandle(handle)
```

Remote paths use `/` as the separator. A path beginning with `/` is absolute; a relative path is interpreted relative to the authenticated user's home directory. An empty path refers to that default directory.

This method does not change a working directory. SFTP is not FTP and has no persistent current-directory command.

Returns TRUE for success, FALSE for failure.

Async variant: `OpenDirAsync` — same arguments, returns a `Task` (see Async variants below).

See also:

- [Understanding SFTP Absolute FilePaths](http://www.cknotes.com/?p=135)

### SFtp.OpenFile

`Chilkat 11.7.0 · wc · SFtp · OpenFile · method`

```c
BOOL CkSFtpW_OpenFile(HCkSFtpW cHandle, const wchar_t *remotePath, const wchar_t *access, const wchar_t *createDisposition, const wchar_t *outStr);
const wchar_t *CkSFtpW_openFile(HCkSFtpW cHandle, const wchar_t *remotePath, const wchar_t *access, const wchar_t *createDisposition);
```

Opens or creates the remote file at `remotePath` and returns a handle for subsequent read or write operations. Close the handle with `CloseHandle` when finished.

`access` must be `readOnly`, `writeOnly`, or `readWrite`.

`createDisposition` is a comma-separated list. It must contain exactly one primary disposition:

| Primary disposition | Behavior |
| :--- | :--- |
| `createNew` | Create a new file; fail if it already exists. |
| `createTruncate` | Create a new file, or open and truncate an existing file. |
| `openExisting` | Open an existing file; fail if it does not exist. |
| `openOrCreate` | Open the file if it exists, otherwise create it. |
| `truncateExisting` | Open and truncate an existing file; fail if it does not exist. |

Additional optional keywords are:

| Option | Behavior |
| :--- | :--- |
| `appendData` | Write at the end of the file. Appends are not guaranteed to be atomic. |
| `appendDataAtomic` | Append atomically so concurrent appenders do not collide. SFTP v5 or later. |
| `textMode` | Request server text-mode processing and canonical newline conversion. SFTP v5 or later. |
| `blockRead` | Request exclusive read access. SFTP v5 or later. |
| `blockWrite` | Request exclusive write access. SFTP v5 or later. |
| `blockDelete` | Prevent deletion while the handle is open. SFTP v5 or later. |
| `blockAdvisory` | Make the requested block modes advisory. SFTP v5 or later. |
| `noFollow` | Fail if the final path component is a symbolic link. SFTP v5 or later. |
| `deleteOnClose` | Request deletion when the last handle is closed. SFTP v5 or later. |
| `accessAuditAlarmInfo` | Request privileges needed to read or write AUDIT or ALARM ACL entries. SFTP v5 or later. |
| `accessBackup` | Request backup/restore privileges that may bypass normal access checks. SFTP v5 or later. |
| `backupStream` | Read or write a server-specific backup stream. SFTP v5 or later. |

Options marked SFTP v5 or later require `ForceV3` to be `FALSE` and a negotiated `ProtocolVersion` of at least `5`.

An absolute remote path begins with `/`. A relative path is interpreted from the authenticated user's home directory. Some servers require a filename in the home directory to be written as `./filename`.

**Use only documented values:** Some servers or Chilkat versions may tolerate an unknown access value, an unknown option, or conflicting primary dispositions, but the resulting behavior is unspecified. Supply one documented access value and exactly one primary disposition.

`appendData` forces writes to the end of the file, including explicit-offset writes. By itself it opens an existing file but does not create a missing file; combine it with an appropriate primary disposition when creation is required. Options defined for SFTP v5 or later must not be assumed to take effect when an older version is negotiated, even if the open request succeeds.

Returns TRUE for success, FALSE for failure.

Async variant: `OpenFileAsync` — same arguments, returns a `Task` (see Async variants below).

See also:

- [Understanding SFTP Absolute FilePaths](http://www.cknotes.com/?p=135)
- [SFTP Server Responds with SSH_FX_NO_SUCH_FILE](https://cknotes.com/sftp-server-responds-with-ssh_fx_no_such_file-when-trying-to-openfile/)

### SFtp.ReadDirListing

`Chilkat 11.7.0 · wc · SFtp · ReadDirListing · method · since 11.0.0`

```c
BOOL CkSFtpW_ReadDirListing(HCkSFtpW cHandle, const wchar_t *handle, HCkSFtpDirW dirObj);
```

Reads all remaining directory entries from `handle`, which must have been returned by `OpenDir`, and stores them in `dirObj`. Entries are returned in server order; Chilkat does not sort the listing.

After end-of-directory has been reached, another call on the same handle returns `TRUE`, adds no entries, and sets `LastStatusCode` to `SSH_FX_EOF`.

This method does not clear `dirObj`. Use a new or cleared `SFtpDir` object when an empty result must replace an earlier listing. Close the directory handle when finished.

Returns TRUE for success, FALSE for failure.

Async variant: `ReadDirListingAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.ReadFileBd

`Chilkat 11.7.0 · wc · SFtp · ReadFileBd · method · since 9.5.0.77`

```c
BOOL CkSFtpW_ReadFileBd(HCkSFtpW cHandle, const wchar_t *handle, int numBytes, HCkBinDataW bd);
```

Reads up to `numBytes` bytes from the current position of the remote file identified by `handle` and appends them to `bd`. The handle must have been returned by `OpenFile`.

Fewer bytes can be read when end-of-file is reached. Repeat the call until `Eof(handle)` returns `TRUE` to read the entire file incrementally.

This method shares the handle's sequential read position with `ReadFileBytes` and `ReadFileText`. Existing bytes in `bd` are preserved.

Returns TRUE for success, FALSE for failure.

Async variant: `ReadFileBdAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.ReadFileText

`Chilkat 11.7.0 · wc · SFtp · ReadFileText · method`

```c
BOOL CkSFtpW_ReadFileText(HCkSFtpW cHandle, const wchar_t *handle, int numBytes, const wchar_t *charset, const wchar_t *outStr);
const wchar_t *CkSFtpW_readFileText(HCkSFtpW cHandle, const wchar_t *handle, int numBytes, const wchar_t *charset);
```

Reads up to `numBytes` bytes from the current position of `handle`, decodes the bytes using `charset`, and returns the resulting text.

See [Supported Charsets](https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp).

The requested size is measured in bytes, not characters. With a multibyte encoding such as UTF-8 or Shift_JIS, the final character can be split across calls. For robust streaming, read raw bytes and decode with application-maintained state.

**Multibyte boundaries:** Chilkat does not retain an incomplete multibyte character between calls. If `numBytes` ends in the middle of a UTF-8 sequence, the first returned string ends with the incomplete bytes and the next call begins with the remaining bytes. Choose byte counts that end on character boundaries, or read bytes and perform streaming decoding in the application.

Returns TRUE for success, FALSE for failure.

Async variant: `ReadFileTextAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.ReadFileText32

`Chilkat 11.7.0 · wc · SFtp · ReadFileText32 · method`

```c
BOOL CkSFtpW_ReadFileText32(HCkSFtpW cHandle, const wchar_t *handle, int offset, int numBytes, const wchar_t *charset, const wchar_t *outStr);
const wchar_t *CkSFtpW_readFileText32(HCkSFtpW cHandle, const wchar_t *handle, int offset, int numBytes, const wchar_t *charset);
```

Reads up to `numBytes` bytes from `handle` at the 32-bit byte `offset`, decodes the bytes using `charset`, and returns the resulting text.

See [Supported Charsets](https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp).

The requested size is measured in bytes, not characters. With a multibyte encoding such as UTF-8 or Shift_JIS, the final character can be split across calls. For robust streaming, read raw bytes and decode with application-maintained state.

Returns TRUE for success, FALSE for failure.

Async variant: `ReadFileText32Async` — same arguments, returns a `Task` (see Async variants below).

### SFtp.ReadFileText64

`Chilkat 11.7.0 · wc · SFtp · ReadFileText64 · method`

```c
BOOL CkSFtpW_ReadFileText64(HCkSFtpW cHandle, const wchar_t *handle, __int64 offset, int numBytes, const wchar_t *charset, const wchar_t *outStr);
const wchar_t *CkSFtpW_readFileText64(HCkSFtpW cHandle, const wchar_t *handle, __int64 offset, int numBytes, const wchar_t *charset);
```

Reads up to `numBytes` bytes from `handle` at the 64-bit byte `offset`, decodes the bytes using `charset`, and returns the resulting text.

See [Supported Charsets](https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp).

The requested size is measured in bytes, not characters. With a multibyte encoding such as UTF-8 or Shift_JIS, the final character can be split across calls. For robust streaming, read raw bytes and decode with application-maintained state.

Returns TRUE for success, FALSE for failure.

Async variant: `ReadFileText64Async` — same arguments, returns a `Task` (see Async variants below).

### SFtp.ReadFileText64s

`Chilkat 11.7.0 · wc · SFtp · ReadFileText64s · method`

```c
BOOL CkSFtpW_ReadFileText64s(HCkSFtpW cHandle, const wchar_t *handle, const wchar_t *offset, int numBytes, const wchar_t *charset, const wchar_t *outStr);
const wchar_t *CkSFtpW_readFileText64s(HCkSFtpW cHandle, const wchar_t *handle, const wchar_t *offset, int numBytes, const wchar_t *charset);
```

Reads up to `numBytes` bytes from `handle` at the byte offset supplied as decimal string `offset`, decodes the bytes using `charset`, and returns the resulting text.

See [Supported Charsets](https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp).

The requested size is measured in bytes, not characters. With a multibyte encoding, the final character can be split across calls.

Returns TRUE for success, FALSE for failure.

Async variant: `ReadFileText64sAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.ReadLink

`Chilkat 11.7.0 · wc · SFtp · ReadLink · method · since 9.5.0.71`

```c
BOOL CkSFtpW_ReadLink(HCkSFtpW cHandle, const wchar_t *path, const wchar_t *outStr);
const wchar_t *CkSFtpW_readLink(HCkSFtpW cHandle, const wchar_t *path);
```

Returns the target path stored in the symbolic link at remote `path`.

The returned value is the target string stored in the link. It is not automatically canonicalized and can be relative, absolute, or refer to a nonexistent target.

Returns TRUE for success, FALSE for failure.

Async variant: `ReadLinkAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.RealPath

`Chilkat 11.7.0 · wc · SFtp · RealPath · method`

```c
BOOL CkSFtpW_RealPath(HCkSFtpW cHandle, const wchar_t *originalPath, const wchar_t *composePath, const wchar_t *outStr);
const wchar_t *CkSFtpW_realPath(HCkSFtpW cHandle, const wchar_t *originalPath, const wchar_t *composePath);
```

Asks the server to canonicalize `originalPath` and returns the resulting absolute remote path.

For SFTP v5 or later, `composePath` may optionally modify or extend the original path; pass an empty string when no composition is needed. If `composePath` is absolute, it replaces `originalPath`.

SFTP v3 and v4 do not support path composition. On those versions, `composePath` is ignored and the method canonicalizes only `originalPath`.

Returns TRUE for success, FALSE for failure.

Async variant: `RealPathAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.RemoveDir

`Chilkat 11.7.0 · wc · SFtp · RemoveDir · method`

```c
BOOL CkSFtpW_RemoveDir(HCkSFtpW cHandle, const wchar_t *path);
```

Deletes the remote directory specified by `path`.

Most SFTP servers require the directory to be empty before it can be removed.

Returns TRUE for success, FALSE for failure.

Async variant: `RemoveDirAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.RemoveFile

`Chilkat 11.7.0 · wc · SFtp · RemoveFile · method`

```c
BOOL CkSFtpW_RemoveFile(HCkSFtpW cHandle, const wchar_t *filename);
```

Deletes the remote file specified by `filename`.

Returns TRUE for success, FALSE for failure.

Async variant: `RemoveFileAsync` — same arguments, returns a `Task` (see Async variants below).

See also:

- [Understanding SFTP Absolute FilePaths](http://www.cknotes.com/?p=135)

### SFtp.RenameFileOrDir

`Chilkat 11.7.0 · wc · SFtp · RenameFileOrDir · method`

```c
BOOL CkSFtpW_RenameFileOrDir(HCkSFtpW cHandle, const wchar_t *oldPath, const wchar_t *newPath);
```

Renames or moves a remote file or directory from `oldPath` to `newPath`.

```
oldPath: someDirA/filename
newPath: someDirB/abc/xyz/filename
```

Returns TRUE for success, FALSE for failure.

Async variant: `RenameFileOrDirAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.ResumeDownloadFileByName

`Chilkat 11.7.0 · wc · SFtp · ResumeDownloadFileByName · method`

```c
BOOL CkSFtpW_ResumeDownloadFileByName(HCkSFtpW cHandle, const wchar_t *remoteFilePath, const wchar_t *localFilePath);
```

Resumes downloading `remoteFilePath` to the local filesystem path `localFilePath`. Chilkat uses only the existing local file size as the remote starting offset.

- If the local file is missing or empty, a normal download is performed.
- If it is smaller, the remaining remote bytes are appended after the existing local length.
- If it is the same size or larger, the method treats the download as complete and does not truncate or verify the local content.

**Important:** The existing local bytes are not compared with the remote source. Before resuming, the application must ensure that the local file is the correct prefix of the remote file.

Returns TRUE for success, FALSE for failure.

Async variant: `ResumeDownloadFileByNameAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.ResumeUploadFileByName

`Chilkat 11.7.0 · wc · SFtp · ResumeUploadFileByName · method`

```c
BOOL CkSFtpW_ResumeUploadFileByName(HCkSFtpW cHandle, const wchar_t *remoteFilePath, const wchar_t *localFilePath);
```

Resumes uploading the local file at `localFilePath` to `remoteFilePath`. Chilkat uses only the existing remote file size as the local starting offset.

- If the remote file is missing or empty, a normal upload is performed.
- If it is smaller, the remaining local bytes are appended after the existing remote length.
- If it is the same size or larger, the method treats the upload as complete and does not truncate or verify the remote content.

**Important:** The existing remote bytes are not compared with the local source. Before resuming, the application must ensure that the remote file is the correct prefix of the local file.

Returns TRUE for success, FALSE for failure.

Async variant: `ResumeUploadFileByNameAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.SendIgnore

`Chilkat 11.7.0 · wc · SFtp · SendIgnore · method · since 9.5.0.66`

```c
BOOL CkSFtpW_SendIgnore(HCkSFtpW cHandle);
```

**Full documentation for this method (same in every language):** [Explaining SFTP RealPath](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/sftp_realpath.md)

Sends an SSH `IGNORE` message. No SFTP file handle or channel is required.

The server does not send a reply, but a successful send helps verify that the SSH connection is still writable.

Returns TRUE for success, FALSE for failure.

Async variant: `SendIgnoreAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.SetAllowedAlgorithms

`Chilkat 11.7.0 · wc · SFtp · SetAllowedAlgorithms · method · since 9.5.0.99`

```c
BOOL CkSFtpW_SetAllowedAlgorithms(HCkSFtpW cHandle, HCkJsonObjectW json);
```

Configures the exact set of SSH algorithms permitted for subsequent connections using the settings in `json`.

Call this method before `Connect`. The connection fails when no mutually supported algorithm remains in a required category.

Returns TRUE for success, FALSE for failure.

### SFtp.SetCreateDt

`Chilkat 11.7.0 · wc · SFtp · SetCreateDt · method`

```c
BOOL CkSFtpW_SetCreateDt(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL isHandle, HCkDateTimeW createDateTime);
```

Sets the remote file's creation date and time. `pathOrHandle` may contain a remote path or an open handle. Set `isHandle` to `TRUE` for a handle and `FALSE` for a path.

SFTP v3 and earlier do not support setting creation time.

`createDateTime` supplies the new value.

Returns TRUE for success, FALSE for failure.

Async variant: `SetCreateDtAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.SetCreateTimeStr

`Chilkat 11.7.0 · wc · SFtp · SetCreateTimeStr · method`

```c
BOOL CkSFtpW_SetCreateTimeStr(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bIsHandle, const wchar_t *dateTimeStr);
```

Sets the remote file's creation date and time. `pathOrHandle` may contain a remote path or an open handle. Set `bIsHandle` to `TRUE` for a handle and `FALSE` for a path.

Pass the value in `dateTimeStr` as an RFC 822 formatted string, for example `Fri, 21 Nov 1997 09:55:06 -0600`.

SFTP v3 and earlier do not support setting creation time.

Returns TRUE for success, FALSE for failure.

Async variant: `SetCreateTimeStrAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.SetLastAccessDt

`Chilkat 11.7.0 · wc · SFtp · SetLastAccessDt · method`

```c
BOOL CkSFtpW_SetLastAccessDt(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL isHandle, HCkDateTimeW accessDateTime);
```

Sets the remote file's last-access date and time. `pathOrHandle` may contain a remote path or an open handle. Set `isHandle` to `TRUE` for a handle and `FALSE` for a path.

`accessDateTime` supplies the new value.

Returns TRUE for success, FALSE for failure.

Async variant: `SetLastAccessDtAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.SetLastAccessTimeStr

`Chilkat 11.7.0 · wc · SFtp · SetLastAccessTimeStr · method`

```c
BOOL CkSFtpW_SetLastAccessTimeStr(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bIsHandle, const wchar_t *dateTimeStr);
```

Sets the remote file's last-access date and time. `pathOrHandle` may contain a remote path or an open handle. Set `bIsHandle` to `TRUE` for a handle and `FALSE` for a path.

Pass the value in `dateTimeStr` as an RFC 822 formatted string, for example `Fri, 21 Nov 1997 09:55:06 -0600`.

Returns TRUE for success, FALSE for failure.

Async variant: `SetLastAccessTimeStrAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.SetLastModifiedDt

`Chilkat 11.7.0 · wc · SFtp · SetLastModifiedDt · method`

```c
BOOL CkSFtpW_SetLastModifiedDt(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL isHandle, HCkDateTimeW modifiedDateTime);
```

Sets the remote file's last-modified date and time. `pathOrHandle` may contain a remote path or an open handle. Set `isHandle` to `TRUE` for a handle and `FALSE` for a path.

`modifiedDateTime` supplies the new value.

Returns TRUE for success, FALSE for failure.

Async variant: `SetLastModifiedDtAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.SetLastModifiedTimeStr

`Chilkat 11.7.0 · wc · SFtp · SetLastModifiedTimeStr · method`

```c
BOOL CkSFtpW_SetLastModifiedTimeStr(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bIsHandle, const wchar_t *dateTimeStr);
```

Sets the remote file's last-modified date and time. `pathOrHandle` may contain a remote path or an open handle. Set `bIsHandle` to `TRUE` for a handle and `FALSE` for a path.

Pass the value in `dateTimeStr` as an RFC 822 formatted string, for example `Fri, 21 Nov 1997 09:55:06 -0600`.

When SFTP v3 is negotiated, the stored timestamp has whole-second precision.

Returns TRUE for success, FALSE for failure.

Async variant: `SetLastModifiedTimeStrAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.SetOwnerAndGroup

`Chilkat 11.7.0 · wc · SFtp · SetOwnerAndGroup · method`

```c
BOOL CkSFtpW_SetOwnerAndGroup(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL isHandle, const wchar_t *owner, const wchar_t *group);
```

Sets the owner and group of the remote item identified by `pathOrHandle`. Set `isHandle` to `TRUE` for an open handle and `FALSE` for a remote path.

`owner` and `group` supply the new textual owner and group values.

SFTP v3 and earlier do not support textual owner and group names.

Returns TRUE for success, FALSE for failure.

Async variant: `SetOwnerAndGroupAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.SetPermissions

`Chilkat 11.7.0 · wc · SFtp · SetPermissions · method`

```c
BOOL CkSFtpW_SetPermissions(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL isHandle, int permissions);
```

Sets the POSIX permission bits for the remote item identified by `pathOrHandle`. Set `isHandle` to `TRUE` for an open handle and `FALSE` for a remote path.

Pass the permission bits, not the file-type bits. In languages supporting octal integer literals, common values include `0600`, `0644`, and `0755`. Their decimal equivalents are `384`, `420`, and `493`.

After setting permissions, `GetFilePermissions` returns the complete mode, including the file-type bits. For example, setting `0644` on a regular file can subsequently return `0100644`.

Returns TRUE for success, FALSE for failure.

Async variant: `SetPermissionsAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.StartKeyboardAuth

`Chilkat 11.7.0 · wc · SFtp · StartKeyboardAuth · method · since 9.5.0.88`

```c
BOOL CkSFtpW_StartKeyboardAuth(HCkSFtpW cHandle, const wchar_t *login, const wchar_t *outStr);
const wchar_t *CkSFtpW_startKeyboardAuth(HCkSFtpW cHandle, const wchar_t *login);
```

Begins keyboard-interactive authentication for `login` and returns XML describing the server's prompts.

```
<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>
```

The `echo` attribute indicates whether the response may be displayed while entered. A value of `0` normally identifies secret input such as a password.

If authentication immediately succeeds or fails, the result has one of these forms:

```
<success>success message</success>

<error>error message</error>
```

Returns TRUE for success, FALSE for failure.

Async variant: `StartKeyboardAuthAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.SymLink

`Chilkat 11.7.0 · wc · SFtp · SymLink · method · since 9.5.0.71`

```c
BOOL CkSFtpW_SymLink(HCkSFtpW cHandle, const wchar_t *oldPath, const wchar_t *newPath);
```

Creates a symbolic link on the server. `oldPath` identifies the link target and `newPath` identifies the new symbolic-link path.

The server's SFTP implementation determines path interpretation and whether symbolic links are permitted.

Returns TRUE for success, FALSE for failure.

Async variant: `SymLinkAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.SyncTreeDownload

`Chilkat 11.7.0 · wc · SFtp · SyncTreeDownload · method`

```c
BOOL CkSFtpW_SyncTreeDownload(HCkSFtpW cHandle, const wchar_t *remoteRoot, const wchar_t *localRoot, int mode, BOOL recurse);
```

Synchronizes files from the remote directory `remoteRoot` to the local filesystem directory `localRoot`.

| Mode | Behavior |
| :--- | :--- |
| `0` | Download all files. |
| `1` | Download files that do not exist locally. |
| `2` | Download files that are newer remotely or missing locally. |
| `3` | Download only files that are newer remotely; do not download missing local files. |
| `5` | Download files that are missing locally or differ in size. |
| `6` | Mode 5 plus files that are newer remotely. |
| `99` | Do not download; delete remote files that do not exist locally. |

Set `recurse` to `TRUE` to descend into subdirectories. An absolute remote path begins with `/`; a relative path is interpreted from the authenticated user's home directory.

Use `GetSyncedFiles` after the operation to retrieve the relative paths that were downloaded or created.

With `SyncCreateAllLocalDirs` set to `TRUE`, mode `0` creates empty remote directories locally. Mode `1` downloads only missing local files and preserves existing local files. Mode `99` deletes files from the remote tree that are absent locally; it does not delete extra local files.

Returns TRUE for success, FALSE for failure.

Async variant: `SyncTreeDownloadAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.SyncTreeUpload

`Chilkat 11.7.0 · wc · SFtp · SyncTreeUpload · method`

```c
BOOL CkSFtpW_SyncTreeUpload(HCkSFtpW cHandle, const wchar_t *localBaseDir, const wchar_t *remoteBaseDir, int mode, BOOL bRecurse);
```

Synchronizes files from the local filesystem directory `localBaseDir` to the remote directory `remoteBaseDir`.

| Mode | Behavior |
| :--- | :--- |
| `0` | Upload all files. |
| `1` | Upload files that do not exist remotely. |
| `2` | Upload files that are newer locally or missing remotely. |
| `3` | Upload only files that are newer locally; do not upload missing remote files. |
| `4` | Upload files that are missing remotely or differ in size. |
| `5` | Mode 4 plus files that are newer locally. |

Set `bRecurse` to `TRUE` to descend into subdirectories. An absolute remote path begins with `/`; a relative path is interpreted from the authenticated user's home directory.

Use `GetSyncedFiles` after the operation to retrieve the relative paths that were uploaded.

Mode `0` also creates empty remote directories. Mode `1` uploads only missing files and does not replace an existing remote file merely because the local file is newer; use mode `2` for missing-or-newer behavior. The filename and directory filters are applied during recursive traversal.

Returns TRUE for success, FALSE for failure.

Async variant: `SyncTreeUploadAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.UploadBd

`Chilkat 11.7.0 · wc · SFtp · UploadBd · method · since 9.5.0.62`

```c
BOOL CkSFtpW_UploadBd(HCkSFtpW cHandle, HCkBinDataW binData, const wchar_t *remoteFilePath);
```

Uploads all bytes in `binData` to the remote file at `remoteFilePath`.

If the destination exists, it is truncated before the bytes are uploaded.

Returns TRUE for success, FALSE for failure.

Async variant: `UploadBdAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.UploadFile

`Chilkat 11.7.0 · wc · SFtp · UploadFile · method`

```c
BOOL CkSFtpW_UploadFile(HCkSFtpW cHandle, const wchar_t *handle, const wchar_t *fromLocalFilePath);
```

Streams the local filesystem file at `fromLocalFilePath` to the remote file identified by `handle`. The handle must have been returned by `OpenFile`.

Close the remote handle when the upload is complete.

The upload begins at the handle's current sequential write position. Existing bytes before that position are preserved unless the file was truncated when opened.

Returns TRUE for success, FALSE for failure.

Async variant: `UploadFileAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.UploadFileByName

`Chilkat 11.7.0 · wc · SFtp · UploadFileByName · method`

```c
BOOL CkSFtpW_UploadFileByName(HCkSFtpW cHandle, const wchar_t *remoteFilePath, const wchar_t *localFilePath);
```

Uploads the local filesystem file at `localFilePath` to `remoteFilePath`.

When `PreserveDate` is `TRUE`, Chilkat preserves the local file's last-modified time on the remote file.

An absolute remote path begins with `/` and is relative to the server filesystem root. A relative path is interpreted relative to the authenticated user's home directory.

If the destination exists, it is truncated before the upload. A zero-byte local file creates or truncates the remote file to zero bytes. Missing remote parent directories are not created automatically.

Returns TRUE for success, FALSE for failure.

Async variant: `UploadFileByNameAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.UploadSb

`Chilkat 11.7.0 · wc · SFtp · UploadSb · method · since 9.5.0.62`

```c
BOOL CkSFtpW_UploadSb(HCkSFtpW cHandle, HCkStringBuilderW sb, const wchar_t *remoteFilePath, const wchar_t *charset, BOOL includeBom);
```

Encodes the text in `sb` using `charset` and uploads it to `remoteFilePath`.

Set `includeBom` to `TRUE` to prepend a byte-order mark when the selected encoding supports one.

If the destination exists, it is truncated before the text is uploaded. For `utf-8`, setting `includeBom` to `TRUE` prepends the three bytes `EF BB BF`; setting it to `FALSE` omits them.

Returns TRUE for success, FALSE for failure.

Async variant: `UploadSbAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.WriteFileBd

`Chilkat 11.7.0 · wc · SFtp · WriteFileBd · method · since 9.5.0.77`

```c
BOOL CkSFtpW_WriteFileBd(HCkSFtpW cHandle, const wchar_t *handle, HCkBinDataW bd);
```

Appends all bytes in `bd` to the remote file identified by `handle`. The handle must have been returned by `OpenFile`.

Returns TRUE for success, FALSE for failure.

Async variant: `WriteFileBdAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.WriteFileText

`Chilkat 11.7.0 · wc · SFtp · WriteFileText · method`

```c
BOOL CkSFtpW_WriteFileText(HCkSFtpW cHandle, const wchar_t *handle, const wchar_t *charset, const wchar_t *textData);
```

Encodes `textData` using `charset` and writes the resulting bytes at the current sequential write position for `handle`.

The position is maintained by Chilkat for the handle. Opening an existing file with `openOrCreate` positions sequential writes at the current end of the file. An explicit-offset write can change the position used by the next sequential write. When the file was opened with `appendData`, writes are forced to the end.

See [Supported Charsets](https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp).

No byte-order mark or line ending is added unless it is present in the supplied text or produced by the selected encoding.

Returns TRUE for success, FALSE for failure.

Async variant: `WriteFileTextAsync` — same arguments, returns a `Task` (see Async variants below).

### SFtp.WriteFileText32

`Chilkat 11.7.0 · wc · SFtp · WriteFileText32 · method`

```c
BOOL CkSFtpW_WriteFileText32(HCkSFtpW cHandle, const wchar_t *handle, int offset32, const wchar_t *charset, const wchar_t *textData);
```

Encodes `textData` using `charset` and writes the resulting bytes to `handle` at the 32-bit byte offset `offset32`.

After a successful explicit-offset write, the next sequential write begins immediately after the bytes written by this call. If the file was opened with `appendData`, the server appends and the explicit offset does not control placement.

See [Supported Charsets](https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp).

`offset32` must be nonnegative. A negative value can be interpreted as a very large unsigned offset. Writing beyond end-of-file can create a sparse file; whether the gap is sparse is determined by the server filesystem.

No byte-order mark or line ending is added unless it is present in the supplied text or produced by the selected encoding.

Returns TRUE for success, FALSE for failure.

Async variant: `WriteFileText32Async` — same arguments, returns a `Task` (see Async variants below).

### SFtp.WriteFileText64

`Chilkat 11.7.0 · wc · SFtp · WriteFileText64 · method`

```c
BOOL CkSFtpW_WriteFileText64(HCkSFtpW cHandle, const wchar_t *handle, __int64 offset64, const wchar_t *charset, const wchar_t *textData);
```

Encodes `textData` using `charset` and writes the resulting bytes to `handle` at the 64-bit byte offset `offset64`.

See [Supported Charsets](https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp).

No byte-order mark or line ending is added unless it is present in the supplied text or produced by the selected encoding.

Returns TRUE for success, FALSE for failure.

Async variant: `WriteFileText64Async` — same arguments, returns a `Task` (see Async variants below).

### SFtp.WriteFileText64s

`Chilkat 11.7.0 · wc · SFtp · WriteFileText64s · method`

```c
BOOL CkSFtpW_WriteFileText64s(HCkSFtpW cHandle, const wchar_t *handle, const wchar_t *offset64, const wchar_t *charset, const wchar_t *textData);
```

Encodes `textData` using `charset` and writes the resulting bytes to `handle` at the byte offset supplied as decimal string `offset64`.

See [Supported Charsets](https://www.chilkatsoft.com/charsets_supported_by_chilkat.asp).

No byte-order mark or line ending is added unless it is present in the supplied text or produced by the selected encoding.

Returns TRUE for success, FALSE for failure.

Async variant: `WriteFileText64sAsync` — same arguments, returns a `Task` (see Async variants below).

## Events and callbacks

This binding delivers progress information through callbacks (AbortCheck, PercentDone, ProgressInfo, TaskCompleted) rather than events. See `guide.md` for how to attach them in Unicode C.

## Async variants

Each returns a `Task` instead of the result and takes the same arguments as the synchronous method; run the task, wait for `Finished`, then read the result from the task. No new Async methods are added from 11.7.0 on.

```c
HCkTaskW CkSFtpW_AuthenticatePkAsync(HCkSFtpW cHandle, const wchar_t *username, HCkSshKeyW privateKey);
HCkTaskW CkSFtpW_AuthenticatePwAsync(HCkSFtpW cHandle, const wchar_t *login, const wchar_t *password);
HCkTaskW CkSFtpW_AuthenticatePwPkAsync(HCkSFtpW cHandle, const wchar_t *username, const wchar_t *password, HCkSshKeyW privateKey);
HCkTaskW CkSFtpW_AuthenticateSecPwAsync(HCkSFtpW cHandle, HCkSecureStringW login, HCkSecureStringW password);
HCkTaskW CkSFtpW_AuthenticateSecPwPkAsync(HCkSFtpW cHandle, HCkSecureStringW username, HCkSecureStringW password, HCkSshKeyW privateKey);
HCkTaskW CkSFtpW_CloseHandleAsync(HCkSFtpW cHandle, const wchar_t *handle);
HCkTaskW CkSFtpW_ConnectAsync(HCkSFtpW cHandle, const wchar_t *domainName, int port);
HCkTaskW CkSFtpW_ConnectThroughSshAsync(HCkSFtpW cHandle, HCkSshW sshConn, const wchar_t *hostname, int port);
HCkTaskW CkSFtpW_ContinueKeyboardAuthAsync(HCkSFtpW cHandle, const wchar_t *response);
HCkTaskW CkSFtpW_CopyFileAttrAsync(HCkSFtpW cHandle, const wchar_t *localFilename, const wchar_t *remoteFilename, BOOL isHandle);
HCkTaskW CkSFtpW_CreateDirAsync(HCkSFtpW cHandle, const wchar_t *path);
HCkTaskW CkSFtpW_DownloadBdAsync(HCkSFtpW cHandle, const wchar_t *remoteFilePath, HCkBinDataW binData);
HCkTaskW CkSFtpW_DownloadFileAsync(HCkSFtpW cHandle, const wchar_t *handle, const wchar_t *toFilename);
HCkTaskW CkSFtpW_DownloadFileByNameAsync(HCkSFtpW cHandle, const wchar_t *remoteFilePath, const wchar_t *localFilePath);
HCkTaskW CkSFtpW_DownloadSbAsync(HCkSFtpW cHandle, const wchar_t *remoteFilePath, const wchar_t *charset, HCkStringBuilderW sb);
HCkTaskW CkSFtpW_FileExistsAsync(HCkSFtpW cHandle, const wchar_t *remotePath, BOOL followLinks);
HCkTaskW CkSFtpW_FsyncAsync(HCkSFtpW cHandle, const wchar_t *handle);
HCkTaskW CkSFtpW_GetFileCreateTimeStrAsync(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);
HCkTaskW CkSFtpW_GetFileGroupAsync(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);
HCkTaskW CkSFtpW_GetFileLastAccessStrAsync(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);
HCkTaskW CkSFtpW_GetFileLastModifiedStrAsync(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);
HCkTaskW CkSFtpW_GetFileOwnerAsync(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);
HCkTaskW CkSFtpW_GetFilePermissionsAsync(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);
HCkTaskW CkSFtpW_GetFileSize32Async(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);
HCkTaskW CkSFtpW_GetFileSize64Async(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);
HCkTaskW CkSFtpW_GetFileSizeStrAsync(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bFollowLinks, BOOL bIsHandle);
HCkTaskW CkSFtpW_HardLinkAsync(HCkSFtpW cHandle, const wchar_t *oldPath, const wchar_t *newPath);
HCkTaskW CkSFtpW_InitializeSftpAsync(HCkSFtpW cHandle);
HCkTaskW CkSFtpW_OpenDirAsync(HCkSFtpW cHandle, const wchar_t *path);
HCkTaskW CkSFtpW_OpenFileAsync(HCkSFtpW cHandle, const wchar_t *remotePath, const wchar_t *access, const wchar_t *createDisposition);
HCkTaskW CkSFtpW_ReadDirListingAsync(HCkSFtpW cHandle, const wchar_t *handle, HCkSFtpDirW dirObj);
HCkTaskW CkSFtpW_ReadFileBdAsync(HCkSFtpW cHandle, const wchar_t *handle, int numBytes, HCkBinDataW bd);
HCkTaskW CkSFtpW_ReadFileTextAsync(HCkSFtpW cHandle, const wchar_t *handle, int numBytes, const wchar_t *charset);
HCkTaskW CkSFtpW_ReadFileText32Async(HCkSFtpW cHandle, const wchar_t *handle, int offset, int numBytes, const wchar_t *charset);
HCkTaskW CkSFtpW_ReadFileText64Async(HCkSFtpW cHandle, const wchar_t *handle, __int64 offset, int numBytes, const wchar_t *charset);
HCkTaskW CkSFtpW_ReadFileText64sAsync(HCkSFtpW cHandle, const wchar_t *handle, const wchar_t *offset, int numBytes, const wchar_t *charset);
HCkTaskW CkSFtpW_ReadLinkAsync(HCkSFtpW cHandle, const wchar_t *path);
HCkTaskW CkSFtpW_RealPathAsync(HCkSFtpW cHandle, const wchar_t *originalPath, const wchar_t *composePath);
HCkTaskW CkSFtpW_RemoveDirAsync(HCkSFtpW cHandle, const wchar_t *path);
HCkTaskW CkSFtpW_RemoveFileAsync(HCkSFtpW cHandle, const wchar_t *filename);
HCkTaskW CkSFtpW_RenameFileOrDirAsync(HCkSFtpW cHandle, const wchar_t *oldPath, const wchar_t *newPath);
HCkTaskW CkSFtpW_ResumeDownloadFileByNameAsync(HCkSFtpW cHandle, const wchar_t *remoteFilePath, const wchar_t *localFilePath);
HCkTaskW CkSFtpW_ResumeUploadFileByNameAsync(HCkSFtpW cHandle, const wchar_t *remoteFilePath, const wchar_t *localFilePath);
HCkTaskW CkSFtpW_SendIgnoreAsync(HCkSFtpW cHandle);
HCkTaskW CkSFtpW_SetCreateDtAsync(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL isHandle, HCkDateTimeW createDateTime);
HCkTaskW CkSFtpW_SetCreateTimeStrAsync(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bIsHandle, const wchar_t *dateTimeStr);
HCkTaskW CkSFtpW_SetLastAccessDtAsync(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL isHandle, HCkDateTimeW accessDateTime);
HCkTaskW CkSFtpW_SetLastAccessTimeStrAsync(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bIsHandle, const wchar_t *dateTimeStr);
HCkTaskW CkSFtpW_SetLastModifiedDtAsync(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL isHandle, HCkDateTimeW modifiedDateTime);
HCkTaskW CkSFtpW_SetLastModifiedTimeStrAsync(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL bIsHandle, const wchar_t *dateTimeStr);
HCkTaskW CkSFtpW_SetOwnerAndGroupAsync(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL isHandle, const wchar_t *owner, const wchar_t *group);
HCkTaskW CkSFtpW_SetPermissionsAsync(HCkSFtpW cHandle, const wchar_t *pathOrHandle, BOOL isHandle, int permissions);
HCkTaskW CkSFtpW_StartKeyboardAuthAsync(HCkSFtpW cHandle, const wchar_t *login);
HCkTaskW CkSFtpW_SymLinkAsync(HCkSFtpW cHandle, const wchar_t *oldPath, const wchar_t *newPath);
HCkTaskW CkSFtpW_SyncTreeDownloadAsync(HCkSFtpW cHandle, const wchar_t *remoteRoot, const wchar_t *localRoot, int mode, BOOL recurse);
HCkTaskW CkSFtpW_SyncTreeUploadAsync(HCkSFtpW cHandle, const wchar_t *localBaseDir, const wchar_t *remoteBaseDir, int mode, BOOL bRecurse);
HCkTaskW CkSFtpW_UploadBdAsync(HCkSFtpW cHandle, HCkBinDataW binData, const wchar_t *remoteFilePath);
HCkTaskW CkSFtpW_UploadFileAsync(HCkSFtpW cHandle, const wchar_t *handle, const wchar_t *fromLocalFilePath);
HCkTaskW CkSFtpW_UploadFileByNameAsync(HCkSFtpW cHandle, const wchar_t *remoteFilePath, const wchar_t *localFilePath);
HCkTaskW CkSFtpW_UploadSbAsync(HCkSFtpW cHandle, HCkStringBuilderW sb, const wchar_t *remoteFilePath, const wchar_t *charset, BOOL includeBom);
HCkTaskW CkSFtpW_WriteFileBdAsync(HCkSFtpW cHandle, const wchar_t *handle, HCkBinDataW bd);
HCkTaskW CkSFtpW_WriteFileTextAsync(HCkSFtpW cHandle, const wchar_t *handle, const wchar_t *charset, const wchar_t *textData);
HCkTaskW CkSFtpW_WriteFileText32Async(HCkSFtpW cHandle, const wchar_t *handle, int offset32, const wchar_t *charset, const wchar_t *textData);
HCkTaskW CkSFtpW_WriteFileText64Async(HCkSFtpW cHandle, const wchar_t *handle, __int64 offset64, const wchar_t *charset, const wchar_t *textData);
HCkTaskW CkSFtpW_WriteFileText64sAsync(HCkSFtpW cHandle, const wchar_t *handle, const wchar_t *offset64, const wchar_t *charset, const wchar_t *textData);
```

## Deprecated members — do not use in new code

| Member | Kind | Deprecated in | Use instead |
|---|---|---|---|
| `AccumulateBytes` | method | before 11.6.1 | — |
| `Add64` | method | before 11.6.1 | — |
| `ClearAccumulateBuffer` | method | before 11.6.1 | — |
| `GetFileCreateDt` | method | before 11.6.1 | — |
| `GetFileLastAccessDt` | method | before 11.6.1 | — |
| `GetFileLastModifiedDt` | method | before 11.6.1 | — |
| `LastJsonData` | method | before 11.6.1 | — |
| `ReadDir` | method | before 11.6.1 | `ReadDirListing` |
| `ReadFileBytes` | method | before 11.6.1 | — |
| `ReadFileBytes32` | method | before 11.6.1 | — |
| `ReadFileBytes64` | method | before 11.6.1 | — |
| `ReadFileBytes64s` | method | before 11.6.1 | — |
| `WriteFileBytes` | method | before 11.6.1 | — |
| `WriteFileBytes32` | method | before 11.6.1 | — |
| `WriteFileBytes64` | method | before 11.6.1 | — |
| `WriteFileBytes64s` | method | before 11.6.1 | — |

## Related classes

[`BinData`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/classes/BinData.md), [`CkDateTime`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/classes/CkDateTime.md), [`JsonObject`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/classes/JsonObject.md), [`SFtpDir`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/classes/SFtpDir.md), [`SecureString`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/classes/SecureString.md), [`Ssh`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/classes/Ssh.md), [`SshKey`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/classes/SshKey.md), [`StringBuilder`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/classes/StringBuilder.md), [`StringTable`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/classes/StringTable.md), [`Task`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/wc/classes/Task.md)

