(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::SftpFailure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::SftpBadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::SftpNoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::SftpNoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::SftpLockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"}],"string":"[\n {\n \"comment\": \"Why not use the enum instead?\\nIf there's a good reason, you should static_assert instead of a comment.\\nThis will help make sure it's always true / doesn't rot over time, unlikely as that may be.\",\n \"path\": \"src/SFML/Network/Sftp.cpp\",\n \"hunk\": \"@@ -0,0 +1,1377 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+// clang-format off\\n+#include <libssh2_sftp.h>\\n+// clang-format on\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ libssh2_exit();\\n+ }\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\\n+{\\n+ static std::mutex mutex;\\n+ const std::lock_guard lock(mutex);\\n+\\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\\n+ auto sharedPtr = weakPtr.lock();\\n+\\n+ if (sharedPtr)\\n+ return sharedPtr;\\n+\\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\\n+ weakPtr = sharedPtr;\\n+\\n+ return sharedPtr;\\n+}\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::SftpFailure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::SftpBadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::SftpNoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::SftpNoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::SftpLockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\\nnew file mode 100644\\nindex 0000000000..95ab95a45e\\n--- /dev/null\\n+++ b/src/SFML/Network/Sftp.cpp\\n@@ -0,0 +1,1347 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+#include <SFML/System/Err.hpp>\\n+\\n+#include <libssh2_sftp.h>\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <ostream>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ libssh2_exit();\\n+ }\\n+\\n+ static inline std::mutex mutex;\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::Error, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::EndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::NoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::PermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::Failure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::BadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::NoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::ConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::OperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::InvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::NoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::WriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::NoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::QuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::LockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::NotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::InvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::LinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl : LibSsh2Initializer\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\\n+ {\\n+ const auto result = waitForOperationComplete(\\n+ [&]\\n+ {\\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\\n+\\n+ if (sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ bool posixRenameSupported = true;\\n+ std::filesystem::path cachedHomePath;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\\n+{\\n+ // Clear the cached home path\\n+ m_impl->cachedHomePath.clear();\\n+\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length == 0)\\n+ return std::nullopt;\\n+\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ err() << \\\"SFTP: Cannot get session information, session not yet started\\\" << std::endl;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Ensure the passphrase is NULL-terminated\\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\\n+ return login(name,\\n+ publicKeyData.data(),\\n+ publicKeyData.length(),\\n+ privateKeyData.data(),\\n+ privateKeyData.length(),\\n+ privateKeyPassphraseString.c_str(),\\n+ timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Check if we already cached the result for the home path\\n+ if ((path == \\\".\\\") && !m_impl->cachedHomePath.empty())\\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\\n+ .generic_u8string();\\n+\\n+ // Cache the result for the home path\\n+ if (path == \\\".\\\")\\n+ m_impl->cachedHomePath = genericPath;\\n+\\n+ return {Result(Result::Value::Success), genericPath};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\\n+ &attributes);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ {\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ 0,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENDIR);\\n+\\n+ if (handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (!handle)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+ }\\n+\\n+ std::vector<Attributes> listing;\\n+\\n+ {\\n+ std::array<char, 4096> buffer{};\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\\n+ timeout);\\n+\\n+ if (result > 0)\\n+ {\\n+ listing.emplace_back(\\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\\n+ attributes));\\n+\\n+ continue;\\n+ }\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ if (result == 0)\\n+ break;\\n+ }\\n+ }\\n+\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ return {Result(Result::Value::Success), std::move(listing)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\\n+ std::filesystem::perms permissions,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ makePermissions(permissions));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto oldPathString = oldPath.generic_u8string();\\n+ const auto newPathString = newPath.generic_u8string();\\n+\\n+ // POSIX rename is only supported starting from libssh2 1.11.1\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // POSIX rename doesn't support not overwriting\\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\\n+#endif\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ if (usePosix)\\n+ {\\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()));\\n+ }\\n+#endif\\n+\\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()),\\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // Retry using normal rename if we find out POSIX rename isn't supported\\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\\n+ {\\n+ m_impl->posixRenameSupported = false;\\n+ usePosix = false;\\n+ continue;\\n+ }\\n+#endif\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for reading\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ LIBSSH2_FXF_READ,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Read from the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ auto* ptr = buffer.get();\\n+ int read{};\\n+ std::size_t totalRead{};\\n+\\n+ while (length > 0)\\n+ {\\n+ read = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (read == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (read <= 0)\\n+ break;\\n+\\n+ ptr += read;\\n+ length -= static_cast<std::size_t>(read);\\n+ totalRead += static_cast<std::size_t>(read);\\n+ }\\n+\\n+ if (read < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ const auto stop = !callback(buffer.get(), totalRead);\\n+\\n+ // If read is 0 then we have reached EOF\\n+ if (stop || (read == 0))\\n+ break;\\n+\\n+ const auto expand = (totalRead == bufferSize);\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions,\\n+ bool truncate,\\n+ bool append,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for writing\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\\n+ makePermissions(permissions),\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Write to the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ const auto stop = !callback(buffer.get(), length);\\n+ const auto expand = (length == bufferSize);\\n+ const auto* ptr = buffer.get();\\n+ int written{};\\n+\\n+ while (length > 0)\\n+ {\\n+ written = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (written == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (written < 0)\\n+ break;\\n+\\n+ ptr += written;\\n+ length -= static_cast<std::size_t>(written);\\n+ }\\n+\\n+ if (written < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ if (stop)\\n+ break;\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+} // namespace sf\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10075,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"This function / pattern is far more complex than it needs to be.\n\nWe don't need a special object to store the initialisation, although I think I see the purpose of the mutex given we don't know what the client code will do and libssh2_init is not thread safe.\n\nHowever, it would be much easier to reason about by...\n- removing the libssh2initlialzer type\n- making any required locks in Impl ctor\n\nI'm not sure why we need a shared_ptr here, esp. for a hidden non-static member can you elaborate? Is there some kind of issue with multiple calls to libssh2_init? In which case a more Meyers singleton-esk solution might be better.\n\nAlso, because it's part of the declaration for the type, using a functor here and keeping it as a private member. will increase memory usage by one byte for no benefit. Given it's never directly called outside of the member initialisation, it would seem better to just make the call directly in the Impl ctor.\n\nI can see the use of the dtor for RAII, but that could be achieved with a simpler struct inline potentially. Do you now if we need account for thread safety on exit? Might be better to just in case. I imagine it'll need to share the mutex with init."},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"},"changed_files":{"kind":"list like","value":["src/SFML/Network/Sftp.cpp"],"string":"[\n \"src/SFML/Network/Sftp.cpp\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"This function / pattern is far more complex than it needs to be.\n\nWe don't need a special object to store the initialisation, although I think I see the purpose of the mutex given we don't know what the client code will do and libssh2_init is not thread safe.\n\nHowever, it would be much easier to reason about by...\n- removing the libssh2initlialzer type\n- making any required locks in Impl ctor\n\nI'm not sure why we need a shared_ptr here, esp. for a hidden non-static member can you elaborate? Is there some kind of issue with multiple calls to libssh2_init? In which case a more Meyers singleton-esk solution might be better.\n\nAlso, because it's part of the declaration for the type, using a functor here and keeping it as a private member. will increase memory usage by one byte for no benefit. Given it's never directly called outside of the member initialisation, it would seem better to just make the call directly in the Impl ctor.\n\nI can see the use of the dtor for RAII, but that could be achieved with a simpler struct inline potentially. Do you now if we need account for thread safety on exit? Might be better to just in case. I imagine it'll need to share the mutex with init.","path":"src/SFML/Network/Sftp.cpp","hunk":"@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+// clang-format off\n+#include <libssh2_sftp.h>\n+// clang-format on\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ libssh2_exit();\n+ }\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\n+{\n+ static std::mutex mutex;\n+ const std::lock_guard lock(mutex);\n+\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\n+ auto sharedPtr = weakPtr.lock();\n+\n+ if (sharedPtr)\n+ return sharedPtr;\n+\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\n+ weakPtr = sharedPtr;\n+\n+ return sharedPtr;\n+}","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"}],"string":"[\n {\n \"comment\": \"This function / pattern is far more complex than it needs to be.\\n\\nWe don't need a special object to store the initialisation, although I think I see the purpose of the mutex given we don't know what the client code will do and libssh2_init is not thread safe.\\n\\nHowever, it would be much easier to reason about by...\\n- removing the libssh2initlialzer type\\n- making any required locks in Impl ctor\\n\\nI'm not sure why we need a shared_ptr here, esp. for a hidden non-static member can you elaborate? Is there some kind of issue with multiple calls to libssh2_init? In which case a more Meyers singleton-esk solution might be better.\\n\\nAlso, because it's part of the declaration for the type, using a functor here and keeping it as a private member. will increase memory usage by one byte for no benefit. Given it's never directly called outside of the member initialisation, it would seem better to just make the call directly in the Impl ctor.\\n\\nI can see the use of the dtor for RAII, but that could be achieved with a simpler struct inline potentially. Do you now if we need account for thread safety on exit? Might be better to just in case. I imagine it'll need to share the mutex with init.\",\n \"path\": \"src/SFML/Network/Sftp.cpp\",\n \"hunk\": \"@@ -0,0 +1,1377 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+// clang-format off\\n+#include <libssh2_sftp.h>\\n+// clang-format on\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ libssh2_exit();\\n+ }\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\\n+{\\n+ static std::mutex mutex;\\n+ const std::lock_guard lock(mutex);\\n+\\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\\n+ auto sharedPtr = weakPtr.lock();\\n+\\n+ if (sharedPtr)\\n+ return sharedPtr;\\n+\\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\\n+ weakPtr = sharedPtr;\\n+\\n+ return sharedPtr;\\n+}\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\\nnew file mode 100644\\nindex 0000000000..95ab95a45e\\n--- /dev/null\\n+++ b/src/SFML/Network/Sftp.cpp\\n@@ -0,0 +1,1347 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+#include <SFML/System/Err.hpp>\\n+\\n+#include <libssh2_sftp.h>\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <ostream>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ libssh2_exit();\\n+ }\\n+\\n+ static inline std::mutex mutex;\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::Error, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::EndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::NoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::PermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::Failure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::BadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::NoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::ConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::OperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::InvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::NoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::WriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::NoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::QuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::LockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::NotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::InvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::LinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl : LibSsh2Initializer\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\\n+ {\\n+ const auto result = waitForOperationComplete(\\n+ [&]\\n+ {\\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\\n+\\n+ if (sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ bool posixRenameSupported = true;\\n+ std::filesystem::path cachedHomePath;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\\n+{\\n+ // Clear the cached home path\\n+ m_impl->cachedHomePath.clear();\\n+\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length == 0)\\n+ return std::nullopt;\\n+\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ err() << \\\"SFTP: Cannot get session information, session not yet started\\\" << std::endl;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Ensure the passphrase is NULL-terminated\\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\\n+ return login(name,\\n+ publicKeyData.data(),\\n+ publicKeyData.length(),\\n+ privateKeyData.data(),\\n+ privateKeyData.length(),\\n+ privateKeyPassphraseString.c_str(),\\n+ timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Check if we already cached the result for the home path\\n+ if ((path == \\\".\\\") && !m_impl->cachedHomePath.empty())\\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\\n+ .generic_u8string();\\n+\\n+ // Cache the result for the home path\\n+ if (path == \\\".\\\")\\n+ m_impl->cachedHomePath = genericPath;\\n+\\n+ return {Result(Result::Value::Success), genericPath};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\\n+ &attributes);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ {\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ 0,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENDIR);\\n+\\n+ if (handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (!handle)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+ }\\n+\\n+ std::vector<Attributes> listing;\\n+\\n+ {\\n+ std::array<char, 4096> buffer{};\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\\n+ timeout);\\n+\\n+ if (result > 0)\\n+ {\\n+ listing.emplace_back(\\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\\n+ attributes));\\n+\\n+ continue;\\n+ }\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ if (result == 0)\\n+ break;\\n+ }\\n+ }\\n+\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ return {Result(Result::Value::Success), std::move(listing)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\\n+ std::filesystem::perms permissions,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ makePermissions(permissions));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto oldPathString = oldPath.generic_u8string();\\n+ const auto newPathString = newPath.generic_u8string();\\n+\\n+ // POSIX rename is only supported starting from libssh2 1.11.1\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // POSIX rename doesn't support not overwriting\\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\\n+#endif\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ if (usePosix)\\n+ {\\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()));\\n+ }\\n+#endif\\n+\\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()),\\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // Retry using normal rename if we find out POSIX rename isn't supported\\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\\n+ {\\n+ m_impl->posixRenameSupported = false;\\n+ usePosix = false;\\n+ continue;\\n+ }\\n+#endif\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for reading\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ LIBSSH2_FXF_READ,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Read from the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ auto* ptr = buffer.get();\\n+ int read{};\\n+ std::size_t totalRead{};\\n+\\n+ while (length > 0)\\n+ {\\n+ read = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (read == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (read <= 0)\\n+ break;\\n+\\n+ ptr += read;\\n+ length -= static_cast<std::size_t>(read);\\n+ totalRead += static_cast<std::size_t>(read);\\n+ }\\n+\\n+ if (read < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ const auto stop = !callback(buffer.get(), totalRead);\\n+\\n+ // If read is 0 then we have reached EOF\\n+ if (stop || (read == 0))\\n+ break;\\n+\\n+ const auto expand = (totalRead == bufferSize);\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions,\\n+ bool truncate,\\n+ bool append,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for writing\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\\n+ makePermissions(permissions),\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Write to the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ const auto stop = !callback(buffer.get(), length);\\n+ const auto expand = (length == bufferSize);\\n+ const auto* ptr = buffer.get();\\n+ int written{};\\n+\\n+ while (length > 0)\\n+ {\\n+ written = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (written == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (written < 0)\\n+ break;\\n+\\n+ ptr += written;\\n+ length -= static_cast<std::size_t>(written);\\n+ }\\n+\\n+ if (written < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ if (stop)\\n+ break;\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+} // namespace sf\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10076,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"This is a bit obtuse to read and there's more standard ones available. I think this should be replaced with `std::filesystem::perm_options`. This reduces the risk of small typos completely changing the meaning, esp. in such a dense piece of code."},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"},"changed_files":{"kind":"list like","value":["src/SFML/Network/Sftp.cpp"],"string":"[\n \"src/SFML/Network/Sftp.cpp\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"This is a bit obtuse to read and there's more standard ones available. I think this should be replaced with `std::filesystem::perm_options`. This reduces the risk of small typos completely changing the meaning, esp. in such a dense piece of code.","path":"src/SFML/Network/Sftp.cpp","hunk":"@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+// clang-format off\n+#include <libssh2_sftp.h>\n+// clang-format on\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ libssh2_exit();\n+ }\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\n+{\n+ static std::mutex mutex;\n+ const std::lock_guard lock(mutex);\n+\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\n+ auto sharedPtr = weakPtr.lock();\n+\n+ if (sharedPtr)\n+ return sharedPtr;\n+\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\n+ weakPtr = sharedPtr;\n+\n+ return sharedPtr;\n+}\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"}],"string":"[\n {\n \"comment\": \"This is a bit obtuse to read and there's more standard ones available. I think this should be replaced with `std::filesystem::perm_options`. This reduces the risk of small typos completely changing the meaning, esp. in such a dense piece of code.\",\n \"path\": \"src/SFML/Network/Sftp.cpp\",\n \"hunk\": \"@@ -0,0 +1,1377 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+// clang-format off\\n+#include <libssh2_sftp.h>\\n+// clang-format on\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ libssh2_exit();\\n+ }\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\\n+{\\n+ static std::mutex mutex;\\n+ const std::lock_guard lock(mutex);\\n+\\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\\n+ auto sharedPtr = weakPtr.lock();\\n+\\n+ if (sharedPtr)\\n+ return sharedPtr;\\n+\\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\\n+ weakPtr = sharedPtr;\\n+\\n+ return sharedPtr;\\n+}\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\\nnew file mode 100644\\nindex 0000000000..95ab95a45e\\n--- /dev/null\\n+++ b/src/SFML/Network/Sftp.cpp\\n@@ -0,0 +1,1347 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+#include <SFML/System/Err.hpp>\\n+\\n+#include <libssh2_sftp.h>\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <ostream>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ libssh2_exit();\\n+ }\\n+\\n+ static inline std::mutex mutex;\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::Error, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::EndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::NoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::PermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::Failure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::BadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::NoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::ConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::OperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::InvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::NoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::WriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::NoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::QuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::LockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::NotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::InvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::LinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl : LibSsh2Initializer\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\\n+ {\\n+ const auto result = waitForOperationComplete(\\n+ [&]\\n+ {\\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\\n+\\n+ if (sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ bool posixRenameSupported = true;\\n+ std::filesystem::path cachedHomePath;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\\n+{\\n+ // Clear the cached home path\\n+ m_impl->cachedHomePath.clear();\\n+\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length == 0)\\n+ return std::nullopt;\\n+\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ err() << \\\"SFTP: Cannot get session information, session not yet started\\\" << std::endl;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Ensure the passphrase is NULL-terminated\\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\\n+ return login(name,\\n+ publicKeyData.data(),\\n+ publicKeyData.length(),\\n+ privateKeyData.data(),\\n+ privateKeyData.length(),\\n+ privateKeyPassphraseString.c_str(),\\n+ timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Check if we already cached the result for the home path\\n+ if ((path == \\\".\\\") && !m_impl->cachedHomePath.empty())\\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\\n+ .generic_u8string();\\n+\\n+ // Cache the result for the home path\\n+ if (path == \\\".\\\")\\n+ m_impl->cachedHomePath = genericPath;\\n+\\n+ return {Result(Result::Value::Success), genericPath};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\\n+ &attributes);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ {\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ 0,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENDIR);\\n+\\n+ if (handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (!handle)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+ }\\n+\\n+ std::vector<Attributes> listing;\\n+\\n+ {\\n+ std::array<char, 4096> buffer{};\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\\n+ timeout);\\n+\\n+ if (result > 0)\\n+ {\\n+ listing.emplace_back(\\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\\n+ attributes));\\n+\\n+ continue;\\n+ }\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ if (result == 0)\\n+ break;\\n+ }\\n+ }\\n+\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ return {Result(Result::Value::Success), std::move(listing)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\\n+ std::filesystem::perms permissions,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ makePermissions(permissions));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto oldPathString = oldPath.generic_u8string();\\n+ const auto newPathString = newPath.generic_u8string();\\n+\\n+ // POSIX rename is only supported starting from libssh2 1.11.1\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // POSIX rename doesn't support not overwriting\\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\\n+#endif\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ if (usePosix)\\n+ {\\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()));\\n+ }\\n+#endif\\n+\\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()),\\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // Retry using normal rename if we find out POSIX rename isn't supported\\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\\n+ {\\n+ m_impl->posixRenameSupported = false;\\n+ usePosix = false;\\n+ continue;\\n+ }\\n+#endif\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for reading\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ LIBSSH2_FXF_READ,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Read from the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ auto* ptr = buffer.get();\\n+ int read{};\\n+ std::size_t totalRead{};\\n+\\n+ while (length > 0)\\n+ {\\n+ read = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (read == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (read <= 0)\\n+ break;\\n+\\n+ ptr += read;\\n+ length -= static_cast<std::size_t>(read);\\n+ totalRead += static_cast<std::size_t>(read);\\n+ }\\n+\\n+ if (read < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ const auto stop = !callback(buffer.get(), totalRead);\\n+\\n+ // If read is 0 then we have reached EOF\\n+ if (stop || (read == 0))\\n+ break;\\n+\\n+ const auto expand = (totalRead == bufferSize);\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions,\\n+ bool truncate,\\n+ bool append,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for writing\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\\n+ makePermissions(permissions),\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Write to the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ const auto stop = !callback(buffer.get(), length);\\n+ const auto expand = (length == bufferSize);\\n+ const auto* ptr = buffer.get();\\n+ int written{};\\n+\\n+ while (length > 0)\\n+ {\\n+ written = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (written == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (written < 0)\\n+ break;\\n+\\n+ ptr += written;\\n+ length -= static_cast<std::size_t>(written);\\n+ }\\n+\\n+ if (written < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ if (stop)\\n+ break;\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+} // namespace sf\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10077,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"How come?"},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/src/SFML/Network/CMakeLists.txt b/src/SFML/Network/CMakeLists.txt\nindex 076b4459e9..d62e802b76 100644\n--- a/src/SFML/Network/CMakeLists.txt\n+++ b/src/SFML/Network/CMakeLists.txt\n@@ -14,6 +14,8 @@ set(SRC\n ${INCROOT}/IpAddress.hpp\n ${SRCROOT}/Packet.cpp\n ${INCROOT}/Packet.hpp\n+ ${SRCROOT}/Sftp.cpp\n+ ${INCROOT}/Sftp.hpp\n ${SRCROOT}/Socket.cpp\n ${INCROOT}/Socket.hpp\n ${SRCROOT}/SocketImpl.hpp\n@@ -56,11 +58,12 @@ endif()\n \n if(SFML_USE_SYSTEM_DEPS)\n find_package(MbedTLS REQUIRED)\n+ find_package(Libssh2 REQUIRED)\n else()\n+ include(FetchContent)\n+\n # use a block to scope option variables we have to set\n block()\n- include(FetchContent)\n-\n set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)\n set(BUILD_SHARED_LIBS OFF)\n set(ENABLE_TESTING OFF)\n@@ -73,6 +76,7 @@ else()\n URL https://github.com/Mbed-TLS/mbedtls/releases/download/mbedtls-3.6.5/mbedtls-3.6.5.tar.bz2\n URL_HASH SHA256=4a11f1777bb95bf4ad96721cac945a26e04bf19f57d905f241fe77ebeddf46d8\n DOWNLOAD_NO_PROGRESS ON\n+ OVERRIDE_FIND_PACKAGE\n # patch out parts we don't want of the MbedTLS CMake configuration and write to configuration files\n # - disable building 3rdparty targets\n # - add CMAKE_DEBUG_POSTFIX\n@@ -82,23 +86,51 @@ else()\n FetchContent_MakeAvailable(MbedTLS)\n endblock()\n \n- set_target_properties(mbedtls mbedcrypto mbedx509 PROPERTIES FOLDER \"Dependencies\" SYSTEM ON)\n+ # use a block to scope option variables we have to set\n+ block()\n+ set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)\n+ set(BUILD_SHARED_LIBS OFF)\n+ set(BUILD_EXAMPLES OFF)\n+ set(BUILD_TESTING OFF)\n+ set(CRYPTO_BACKEND \"mbedTLS\" CACHE STRING \"\")\n+ set(LIBSSH2_NO_DEPRECATED ON)\n+ set(LIBSSH2_BUILD_DOCS OFF)\n+\n+ FetchContent_Declare(libssh2\n+ URL https://github.com/libssh2/libssh2/archive/704299e997bf518375dc9222670c57b800ac59e6.tar.gz\n+ URL_HASH SHA256=10c3a28bf3099b2a4a6c21a7f4a180fb1bacf5ee6560ccc5542e62f762b2f4f1\n+ DOWNLOAD_NO_PROGRESS ON\n+ # patch broken parts of libssh2\n+ # - Fix returning a pointer to stack memory by forcing libssh to make a copy of it instead\n+ PATCH_COMMAND ${CMAKE_COMMAND} -DLIBSSH2_DIR=${FETCHCONTENT_BASE_DIR}/libssh2-src -DMODULES_DIR=${CMAKE_CURRENT_LIST_DIR}/../../../cmake/Modules -P ${PROJECT_SOURCE_DIR}/tools/libssh2/PatchLibssh2.cmake)\n+ FetchContent_MakeAvailable(libssh2)\n+ endblock()\n+\n+ set_target_properties(mbedtls mbedcrypto mbedx509 libssh2_static PROPERTIES FOLDER \"Dependencies\" SYSTEM ON)\n \n # if building SFML as a shared library or on android (where exes are shared libs) and linking our dependencies in\n # as static libraries we need to build them with -fPIC\n if(BUILD_SHARED_LIBS OR SFML_OS_ANDROID)\n- set_target_properties(mbedtls mbedcrypto mbedx509 PROPERTIES POSITION_INDEPENDENT_CODE ON)\n+ set_target_properties(mbedtls mbedcrypto mbedx509 libssh2_static PROPERTIES POSITION_INDEPENDENT_CODE ON)\n endif()\n \n # disable building dependencies as part of a unity build, they don't support it\n- set_target_properties(mbedtls mbedcrypto mbedx509 PROPERTIES UNITY_BUILD OFF)\n+ set_target_properties(mbedtls mbedcrypto mbedx509 libssh2_static PROPERTIES UNITY_BUILD OFF)\n \n sfml_set_stdlib(mbedtls)\n sfml_set_stdlib(mbedcrypto)\n sfml_set_stdlib(mbedx509)\n+ sfml_set_stdlib(libssh2_static)\n+\n+ # Set libssh2 to include/link to MbedTLS\n+ target_compile_definitions(libssh2_static PRIVATE LIBSSH2_MBEDTLS)\n+ target_include_directories(libssh2_static PRIVATE \"${FETCHCONTENT_BASE_DIR}/mbedtls-src/include\")\n+\n+ # Disable all warnings\n+ target_compile_options(libssh2_static PRIVATE -w)\n endif()\n \n-target_link_libraries(sfml-network PRIVATE mbedtls mbedcrypto mbedx509)\n+target_link_libraries(sfml-network PRIVATE libssh2::libssh2 mbedtls mbedcrypto mbedx509)\n \n if(SFML_OS_WINDOWS)\n target_include_directories(sfml-network SYSTEM PRIVATE \"${PROJECT_SOURCE_DIR}/extlibs/headers/wepoll\")\n"},"changed_files":{"kind":"list like","value":["src/SFML/Network/CMakeLists.txt"],"string":"[\n \"src/SFML/Network/CMakeLists.txt\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"How come?","path":"src/SFML/Network/CMakeLists.txt","hunk":"@@ -69,6 +72,7 @@ else()\n URL https://github.com/Mbed-TLS/mbedtls/releases/download/mbedtls-3.6.5/mbedtls-3.6.5.tar.bz2\n URL_HASH SHA256=4a11f1777bb95bf4ad96721cac945a26e04bf19f57d905f241fe77ebeddf46d8\n DOWNLOAD_NO_PROGRESS ON\n+ OVERRIDE_FIND_PACKAGE","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/src/SFML/Network/CMakeLists.txt b/src/SFML/Network/CMakeLists.txt\nindex 076b4459e9..d62e802b76 100644\n--- a/src/SFML/Network/CMakeLists.txt\n+++ b/src/SFML/Network/CMakeLists.txt\n@@ -14,6 +14,8 @@ set(SRC\n ${INCROOT}/IpAddress.hpp\n ${SRCROOT}/Packet.cpp\n ${INCROOT}/Packet.hpp\n+ ${SRCROOT}/Sftp.cpp\n+ ${INCROOT}/Sftp.hpp\n ${SRCROOT}/Socket.cpp\n ${INCROOT}/Socket.hpp\n ${SRCROOT}/SocketImpl.hpp\n@@ -56,11 +58,12 @@ endif()\n \n if(SFML_USE_SYSTEM_DEPS)\n find_package(MbedTLS REQUIRED)\n+ find_package(Libssh2 REQUIRED)\n else()\n+ include(FetchContent)\n+\n # use a block to scope option variables we have to set\n block()\n- include(FetchContent)\n-\n set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)\n set(BUILD_SHARED_LIBS OFF)\n set(ENABLE_TESTING OFF)\n@@ -73,6 +76,7 @@ else()\n URL https://github.com/Mbed-TLS/mbedtls/releases/download/mbedtls-3.6.5/mbedtls-3.6.5.tar.bz2\n URL_HASH SHA256=4a11f1777bb95bf4ad96721cac945a26e04bf19f57d905f241fe77ebeddf46d8\n DOWNLOAD_NO_PROGRESS ON\n+ OVERRIDE_FIND_PACKAGE\n # patch out parts we don't want of the MbedTLS CMake configuration and write to configuration files\n # - disable building 3rdparty targets\n # - add CMAKE_DEBUG_POSTFIX\n@@ -82,23 +86,51 @@ else()\n FetchContent_MakeAvailable(MbedTLS)\n endblock()\n \n- set_target_properties(mbedtls mbedcrypto mbedx509 PROPERTIES FOLDER \"Dependencies\" SYSTEM ON)\n+ # use a block to scope option variables we have to set\n+ block()\n+ set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)\n+ set(BUILD_SHARED_LIBS OFF)\n+ set(BUILD_EXAMPLES OFF)\n+ set(BUILD_TESTING OFF)\n+ set(CRYPTO_BACKEND \"mbedTLS\" CACHE STRING \"\")\n+ set(LIBSSH2_NO_DEPRECATED ON)\n+ set(LIBSSH2_BUILD_DOCS OFF)\n+\n+ FetchContent_Declare(libssh2\n+ URL https://github.com/libssh2/libssh2/archive/704299e997bf518375dc9222670c57b800ac59e6.tar.gz\n+ URL_HASH SHA256=10c3a28bf3099b2a4a6c21a7f4a180fb1bacf5ee6560ccc5542e62f762b2f4f1\n+ DOWNLOAD_NO_PROGRESS ON\n+ # patch broken parts of libssh2\n+ # - Fix returning a pointer to stack memory by forcing libssh to make a copy of it instead\n+ PATCH_COMMAND ${CMAKE_COMMAND} -DLIBSSH2_DIR=${FETCHCONTENT_BASE_DIR}/libssh2-src -DMODULES_DIR=${CMAKE_CURRENT_LIST_DIR}/../../../cmake/Modules -P ${PROJECT_SOURCE_DIR}/tools/libssh2/PatchLibssh2.cmake)\n+ FetchContent_MakeAvailable(libssh2)\n+ endblock()\n+\n+ set_target_properties(mbedtls mbedcrypto mbedx509 libssh2_static PROPERTIES FOLDER \"Dependencies\" SYSTEM ON)\n \n # if building SFML as a shared library or on android (where exes are shared libs) and linking our dependencies in\n # as static libraries we need to build them with -fPIC\n if(BUILD_SHARED_LIBS OR SFML_OS_ANDROID)\n- set_target_properties(mbedtls mbedcrypto mbedx509 PROPERTIES POSITION_INDEPENDENT_CODE ON)\n+ set_target_properties(mbedtls mbedcrypto mbedx509 libssh2_static PROPERTIES POSITION_INDEPENDENT_CODE ON)\n endif()\n \n # disable building dependencies as part of a unity build, they don't support it\n- set_target_properties(mbedtls mbedcrypto mbedx509 PROPERTIES UNITY_BUILD OFF)\n+ set_target_properties(mbedtls mbedcrypto mbedx509 libssh2_static PROPERTIES UNITY_BUILD OFF)\n \n sfml_set_stdlib(mbedtls)\n sfml_set_stdlib(mbedcrypto)\n sfml_set_stdlib(mbedx509)\n+ sfml_set_stdlib(libssh2_static)\n+\n+ # Set libssh2 to include/link to MbedTLS\n+ target_compile_definitions(libssh2_static PRIVATE LIBSSH2_MBEDTLS)\n+ target_include_directories(libssh2_static PRIVATE \"${FETCHCONTENT_BASE_DIR}/mbedtls-src/include\")\n+\n+ # Disable all warnings\n+ target_compile_options(libssh2_static PRIVATE -w)\n endif()\n \n-target_link_libraries(sfml-network PRIVATE mbedtls mbedcrypto mbedx509)\n+target_link_libraries(sfml-network PRIVATE libssh2::libssh2 mbedtls mbedcrypto mbedx509)\n \n if(SFML_OS_WINDOWS)\n target_include_directories(sfml-network SYSTEM PRIVATE \"${PROJECT_SOURCE_DIR}/extlibs/headers/wepoll\")\n"}],"string":"[\n {\n \"comment\": \"How come?\",\n \"path\": \"src/SFML/Network/CMakeLists.txt\",\n \"hunk\": \"@@ -69,6 +72,7 @@ else()\\n URL https://github.com/Mbed-TLS/mbedtls/releases/download/mbedtls-3.6.5/mbedtls-3.6.5.tar.bz2\\n URL_HASH SHA256=4a11f1777bb95bf4ad96721cac945a26e04bf19f57d905f241fe77ebeddf46d8\\n DOWNLOAD_NO_PROGRESS ON\\n+ OVERRIDE_FIND_PACKAGE\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/src/SFML/Network/CMakeLists.txt b/src/SFML/Network/CMakeLists.txt\\nindex 076b4459e9..d62e802b76 100644\\n--- a/src/SFML/Network/CMakeLists.txt\\n+++ b/src/SFML/Network/CMakeLists.txt\\n@@ -14,6 +14,8 @@ set(SRC\\n ${INCROOT}/IpAddress.hpp\\n ${SRCROOT}/Packet.cpp\\n ${INCROOT}/Packet.hpp\\n+ ${SRCROOT}/Sftp.cpp\\n+ ${INCROOT}/Sftp.hpp\\n ${SRCROOT}/Socket.cpp\\n ${INCROOT}/Socket.hpp\\n ${SRCROOT}/SocketImpl.hpp\\n@@ -56,11 +58,12 @@ endif()\\n \\n if(SFML_USE_SYSTEM_DEPS)\\n find_package(MbedTLS REQUIRED)\\n+ find_package(Libssh2 REQUIRED)\\n else()\\n+ include(FetchContent)\\n+\\n # use a block to scope option variables we have to set\\n block()\\n- include(FetchContent)\\n-\\n set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)\\n set(BUILD_SHARED_LIBS OFF)\\n set(ENABLE_TESTING OFF)\\n@@ -73,6 +76,7 @@ else()\\n URL https://github.com/Mbed-TLS/mbedtls/releases/download/mbedtls-3.6.5/mbedtls-3.6.5.tar.bz2\\n URL_HASH SHA256=4a11f1777bb95bf4ad96721cac945a26e04bf19f57d905f241fe77ebeddf46d8\\n DOWNLOAD_NO_PROGRESS ON\\n+ OVERRIDE_FIND_PACKAGE\\n # patch out parts we don't want of the MbedTLS CMake configuration and write to configuration files\\n # - disable building 3rdparty targets\\n # - add CMAKE_DEBUG_POSTFIX\\n@@ -82,23 +86,51 @@ else()\\n FetchContent_MakeAvailable(MbedTLS)\\n endblock()\\n \\n- set_target_properties(mbedtls mbedcrypto mbedx509 PROPERTIES FOLDER \\\"Dependencies\\\" SYSTEM ON)\\n+ # use a block to scope option variables we have to set\\n+ block()\\n+ set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)\\n+ set(BUILD_SHARED_LIBS OFF)\\n+ set(BUILD_EXAMPLES OFF)\\n+ set(BUILD_TESTING OFF)\\n+ set(CRYPTO_BACKEND \\\"mbedTLS\\\" CACHE STRING \\\"\\\")\\n+ set(LIBSSH2_NO_DEPRECATED ON)\\n+ set(LIBSSH2_BUILD_DOCS OFF)\\n+\\n+ FetchContent_Declare(libssh2\\n+ URL https://github.com/libssh2/libssh2/archive/704299e997bf518375dc9222670c57b800ac59e6.tar.gz\\n+ URL_HASH SHA256=10c3a28bf3099b2a4a6c21a7f4a180fb1bacf5ee6560ccc5542e62f762b2f4f1\\n+ DOWNLOAD_NO_PROGRESS ON\\n+ # patch broken parts of libssh2\\n+ # - Fix returning a pointer to stack memory by forcing libssh to make a copy of it instead\\n+ PATCH_COMMAND ${CMAKE_COMMAND} -DLIBSSH2_DIR=${FETCHCONTENT_BASE_DIR}/libssh2-src -DMODULES_DIR=${CMAKE_CURRENT_LIST_DIR}/../../../cmake/Modules -P ${PROJECT_SOURCE_DIR}/tools/libssh2/PatchLibssh2.cmake)\\n+ FetchContent_MakeAvailable(libssh2)\\n+ endblock()\\n+\\n+ set_target_properties(mbedtls mbedcrypto mbedx509 libssh2_static PROPERTIES FOLDER \\\"Dependencies\\\" SYSTEM ON)\\n \\n # if building SFML as a shared library or on android (where exes are shared libs) and linking our dependencies in\\n # as static libraries we need to build them with -fPIC\\n if(BUILD_SHARED_LIBS OR SFML_OS_ANDROID)\\n- set_target_properties(mbedtls mbedcrypto mbedx509 PROPERTIES POSITION_INDEPENDENT_CODE ON)\\n+ set_target_properties(mbedtls mbedcrypto mbedx509 libssh2_static PROPERTIES POSITION_INDEPENDENT_CODE ON)\\n endif()\\n \\n # disable building dependencies as part of a unity build, they don't support it\\n- set_target_properties(mbedtls mbedcrypto mbedx509 PROPERTIES UNITY_BUILD OFF)\\n+ set_target_properties(mbedtls mbedcrypto mbedx509 libssh2_static PROPERTIES UNITY_BUILD OFF)\\n \\n sfml_set_stdlib(mbedtls)\\n sfml_set_stdlib(mbedcrypto)\\n sfml_set_stdlib(mbedx509)\\n+ sfml_set_stdlib(libssh2_static)\\n+\\n+ # Set libssh2 to include/link to MbedTLS\\n+ target_compile_definitions(libssh2_static PRIVATE LIBSSH2_MBEDTLS)\\n+ target_include_directories(libssh2_static PRIVATE \\\"${FETCHCONTENT_BASE_DIR}/mbedtls-src/include\\\")\\n+\\n+ # Disable all warnings\\n+ target_compile_options(libssh2_static PRIVATE -w)\\n endif()\\n \\n-target_link_libraries(sfml-network PRIVATE mbedtls mbedcrypto mbedx509)\\n+target_link_libraries(sfml-network PRIVATE libssh2::libssh2 mbedtls mbedcrypto mbedx509)\\n \\n if(SFML_OS_WINDOWS)\\n target_include_directories(sfml-network SYSTEM PRIVATE \\\"${PROJECT_SOURCE_DIR}/extlibs/headers/wepoll\\\")\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10078,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"these should be scoped to a target"},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/src/SFML/Network/CMakeLists.txt b/src/SFML/Network/CMakeLists.txt\nindex 076b4459e9..d62e802b76 100644\n--- a/src/SFML/Network/CMakeLists.txt\n+++ b/src/SFML/Network/CMakeLists.txt\n@@ -14,6 +14,8 @@ set(SRC\n ${INCROOT}/IpAddress.hpp\n ${SRCROOT}/Packet.cpp\n ${INCROOT}/Packet.hpp\n+ ${SRCROOT}/Sftp.cpp\n+ ${INCROOT}/Sftp.hpp\n ${SRCROOT}/Socket.cpp\n ${INCROOT}/Socket.hpp\n ${SRCROOT}/SocketImpl.hpp\n@@ -56,11 +58,12 @@ endif()\n \n if(SFML_USE_SYSTEM_DEPS)\n find_package(MbedTLS REQUIRED)\n+ find_package(Libssh2 REQUIRED)\n else()\n+ include(FetchContent)\n+\n # use a block to scope option variables we have to set\n block()\n- include(FetchContent)\n-\n set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)\n set(BUILD_SHARED_LIBS OFF)\n set(ENABLE_TESTING OFF)\n@@ -73,6 +76,7 @@ else()\n URL https://github.com/Mbed-TLS/mbedtls/releases/download/mbedtls-3.6.5/mbedtls-3.6.5.tar.bz2\n URL_HASH SHA256=4a11f1777bb95bf4ad96721cac945a26e04bf19f57d905f241fe77ebeddf46d8\n DOWNLOAD_NO_PROGRESS ON\n+ OVERRIDE_FIND_PACKAGE\n # patch out parts we don't want of the MbedTLS CMake configuration and write to configuration files\n # - disable building 3rdparty targets\n # - add CMAKE_DEBUG_POSTFIX\n@@ -82,23 +86,51 @@ else()\n FetchContent_MakeAvailable(MbedTLS)\n endblock()\n \n- set_target_properties(mbedtls mbedcrypto mbedx509 PROPERTIES FOLDER \"Dependencies\" SYSTEM ON)\n+ # use a block to scope option variables we have to set\n+ block()\n+ set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)\n+ set(BUILD_SHARED_LIBS OFF)\n+ set(BUILD_EXAMPLES OFF)\n+ set(BUILD_TESTING OFF)\n+ set(CRYPTO_BACKEND \"mbedTLS\" CACHE STRING \"\")\n+ set(LIBSSH2_NO_DEPRECATED ON)\n+ set(LIBSSH2_BUILD_DOCS OFF)\n+\n+ FetchContent_Declare(libssh2\n+ URL https://github.com/libssh2/libssh2/archive/704299e997bf518375dc9222670c57b800ac59e6.tar.gz\n+ URL_HASH SHA256=10c3a28bf3099b2a4a6c21a7f4a180fb1bacf5ee6560ccc5542e62f762b2f4f1\n+ DOWNLOAD_NO_PROGRESS ON\n+ # patch broken parts of libssh2\n+ # - Fix returning a pointer to stack memory by forcing libssh to make a copy of it instead\n+ PATCH_COMMAND ${CMAKE_COMMAND} -DLIBSSH2_DIR=${FETCHCONTENT_BASE_DIR}/libssh2-src -DMODULES_DIR=${CMAKE_CURRENT_LIST_DIR}/../../../cmake/Modules -P ${PROJECT_SOURCE_DIR}/tools/libssh2/PatchLibssh2.cmake)\n+ FetchContent_MakeAvailable(libssh2)\n+ endblock()\n+\n+ set_target_properties(mbedtls mbedcrypto mbedx509 libssh2_static PROPERTIES FOLDER \"Dependencies\" SYSTEM ON)\n \n # if building SFML as a shared library or on android (where exes are shared libs) and linking our dependencies in\n # as static libraries we need to build them with -fPIC\n if(BUILD_SHARED_LIBS OR SFML_OS_ANDROID)\n- set_target_properties(mbedtls mbedcrypto mbedx509 PROPERTIES POSITION_INDEPENDENT_CODE ON)\n+ set_target_properties(mbedtls mbedcrypto mbedx509 libssh2_static PROPERTIES POSITION_INDEPENDENT_CODE ON)\n endif()\n \n # disable building dependencies as part of a unity build, they don't support it\n- set_target_properties(mbedtls mbedcrypto mbedx509 PROPERTIES UNITY_BUILD OFF)\n+ set_target_properties(mbedtls mbedcrypto mbedx509 libssh2_static PROPERTIES UNITY_BUILD OFF)\n \n sfml_set_stdlib(mbedtls)\n sfml_set_stdlib(mbedcrypto)\n sfml_set_stdlib(mbedx509)\n+ sfml_set_stdlib(libssh2_static)\n+\n+ # Set libssh2 to include/link to MbedTLS\n+ target_compile_definitions(libssh2_static PRIVATE LIBSSH2_MBEDTLS)\n+ target_include_directories(libssh2_static PRIVATE \"${FETCHCONTENT_BASE_DIR}/mbedtls-src/include\")\n+\n+ # Disable all warnings\n+ target_compile_options(libssh2_static PRIVATE -w)\n endif()\n \n-target_link_libraries(sfml-network PRIVATE mbedtls mbedcrypto mbedx509)\n+target_link_libraries(sfml-network PRIVATE libssh2::libssh2 mbedtls mbedcrypto mbedx509)\n \n if(SFML_OS_WINDOWS)\n target_include_directories(sfml-network SYSTEM PRIVATE \"${PROJECT_SOURCE_DIR}/extlibs/headers/wepoll\")\n"},"changed_files":{"kind":"list like","value":["src/SFML/Network/CMakeLists.txt"],"string":"[\n \"src/SFML/Network/CMakeLists.txt\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"these should be scoped to a target","path":"src/SFML/Network/CMakeLists.txt","hunk":"@@ -78,23 +82,55 @@ else()\n FetchContent_MakeAvailable(MbedTLS)\n endblock()\n \n- set_target_properties(mbedtls mbedcrypto mbedx509 PROPERTIES FOLDER \"Dependencies\" SYSTEM ON)\n+ # use a block to scope option variables we have to set\n+ block()\n+ set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)\n+ set(BUILD_SHARED_LIBS OFF)\n+ set(BUILD_EXAMPLES OFF)\n+ set(BUILD_TESTING OFF)\n+ set(CRYPTO_BACKEND \"mbedTLS\" CACHE STRING \"\")\n+ set(LIBSSH2_NO_DEPRECATED ON)\n+ set(LIBSSH2_BUILD_DOCS OFF)","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/src/SFML/Network/CMakeLists.txt b/src/SFML/Network/CMakeLists.txt\nindex 076b4459e9..d62e802b76 100644\n--- a/src/SFML/Network/CMakeLists.txt\n+++ b/src/SFML/Network/CMakeLists.txt\n@@ -14,6 +14,8 @@ set(SRC\n ${INCROOT}/IpAddress.hpp\n ${SRCROOT}/Packet.cpp\n ${INCROOT}/Packet.hpp\n+ ${SRCROOT}/Sftp.cpp\n+ ${INCROOT}/Sftp.hpp\n ${SRCROOT}/Socket.cpp\n ${INCROOT}/Socket.hpp\n ${SRCROOT}/SocketImpl.hpp\n@@ -56,11 +58,12 @@ endif()\n \n if(SFML_USE_SYSTEM_DEPS)\n find_package(MbedTLS REQUIRED)\n+ find_package(Libssh2 REQUIRED)\n else()\n+ include(FetchContent)\n+\n # use a block to scope option variables we have to set\n block()\n- include(FetchContent)\n-\n set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)\n set(BUILD_SHARED_LIBS OFF)\n set(ENABLE_TESTING OFF)\n@@ -73,6 +76,7 @@ else()\n URL https://github.com/Mbed-TLS/mbedtls/releases/download/mbedtls-3.6.5/mbedtls-3.6.5.tar.bz2\n URL_HASH SHA256=4a11f1777bb95bf4ad96721cac945a26e04bf19f57d905f241fe77ebeddf46d8\n DOWNLOAD_NO_PROGRESS ON\n+ OVERRIDE_FIND_PACKAGE\n # patch out parts we don't want of the MbedTLS CMake configuration and write to configuration files\n # - disable building 3rdparty targets\n # - add CMAKE_DEBUG_POSTFIX\n@@ -82,23 +86,51 @@ else()\n FetchContent_MakeAvailable(MbedTLS)\n endblock()\n \n- set_target_properties(mbedtls mbedcrypto mbedx509 PROPERTIES FOLDER \"Dependencies\" SYSTEM ON)\n+ # use a block to scope option variables we have to set\n+ block()\n+ set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)\n+ set(BUILD_SHARED_LIBS OFF)\n+ set(BUILD_EXAMPLES OFF)\n+ set(BUILD_TESTING OFF)\n+ set(CRYPTO_BACKEND \"mbedTLS\" CACHE STRING \"\")\n+ set(LIBSSH2_NO_DEPRECATED ON)\n+ set(LIBSSH2_BUILD_DOCS OFF)\n+\n+ FetchContent_Declare(libssh2\n+ URL https://github.com/libssh2/libssh2/archive/704299e997bf518375dc9222670c57b800ac59e6.tar.gz\n+ URL_HASH SHA256=10c3a28bf3099b2a4a6c21a7f4a180fb1bacf5ee6560ccc5542e62f762b2f4f1\n+ DOWNLOAD_NO_PROGRESS ON\n+ # patch broken parts of libssh2\n+ # - Fix returning a pointer to stack memory by forcing libssh to make a copy of it instead\n+ PATCH_COMMAND ${CMAKE_COMMAND} -DLIBSSH2_DIR=${FETCHCONTENT_BASE_DIR}/libssh2-src -DMODULES_DIR=${CMAKE_CURRENT_LIST_DIR}/../../../cmake/Modules -P ${PROJECT_SOURCE_DIR}/tools/libssh2/PatchLibssh2.cmake)\n+ FetchContent_MakeAvailable(libssh2)\n+ endblock()\n+\n+ set_target_properties(mbedtls mbedcrypto mbedx509 libssh2_static PROPERTIES FOLDER \"Dependencies\" SYSTEM ON)\n \n # if building SFML as a shared library or on android (where exes are shared libs) and linking our dependencies in\n # as static libraries we need to build them with -fPIC\n if(BUILD_SHARED_LIBS OR SFML_OS_ANDROID)\n- set_target_properties(mbedtls mbedcrypto mbedx509 PROPERTIES POSITION_INDEPENDENT_CODE ON)\n+ set_target_properties(mbedtls mbedcrypto mbedx509 libssh2_static PROPERTIES POSITION_INDEPENDENT_CODE ON)\n endif()\n \n # disable building dependencies as part of a unity build, they don't support it\n- set_target_properties(mbedtls mbedcrypto mbedx509 PROPERTIES UNITY_BUILD OFF)\n+ set_target_properties(mbedtls mbedcrypto mbedx509 libssh2_static PROPERTIES UNITY_BUILD OFF)\n \n sfml_set_stdlib(mbedtls)\n sfml_set_stdlib(mbedcrypto)\n sfml_set_stdlib(mbedx509)\n+ sfml_set_stdlib(libssh2_static)\n+\n+ # Set libssh2 to include/link to MbedTLS\n+ target_compile_definitions(libssh2_static PRIVATE LIBSSH2_MBEDTLS)\n+ target_include_directories(libssh2_static PRIVATE \"${FETCHCONTENT_BASE_DIR}/mbedtls-src/include\")\n+\n+ # Disable all warnings\n+ target_compile_options(libssh2_static PRIVATE -w)\n endif()\n \n-target_link_libraries(sfml-network PRIVATE mbedtls mbedcrypto mbedx509)\n+target_link_libraries(sfml-network PRIVATE libssh2::libssh2 mbedtls mbedcrypto mbedx509)\n \n if(SFML_OS_WINDOWS)\n target_include_directories(sfml-network SYSTEM PRIVATE \"${PROJECT_SOURCE_DIR}/extlibs/headers/wepoll\")\n"}],"string":"[\n {\n \"comment\": \"these should be scoped to a target\",\n \"path\": \"src/SFML/Network/CMakeLists.txt\",\n \"hunk\": \"@@ -78,23 +82,55 @@ else()\\n FetchContent_MakeAvailable(MbedTLS)\\n endblock()\\n \\n- set_target_properties(mbedtls mbedcrypto mbedx509 PROPERTIES FOLDER \\\"Dependencies\\\" SYSTEM ON)\\n+ # use a block to scope option variables we have to set\\n+ block()\\n+ set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)\\n+ set(BUILD_SHARED_LIBS OFF)\\n+ set(BUILD_EXAMPLES OFF)\\n+ set(BUILD_TESTING OFF)\\n+ set(CRYPTO_BACKEND \\\"mbedTLS\\\" CACHE STRING \\\"\\\")\\n+ set(LIBSSH2_NO_DEPRECATED ON)\\n+ set(LIBSSH2_BUILD_DOCS OFF)\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/src/SFML/Network/CMakeLists.txt b/src/SFML/Network/CMakeLists.txt\\nindex 076b4459e9..d62e802b76 100644\\n--- a/src/SFML/Network/CMakeLists.txt\\n+++ b/src/SFML/Network/CMakeLists.txt\\n@@ -14,6 +14,8 @@ set(SRC\\n ${INCROOT}/IpAddress.hpp\\n ${SRCROOT}/Packet.cpp\\n ${INCROOT}/Packet.hpp\\n+ ${SRCROOT}/Sftp.cpp\\n+ ${INCROOT}/Sftp.hpp\\n ${SRCROOT}/Socket.cpp\\n ${INCROOT}/Socket.hpp\\n ${SRCROOT}/SocketImpl.hpp\\n@@ -56,11 +58,12 @@ endif()\\n \\n if(SFML_USE_SYSTEM_DEPS)\\n find_package(MbedTLS REQUIRED)\\n+ find_package(Libssh2 REQUIRED)\\n else()\\n+ include(FetchContent)\\n+\\n # use a block to scope option variables we have to set\\n block()\\n- include(FetchContent)\\n-\\n set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)\\n set(BUILD_SHARED_LIBS OFF)\\n set(ENABLE_TESTING OFF)\\n@@ -73,6 +76,7 @@ else()\\n URL https://github.com/Mbed-TLS/mbedtls/releases/download/mbedtls-3.6.5/mbedtls-3.6.5.tar.bz2\\n URL_HASH SHA256=4a11f1777bb95bf4ad96721cac945a26e04bf19f57d905f241fe77ebeddf46d8\\n DOWNLOAD_NO_PROGRESS ON\\n+ OVERRIDE_FIND_PACKAGE\\n # patch out parts we don't want of the MbedTLS CMake configuration and write to configuration files\\n # - disable building 3rdparty targets\\n # - add CMAKE_DEBUG_POSTFIX\\n@@ -82,23 +86,51 @@ else()\\n FetchContent_MakeAvailable(MbedTLS)\\n endblock()\\n \\n- set_target_properties(mbedtls mbedcrypto mbedx509 PROPERTIES FOLDER \\\"Dependencies\\\" SYSTEM ON)\\n+ # use a block to scope option variables we have to set\\n+ block()\\n+ set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)\\n+ set(BUILD_SHARED_LIBS OFF)\\n+ set(BUILD_EXAMPLES OFF)\\n+ set(BUILD_TESTING OFF)\\n+ set(CRYPTO_BACKEND \\\"mbedTLS\\\" CACHE STRING \\\"\\\")\\n+ set(LIBSSH2_NO_DEPRECATED ON)\\n+ set(LIBSSH2_BUILD_DOCS OFF)\\n+\\n+ FetchContent_Declare(libssh2\\n+ URL https://github.com/libssh2/libssh2/archive/704299e997bf518375dc9222670c57b800ac59e6.tar.gz\\n+ URL_HASH SHA256=10c3a28bf3099b2a4a6c21a7f4a180fb1bacf5ee6560ccc5542e62f762b2f4f1\\n+ DOWNLOAD_NO_PROGRESS ON\\n+ # patch broken parts of libssh2\\n+ # - Fix returning a pointer to stack memory by forcing libssh to make a copy of it instead\\n+ PATCH_COMMAND ${CMAKE_COMMAND} -DLIBSSH2_DIR=${FETCHCONTENT_BASE_DIR}/libssh2-src -DMODULES_DIR=${CMAKE_CURRENT_LIST_DIR}/../../../cmake/Modules -P ${PROJECT_SOURCE_DIR}/tools/libssh2/PatchLibssh2.cmake)\\n+ FetchContent_MakeAvailable(libssh2)\\n+ endblock()\\n+\\n+ set_target_properties(mbedtls mbedcrypto mbedx509 libssh2_static PROPERTIES FOLDER \\\"Dependencies\\\" SYSTEM ON)\\n \\n # if building SFML as a shared library or on android (where exes are shared libs) and linking our dependencies in\\n # as static libraries we need to build them with -fPIC\\n if(BUILD_SHARED_LIBS OR SFML_OS_ANDROID)\\n- set_target_properties(mbedtls mbedcrypto mbedx509 PROPERTIES POSITION_INDEPENDENT_CODE ON)\\n+ set_target_properties(mbedtls mbedcrypto mbedx509 libssh2_static PROPERTIES POSITION_INDEPENDENT_CODE ON)\\n endif()\\n \\n # disable building dependencies as part of a unity build, they don't support it\\n- set_target_properties(mbedtls mbedcrypto mbedx509 PROPERTIES UNITY_BUILD OFF)\\n+ set_target_properties(mbedtls mbedcrypto mbedx509 libssh2_static PROPERTIES UNITY_BUILD OFF)\\n \\n sfml_set_stdlib(mbedtls)\\n sfml_set_stdlib(mbedcrypto)\\n sfml_set_stdlib(mbedx509)\\n+ sfml_set_stdlib(libssh2_static)\\n+\\n+ # Set libssh2 to include/link to MbedTLS\\n+ target_compile_definitions(libssh2_static PRIVATE LIBSSH2_MBEDTLS)\\n+ target_include_directories(libssh2_static PRIVATE \\\"${FETCHCONTENT_BASE_DIR}/mbedtls-src/include\\\")\\n+\\n+ # Disable all warnings\\n+ target_compile_options(libssh2_static PRIVATE -w)\\n endif()\\n \\n-target_link_libraries(sfml-network PRIVATE mbedtls mbedcrypto mbedx509)\\n+target_link_libraries(sfml-network PRIVATE libssh2::libssh2 mbedtls mbedcrypto mbedx509)\\n \\n if(SFML_OS_WINDOWS)\\n target_include_directories(sfml-network SYSTEM PRIVATE \\\"${PROJECT_SOURCE_DIR}/extlibs/headers/wepoll\\\")\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10079,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"How come the formatting was turned off for just this line?"},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"},"changed_files":{"kind":"list like","value":["src/SFML/Network/Sftp.cpp"],"string":"[\n \"src/SFML/Network/Sftp.cpp\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"How come the formatting was turned off for just this line?","path":"src/SFML/Network/Sftp.cpp","hunk":"@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+// clang-format off\n+#include <libssh2_sftp.h>\n+// clang-format on","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"}],"string":"[\n {\n \"comment\": \"How come the formatting was turned off for just this line?\",\n \"path\": \"src/SFML/Network/Sftp.cpp\",\n \"hunk\": \"@@ -0,0 +1,1377 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+// clang-format off\\n+#include <libssh2_sftp.h>\\n+// clang-format on\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\\nnew file mode 100644\\nindex 0000000000..95ab95a45e\\n--- /dev/null\\n+++ b/src/SFML/Network/Sftp.cpp\\n@@ -0,0 +1,1347 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+#include <SFML/System/Err.hpp>\\n+\\n+#include <libssh2_sftp.h>\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <ostream>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ libssh2_exit();\\n+ }\\n+\\n+ static inline std::mutex mutex;\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::Error, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::EndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::NoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::PermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::Failure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::BadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::NoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::ConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::OperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::InvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::NoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::WriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::NoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::QuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::LockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::NotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::InvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::LinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl : LibSsh2Initializer\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\\n+ {\\n+ const auto result = waitForOperationComplete(\\n+ [&]\\n+ {\\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\\n+\\n+ if (sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ bool posixRenameSupported = true;\\n+ std::filesystem::path cachedHomePath;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\\n+{\\n+ // Clear the cached home path\\n+ m_impl->cachedHomePath.clear();\\n+\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length == 0)\\n+ return std::nullopt;\\n+\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ err() << \\\"SFTP: Cannot get session information, session not yet started\\\" << std::endl;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Ensure the passphrase is NULL-terminated\\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\\n+ return login(name,\\n+ publicKeyData.data(),\\n+ publicKeyData.length(),\\n+ privateKeyData.data(),\\n+ privateKeyData.length(),\\n+ privateKeyPassphraseString.c_str(),\\n+ timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Check if we already cached the result for the home path\\n+ if ((path == \\\".\\\") && !m_impl->cachedHomePath.empty())\\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\\n+ .generic_u8string();\\n+\\n+ // Cache the result for the home path\\n+ if (path == \\\".\\\")\\n+ m_impl->cachedHomePath = genericPath;\\n+\\n+ return {Result(Result::Value::Success), genericPath};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\\n+ &attributes);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ {\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ 0,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENDIR);\\n+\\n+ if (handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (!handle)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+ }\\n+\\n+ std::vector<Attributes> listing;\\n+\\n+ {\\n+ std::array<char, 4096> buffer{};\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\\n+ timeout);\\n+\\n+ if (result > 0)\\n+ {\\n+ listing.emplace_back(\\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\\n+ attributes));\\n+\\n+ continue;\\n+ }\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ if (result == 0)\\n+ break;\\n+ }\\n+ }\\n+\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ return {Result(Result::Value::Success), std::move(listing)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\\n+ std::filesystem::perms permissions,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ makePermissions(permissions));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto oldPathString = oldPath.generic_u8string();\\n+ const auto newPathString = newPath.generic_u8string();\\n+\\n+ // POSIX rename is only supported starting from libssh2 1.11.1\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // POSIX rename doesn't support not overwriting\\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\\n+#endif\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ if (usePosix)\\n+ {\\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()));\\n+ }\\n+#endif\\n+\\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()),\\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // Retry using normal rename if we find out POSIX rename isn't supported\\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\\n+ {\\n+ m_impl->posixRenameSupported = false;\\n+ usePosix = false;\\n+ continue;\\n+ }\\n+#endif\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for reading\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ LIBSSH2_FXF_READ,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Read from the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ auto* ptr = buffer.get();\\n+ int read{};\\n+ std::size_t totalRead{};\\n+\\n+ while (length > 0)\\n+ {\\n+ read = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (read == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (read <= 0)\\n+ break;\\n+\\n+ ptr += read;\\n+ length -= static_cast<std::size_t>(read);\\n+ totalRead += static_cast<std::size_t>(read);\\n+ }\\n+\\n+ if (read < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ const auto stop = !callback(buffer.get(), totalRead);\\n+\\n+ // If read is 0 then we have reached EOF\\n+ if (stop || (read == 0))\\n+ break;\\n+\\n+ const auto expand = (totalRead == bufferSize);\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions,\\n+ bool truncate,\\n+ bool append,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for writing\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\\n+ makePermissions(permissions),\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Write to the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ const auto stop = !callback(buffer.get(), length);\\n+ const auto expand = (length == bufferSize);\\n+ const auto* ptr = buffer.get();\\n+ int written{};\\n+\\n+ while (length > 0)\\n+ {\\n+ written = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (written == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (written < 0)\\n+ break;\\n+\\n+ ptr += written;\\n+ length -= static_cast<std::size_t>(written);\\n+ }\\n+\\n+ if (written < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ if (stop)\\n+ break;\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+} // namespace sf\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10080,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"Do we need to take into account sender vs. receiver time zone here?"},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"},"changed_files":{"kind":"list like","value":["src/SFML/Network/Sftp.cpp"],"string":"[\n \"src/SFML/Network/Sftp.cpp\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"Do we need to take into account sender vs. receiver time zone here?","path":"src/SFML/Network/Sftp.cpp","hunk":"@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+// clang-format off\n+#include <libssh2_sftp.h>\n+// clang-format on\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ libssh2_exit();\n+ }\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\n+{\n+ static std::mutex mutex;\n+ const std::lock_guard lock(mutex);\n+\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\n+ auto sharedPtr = weakPtr.lock();\n+\n+ if (sharedPtr)\n+ return sharedPtr;\n+\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\n+ weakPtr = sharedPtr;\n+\n+ return sharedPtr;\n+}\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"}],"string":"[\n {\n \"comment\": \"Do we need to take into account sender vs. receiver time zone here?\",\n \"path\": \"src/SFML/Network/Sftp.cpp\",\n \"hunk\": \"@@ -0,0 +1,1377 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+// clang-format off\\n+#include <libssh2_sftp.h>\\n+// clang-format on\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ libssh2_exit();\\n+ }\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\\n+{\\n+ static std::mutex mutex;\\n+ const std::lock_guard lock(mutex);\\n+\\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\\n+ auto sharedPtr = weakPtr.lock();\\n+\\n+ if (sharedPtr)\\n+ return sharedPtr;\\n+\\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\\n+ weakPtr = sharedPtr;\\n+\\n+ return sharedPtr;\\n+}\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\\nnew file mode 100644\\nindex 0000000000..95ab95a45e\\n--- /dev/null\\n+++ b/src/SFML/Network/Sftp.cpp\\n@@ -0,0 +1,1347 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+#include <SFML/System/Err.hpp>\\n+\\n+#include <libssh2_sftp.h>\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <ostream>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ libssh2_exit();\\n+ }\\n+\\n+ static inline std::mutex mutex;\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::Error, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::EndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::NoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::PermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::Failure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::BadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::NoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::ConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::OperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::InvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::NoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::WriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::NoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::QuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::LockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::NotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::InvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::LinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl : LibSsh2Initializer\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\\n+ {\\n+ const auto result = waitForOperationComplete(\\n+ [&]\\n+ {\\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\\n+\\n+ if (sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ bool posixRenameSupported = true;\\n+ std::filesystem::path cachedHomePath;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\\n+{\\n+ // Clear the cached home path\\n+ m_impl->cachedHomePath.clear();\\n+\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length == 0)\\n+ return std::nullopt;\\n+\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ err() << \\\"SFTP: Cannot get session information, session not yet started\\\" << std::endl;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Ensure the passphrase is NULL-terminated\\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\\n+ return login(name,\\n+ publicKeyData.data(),\\n+ publicKeyData.length(),\\n+ privateKeyData.data(),\\n+ privateKeyData.length(),\\n+ privateKeyPassphraseString.c_str(),\\n+ timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Check if we already cached the result for the home path\\n+ if ((path == \\\".\\\") && !m_impl->cachedHomePath.empty())\\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\\n+ .generic_u8string();\\n+\\n+ // Cache the result for the home path\\n+ if (path == \\\".\\\")\\n+ m_impl->cachedHomePath = genericPath;\\n+\\n+ return {Result(Result::Value::Success), genericPath};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\\n+ &attributes);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ {\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ 0,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENDIR);\\n+\\n+ if (handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (!handle)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+ }\\n+\\n+ std::vector<Attributes> listing;\\n+\\n+ {\\n+ std::array<char, 4096> buffer{};\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\\n+ timeout);\\n+\\n+ if (result > 0)\\n+ {\\n+ listing.emplace_back(\\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\\n+ attributes));\\n+\\n+ continue;\\n+ }\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ if (result == 0)\\n+ break;\\n+ }\\n+ }\\n+\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ return {Result(Result::Value::Success), std::move(listing)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\\n+ std::filesystem::perms permissions,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ makePermissions(permissions));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto oldPathString = oldPath.generic_u8string();\\n+ const auto newPathString = newPath.generic_u8string();\\n+\\n+ // POSIX rename is only supported starting from libssh2 1.11.1\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // POSIX rename doesn't support not overwriting\\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\\n+#endif\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ if (usePosix)\\n+ {\\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()));\\n+ }\\n+#endif\\n+\\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()),\\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // Retry using normal rename if we find out POSIX rename isn't supported\\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\\n+ {\\n+ m_impl->posixRenameSupported = false;\\n+ usePosix = false;\\n+ continue;\\n+ }\\n+#endif\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for reading\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ LIBSSH2_FXF_READ,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Read from the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ auto* ptr = buffer.get();\\n+ int read{};\\n+ std::size_t totalRead{};\\n+\\n+ while (length > 0)\\n+ {\\n+ read = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (read == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (read <= 0)\\n+ break;\\n+\\n+ ptr += read;\\n+ length -= static_cast<std::size_t>(read);\\n+ totalRead += static_cast<std::size_t>(read);\\n+ }\\n+\\n+ if (read < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ const auto stop = !callback(buffer.get(), totalRead);\\n+\\n+ // If read is 0 then we have reached EOF\\n+ if (stop || (read == 0))\\n+ break;\\n+\\n+ const auto expand = (totalRead == bufferSize);\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions,\\n+ bool truncate,\\n+ bool append,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for writing\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\\n+ makePermissions(permissions),\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Write to the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ const auto stop = !callback(buffer.get(), length);\\n+ const auto expand = (length == bufferSize);\\n+ const auto* ptr = buffer.get();\\n+ int written{};\\n+\\n+ while (length > 0)\\n+ {\\n+ written = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (written == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (written < 0)\\n+ break;\\n+\\n+ ptr += written;\\n+ length -= static_cast<std::size_t>(written);\\n+ }\\n+\\n+ if (written < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ if (stop)\\n+ break;\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+} // namespace sf\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10081,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"This error message could be more precise; we know we've got a nullptr."},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"},"changed_files":{"kind":"list like","value":["src/SFML/Network/Sftp.cpp"],"string":"[\n \"src/SFML/Network/Sftp.cpp\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"This error message could be more precise; we know we've got a nullptr.","path":"src/SFML/Network/Sftp.cpp","hunk":"@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+// clang-format off\n+#include <libssh2_sftp.h>\n+// clang-format on\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ libssh2_exit();\n+ }\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\n+{\n+ static std::mutex mutex;\n+ const std::lock_guard lock(mutex);\n+\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\n+ auto sharedPtr = weakPtr.lock();\n+\n+ if (sharedPtr)\n+ return sharedPtr;\n+\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\n+ weakPtr = sharedPtr;\n+\n+ return sharedPtr;\n+}\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"}],"string":"[\n {\n \"comment\": \"This error message could be more precise; we know we've got a nullptr.\",\n \"path\": \"src/SFML/Network/Sftp.cpp\",\n \"hunk\": \"@@ -0,0 +1,1377 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+// clang-format off\\n+#include <libssh2_sftp.h>\\n+// clang-format on\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ libssh2_exit();\\n+ }\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\\n+{\\n+ static std::mutex mutex;\\n+ const std::lock_guard lock(mutex);\\n+\\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\\n+ auto sharedPtr = weakPtr.lock();\\n+\\n+ if (sharedPtr)\\n+ return sharedPtr;\\n+\\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\\n+ weakPtr = sharedPtr;\\n+\\n+ return sharedPtr;\\n+}\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\\nnew file mode 100644\\nindex 0000000000..95ab95a45e\\n--- /dev/null\\n+++ b/src/SFML/Network/Sftp.cpp\\n@@ -0,0 +1,1347 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+#include <SFML/System/Err.hpp>\\n+\\n+#include <libssh2_sftp.h>\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <ostream>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ libssh2_exit();\\n+ }\\n+\\n+ static inline std::mutex mutex;\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::Error, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::EndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::NoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::PermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::Failure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::BadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::NoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::ConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::OperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::InvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::NoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::WriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::NoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::QuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::LockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::NotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::InvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::LinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl : LibSsh2Initializer\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\\n+ {\\n+ const auto result = waitForOperationComplete(\\n+ [&]\\n+ {\\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\\n+\\n+ if (sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ bool posixRenameSupported = true;\\n+ std::filesystem::path cachedHomePath;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\\n+{\\n+ // Clear the cached home path\\n+ m_impl->cachedHomePath.clear();\\n+\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length == 0)\\n+ return std::nullopt;\\n+\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ err() << \\\"SFTP: Cannot get session information, session not yet started\\\" << std::endl;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Ensure the passphrase is NULL-terminated\\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\\n+ return login(name,\\n+ publicKeyData.data(),\\n+ publicKeyData.length(),\\n+ privateKeyData.data(),\\n+ privateKeyData.length(),\\n+ privateKeyPassphraseString.c_str(),\\n+ timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Check if we already cached the result for the home path\\n+ if ((path == \\\".\\\") && !m_impl->cachedHomePath.empty())\\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\\n+ .generic_u8string();\\n+\\n+ // Cache the result for the home path\\n+ if (path == \\\".\\\")\\n+ m_impl->cachedHomePath = genericPath;\\n+\\n+ return {Result(Result::Value::Success), genericPath};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\\n+ &attributes);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ {\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ 0,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENDIR);\\n+\\n+ if (handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (!handle)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+ }\\n+\\n+ std::vector<Attributes> listing;\\n+\\n+ {\\n+ std::array<char, 4096> buffer{};\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\\n+ timeout);\\n+\\n+ if (result > 0)\\n+ {\\n+ listing.emplace_back(\\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\\n+ attributes));\\n+\\n+ continue;\\n+ }\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ if (result == 0)\\n+ break;\\n+ }\\n+ }\\n+\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ return {Result(Result::Value::Success), std::move(listing)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\\n+ std::filesystem::perms permissions,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ makePermissions(permissions));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto oldPathString = oldPath.generic_u8string();\\n+ const auto newPathString = newPath.generic_u8string();\\n+\\n+ // POSIX rename is only supported starting from libssh2 1.11.1\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // POSIX rename doesn't support not overwriting\\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\\n+#endif\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ if (usePosix)\\n+ {\\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()));\\n+ }\\n+#endif\\n+\\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()),\\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // Retry using normal rename if we find out POSIX rename isn't supported\\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\\n+ {\\n+ m_impl->posixRenameSupported = false;\\n+ usePosix = false;\\n+ continue;\\n+ }\\n+#endif\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for reading\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ LIBSSH2_FXF_READ,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Read from the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ auto* ptr = buffer.get();\\n+ int read{};\\n+ std::size_t totalRead{};\\n+\\n+ while (length > 0)\\n+ {\\n+ read = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (read == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (read <= 0)\\n+ break;\\n+\\n+ ptr += read;\\n+ length -= static_cast<std::size_t>(read);\\n+ totalRead += static_cast<std::size_t>(read);\\n+ }\\n+\\n+ if (read < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ const auto stop = !callback(buffer.get(), totalRead);\\n+\\n+ // If read is 0 then we have reached EOF\\n+ if (stop || (read == 0))\\n+ break;\\n+\\n+ const auto expand = (totalRead == bufferSize);\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions,\\n+ bool truncate,\\n+ bool append,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for writing\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\\n+ makePermissions(permissions),\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Write to the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ const auto stop = !callback(buffer.get(), length);\\n+ const auto expand = (length == bufferSize);\\n+ const auto* ptr = buffer.get();\\n+ int written{};\\n+\\n+ while (length > 0)\\n+ {\\n+ written = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (written == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (written < 0)\\n+ break;\\n+\\n+ ptr += written;\\n+ length -= static_cast<std::size_t>(written);\\n+ }\\n+\\n+ if (written < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ if (stop)\\n+ break;\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+} // namespace sf\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10082,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"When would you not want to pass the sftp pointer?\nWould it be better to use an optional here rather than nullptr; easier to spot that it might not have a value later down the line."},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"},"changed_files":{"kind":"list like","value":["src/SFML/Network/Sftp.cpp"],"string":"[\n \"src/SFML/Network/Sftp.cpp\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"When would you not want to pass the sftp pointer?\nWould it be better to use an optional here rather than nullptr; easier to spot that it might not have a value later down the line.","path":"src/SFML/Network/Sftp.cpp","hunk":"@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+// clang-format off\n+#include <libssh2_sftp.h>\n+// clang-format on\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ libssh2_exit();\n+ }\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\n+{\n+ static std::mutex mutex;\n+ const std::lock_guard lock(mutex);\n+\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\n+ auto sharedPtr = weakPtr.lock();\n+\n+ if (sharedPtr)\n+ return sharedPtr;\n+\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\n+ weakPtr = sharedPtr;\n+\n+ return sharedPtr;\n+}\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::SftpFailure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::SftpBadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::SftpNoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::SftpNoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::SftpLockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"}],"string":"[\n {\n \"comment\": \"When would you not want to pass the sftp pointer?\\nWould it be better to use an optional here rather than nullptr; easier to spot that it might not have a value later down the line.\",\n \"path\": \"src/SFML/Network/Sftp.cpp\",\n \"hunk\": \"@@ -0,0 +1,1377 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+// clang-format off\\n+#include <libssh2_sftp.h>\\n+// clang-format on\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ libssh2_exit();\\n+ }\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\\n+{\\n+ static std::mutex mutex;\\n+ const std::lock_guard lock(mutex);\\n+\\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\\n+ auto sharedPtr = weakPtr.lock();\\n+\\n+ if (sharedPtr)\\n+ return sharedPtr;\\n+\\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\\n+ weakPtr = sharedPtr;\\n+\\n+ return sharedPtr;\\n+}\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::SftpFailure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::SftpBadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::SftpNoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::SftpNoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::SftpLockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\\nnew file mode 100644\\nindex 0000000000..95ab95a45e\\n--- /dev/null\\n+++ b/src/SFML/Network/Sftp.cpp\\n@@ -0,0 +1,1347 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+#include <SFML/System/Err.hpp>\\n+\\n+#include <libssh2_sftp.h>\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <ostream>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ libssh2_exit();\\n+ }\\n+\\n+ static inline std::mutex mutex;\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::Error, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::EndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::NoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::PermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::Failure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::BadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::NoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::ConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::OperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::InvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::NoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::WriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::NoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::QuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::LockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::NotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::InvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::LinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl : LibSsh2Initializer\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\\n+ {\\n+ const auto result = waitForOperationComplete(\\n+ [&]\\n+ {\\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\\n+\\n+ if (sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ bool posixRenameSupported = true;\\n+ std::filesystem::path cachedHomePath;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\\n+{\\n+ // Clear the cached home path\\n+ m_impl->cachedHomePath.clear();\\n+\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length == 0)\\n+ return std::nullopt;\\n+\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ err() << \\\"SFTP: Cannot get session information, session not yet started\\\" << std::endl;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Ensure the passphrase is NULL-terminated\\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\\n+ return login(name,\\n+ publicKeyData.data(),\\n+ publicKeyData.length(),\\n+ privateKeyData.data(),\\n+ privateKeyData.length(),\\n+ privateKeyPassphraseString.c_str(),\\n+ timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Check if we already cached the result for the home path\\n+ if ((path == \\\".\\\") && !m_impl->cachedHomePath.empty())\\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\\n+ .generic_u8string();\\n+\\n+ // Cache the result for the home path\\n+ if (path == \\\".\\\")\\n+ m_impl->cachedHomePath = genericPath;\\n+\\n+ return {Result(Result::Value::Success), genericPath};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\\n+ &attributes);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ {\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ 0,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENDIR);\\n+\\n+ if (handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (!handle)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+ }\\n+\\n+ std::vector<Attributes> listing;\\n+\\n+ {\\n+ std::array<char, 4096> buffer{};\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\\n+ timeout);\\n+\\n+ if (result > 0)\\n+ {\\n+ listing.emplace_back(\\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\\n+ attributes));\\n+\\n+ continue;\\n+ }\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ if (result == 0)\\n+ break;\\n+ }\\n+ }\\n+\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ return {Result(Result::Value::Success), std::move(listing)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\\n+ std::filesystem::perms permissions,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ makePermissions(permissions));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto oldPathString = oldPath.generic_u8string();\\n+ const auto newPathString = newPath.generic_u8string();\\n+\\n+ // POSIX rename is only supported starting from libssh2 1.11.1\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // POSIX rename doesn't support not overwriting\\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\\n+#endif\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ if (usePosix)\\n+ {\\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()));\\n+ }\\n+#endif\\n+\\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()),\\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // Retry using normal rename if we find out POSIX rename isn't supported\\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\\n+ {\\n+ m_impl->posixRenameSupported = false;\\n+ usePosix = false;\\n+ continue;\\n+ }\\n+#endif\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for reading\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ LIBSSH2_FXF_READ,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Read from the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ auto* ptr = buffer.get();\\n+ int read{};\\n+ std::size_t totalRead{};\\n+\\n+ while (length > 0)\\n+ {\\n+ read = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (read == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (read <= 0)\\n+ break;\\n+\\n+ ptr += read;\\n+ length -= static_cast<std::size_t>(read);\\n+ totalRead += static_cast<std::size_t>(read);\\n+ }\\n+\\n+ if (read < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ const auto stop = !callback(buffer.get(), totalRead);\\n+\\n+ // If read is 0 then we have reached EOF\\n+ if (stop || (read == 0))\\n+ break;\\n+\\n+ const auto expand = (totalRead == bufferSize);\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions,\\n+ bool truncate,\\n+ bool append,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for writing\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\\n+ makePermissions(permissions),\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Write to the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ const auto stop = !callback(buffer.get(), length);\\n+ const auto expand = (length == bufferSize);\\n+ const auto* ptr = buffer.get();\\n+ int written{};\\n+\\n+ while (length > 0)\\n+ {\\n+ written = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (written == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (written < 0)\\n+ break;\\n+\\n+ ptr += written;\\n+ length -= static_cast<std::size_t>(written);\\n+ }\\n+\\n+ if (written < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ if (stop)\\n+ break;\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+} // namespace sf\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10083,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"Given it's deferenced immediately, `implPtr` should be a ref to a pointer instead of a pointer to a pointer."},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"},"changed_files":{"kind":"list like","value":["src/SFML/Network/Sftp.cpp"],"string":"[\n \"src/SFML/Network/Sftp.cpp\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"Given it's deferenced immediately, `implPtr` should be a ref to a pointer instead of a pointer to a pointer.","path":"src/SFML/Network/Sftp.cpp","hunk":"@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+// clang-format off\n+#include <libssh2_sftp.h>\n+// clang-format on\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ libssh2_exit();\n+ }\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\n+{\n+ static std::mutex mutex;\n+ const std::lock_guard lock(mutex);\n+\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\n+ auto sharedPtr = weakPtr.lock();\n+\n+ if (sharedPtr)\n+ return sharedPtr;\n+\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\n+ weakPtr = sharedPtr;\n+\n+ return sharedPtr;\n+}\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::SftpFailure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::SftpBadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::SftpNoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::SftpNoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::SftpLockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"}],"string":"[\n {\n \"comment\": \"Given it's deferenced immediately, `implPtr` should be a ref to a pointer instead of a pointer to a pointer.\",\n \"path\": \"src/SFML/Network/Sftp.cpp\",\n \"hunk\": \"@@ -0,0 +1,1377 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+// clang-format off\\n+#include <libssh2_sftp.h>\\n+// clang-format on\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ libssh2_exit();\\n+ }\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\\n+{\\n+ static std::mutex mutex;\\n+ const std::lock_guard lock(mutex);\\n+\\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\\n+ auto sharedPtr = weakPtr.lock();\\n+\\n+ if (sharedPtr)\\n+ return sharedPtr;\\n+\\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\\n+ weakPtr = sharedPtr;\\n+\\n+ return sharedPtr;\\n+}\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::SftpFailure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::SftpBadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::SftpNoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::SftpNoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::SftpLockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\\nnew file mode 100644\\nindex 0000000000..95ab95a45e\\n--- /dev/null\\n+++ b/src/SFML/Network/Sftp.cpp\\n@@ -0,0 +1,1347 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+#include <SFML/System/Err.hpp>\\n+\\n+#include <libssh2_sftp.h>\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <ostream>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ libssh2_exit();\\n+ }\\n+\\n+ static inline std::mutex mutex;\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::Error, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::EndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::NoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::PermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::Failure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::BadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::NoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::ConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::OperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::InvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::NoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::WriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::NoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::QuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::LockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::NotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::InvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::LinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl : LibSsh2Initializer\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\\n+ {\\n+ const auto result = waitForOperationComplete(\\n+ [&]\\n+ {\\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\\n+\\n+ if (sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ bool posixRenameSupported = true;\\n+ std::filesystem::path cachedHomePath;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\\n+{\\n+ // Clear the cached home path\\n+ m_impl->cachedHomePath.clear();\\n+\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length == 0)\\n+ return std::nullopt;\\n+\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ err() << \\\"SFTP: Cannot get session information, session not yet started\\\" << std::endl;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Ensure the passphrase is NULL-terminated\\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\\n+ return login(name,\\n+ publicKeyData.data(),\\n+ publicKeyData.length(),\\n+ privateKeyData.data(),\\n+ privateKeyData.length(),\\n+ privateKeyPassphraseString.c_str(),\\n+ timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Check if we already cached the result for the home path\\n+ if ((path == \\\".\\\") && !m_impl->cachedHomePath.empty())\\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\\n+ .generic_u8string();\\n+\\n+ // Cache the result for the home path\\n+ if (path == \\\".\\\")\\n+ m_impl->cachedHomePath = genericPath;\\n+\\n+ return {Result(Result::Value::Success), genericPath};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\\n+ &attributes);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ {\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ 0,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENDIR);\\n+\\n+ if (handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (!handle)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+ }\\n+\\n+ std::vector<Attributes> listing;\\n+\\n+ {\\n+ std::array<char, 4096> buffer{};\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\\n+ timeout);\\n+\\n+ if (result > 0)\\n+ {\\n+ listing.emplace_back(\\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\\n+ attributes));\\n+\\n+ continue;\\n+ }\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ if (result == 0)\\n+ break;\\n+ }\\n+ }\\n+\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ return {Result(Result::Value::Success), std::move(listing)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\\n+ std::filesystem::perms permissions,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ makePermissions(permissions));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto oldPathString = oldPath.generic_u8string();\\n+ const auto newPathString = newPath.generic_u8string();\\n+\\n+ // POSIX rename is only supported starting from libssh2 1.11.1\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // POSIX rename doesn't support not overwriting\\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\\n+#endif\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ if (usePosix)\\n+ {\\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()));\\n+ }\\n+#endif\\n+\\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()),\\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // Retry using normal rename if we find out POSIX rename isn't supported\\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\\n+ {\\n+ m_impl->posixRenameSupported = false;\\n+ usePosix = false;\\n+ continue;\\n+ }\\n+#endif\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for reading\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ LIBSSH2_FXF_READ,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Read from the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ auto* ptr = buffer.get();\\n+ int read{};\\n+ std::size_t totalRead{};\\n+\\n+ while (length > 0)\\n+ {\\n+ read = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (read == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (read <= 0)\\n+ break;\\n+\\n+ ptr += read;\\n+ length -= static_cast<std::size_t>(read);\\n+ totalRead += static_cast<std::size_t>(read);\\n+ }\\n+\\n+ if (read < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ const auto stop = !callback(buffer.get(), totalRead);\\n+\\n+ // If read is 0 then we have reached EOF\\n+ if (stop || (read == 0))\\n+ break;\\n+\\n+ const auto expand = (totalRead == bufferSize);\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions,\\n+ bool truncate,\\n+ bool append,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for writing\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\\n+ makePermissions(permissions),\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Write to the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ const auto stop = !callback(buffer.get(), length);\\n+ const auto expand = (length == bufferSize);\\n+ const auto* ptr = buffer.get();\\n+ int written{};\\n+\\n+ while (length > 0)\\n+ {\\n+ written = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (written == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (written < 0)\\n+ break;\\n+\\n+ ptr += written;\\n+ length -= static_cast<std::size_t>(written);\\n+ }\\n+\\n+ if (written < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ if (stop)\\n+ break;\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+} // namespace sf\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10084,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"Downstream users might want to use mutable lambdas here, so a non-const variant would be needed."},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"},"changed_files":{"kind":"list like","value":["src/SFML/Network/Sftp.cpp"],"string":"[\n \"src/SFML/Network/Sftp.cpp\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"Downstream users might want to use mutable lambdas here, so a non-const variant would be needed.","path":"src/SFML/Network/Sftp.cpp","hunk":"@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+// clang-format off\n+#include <libssh2_sftp.h>\n+// clang-format on\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ libssh2_exit();\n+ }\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\n+{\n+ static std::mutex mutex;\n+ const std::lock_guard lock(mutex);\n+\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\n+ auto sharedPtr = weakPtr.lock();\n+\n+ if (sharedPtr)\n+ return sharedPtr;\n+\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\n+ weakPtr = sharedPtr;\n+\n+ return sharedPtr;\n+}\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::SftpFailure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::SftpBadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::SftpNoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::SftpNoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::SftpLockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\n+ bool posixRenameSupported = true;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\n+ m_predicate(std::move(predicate)),\n+ m_period(period)\n+{\n+ if (!m_predicate)\n+ m_predicate = [] { return false; };\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\n+{\n+ return m_predicate;\n+}","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"}],"string":"[\n {\n \"comment\": \"Downstream users might want to use mutable lambdas here, so a non-const variant would be needed.\",\n \"path\": \"src/SFML/Network/Sftp.cpp\",\n \"hunk\": \"@@ -0,0 +1,1377 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+// clang-format off\\n+#include <libssh2_sftp.h>\\n+// clang-format on\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ libssh2_exit();\\n+ }\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\\n+{\\n+ static std::mutex mutex;\\n+ const std::lock_guard lock(mutex);\\n+\\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\\n+ auto sharedPtr = weakPtr.lock();\\n+\\n+ if (sharedPtr)\\n+ return sharedPtr;\\n+\\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\\n+ weakPtr = sharedPtr;\\n+\\n+ return sharedPtr;\\n+}\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::SftpFailure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::SftpBadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::SftpNoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::SftpNoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::SftpLockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\\n+ bool posixRenameSupported = true;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\\n+ m_predicate(std::move(predicate)),\\n+ m_period(period)\\n+{\\n+ if (!m_predicate)\\n+ m_predicate = [] { return false; };\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\\n+{\\n+ return m_predicate;\\n+}\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\\nnew file mode 100644\\nindex 0000000000..95ab95a45e\\n--- /dev/null\\n+++ b/src/SFML/Network/Sftp.cpp\\n@@ -0,0 +1,1347 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+#include <SFML/System/Err.hpp>\\n+\\n+#include <libssh2_sftp.h>\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <ostream>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ libssh2_exit();\\n+ }\\n+\\n+ static inline std::mutex mutex;\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::Error, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::EndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::NoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::PermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::Failure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::BadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::NoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::ConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::OperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::InvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::NoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::WriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::NoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::QuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::LockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::NotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::InvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::LinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl : LibSsh2Initializer\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\\n+ {\\n+ const auto result = waitForOperationComplete(\\n+ [&]\\n+ {\\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\\n+\\n+ if (sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ bool posixRenameSupported = true;\\n+ std::filesystem::path cachedHomePath;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\\n+{\\n+ // Clear the cached home path\\n+ m_impl->cachedHomePath.clear();\\n+\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length == 0)\\n+ return std::nullopt;\\n+\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ err() << \\\"SFTP: Cannot get session information, session not yet started\\\" << std::endl;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Ensure the passphrase is NULL-terminated\\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\\n+ return login(name,\\n+ publicKeyData.data(),\\n+ publicKeyData.length(),\\n+ privateKeyData.data(),\\n+ privateKeyData.length(),\\n+ privateKeyPassphraseString.c_str(),\\n+ timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Check if we already cached the result for the home path\\n+ if ((path == \\\".\\\") && !m_impl->cachedHomePath.empty())\\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\\n+ .generic_u8string();\\n+\\n+ // Cache the result for the home path\\n+ if (path == \\\".\\\")\\n+ m_impl->cachedHomePath = genericPath;\\n+\\n+ return {Result(Result::Value::Success), genericPath};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\\n+ &attributes);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ {\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ 0,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENDIR);\\n+\\n+ if (handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (!handle)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+ }\\n+\\n+ std::vector<Attributes> listing;\\n+\\n+ {\\n+ std::array<char, 4096> buffer{};\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\\n+ timeout);\\n+\\n+ if (result > 0)\\n+ {\\n+ listing.emplace_back(\\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\\n+ attributes));\\n+\\n+ continue;\\n+ }\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ if (result == 0)\\n+ break;\\n+ }\\n+ }\\n+\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ return {Result(Result::Value::Success), std::move(listing)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\\n+ std::filesystem::perms permissions,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ makePermissions(permissions));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto oldPathString = oldPath.generic_u8string();\\n+ const auto newPathString = newPath.generic_u8string();\\n+\\n+ // POSIX rename is only supported starting from libssh2 1.11.1\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // POSIX rename doesn't support not overwriting\\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\\n+#endif\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ if (usePosix)\\n+ {\\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()));\\n+ }\\n+#endif\\n+\\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()),\\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // Retry using normal rename if we find out POSIX rename isn't supported\\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\\n+ {\\n+ m_impl->posixRenameSupported = false;\\n+ usePosix = false;\\n+ continue;\\n+ }\\n+#endif\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for reading\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ LIBSSH2_FXF_READ,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Read from the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ auto* ptr = buffer.get();\\n+ int read{};\\n+ std::size_t totalRead{};\\n+\\n+ while (length > 0)\\n+ {\\n+ read = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (read == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (read <= 0)\\n+ break;\\n+\\n+ ptr += read;\\n+ length -= static_cast<std::size_t>(read);\\n+ totalRead += static_cast<std::size_t>(read);\\n+ }\\n+\\n+ if (read < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ const auto stop = !callback(buffer.get(), totalRead);\\n+\\n+ // If read is 0 then we have reached EOF\\n+ if (stop || (read == 0))\\n+ break;\\n+\\n+ const auto expand = (totalRead == bufferSize);\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions,\\n+ bool truncate,\\n+ bool append,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for writing\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\\n+ makePermissions(permissions),\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Write to the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ const auto stop = !callback(buffer.get(), length);\\n+ const auto expand = (length == bufferSize);\\n+ const auto* ptr = buffer.get();\\n+ int written{};\\n+\\n+ while (length > 0)\\n+ {\\n+ written = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (written == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (written < 0)\\n+ break;\\n+\\n+ ptr += written;\\n+ length -= static_cast<std::size_t>(written);\\n+ }\\n+\\n+ if (written < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ if (stop)\\n+ break;\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+} // namespace sf\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10085,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"This is deprecated upstream. Do you think it's worth adding support given that, or better to just never add it?"},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"},"changed_files":{"kind":"list like","value":["src/SFML/Network/Sftp.cpp"],"string":"[\n \"src/SFML/Network/Sftp.cpp\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"This is deprecated upstream. Do you think it's worth adding support given that, or better to just never add it?","path":"src/SFML/Network/Sftp.cpp","hunk":"@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+// clang-format off\n+#include <libssh2_sftp.h>\n+// clang-format on\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ libssh2_exit();\n+ }\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\n+{\n+ static std::mutex mutex;\n+ const std::lock_guard lock(mutex);\n+\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\n+ auto sharedPtr = weakPtr.lock();\n+\n+ if (sharedPtr)\n+ return sharedPtr;\n+\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\n+ weakPtr = sharedPtr;\n+\n+ return sharedPtr;\n+}\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::SftpFailure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::SftpBadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::SftpNoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::SftpNoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::SftpLockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\n+ bool posixRenameSupported = true;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\n+ m_predicate(std::move(predicate)),\n+ m_period(period)\n+{\n+ if (!m_predicate)\n+ m_predicate = [] { return false; };\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\n+{\n+ return m_predicate;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Time& Sftp::TimeoutPredicate::getPeriod() const\n+{\n+ return m_period;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::ReadinessType::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::ReadinessType::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::ReadinessType::Either);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutPredicate& timeout)\n+{\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length > 0)\n+ {\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"}],"string":"[\n {\n \"comment\": \"This is deprecated upstream. Do you think it's worth adding support given that, or better to just never add it?\",\n \"path\": \"src/SFML/Network/Sftp.cpp\",\n \"hunk\": \"@@ -0,0 +1,1377 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+// clang-format off\\n+#include <libssh2_sftp.h>\\n+// clang-format on\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ libssh2_exit();\\n+ }\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\\n+{\\n+ static std::mutex mutex;\\n+ const std::lock_guard lock(mutex);\\n+\\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\\n+ auto sharedPtr = weakPtr.lock();\\n+\\n+ if (sharedPtr)\\n+ return sharedPtr;\\n+\\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\\n+ weakPtr = sharedPtr;\\n+\\n+ return sharedPtr;\\n+}\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::SftpFailure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::SftpBadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::SftpNoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::SftpNoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::SftpLockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\\n+ bool posixRenameSupported = true;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\\n+ m_predicate(std::move(predicate)),\\n+ m_period(period)\\n+{\\n+ if (!m_predicate)\\n+ m_predicate = [] { return false; };\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\\n+{\\n+ return m_predicate;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Time& Sftp::TimeoutPredicate::getPeriod() const\\n+{\\n+ return m_period;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::ReadinessType::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::ReadinessType::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::ReadinessType::Either);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutPredicate& timeout)\\n+{\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length > 0)\\n+ {\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\\nnew file mode 100644\\nindex 0000000000..95ab95a45e\\n--- /dev/null\\n+++ b/src/SFML/Network/Sftp.cpp\\n@@ -0,0 +1,1347 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+#include <SFML/System/Err.hpp>\\n+\\n+#include <libssh2_sftp.h>\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <ostream>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ libssh2_exit();\\n+ }\\n+\\n+ static inline std::mutex mutex;\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::Error, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::EndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::NoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::PermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::Failure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::BadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::NoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::ConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::OperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::InvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::NoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::WriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::NoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::QuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::LockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::NotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::InvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::LinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl : LibSsh2Initializer\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\\n+ {\\n+ const auto result = waitForOperationComplete(\\n+ [&]\\n+ {\\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\\n+\\n+ if (sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ bool posixRenameSupported = true;\\n+ std::filesystem::path cachedHomePath;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\\n+{\\n+ // Clear the cached home path\\n+ m_impl->cachedHomePath.clear();\\n+\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length == 0)\\n+ return std::nullopt;\\n+\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ err() << \\\"SFTP: Cannot get session information, session not yet started\\\" << std::endl;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Ensure the passphrase is NULL-terminated\\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\\n+ return login(name,\\n+ publicKeyData.data(),\\n+ publicKeyData.length(),\\n+ privateKeyData.data(),\\n+ privateKeyData.length(),\\n+ privateKeyPassphraseString.c_str(),\\n+ timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Check if we already cached the result for the home path\\n+ if ((path == \\\".\\\") && !m_impl->cachedHomePath.empty())\\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\\n+ .generic_u8string();\\n+\\n+ // Cache the result for the home path\\n+ if (path == \\\".\\\")\\n+ m_impl->cachedHomePath = genericPath;\\n+\\n+ return {Result(Result::Value::Success), genericPath};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\\n+ &attributes);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ {\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ 0,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENDIR);\\n+\\n+ if (handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (!handle)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+ }\\n+\\n+ std::vector<Attributes> listing;\\n+\\n+ {\\n+ std::array<char, 4096> buffer{};\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\\n+ timeout);\\n+\\n+ if (result > 0)\\n+ {\\n+ listing.emplace_back(\\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\\n+ attributes));\\n+\\n+ continue;\\n+ }\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ if (result == 0)\\n+ break;\\n+ }\\n+ }\\n+\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ return {Result(Result::Value::Success), std::move(listing)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\\n+ std::filesystem::perms permissions,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ makePermissions(permissions));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto oldPathString = oldPath.generic_u8string();\\n+ const auto newPathString = newPath.generic_u8string();\\n+\\n+ // POSIX rename is only supported starting from libssh2 1.11.1\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // POSIX rename doesn't support not overwriting\\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\\n+#endif\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ if (usePosix)\\n+ {\\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()));\\n+ }\\n+#endif\\n+\\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()),\\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // Retry using normal rename if we find out POSIX rename isn't supported\\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\\n+ {\\n+ m_impl->posixRenameSupported = false;\\n+ usePosix = false;\\n+ continue;\\n+ }\\n+#endif\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for reading\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ LIBSSH2_FXF_READ,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Read from the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ auto* ptr = buffer.get();\\n+ int read{};\\n+ std::size_t totalRead{};\\n+\\n+ while (length > 0)\\n+ {\\n+ read = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (read == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (read <= 0)\\n+ break;\\n+\\n+ ptr += read;\\n+ length -= static_cast<std::size_t>(read);\\n+ totalRead += static_cast<std::size_t>(read);\\n+ }\\n+\\n+ if (read < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ const auto stop = !callback(buffer.get(), totalRead);\\n+\\n+ // If read is 0 then we have reached EOF\\n+ if (stop || (read == 0))\\n+ break;\\n+\\n+ const auto expand = (totalRead == bufferSize);\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions,\\n+ bool truncate,\\n+ bool append,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for writing\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\\n+ makePermissions(permissions),\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Write to the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ const auto stop = !callback(buffer.get(), length);\\n+ const auto expand = (length == bufferSize);\\n+ const auto* ptr = buffer.get();\\n+ int written{};\\n+\\n+ while (length > 0)\\n+ {\\n+ written = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (written == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (written < 0)\\n+ break;\\n+\\n+ ptr += written;\\n+ length -= static_cast<std::size_t>(written);\\n+ }\\n+\\n+ if (written < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ if (stop)\\n+ break;\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+} // namespace sf\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10086,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"There's a name mismatch between DSS and DSA here."},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"},"changed_files":{"kind":"list like","value":["src/SFML/Network/Sftp.cpp"],"string":"[\n \"src/SFML/Network/Sftp.cpp\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"There's a name mismatch between DSS and DSA here.","path":"src/SFML/Network/Sftp.cpp","hunk":"@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+// clang-format off\n+#include <libssh2_sftp.h>\n+// clang-format on\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ libssh2_exit();\n+ }\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\n+{\n+ static std::mutex mutex;\n+ const std::lock_guard lock(mutex);\n+\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\n+ auto sharedPtr = weakPtr.lock();\n+\n+ if (sharedPtr)\n+ return sharedPtr;\n+\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\n+ weakPtr = sharedPtr;\n+\n+ return sharedPtr;\n+}\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::SftpFailure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::SftpBadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::SftpNoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::SftpNoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::SftpLockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\n+ bool posixRenameSupported = true;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\n+ m_predicate(std::move(predicate)),\n+ m_period(period)\n+{\n+ if (!m_predicate)\n+ m_predicate = [] { return false; };\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\n+{\n+ return m_predicate;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Time& Sftp::TimeoutPredicate::getPeriod() const\n+{\n+ return m_period;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::ReadinessType::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::ReadinessType::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::ReadinessType::Either);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutPredicate& timeout)\n+{\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length > 0)\n+ {\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"}],"string":"[\n {\n \"comment\": \"There's a name mismatch between DSS and DSA here.\",\n \"path\": \"src/SFML/Network/Sftp.cpp\",\n \"hunk\": \"@@ -0,0 +1,1377 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+// clang-format off\\n+#include <libssh2_sftp.h>\\n+// clang-format on\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ libssh2_exit();\\n+ }\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\\n+{\\n+ static std::mutex mutex;\\n+ const std::lock_guard lock(mutex);\\n+\\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\\n+ auto sharedPtr = weakPtr.lock();\\n+\\n+ if (sharedPtr)\\n+ return sharedPtr;\\n+\\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\\n+ weakPtr = sharedPtr;\\n+\\n+ return sharedPtr;\\n+}\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::SftpFailure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::SftpBadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::SftpNoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::SftpNoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::SftpLockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\\n+ bool posixRenameSupported = true;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\\n+ m_predicate(std::move(predicate)),\\n+ m_period(period)\\n+{\\n+ if (!m_predicate)\\n+ m_predicate = [] { return false; };\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\\n+{\\n+ return m_predicate;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Time& Sftp::TimeoutPredicate::getPeriod() const\\n+{\\n+ return m_period;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::ReadinessType::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::ReadinessType::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::ReadinessType::Either);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutPredicate& timeout)\\n+{\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length > 0)\\n+ {\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\\nnew file mode 100644\\nindex 0000000000..95ab95a45e\\n--- /dev/null\\n+++ b/src/SFML/Network/Sftp.cpp\\n@@ -0,0 +1,1347 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+#include <SFML/System/Err.hpp>\\n+\\n+#include <libssh2_sftp.h>\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <ostream>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ libssh2_exit();\\n+ }\\n+\\n+ static inline std::mutex mutex;\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::Error, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::EndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::NoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::PermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::Failure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::BadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::NoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::ConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::OperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::InvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::NoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::WriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::NoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::QuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::LockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::NotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::InvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::LinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl : LibSsh2Initializer\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\\n+ {\\n+ const auto result = waitForOperationComplete(\\n+ [&]\\n+ {\\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\\n+\\n+ if (sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ bool posixRenameSupported = true;\\n+ std::filesystem::path cachedHomePath;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\\n+{\\n+ // Clear the cached home path\\n+ m_impl->cachedHomePath.clear();\\n+\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length == 0)\\n+ return std::nullopt;\\n+\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ err() << \\\"SFTP: Cannot get session information, session not yet started\\\" << std::endl;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Ensure the passphrase is NULL-terminated\\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\\n+ return login(name,\\n+ publicKeyData.data(),\\n+ publicKeyData.length(),\\n+ privateKeyData.data(),\\n+ privateKeyData.length(),\\n+ privateKeyPassphraseString.c_str(),\\n+ timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Check if we already cached the result for the home path\\n+ if ((path == \\\".\\\") && !m_impl->cachedHomePath.empty())\\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\\n+ .generic_u8string();\\n+\\n+ // Cache the result for the home path\\n+ if (path == \\\".\\\")\\n+ m_impl->cachedHomePath = genericPath;\\n+\\n+ return {Result(Result::Value::Success), genericPath};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\\n+ &attributes);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ {\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ 0,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENDIR);\\n+\\n+ if (handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (!handle)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+ }\\n+\\n+ std::vector<Attributes> listing;\\n+\\n+ {\\n+ std::array<char, 4096> buffer{};\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\\n+ timeout);\\n+\\n+ if (result > 0)\\n+ {\\n+ listing.emplace_back(\\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\\n+ attributes));\\n+\\n+ continue;\\n+ }\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ if (result == 0)\\n+ break;\\n+ }\\n+ }\\n+\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ return {Result(Result::Value::Success), std::move(listing)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\\n+ std::filesystem::perms permissions,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ makePermissions(permissions));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto oldPathString = oldPath.generic_u8string();\\n+ const auto newPathString = newPath.generic_u8string();\\n+\\n+ // POSIX rename is only supported starting from libssh2 1.11.1\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // POSIX rename doesn't support not overwriting\\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\\n+#endif\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ if (usePosix)\\n+ {\\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()));\\n+ }\\n+#endif\\n+\\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()),\\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // Retry using normal rename if we find out POSIX rename isn't supported\\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\\n+ {\\n+ m_impl->posixRenameSupported = false;\\n+ usePosix = false;\\n+ continue;\\n+ }\\n+#endif\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for reading\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ LIBSSH2_FXF_READ,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Read from the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ auto* ptr = buffer.get();\\n+ int read{};\\n+ std::size_t totalRead{};\\n+\\n+ while (length > 0)\\n+ {\\n+ read = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (read == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (read <= 0)\\n+ break;\\n+\\n+ ptr += read;\\n+ length -= static_cast<std::size_t>(read);\\n+ totalRead += static_cast<std::size_t>(read);\\n+ }\\n+\\n+ if (read < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ const auto stop = !callback(buffer.get(), totalRead);\\n+\\n+ // If read is 0 then we have reached EOF\\n+ if (stop || (read == 0))\\n+ break;\\n+\\n+ const auto expand = (totalRead == bufferSize);\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions,\\n+ bool truncate,\\n+ bool append,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for writing\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\\n+ makePermissions(permissions),\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Write to the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ const auto stop = !callback(buffer.get(), length);\\n+ const auto expand = (length == bufferSize);\\n+ const auto* ptr = buffer.get();\\n+ int written{};\\n+\\n+ while (length > 0)\\n+ {\\n+ written = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (written == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (written < 0)\\n+ break;\\n+\\n+ ptr += written;\\n+ length -= static_cast<std::size_t>(written);\\n+ }\\n+\\n+ if (written < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ if (stop)\\n+ break;\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+} // namespace sf\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10087,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"It might be preferable to only support SHA256 is both are available? It reduces the attack surface for a bad actor. SHA1 was known hash collision attacks and probably more by now."},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"},"changed_files":{"kind":"list like","value":["src/SFML/Network/Sftp.cpp"],"string":"[\n \"src/SFML/Network/Sftp.cpp\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"It might be preferable to only support SHA256 is both are available? It reduces the attack surface for a bad actor. SHA1 was known hash collision attacks and probably more by now.","path":"src/SFML/Network/Sftp.cpp","hunk":"@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+// clang-format off\n+#include <libssh2_sftp.h>\n+// clang-format on\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ libssh2_exit();\n+ }\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\n+{\n+ static std::mutex mutex;\n+ const std::lock_guard lock(mutex);\n+\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\n+ auto sharedPtr = weakPtr.lock();\n+\n+ if (sharedPtr)\n+ return sharedPtr;\n+\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\n+ weakPtr = sharedPtr;\n+\n+ return sharedPtr;\n+}\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::SftpFailure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::SftpBadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::SftpNoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::SftpNoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::SftpLockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\n+ bool posixRenameSupported = true;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\n+ m_predicate(std::move(predicate)),\n+ m_period(period)\n+{\n+ if (!m_predicate)\n+ m_predicate = [] { return false; };\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\n+{\n+ return m_predicate;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Time& Sftp::TimeoutPredicate::getPeriod() const\n+{\n+ return m_period;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::ReadinessType::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::ReadinessType::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::ReadinessType::Either);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutPredicate& timeout)\n+{\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length > 0)\n+ {\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"}],"string":"[\n {\n \"comment\": \"It might be preferable to only support SHA256 is both are available? It reduces the attack surface for a bad actor. SHA1 was known hash collision attacks and probably more by now.\",\n \"path\": \"src/SFML/Network/Sftp.cpp\",\n \"hunk\": \"@@ -0,0 +1,1377 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+// clang-format off\\n+#include <libssh2_sftp.h>\\n+// clang-format on\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ libssh2_exit();\\n+ }\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\\n+{\\n+ static std::mutex mutex;\\n+ const std::lock_guard lock(mutex);\\n+\\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\\n+ auto sharedPtr = weakPtr.lock();\\n+\\n+ if (sharedPtr)\\n+ return sharedPtr;\\n+\\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\\n+ weakPtr = sharedPtr;\\n+\\n+ return sharedPtr;\\n+}\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::SftpFailure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::SftpBadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::SftpNoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::SftpNoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::SftpLockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\\n+ bool posixRenameSupported = true;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\\n+ m_predicate(std::move(predicate)),\\n+ m_period(period)\\n+{\\n+ if (!m_predicate)\\n+ m_predicate = [] { return false; };\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\\n+{\\n+ return m_predicate;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Time& Sftp::TimeoutPredicate::getPeriod() const\\n+{\\n+ return m_period;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::ReadinessType::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::ReadinessType::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::ReadinessType::Either);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutPredicate& timeout)\\n+{\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length > 0)\\n+ {\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\\nnew file mode 100644\\nindex 0000000000..95ab95a45e\\n--- /dev/null\\n+++ b/src/SFML/Network/Sftp.cpp\\n@@ -0,0 +1,1347 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+#include <SFML/System/Err.hpp>\\n+\\n+#include <libssh2_sftp.h>\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <ostream>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ libssh2_exit();\\n+ }\\n+\\n+ static inline std::mutex mutex;\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::Error, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::EndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::NoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::PermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::Failure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::BadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::NoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::ConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::OperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::InvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::NoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::WriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::NoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::QuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::LockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::NotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::InvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::LinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl : LibSsh2Initializer\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\\n+ {\\n+ const auto result = waitForOperationComplete(\\n+ [&]\\n+ {\\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\\n+\\n+ if (sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ bool posixRenameSupported = true;\\n+ std::filesystem::path cachedHomePath;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\\n+{\\n+ // Clear the cached home path\\n+ m_impl->cachedHomePath.clear();\\n+\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length == 0)\\n+ return std::nullopt;\\n+\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ err() << \\\"SFTP: Cannot get session information, session not yet started\\\" << std::endl;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Ensure the passphrase is NULL-terminated\\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\\n+ return login(name,\\n+ publicKeyData.data(),\\n+ publicKeyData.length(),\\n+ privateKeyData.data(),\\n+ privateKeyData.length(),\\n+ privateKeyPassphraseString.c_str(),\\n+ timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Check if we already cached the result for the home path\\n+ if ((path == \\\".\\\") && !m_impl->cachedHomePath.empty())\\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\\n+ .generic_u8string();\\n+\\n+ // Cache the result for the home path\\n+ if (path == \\\".\\\")\\n+ m_impl->cachedHomePath = genericPath;\\n+\\n+ return {Result(Result::Value::Success), genericPath};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\\n+ &attributes);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ {\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ 0,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENDIR);\\n+\\n+ if (handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (!handle)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+ }\\n+\\n+ std::vector<Attributes> listing;\\n+\\n+ {\\n+ std::array<char, 4096> buffer{};\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\\n+ timeout);\\n+\\n+ if (result > 0)\\n+ {\\n+ listing.emplace_back(\\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\\n+ attributes));\\n+\\n+ continue;\\n+ }\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ if (result == 0)\\n+ break;\\n+ }\\n+ }\\n+\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ return {Result(Result::Value::Success), std::move(listing)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\\n+ std::filesystem::perms permissions,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ makePermissions(permissions));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto oldPathString = oldPath.generic_u8string();\\n+ const auto newPathString = newPath.generic_u8string();\\n+\\n+ // POSIX rename is only supported starting from libssh2 1.11.1\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // POSIX rename doesn't support not overwriting\\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\\n+#endif\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ if (usePosix)\\n+ {\\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()));\\n+ }\\n+#endif\\n+\\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()),\\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // Retry using normal rename if we find out POSIX rename isn't supported\\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\\n+ {\\n+ m_impl->posixRenameSupported = false;\\n+ usePosix = false;\\n+ continue;\\n+ }\\n+#endif\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for reading\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ LIBSSH2_FXF_READ,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Read from the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ auto* ptr = buffer.get();\\n+ int read{};\\n+ std::size_t totalRead{};\\n+\\n+ while (length > 0)\\n+ {\\n+ read = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (read == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (read <= 0)\\n+ break;\\n+\\n+ ptr += read;\\n+ length -= static_cast<std::size_t>(read);\\n+ totalRead += static_cast<std::size_t>(read);\\n+ }\\n+\\n+ if (read < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ const auto stop = !callback(buffer.get(), totalRead);\\n+\\n+ // If read is 0 then we have reached EOF\\n+ if (stop || (read == 0))\\n+ break;\\n+\\n+ const auto expand = (totalRead == bufferSize);\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions,\\n+ bool truncate,\\n+ bool append,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for writing\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\\n+ makePermissions(permissions),\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Write to the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ const auto stop = !callback(buffer.get(), length);\\n+ const auto expand = (length == bufferSize);\\n+ const auto* ptr = buffer.get();\\n+ int written{};\\n+\\n+ while (length > 0)\\n+ {\\n+ written = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (written == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (written < 0)\\n+ break;\\n+\\n+ ptr += written;\\n+ length -= static_cast<std::size_t>(written);\\n+ }\\n+\\n+ if (written < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ if (stop)\\n+ break;\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+} // namespace sf\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10088,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"[nit] this extra nesting can be removed by just checking for this and early returning, rather than an if-else."},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"},"changed_files":{"kind":"list like","value":["src/SFML/Network/Sftp.cpp"],"string":"[\n \"src/SFML/Network/Sftp.cpp\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"[nit] this extra nesting can be removed by just checking for this and early returning, rather than an if-else.","path":"src/SFML/Network/Sftp.cpp","hunk":"@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+// clang-format off\n+#include <libssh2_sftp.h>\n+// clang-format on\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ libssh2_exit();\n+ }\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\n+{\n+ static std::mutex mutex;\n+ const std::lock_guard lock(mutex);\n+\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\n+ auto sharedPtr = weakPtr.lock();\n+\n+ if (sharedPtr)\n+ return sharedPtr;\n+\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\n+ weakPtr = sharedPtr;\n+\n+ return sharedPtr;\n+}\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::SftpFailure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::SftpBadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::SftpNoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::SftpNoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::SftpLockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\n+ bool posixRenameSupported = true;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\n+ m_predicate(std::move(predicate)),\n+ m_period(period)\n+{\n+ if (!m_predicate)\n+ m_predicate = [] { return false; };\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\n+{\n+ return m_predicate;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Time& Sftp::TimeoutPredicate::getPeriod() const\n+{\n+ return m_period;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::ReadinessType::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::ReadinessType::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::ReadinessType::Either);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutPredicate& timeout)\n+{\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length > 0)\n+ {\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+ else\n+ {\n+ return std::nullopt;\n+ }","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"}],"string":"[\n {\n \"comment\": \"[nit] this extra nesting can be removed by just checking for this and early returning, rather than an if-else.\",\n \"path\": \"src/SFML/Network/Sftp.cpp\",\n \"hunk\": \"@@ -0,0 +1,1377 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+// clang-format off\\n+#include <libssh2_sftp.h>\\n+// clang-format on\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ libssh2_exit();\\n+ }\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\\n+{\\n+ static std::mutex mutex;\\n+ const std::lock_guard lock(mutex);\\n+\\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\\n+ auto sharedPtr = weakPtr.lock();\\n+\\n+ if (sharedPtr)\\n+ return sharedPtr;\\n+\\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\\n+ weakPtr = sharedPtr;\\n+\\n+ return sharedPtr;\\n+}\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::SftpFailure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::SftpBadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::SftpNoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::SftpNoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::SftpLockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\\n+ bool posixRenameSupported = true;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\\n+ m_predicate(std::move(predicate)),\\n+ m_period(period)\\n+{\\n+ if (!m_predicate)\\n+ m_predicate = [] { return false; };\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\\n+{\\n+ return m_predicate;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Time& Sftp::TimeoutPredicate::getPeriod() const\\n+{\\n+ return m_period;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::ReadinessType::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::ReadinessType::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::ReadinessType::Either);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutPredicate& timeout)\\n+{\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length > 0)\\n+ {\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+ else\\n+ {\\n+ return std::nullopt;\\n+ }\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\\nnew file mode 100644\\nindex 0000000000..95ab95a45e\\n--- /dev/null\\n+++ b/src/SFML/Network/Sftp.cpp\\n@@ -0,0 +1,1347 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+#include <SFML/System/Err.hpp>\\n+\\n+#include <libssh2_sftp.h>\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <ostream>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ libssh2_exit();\\n+ }\\n+\\n+ static inline std::mutex mutex;\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::Error, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::EndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::NoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::PermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::Failure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::BadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::NoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::ConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::OperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::InvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::NoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::WriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::NoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::QuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::LockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::NotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::InvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::LinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl : LibSsh2Initializer\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\\n+ {\\n+ const auto result = waitForOperationComplete(\\n+ [&]\\n+ {\\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\\n+\\n+ if (sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ bool posixRenameSupported = true;\\n+ std::filesystem::path cachedHomePath;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\\n+{\\n+ // Clear the cached home path\\n+ m_impl->cachedHomePath.clear();\\n+\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length == 0)\\n+ return std::nullopt;\\n+\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ err() << \\\"SFTP: Cannot get session information, session not yet started\\\" << std::endl;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Ensure the passphrase is NULL-terminated\\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\\n+ return login(name,\\n+ publicKeyData.data(),\\n+ publicKeyData.length(),\\n+ privateKeyData.data(),\\n+ privateKeyData.length(),\\n+ privateKeyPassphraseString.c_str(),\\n+ timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Check if we already cached the result for the home path\\n+ if ((path == \\\".\\\") && !m_impl->cachedHomePath.empty())\\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\\n+ .generic_u8string();\\n+\\n+ // Cache the result for the home path\\n+ if (path == \\\".\\\")\\n+ m_impl->cachedHomePath = genericPath;\\n+\\n+ return {Result(Result::Value::Success), genericPath};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\\n+ &attributes);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ {\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ 0,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENDIR);\\n+\\n+ if (handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (!handle)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+ }\\n+\\n+ std::vector<Attributes> listing;\\n+\\n+ {\\n+ std::array<char, 4096> buffer{};\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\\n+ timeout);\\n+\\n+ if (result > 0)\\n+ {\\n+ listing.emplace_back(\\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\\n+ attributes));\\n+\\n+ continue;\\n+ }\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ if (result == 0)\\n+ break;\\n+ }\\n+ }\\n+\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ return {Result(Result::Value::Success), std::move(listing)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\\n+ std::filesystem::perms permissions,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ makePermissions(permissions));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto oldPathString = oldPath.generic_u8string();\\n+ const auto newPathString = newPath.generic_u8string();\\n+\\n+ // POSIX rename is only supported starting from libssh2 1.11.1\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // POSIX rename doesn't support not overwriting\\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\\n+#endif\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ if (usePosix)\\n+ {\\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()));\\n+ }\\n+#endif\\n+\\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()),\\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // Retry using normal rename if we find out POSIX rename isn't supported\\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\\n+ {\\n+ m_impl->posixRenameSupported = false;\\n+ usePosix = false;\\n+ continue;\\n+ }\\n+#endif\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for reading\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ LIBSSH2_FXF_READ,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Read from the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ auto* ptr = buffer.get();\\n+ int read{};\\n+ std::size_t totalRead{};\\n+\\n+ while (length > 0)\\n+ {\\n+ read = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (read == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (read <= 0)\\n+ break;\\n+\\n+ ptr += read;\\n+ length -= static_cast<std::size_t>(read);\\n+ totalRead += static_cast<std::size_t>(read);\\n+ }\\n+\\n+ if (read < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ const auto stop = !callback(buffer.get(), totalRead);\\n+\\n+ // If read is 0 then we have reached EOF\\n+ if (stop || (read == 0))\\n+ break;\\n+\\n+ const auto expand = (totalRead == bufferSize);\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions,\\n+ bool truncate,\\n+ bool append,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for writing\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\\n+ makePermissions(permissions),\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Write to the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ const auto stop = !callback(buffer.get(), length);\\n+ const auto expand = (length == bufferSize);\\n+ const auto* ptr = buffer.get();\\n+ int written{};\\n+\\n+ while (length > 0)\\n+ {\\n+ written = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (written == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (written < 0)\\n+ break;\\n+\\n+ ptr += written;\\n+ length -= static_cast<std::size_t>(written);\\n+ }\\n+\\n+ if (written < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ if (stop)\\n+ break;\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+} // namespace sf\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10089,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"Do these have to be set; an empty but valid string may confuse people. Possible alternative: std::optional"},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"},"changed_files":{"kind":"list like","value":["src/SFML/Network/Sftp.cpp"],"string":"[\n \"src/SFML/Network/Sftp.cpp\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"Do these have to be set; an empty but valid string may confuse people. Possible alternative: std::optional","path":"src/SFML/Network/Sftp.cpp","hunk":"@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+// clang-format off\n+#include <libssh2_sftp.h>\n+// clang-format on\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ libssh2_exit();\n+ }\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\n+{\n+ static std::mutex mutex;\n+ const std::lock_guard lock(mutex);\n+\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\n+ auto sharedPtr = weakPtr.lock();\n+\n+ if (sharedPtr)\n+ return sharedPtr;\n+\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\n+ weakPtr = sharedPtr;\n+\n+ return sharedPtr;\n+}\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::SftpFailure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::SftpBadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::SftpNoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::SftpNoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::SftpLockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\n+ bool posixRenameSupported = true;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\n+ m_predicate(std::move(predicate)),\n+ m_period(period)\n+{\n+ if (!m_predicate)\n+ m_predicate = [] { return false; };\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\n+{\n+ return m_predicate;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Time& Sftp::TimeoutPredicate::getPeriod() const\n+{\n+ return m_period;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::ReadinessType::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::ReadinessType::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::ReadinessType::Either);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutPredicate& timeout)\n+{\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length > 0)\n+ {\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+ else\n+ {\n+ return std::nullopt;\n+ }\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ return \"\";","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"}],"string":"[\n {\n \"comment\": \"Do these have to be set; an empty but valid string may confuse people. Possible alternative: std::optional\",\n \"path\": \"src/SFML/Network/Sftp.cpp\",\n \"hunk\": \"@@ -0,0 +1,1377 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+// clang-format off\\n+#include <libssh2_sftp.h>\\n+// clang-format on\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ libssh2_exit();\\n+ }\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\\n+{\\n+ static std::mutex mutex;\\n+ const std::lock_guard lock(mutex);\\n+\\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\\n+ auto sharedPtr = weakPtr.lock();\\n+\\n+ if (sharedPtr)\\n+ return sharedPtr;\\n+\\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\\n+ weakPtr = sharedPtr;\\n+\\n+ return sharedPtr;\\n+}\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::SftpFailure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::SftpBadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::SftpNoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::SftpNoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::SftpLockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\\n+ bool posixRenameSupported = true;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\\n+ m_predicate(std::move(predicate)),\\n+ m_period(period)\\n+{\\n+ if (!m_predicate)\\n+ m_predicate = [] { return false; };\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\\n+{\\n+ return m_predicate;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Time& Sftp::TimeoutPredicate::getPeriod() const\\n+{\\n+ return m_period;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::ReadinessType::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::ReadinessType::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::ReadinessType::Either);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutPredicate& timeout)\\n+{\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length > 0)\\n+ {\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+ else\\n+ {\\n+ return std::nullopt;\\n+ }\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ return \\\"\\\";\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\\nnew file mode 100644\\nindex 0000000000..95ab95a45e\\n--- /dev/null\\n+++ b/src/SFML/Network/Sftp.cpp\\n@@ -0,0 +1,1347 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+#include <SFML/System/Err.hpp>\\n+\\n+#include <libssh2_sftp.h>\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <ostream>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ libssh2_exit();\\n+ }\\n+\\n+ static inline std::mutex mutex;\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::Error, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::EndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::NoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::PermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::Failure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::BadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::NoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::ConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::OperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::InvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::NoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::WriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::NoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::QuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::LockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::NotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::InvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::LinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl : LibSsh2Initializer\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\\n+ {\\n+ const auto result = waitForOperationComplete(\\n+ [&]\\n+ {\\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\\n+\\n+ if (sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ bool posixRenameSupported = true;\\n+ std::filesystem::path cachedHomePath;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\\n+{\\n+ // Clear the cached home path\\n+ m_impl->cachedHomePath.clear();\\n+\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length == 0)\\n+ return std::nullopt;\\n+\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ err() << \\\"SFTP: Cannot get session information, session not yet started\\\" << std::endl;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Ensure the passphrase is NULL-terminated\\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\\n+ return login(name,\\n+ publicKeyData.data(),\\n+ publicKeyData.length(),\\n+ privateKeyData.data(),\\n+ privateKeyData.length(),\\n+ privateKeyPassphraseString.c_str(),\\n+ timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Check if we already cached the result for the home path\\n+ if ((path == \\\".\\\") && !m_impl->cachedHomePath.empty())\\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\\n+ .generic_u8string();\\n+\\n+ // Cache the result for the home path\\n+ if (path == \\\".\\\")\\n+ m_impl->cachedHomePath = genericPath;\\n+\\n+ return {Result(Result::Value::Success), genericPath};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\\n+ &attributes);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ {\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ 0,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENDIR);\\n+\\n+ if (handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (!handle)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+ }\\n+\\n+ std::vector<Attributes> listing;\\n+\\n+ {\\n+ std::array<char, 4096> buffer{};\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\\n+ timeout);\\n+\\n+ if (result > 0)\\n+ {\\n+ listing.emplace_back(\\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\\n+ attributes));\\n+\\n+ continue;\\n+ }\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ if (result == 0)\\n+ break;\\n+ }\\n+ }\\n+\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ return {Result(Result::Value::Success), std::move(listing)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\\n+ std::filesystem::perms permissions,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ makePermissions(permissions));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto oldPathString = oldPath.generic_u8string();\\n+ const auto newPathString = newPath.generic_u8string();\\n+\\n+ // POSIX rename is only supported starting from libssh2 1.11.1\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // POSIX rename doesn't support not overwriting\\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\\n+#endif\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ if (usePosix)\\n+ {\\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()));\\n+ }\\n+#endif\\n+\\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()),\\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // Retry using normal rename if we find out POSIX rename isn't supported\\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\\n+ {\\n+ m_impl->posixRenameSupported = false;\\n+ usePosix = false;\\n+ continue;\\n+ }\\n+#endif\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for reading\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ LIBSSH2_FXF_READ,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Read from the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ auto* ptr = buffer.get();\\n+ int read{};\\n+ std::size_t totalRead{};\\n+\\n+ while (length > 0)\\n+ {\\n+ read = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (read == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (read <= 0)\\n+ break;\\n+\\n+ ptr += read;\\n+ length -= static_cast<std::size_t>(read);\\n+ totalRead += static_cast<std::size_t>(read);\\n+ }\\n+\\n+ if (read < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ const auto stop = !callback(buffer.get(), totalRead);\\n+\\n+ // If read is 0 then we have reached EOF\\n+ if (stop || (read == 0))\\n+ break;\\n+\\n+ const auto expand = (totalRead == bufferSize);\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions,\\n+ bool truncate,\\n+ bool append,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for writing\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\\n+ makePermissions(permissions),\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Write to the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ const auto stop = !callback(buffer.get(), length);\\n+ const auto expand = (length == bufferSize);\\n+ const auto* ptr = buffer.get();\\n+ int written{};\\n+\\n+ while (length > 0)\\n+ {\\n+ written = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (written == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (written < 0)\\n+ break;\\n+\\n+ ptr += written;\\n+ length -= static_cast<std::size_t>(written);\\n+ }\\n+\\n+ if (written < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ if (stop)\\n+ break;\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+} // namespace sf\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10090,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"unsigned int may be smaller than the size_t password. In extreme cases, this will lead to the uncorrect length being passed and a possible buffer overflow exploit being available.\n\nThis edge case should be checked for; it's a security issue."},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"},"changed_files":{"kind":"list like","value":["src/SFML/Network/Sftp.cpp"],"string":"[\n \"src/SFML/Network/Sftp.cpp\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"unsigned int may be smaller than the size_t password. In extreme cases, this will lead to the uncorrect length being passed and a possible buffer overflow exploit being available.\n\nThis edge case should be checked for; it's a security issue.","path":"src/SFML/Network/Sftp.cpp","hunk":"@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+// clang-format off\n+#include <libssh2_sftp.h>\n+// clang-format on\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ libssh2_exit();\n+ }\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\n+{\n+ static std::mutex mutex;\n+ const std::lock_guard lock(mutex);\n+\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\n+ auto sharedPtr = weakPtr.lock();\n+\n+ if (sharedPtr)\n+ return sharedPtr;\n+\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\n+ weakPtr = sharedPtr;\n+\n+ return sharedPtr;\n+}\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::SftpFailure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::SftpBadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::SftpNoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::SftpNoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::SftpLockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\n+ bool posixRenameSupported = true;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\n+ m_predicate(std::move(predicate)),\n+ m_period(period)\n+{\n+ if (!m_predicate)\n+ m_predicate = [] { return false; };\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\n+{\n+ return m_predicate;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Time& Sftp::TimeoutPredicate::getPeriod() const\n+{\n+ return m_period;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::ReadinessType::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::ReadinessType::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::ReadinessType::Either);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutPredicate& timeout)\n+{\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length > 0)\n+ {\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+ else\n+ {\n+ return std::nullopt;\n+ }\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(const std::string& name, const std::string& password, const TimeoutPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"}],"string":"[\n {\n \"comment\": \"unsigned int may be smaller than the size_t password. In extreme cases, this will lead to the uncorrect length being passed and a possible buffer overflow exploit being available.\\n\\nThis edge case should be checked for; it's a security issue.\",\n \"path\": \"src/SFML/Network/Sftp.cpp\",\n \"hunk\": \"@@ -0,0 +1,1377 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+// clang-format off\\n+#include <libssh2_sftp.h>\\n+// clang-format on\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ libssh2_exit();\\n+ }\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\\n+{\\n+ static std::mutex mutex;\\n+ const std::lock_guard lock(mutex);\\n+\\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\\n+ auto sharedPtr = weakPtr.lock();\\n+\\n+ if (sharedPtr)\\n+ return sharedPtr;\\n+\\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\\n+ weakPtr = sharedPtr;\\n+\\n+ return sharedPtr;\\n+}\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::SftpFailure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::SftpBadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::SftpNoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::SftpNoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::SftpLockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\\n+ bool posixRenameSupported = true;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\\n+ m_predicate(std::move(predicate)),\\n+ m_period(period)\\n+{\\n+ if (!m_predicate)\\n+ m_predicate = [] { return false; };\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\\n+{\\n+ return m_predicate;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Time& Sftp::TimeoutPredicate::getPeriod() const\\n+{\\n+ return m_period;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::ReadinessType::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::ReadinessType::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::ReadinessType::Either);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutPredicate& timeout)\\n+{\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length > 0)\\n+ {\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+ else\\n+ {\\n+ return std::nullopt;\\n+ }\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(const std::string& name, const std::string& password, const TimeoutPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\\nnew file mode 100644\\nindex 0000000000..95ab95a45e\\n--- /dev/null\\n+++ b/src/SFML/Network/Sftp.cpp\\n@@ -0,0 +1,1347 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+#include <SFML/System/Err.hpp>\\n+\\n+#include <libssh2_sftp.h>\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <ostream>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ libssh2_exit();\\n+ }\\n+\\n+ static inline std::mutex mutex;\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::Error, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::EndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::NoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::PermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::Failure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::BadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::NoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::ConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::OperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::InvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::NoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::WriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::NoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::QuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::LockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::NotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::InvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::LinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl : LibSsh2Initializer\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\\n+ {\\n+ const auto result = waitForOperationComplete(\\n+ [&]\\n+ {\\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\\n+\\n+ if (sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ bool posixRenameSupported = true;\\n+ std::filesystem::path cachedHomePath;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\\n+{\\n+ // Clear the cached home path\\n+ m_impl->cachedHomePath.clear();\\n+\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length == 0)\\n+ return std::nullopt;\\n+\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ err() << \\\"SFTP: Cannot get session information, session not yet started\\\" << std::endl;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Ensure the passphrase is NULL-terminated\\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\\n+ return login(name,\\n+ publicKeyData.data(),\\n+ publicKeyData.length(),\\n+ privateKeyData.data(),\\n+ privateKeyData.length(),\\n+ privateKeyPassphraseString.c_str(),\\n+ timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Check if we already cached the result for the home path\\n+ if ((path == \\\".\\\") && !m_impl->cachedHomePath.empty())\\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\\n+ .generic_u8string();\\n+\\n+ // Cache the result for the home path\\n+ if (path == \\\".\\\")\\n+ m_impl->cachedHomePath = genericPath;\\n+\\n+ return {Result(Result::Value::Success), genericPath};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\\n+ &attributes);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ {\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ 0,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENDIR);\\n+\\n+ if (handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (!handle)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+ }\\n+\\n+ std::vector<Attributes> listing;\\n+\\n+ {\\n+ std::array<char, 4096> buffer{};\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\\n+ timeout);\\n+\\n+ if (result > 0)\\n+ {\\n+ listing.emplace_back(\\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\\n+ attributes));\\n+\\n+ continue;\\n+ }\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ if (result == 0)\\n+ break;\\n+ }\\n+ }\\n+\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ return {Result(Result::Value::Success), std::move(listing)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\\n+ std::filesystem::perms permissions,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ makePermissions(permissions));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto oldPathString = oldPath.generic_u8string();\\n+ const auto newPathString = newPath.generic_u8string();\\n+\\n+ // POSIX rename is only supported starting from libssh2 1.11.1\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // POSIX rename doesn't support not overwriting\\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\\n+#endif\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ if (usePosix)\\n+ {\\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()));\\n+ }\\n+#endif\\n+\\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()),\\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // Retry using normal rename if we find out POSIX rename isn't supported\\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\\n+ {\\n+ m_impl->posixRenameSupported = false;\\n+ usePosix = false;\\n+ continue;\\n+ }\\n+#endif\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for reading\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ LIBSSH2_FXF_READ,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Read from the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ auto* ptr = buffer.get();\\n+ int read{};\\n+ std::size_t totalRead{};\\n+\\n+ while (length > 0)\\n+ {\\n+ read = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (read == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (read <= 0)\\n+ break;\\n+\\n+ ptr += read;\\n+ length -= static_cast<std::size_t>(read);\\n+ totalRead += static_cast<std::size_t>(read);\\n+ }\\n+\\n+ if (read < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ const auto stop = !callback(buffer.get(), totalRead);\\n+\\n+ // If read is 0 then we have reached EOF\\n+ if (stop || (read == 0))\\n+ break;\\n+\\n+ const auto expand = (totalRead == bufferSize);\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions,\\n+ bool truncate,\\n+ bool append,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for writing\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\\n+ makePermissions(permissions),\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Write to the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ const auto stop = !callback(buffer.get(), length);\\n+ const auto expand = (length == bufferSize);\\n+ const auto* ptr = buffer.get();\\n+ int written{};\\n+\\n+ while (length > 0)\\n+ {\\n+ written = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (written == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (written < 0)\\n+ break;\\n+\\n+ ptr += written;\\n+ length -= static_cast<std::size_t>(written);\\n+ }\\n+\\n+ if (written < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ if (stop)\\n+ break;\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+} // namespace sf\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10091,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"any info on thread safety here requirements here?"},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"},"changed_files":{"kind":"list like","value":["src/SFML/Network/Sftp.cpp"],"string":"[\n \"src/SFML/Network/Sftp.cpp\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"any info on thread safety here requirements here?","path":"src/SFML/Network/Sftp.cpp","hunk":"@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+// clang-format off\n+#include <libssh2_sftp.h>\n+// clang-format on\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ libssh2_exit();\n+ }\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\n+{\n+ static std::mutex mutex;\n+ const std::lock_guard lock(mutex);\n+\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\n+ auto sharedPtr = weakPtr.lock();\n+\n+ if (sharedPtr)\n+ return sharedPtr;\n+\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\n+ weakPtr = sharedPtr;\n+\n+ return sharedPtr;\n+}\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::SftpFailure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::SftpBadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::SftpNoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::SftpNoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::SftpLockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\n+ bool posixRenameSupported = true;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\n+ m_predicate(std::move(predicate)),\n+ m_period(period)\n+{\n+ if (!m_predicate)\n+ m_predicate = [] { return false; };\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\n+{\n+ return m_predicate;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Time& Sftp::TimeoutPredicate::getPeriod() const\n+{\n+ return m_period;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::ReadinessType::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::ReadinessType::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::ReadinessType::Either);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutPredicate& timeout)\n+{\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length > 0)\n+ {\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+ else\n+ {\n+ return std::nullopt;\n+ }\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(const std::string& name, const std::string& password, const TimeoutPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ m_impl->sftpSession.reset(libssh2_sftp_init(m_impl->ssh2Session.get()));","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"}],"string":"[\n {\n \"comment\": \"any info on thread safety here requirements here?\",\n \"path\": \"src/SFML/Network/Sftp.cpp\",\n \"hunk\": \"@@ -0,0 +1,1377 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+// clang-format off\\n+#include <libssh2_sftp.h>\\n+// clang-format on\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ libssh2_exit();\\n+ }\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\\n+{\\n+ static std::mutex mutex;\\n+ const std::lock_guard lock(mutex);\\n+\\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\\n+ auto sharedPtr = weakPtr.lock();\\n+\\n+ if (sharedPtr)\\n+ return sharedPtr;\\n+\\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\\n+ weakPtr = sharedPtr;\\n+\\n+ return sharedPtr;\\n+}\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::SftpFailure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::SftpBadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::SftpNoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::SftpNoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::SftpLockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\\n+ bool posixRenameSupported = true;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\\n+ m_predicate(std::move(predicate)),\\n+ m_period(period)\\n+{\\n+ if (!m_predicate)\\n+ m_predicate = [] { return false; };\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\\n+{\\n+ return m_predicate;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Time& Sftp::TimeoutPredicate::getPeriod() const\\n+{\\n+ return m_period;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::ReadinessType::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::ReadinessType::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::ReadinessType::Either);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutPredicate& timeout)\\n+{\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length > 0)\\n+ {\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+ else\\n+ {\\n+ return std::nullopt;\\n+ }\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(const std::string& name, const std::string& password, const TimeoutPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ m_impl->sftpSession.reset(libssh2_sftp_init(m_impl->ssh2Session.get()));\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\\nnew file mode 100644\\nindex 0000000000..95ab95a45e\\n--- /dev/null\\n+++ b/src/SFML/Network/Sftp.cpp\\n@@ -0,0 +1,1347 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+#include <SFML/System/Err.hpp>\\n+\\n+#include <libssh2_sftp.h>\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <ostream>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ libssh2_exit();\\n+ }\\n+\\n+ static inline std::mutex mutex;\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::Error, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::EndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::NoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::PermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::Failure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::BadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::NoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::ConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::OperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::InvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::NoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::WriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::NoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::QuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::LockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::NotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::InvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::LinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl : LibSsh2Initializer\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\\n+ {\\n+ const auto result = waitForOperationComplete(\\n+ [&]\\n+ {\\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\\n+\\n+ if (sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ bool posixRenameSupported = true;\\n+ std::filesystem::path cachedHomePath;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\\n+{\\n+ // Clear the cached home path\\n+ m_impl->cachedHomePath.clear();\\n+\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length == 0)\\n+ return std::nullopt;\\n+\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ err() << \\\"SFTP: Cannot get session information, session not yet started\\\" << std::endl;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Ensure the passphrase is NULL-terminated\\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\\n+ return login(name,\\n+ publicKeyData.data(),\\n+ publicKeyData.length(),\\n+ privateKeyData.data(),\\n+ privateKeyData.length(),\\n+ privateKeyPassphraseString.c_str(),\\n+ timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Check if we already cached the result for the home path\\n+ if ((path == \\\".\\\") && !m_impl->cachedHomePath.empty())\\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\\n+ .generic_u8string();\\n+\\n+ // Cache the result for the home path\\n+ if (path == \\\".\\\")\\n+ m_impl->cachedHomePath = genericPath;\\n+\\n+ return {Result(Result::Value::Success), genericPath};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\\n+ &attributes);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ {\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ 0,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENDIR);\\n+\\n+ if (handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (!handle)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+ }\\n+\\n+ std::vector<Attributes> listing;\\n+\\n+ {\\n+ std::array<char, 4096> buffer{};\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\\n+ timeout);\\n+\\n+ if (result > 0)\\n+ {\\n+ listing.emplace_back(\\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\\n+ attributes));\\n+\\n+ continue;\\n+ }\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ if (result == 0)\\n+ break;\\n+ }\\n+ }\\n+\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ return {Result(Result::Value::Success), std::move(listing)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\\n+ std::filesystem::perms permissions,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ makePermissions(permissions));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto oldPathString = oldPath.generic_u8string();\\n+ const auto newPathString = newPath.generic_u8string();\\n+\\n+ // POSIX rename is only supported starting from libssh2 1.11.1\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // POSIX rename doesn't support not overwriting\\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\\n+#endif\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ if (usePosix)\\n+ {\\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()));\\n+ }\\n+#endif\\n+\\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()),\\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // Retry using normal rename if we find out POSIX rename isn't supported\\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\\n+ {\\n+ m_impl->posixRenameSupported = false;\\n+ usePosix = false;\\n+ continue;\\n+ }\\n+#endif\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for reading\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ LIBSSH2_FXF_READ,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Read from the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ auto* ptr = buffer.get();\\n+ int read{};\\n+ std::size_t totalRead{};\\n+\\n+ while (length > 0)\\n+ {\\n+ read = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (read == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (read <= 0)\\n+ break;\\n+\\n+ ptr += read;\\n+ length -= static_cast<std::size_t>(read);\\n+ totalRead += static_cast<std::size_t>(read);\\n+ }\\n+\\n+ if (read < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ const auto stop = !callback(buffer.get(), totalRead);\\n+\\n+ // If read is 0 then we have reached EOF\\n+ if (stop || (read == 0))\\n+ break;\\n+\\n+ const auto expand = (totalRead == bufferSize);\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions,\\n+ bool truncate,\\n+ bool append,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for writing\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\\n+ makePermissions(permissions),\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Write to the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ const auto stop = !callback(buffer.get(), length);\\n+ const auto expand = (length == bufferSize);\\n+ const auto* ptr = buffer.get();\\n+ int written{};\\n+\\n+ while (length > 0)\\n+ {\\n+ written = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (written == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (written < 0)\\n+ break;\\n+\\n+ ptr += written;\\n+ length -= static_cast<std::size_t>(written);\\n+ }\\n+\\n+ if (written < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ if (stop)\\n+ break;\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+} // namespace sf\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10092,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"need to make sure it can fit into an unsigned int, bad actor may craft a very long file path in an attack. The buffer size will limit the ways in which they can exploit that, but they may be able to find other uses."},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"},"changed_files":{"kind":"list like","value":["src/SFML/Network/Sftp.cpp"],"string":"[\n \"src/SFML/Network/Sftp.cpp\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"need to make sure it can fit into an unsigned int, bad actor may craft a very long file path in an attack. The buffer size will limit the ways in which they can exploit that, but they may be able to find other uses.","path":"src/SFML/Network/Sftp.cpp","hunk":"@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+// clang-format off\n+#include <libssh2_sftp.h>\n+// clang-format on\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ libssh2_exit();\n+ }\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\n+{\n+ static std::mutex mutex;\n+ const std::lock_guard lock(mutex);\n+\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\n+ auto sharedPtr = weakPtr.lock();\n+\n+ if (sharedPtr)\n+ return sharedPtr;\n+\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\n+ weakPtr = sharedPtr;\n+\n+ return sharedPtr;\n+}\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::SftpFailure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::SftpBadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::SftpNoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::SftpNoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::SftpLockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\n+ bool posixRenameSupported = true;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\n+ m_predicate(std::move(predicate)),\n+ m_period(period)\n+{\n+ if (!m_predicate)\n+ m_predicate = [] { return false; };\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\n+{\n+ return m_predicate;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Time& Sftp::TimeoutPredicate::getPeriod() const\n+{\n+ return m_period;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::ReadinessType::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::ReadinessType::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::ReadinessType::Either);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutPredicate& timeout)\n+{\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length > 0)\n+ {\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+ else\n+ {\n+ return std::nullopt;\n+ }\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(const std::string& name, const std::string& password, const TimeoutPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ m_impl->sftpSession.reset(libssh2_sftp_init(m_impl->ssh2Session.get()));\n+\n+ if (m_impl->sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(const std::string& name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ m_impl->sftpSession.reset(libssh2_sftp_init(m_impl->ssh2Session.get()));\n+\n+ if (m_impl->sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"}],"string":"[\n {\n \"comment\": \"need to make sure it can fit into an unsigned int, bad actor may craft a very long file path in an attack. The buffer size will limit the ways in which they can exploit that, but they may be able to find other uses.\",\n \"path\": \"src/SFML/Network/Sftp.cpp\",\n \"hunk\": \"@@ -0,0 +1,1377 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+// clang-format off\\n+#include <libssh2_sftp.h>\\n+// clang-format on\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ libssh2_exit();\\n+ }\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\\n+{\\n+ static std::mutex mutex;\\n+ const std::lock_guard lock(mutex);\\n+\\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\\n+ auto sharedPtr = weakPtr.lock();\\n+\\n+ if (sharedPtr)\\n+ return sharedPtr;\\n+\\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\\n+ weakPtr = sharedPtr;\\n+\\n+ return sharedPtr;\\n+}\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::SftpFailure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::SftpBadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::SftpNoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::SftpNoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::SftpLockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\\n+ bool posixRenameSupported = true;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\\n+ m_predicate(std::move(predicate)),\\n+ m_period(period)\\n+{\\n+ if (!m_predicate)\\n+ m_predicate = [] { return false; };\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\\n+{\\n+ return m_predicate;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Time& Sftp::TimeoutPredicate::getPeriod() const\\n+{\\n+ return m_period;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::ReadinessType::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::ReadinessType::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::ReadinessType::Either);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutPredicate& timeout)\\n+{\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length > 0)\\n+ {\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+ else\\n+ {\\n+ return std::nullopt;\\n+ }\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(const std::string& name, const std::string& password, const TimeoutPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ m_impl->sftpSession.reset(libssh2_sftp_init(m_impl->ssh2Session.get()));\\n+\\n+ if (m_impl->sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(const std::string& name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ m_impl->sftpSession.reset(libssh2_sftp_init(m_impl->ssh2Session.get()));\\n+\\n+ if (m_impl->sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\\nnew file mode 100644\\nindex 0000000000..95ab95a45e\\n--- /dev/null\\n+++ b/src/SFML/Network/Sftp.cpp\\n@@ -0,0 +1,1347 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+#include <SFML/System/Err.hpp>\\n+\\n+#include <libssh2_sftp.h>\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <ostream>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ libssh2_exit();\\n+ }\\n+\\n+ static inline std::mutex mutex;\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::Error, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::EndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::NoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::PermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::Failure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::BadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::NoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::ConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::OperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::InvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::NoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::WriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::NoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::QuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::LockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::NotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::InvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::LinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl : LibSsh2Initializer\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\\n+ {\\n+ const auto result = waitForOperationComplete(\\n+ [&]\\n+ {\\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\\n+\\n+ if (sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ bool posixRenameSupported = true;\\n+ std::filesystem::path cachedHomePath;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\\n+{\\n+ // Clear the cached home path\\n+ m_impl->cachedHomePath.clear();\\n+\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length == 0)\\n+ return std::nullopt;\\n+\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ err() << \\\"SFTP: Cannot get session information, session not yet started\\\" << std::endl;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Ensure the passphrase is NULL-terminated\\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\\n+ return login(name,\\n+ publicKeyData.data(),\\n+ publicKeyData.length(),\\n+ privateKeyData.data(),\\n+ privateKeyData.length(),\\n+ privateKeyPassphraseString.c_str(),\\n+ timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Check if we already cached the result for the home path\\n+ if ((path == \\\".\\\") && !m_impl->cachedHomePath.empty())\\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\\n+ .generic_u8string();\\n+\\n+ // Cache the result for the home path\\n+ if (path == \\\".\\\")\\n+ m_impl->cachedHomePath = genericPath;\\n+\\n+ return {Result(Result::Value::Success), genericPath};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\\n+ &attributes);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ {\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ 0,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENDIR);\\n+\\n+ if (handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (!handle)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+ }\\n+\\n+ std::vector<Attributes> listing;\\n+\\n+ {\\n+ std::array<char, 4096> buffer{};\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\\n+ timeout);\\n+\\n+ if (result > 0)\\n+ {\\n+ listing.emplace_back(\\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\\n+ attributes));\\n+\\n+ continue;\\n+ }\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ if (result == 0)\\n+ break;\\n+ }\\n+ }\\n+\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ return {Result(Result::Value::Success), std::move(listing)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\\n+ std::filesystem::perms permissions,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ makePermissions(permissions));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto oldPathString = oldPath.generic_u8string();\\n+ const auto newPathString = newPath.generic_u8string();\\n+\\n+ // POSIX rename is only supported starting from libssh2 1.11.1\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // POSIX rename doesn't support not overwriting\\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\\n+#endif\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ if (usePosix)\\n+ {\\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()));\\n+ }\\n+#endif\\n+\\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()),\\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // Retry using normal rename if we find out POSIX rename isn't supported\\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\\n+ {\\n+ m_impl->posixRenameSupported = false;\\n+ usePosix = false;\\n+ continue;\\n+ }\\n+#endif\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for reading\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ LIBSSH2_FXF_READ,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Read from the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ auto* ptr = buffer.get();\\n+ int read{};\\n+ std::size_t totalRead{};\\n+\\n+ while (length > 0)\\n+ {\\n+ read = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (read == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (read <= 0)\\n+ break;\\n+\\n+ ptr += read;\\n+ length -= static_cast<std::size_t>(read);\\n+ totalRead += static_cast<std::size_t>(read);\\n+ }\\n+\\n+ if (read < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ const auto stop = !callback(buffer.get(), totalRead);\\n+\\n+ // If read is 0 then we have reached EOF\\n+ if (stop || (read == 0))\\n+ break;\\n+\\n+ const auto expand = (totalRead == bufferSize);\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions,\\n+ bool truncate,\\n+ bool append,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for writing\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\\n+ makePermissions(permissions),\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Write to the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ const auto stop = !callback(buffer.get(), length);\\n+ const auto expand = (length == bufferSize);\\n+ const auto* ptr = buffer.get();\\n+ int written{};\\n+\\n+ while (length > 0)\\n+ {\\n+ written = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (written == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (written < 0)\\n+ break;\\n+\\n+ ptr += written;\\n+ length -= static_cast<std::size_t>(written);\\n+ }\\n+\\n+ if (written < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ if (stop)\\n+ break;\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+} // namespace sf\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10093,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"Can we avoid a network call here; is it safe to presume the cwd won't change between ops?"},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"},"changed_files":{"kind":"list like","value":["src/SFML/Network/Sftp.cpp"],"string":"[\n \"src/SFML/Network/Sftp.cpp\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"Can we avoid a network call here; is it safe to presume the cwd won't change between ops?","path":"src/SFML/Network/Sftp.cpp","hunk":"@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+// clang-format off\n+#include <libssh2_sftp.h>\n+// clang-format on\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ libssh2_exit();\n+ }\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\n+{\n+ static std::mutex mutex;\n+ const std::lock_guard lock(mutex);\n+\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\n+ auto sharedPtr = weakPtr.lock();\n+\n+ if (sharedPtr)\n+ return sharedPtr;\n+\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\n+ weakPtr = sharedPtr;\n+\n+ return sharedPtr;\n+}\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::SftpFailure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::SftpBadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::SftpNoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::SftpNoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::SftpLockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\n+ bool posixRenameSupported = true;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\n+ m_predicate(std::move(predicate)),\n+ m_period(period)\n+{\n+ if (!m_predicate)\n+ m_predicate = [] { return false; };\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\n+{\n+ return m_predicate;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Time& Sftp::TimeoutPredicate::getPeriod() const\n+{\n+ return m_period;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::ReadinessType::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::ReadinessType::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::ReadinessType::Either);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutPredicate& timeout)\n+{\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length > 0)\n+ {\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+ else\n+ {\n+ return std::nullopt;\n+ }\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(const std::string& name, const std::string& password, const TimeoutPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ m_impl->sftpSession.reset(libssh2_sftp_init(m_impl->ssh2Session.get()));\n+\n+ if (m_impl->sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(const std::string& name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ m_impl->sftpSession.reset(libssh2_sftp_init(m_impl->ssh2Session.get()));\n+\n+ if (m_impl->sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success),\n+ std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string()};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"}],"string":"[\n {\n \"comment\": \"Can we avoid a network call here; is it safe to presume the cwd won't change between ops?\",\n \"path\": \"src/SFML/Network/Sftp.cpp\",\n \"hunk\": \"@@ -0,0 +1,1377 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+// clang-format off\\n+#include <libssh2_sftp.h>\\n+// clang-format on\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ libssh2_exit();\\n+ }\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\\n+{\\n+ static std::mutex mutex;\\n+ const std::lock_guard lock(mutex);\\n+\\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\\n+ auto sharedPtr = weakPtr.lock();\\n+\\n+ if (sharedPtr)\\n+ return sharedPtr;\\n+\\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\\n+ weakPtr = sharedPtr;\\n+\\n+ return sharedPtr;\\n+}\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::SftpFailure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::SftpBadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::SftpNoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::SftpNoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::SftpLockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\\n+ bool posixRenameSupported = true;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\\n+ m_predicate(std::move(predicate)),\\n+ m_period(period)\\n+{\\n+ if (!m_predicate)\\n+ m_predicate = [] { return false; };\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\\n+{\\n+ return m_predicate;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Time& Sftp::TimeoutPredicate::getPeriod() const\\n+{\\n+ return m_period;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::ReadinessType::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::ReadinessType::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::ReadinessType::Either);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutPredicate& timeout)\\n+{\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length > 0)\\n+ {\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+ else\\n+ {\\n+ return std::nullopt;\\n+ }\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(const std::string& name, const std::string& password, const TimeoutPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ m_impl->sftpSession.reset(libssh2_sftp_init(m_impl->ssh2Session.get()));\\n+\\n+ if (m_impl->sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(const std::string& name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ m_impl->sftpSession.reset(libssh2_sftp_init(m_impl->ssh2Session.get()));\\n+\\n+ if (m_impl->sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success),\\n+ std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string()};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\\nnew file mode 100644\\nindex 0000000000..95ab95a45e\\n--- /dev/null\\n+++ b/src/SFML/Network/Sftp.cpp\\n@@ -0,0 +1,1347 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+#include <SFML/System/Err.hpp>\\n+\\n+#include <libssh2_sftp.h>\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <ostream>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ libssh2_exit();\\n+ }\\n+\\n+ static inline std::mutex mutex;\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::Error, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::EndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::NoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::PermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::Failure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::BadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::NoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::ConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::OperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::InvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::NoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::WriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::NoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::QuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::LockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::NotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::InvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::LinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl : LibSsh2Initializer\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\\n+ {\\n+ const auto result = waitForOperationComplete(\\n+ [&]\\n+ {\\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\\n+\\n+ if (sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ bool posixRenameSupported = true;\\n+ std::filesystem::path cachedHomePath;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\\n+{\\n+ // Clear the cached home path\\n+ m_impl->cachedHomePath.clear();\\n+\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length == 0)\\n+ return std::nullopt;\\n+\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ err() << \\\"SFTP: Cannot get session information, session not yet started\\\" << std::endl;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Ensure the passphrase is NULL-terminated\\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\\n+ return login(name,\\n+ publicKeyData.data(),\\n+ publicKeyData.length(),\\n+ privateKeyData.data(),\\n+ privateKeyData.length(),\\n+ privateKeyPassphraseString.c_str(),\\n+ timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Check if we already cached the result for the home path\\n+ if ((path == \\\".\\\") && !m_impl->cachedHomePath.empty())\\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\\n+ .generic_u8string();\\n+\\n+ // Cache the result for the home path\\n+ if (path == \\\".\\\")\\n+ m_impl->cachedHomePath = genericPath;\\n+\\n+ return {Result(Result::Value::Success), genericPath};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\\n+ &attributes);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ {\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ 0,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENDIR);\\n+\\n+ if (handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (!handle)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+ }\\n+\\n+ std::vector<Attributes> listing;\\n+\\n+ {\\n+ std::array<char, 4096> buffer{};\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\\n+ timeout);\\n+\\n+ if (result > 0)\\n+ {\\n+ listing.emplace_back(\\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\\n+ attributes));\\n+\\n+ continue;\\n+ }\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ if (result == 0)\\n+ break;\\n+ }\\n+ }\\n+\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ return {Result(Result::Value::Success), std::move(listing)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\\n+ std::filesystem::perms permissions,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ makePermissions(permissions));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto oldPathString = oldPath.generic_u8string();\\n+ const auto newPathString = newPath.generic_u8string();\\n+\\n+ // POSIX rename is only supported starting from libssh2 1.11.1\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // POSIX rename doesn't support not overwriting\\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\\n+#endif\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ if (usePosix)\\n+ {\\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()));\\n+ }\\n+#endif\\n+\\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()),\\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // Retry using normal rename if we find out POSIX rename isn't supported\\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\\n+ {\\n+ m_impl->posixRenameSupported = false;\\n+ usePosix = false;\\n+ continue;\\n+ }\\n+#endif\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for reading\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ LIBSSH2_FXF_READ,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Read from the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ auto* ptr = buffer.get();\\n+ int read{};\\n+ std::size_t totalRead{};\\n+\\n+ while (length > 0)\\n+ {\\n+ read = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (read == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (read <= 0)\\n+ break;\\n+\\n+ ptr += read;\\n+ length -= static_cast<std::size_t>(read);\\n+ totalRead += static_cast<std::size_t>(read);\\n+ }\\n+\\n+ if (read < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ const auto stop = !callback(buffer.get(), totalRead);\\n+\\n+ // If read is 0 then we have reached EOF\\n+ if (stop || (read == 0))\\n+ break;\\n+\\n+ const auto expand = (totalRead == bufferSize);\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions,\\n+ bool truncate,\\n+ bool append,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for writing\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\\n+ makePermissions(permissions),\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Write to the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ const auto stop = !callback(buffer.get(), length);\\n+ const auto expand = (length == bufferSize);\\n+ const auto* ptr = buffer.get();\\n+ int written{};\\n+\\n+ while (length > 0)\\n+ {\\n+ written = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (written == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (written < 0)\\n+ break;\\n+\\n+ ptr += written;\\n+ length -= static_cast<std::size_t>(written);\\n+ }\\n+\\n+ if (written < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ if (stop)\\n+ break;\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+} // namespace sf\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10094,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"why not just use a std::array here? You can get the ptr out via .data()"},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"},"changed_files":{"kind":"list like","value":["src/SFML/Network/Sftp.cpp"],"string":"[\n \"src/SFML/Network/Sftp.cpp\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"why not just use a std::array here? You can get the ptr out via .data()","path":"src/SFML/Network/Sftp.cpp","hunk":"@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+// clang-format off\n+#include <libssh2_sftp.h>\n+// clang-format on\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ libssh2_exit();\n+ }\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\n+{\n+ static std::mutex mutex;\n+ const std::lock_guard lock(mutex);\n+\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\n+ auto sharedPtr = weakPtr.lock();\n+\n+ if (sharedPtr)\n+ return sharedPtr;\n+\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\n+ weakPtr = sharedPtr;\n+\n+ return sharedPtr;\n+}\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::SftpFailure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::SftpBadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::SftpNoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::SftpNoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::SftpLockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\n+ bool posixRenameSupported = true;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\n+ m_predicate(std::move(predicate)),\n+ m_period(period)\n+{\n+ if (!m_predicate)\n+ m_predicate = [] { return false; };\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\n+{\n+ return m_predicate;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Time& Sftp::TimeoutPredicate::getPeriod() const\n+{\n+ return m_period;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::ReadinessType::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::ReadinessType::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::ReadinessType::Either);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutPredicate& timeout)\n+{\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length > 0)\n+ {\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+ else\n+ {\n+ return std::nullopt;\n+ }\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(const std::string& name, const std::string& password, const TimeoutPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ m_impl->sftpSession.reset(libssh2_sftp_init(m_impl->ssh2Session.get()));\n+\n+ if (m_impl->sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(const std::string& name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ m_impl->sftpSession.reset(libssh2_sftp_init(m_impl->ssh2Session.get()));\n+\n+ if (m_impl->sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success),\n+ std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string()};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"}],"string":"[\n {\n \"comment\": \"why not just use a std::array here? You can get the ptr out via .data()\",\n \"path\": \"src/SFML/Network/Sftp.cpp\",\n \"hunk\": \"@@ -0,0 +1,1377 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+// clang-format off\\n+#include <libssh2_sftp.h>\\n+// clang-format on\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ libssh2_exit();\\n+ }\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\\n+{\\n+ static std::mutex mutex;\\n+ const std::lock_guard lock(mutex);\\n+\\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\\n+ auto sharedPtr = weakPtr.lock();\\n+\\n+ if (sharedPtr)\\n+ return sharedPtr;\\n+\\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\\n+ weakPtr = sharedPtr;\\n+\\n+ return sharedPtr;\\n+}\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::SftpFailure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::SftpBadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::SftpNoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::SftpNoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::SftpLockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\\n+ bool posixRenameSupported = true;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\\n+ m_predicate(std::move(predicate)),\\n+ m_period(period)\\n+{\\n+ if (!m_predicate)\\n+ m_predicate = [] { return false; };\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\\n+{\\n+ return m_predicate;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Time& Sftp::TimeoutPredicate::getPeriod() const\\n+{\\n+ return m_period;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::ReadinessType::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::ReadinessType::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::ReadinessType::Either);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutPredicate& timeout)\\n+{\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length > 0)\\n+ {\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+ else\\n+ {\\n+ return std::nullopt;\\n+ }\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(const std::string& name, const std::string& password, const TimeoutPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ m_impl->sftpSession.reset(libssh2_sftp_init(m_impl->ssh2Session.get()));\\n+\\n+ if (m_impl->sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(const std::string& name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ m_impl->sftpSession.reset(libssh2_sftp_init(m_impl->ssh2Session.get()));\\n+\\n+ if (m_impl->sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success),\\n+ std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string()};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\\n+ &attributes);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ {\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ 0,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENDIR);\\n+\\n+ if (handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (!handle)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+ }\\n+\\n+ std::vector<Attributes> listing;\\n+\\n+ {\\n+ std::array<char, 4096> buffer{};\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\\n+ timeout);\\n+\\n+ if (result > 0)\\n+ {\\n+ listing.emplace_back(\\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\\n+ attributes));\\n+\\n+ continue;\\n+ }\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ if (result == 0)\\n+ break;\\n+ }\\n+ }\\n+\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ return {Result(Result::Value::Success), std::move(listing)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\\n+ std::filesystem::perms permissions,\\n+ const TimeoutPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ makePermissions(permissions));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite,\\n+ const TimeoutPredicate& timeout)\\n+{\\n+ const auto oldPathString = oldPath.generic_u8string();\\n+ const auto newPathString = newPath.generic_u8string();\\n+\\n+ // POSIX rename is only supported starting from libssh2 1.11.1\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // POSIX rename doesn't support not overwriting\\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\\n+#endif\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ if (usePosix)\\n+ {\\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()));\\n+ }\\n+#endif\\n+\\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()),\\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // Retry using normal rename if we find out POSIX rename isn't supported\\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\\n+ {\\n+ m_impl->posixRenameSupported = false;\\n+ usePosix = false;\\n+ continue;\\n+ }\\n+#endif\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset,\\n+ const TimeoutPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for reading\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ LIBSSH2_FXF_READ,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Read from the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\\nnew file mode 100644\\nindex 0000000000..95ab95a45e\\n--- /dev/null\\n+++ b/src/SFML/Network/Sftp.cpp\\n@@ -0,0 +1,1347 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+#include <SFML/System/Err.hpp>\\n+\\n+#include <libssh2_sftp.h>\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <ostream>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ libssh2_exit();\\n+ }\\n+\\n+ static inline std::mutex mutex;\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::Error, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::EndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::NoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::PermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::Failure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::BadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::NoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::ConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::OperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::InvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::NoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::WriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::NoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::QuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::LockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::NotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::InvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::LinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl : LibSsh2Initializer\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\\n+ {\\n+ const auto result = waitForOperationComplete(\\n+ [&]\\n+ {\\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\\n+\\n+ if (sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ bool posixRenameSupported = true;\\n+ std::filesystem::path cachedHomePath;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\\n+{\\n+ // Clear the cached home path\\n+ m_impl->cachedHomePath.clear();\\n+\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length == 0)\\n+ return std::nullopt;\\n+\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ err() << \\\"SFTP: Cannot get session information, session not yet started\\\" << std::endl;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Ensure the passphrase is NULL-terminated\\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\\n+ return login(name,\\n+ publicKeyData.data(),\\n+ publicKeyData.length(),\\n+ privateKeyData.data(),\\n+ privateKeyData.length(),\\n+ privateKeyPassphraseString.c_str(),\\n+ timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Check if we already cached the result for the home path\\n+ if ((path == \\\".\\\") && !m_impl->cachedHomePath.empty())\\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\\n+ .generic_u8string();\\n+\\n+ // Cache the result for the home path\\n+ if (path == \\\".\\\")\\n+ m_impl->cachedHomePath = genericPath;\\n+\\n+ return {Result(Result::Value::Success), genericPath};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\\n+ &attributes);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ {\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ 0,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENDIR);\\n+\\n+ if (handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (!handle)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+ }\\n+\\n+ std::vector<Attributes> listing;\\n+\\n+ {\\n+ std::array<char, 4096> buffer{};\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\\n+ timeout);\\n+\\n+ if (result > 0)\\n+ {\\n+ listing.emplace_back(\\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\\n+ attributes));\\n+\\n+ continue;\\n+ }\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ if (result == 0)\\n+ break;\\n+ }\\n+ }\\n+\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ return {Result(Result::Value::Success), std::move(listing)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\\n+ std::filesystem::perms permissions,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ makePermissions(permissions));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto oldPathString = oldPath.generic_u8string();\\n+ const auto newPathString = newPath.generic_u8string();\\n+\\n+ // POSIX rename is only supported starting from libssh2 1.11.1\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // POSIX rename doesn't support not overwriting\\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\\n+#endif\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ if (usePosix)\\n+ {\\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()));\\n+ }\\n+#endif\\n+\\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()),\\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // Retry using normal rename if we find out POSIX rename isn't supported\\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\\n+ {\\n+ m_impl->posixRenameSupported = false;\\n+ usePosix = false;\\n+ continue;\\n+ }\\n+#endif\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for reading\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ LIBSSH2_FXF_READ,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Read from the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ auto* ptr = buffer.get();\\n+ int read{};\\n+ std::size_t totalRead{};\\n+\\n+ while (length > 0)\\n+ {\\n+ read = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (read == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (read <= 0)\\n+ break;\\n+\\n+ ptr += read;\\n+ length -= static_cast<std::size_t>(read);\\n+ totalRead += static_cast<std::size_t>(read);\\n+ }\\n+\\n+ if (read < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ const auto stop = !callback(buffer.get(), totalRead);\\n+\\n+ // If read is 0 then we have reached EOF\\n+ if (stop || (read == 0))\\n+ break;\\n+\\n+ const auto expand = (totalRead == bufferSize);\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions,\\n+ bool truncate,\\n+ bool append,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for writing\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\\n+ makePermissions(permissions),\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Write to the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ const auto stop = !callback(buffer.get(), length);\\n+ const auto expand = (length == bufferSize);\\n+ const auto* ptr = buffer.get();\\n+ int written{};\\n+\\n+ while (length > 0)\\n+ {\\n+ written = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (written == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (written < 0)\\n+ break;\\n+\\n+ ptr += written;\\n+ length -= static_cast<std::size_t>(written);\\n+ }\\n+\\n+ if (written < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ if (stop)\\n+ break;\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+} // namespace sf\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10095,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"do you think there's value in asserting the length is >= read here?"},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"},"changed_files":{"kind":"list like","value":["src/SFML/Network/Sftp.cpp"],"string":"[\n \"src/SFML/Network/Sftp.cpp\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"do you think there's value in asserting the length is >= read here?","path":"src/SFML/Network/Sftp.cpp","hunk":"@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+// clang-format off\n+#include <libssh2_sftp.h>\n+// clang-format on\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ libssh2_exit();\n+ }\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\n+{\n+ static std::mutex mutex;\n+ const std::lock_guard lock(mutex);\n+\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\n+ auto sharedPtr = weakPtr.lock();\n+\n+ if (sharedPtr)\n+ return sharedPtr;\n+\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\n+ weakPtr = sharedPtr;\n+\n+ return sharedPtr;\n+}\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::SftpFailure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::SftpBadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::SftpNoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::SftpNoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::SftpLockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\n+ bool posixRenameSupported = true;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\n+ m_predicate(std::move(predicate)),\n+ m_period(period)\n+{\n+ if (!m_predicate)\n+ m_predicate = [] { return false; };\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\n+{\n+ return m_predicate;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Time& Sftp::TimeoutPredicate::getPeriod() const\n+{\n+ return m_period;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::ReadinessType::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::ReadinessType::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::ReadinessType::Either);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutPredicate& timeout)\n+{\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length > 0)\n+ {\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+ else\n+ {\n+ return std::nullopt;\n+ }\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(const std::string& name, const std::string& password, const TimeoutPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ m_impl->sftpSession.reset(libssh2_sftp_init(m_impl->ssh2Session.get()));\n+\n+ if (m_impl->sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(const std::string& name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ m_impl->sftpSession.reset(libssh2_sftp_init(m_impl->ssh2Session.get()));\n+\n+ if (m_impl->sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success),\n+ std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string()};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\nnew file mode 100644\nindex 0000000000..95ab95a45e\n--- /dev/null\n+++ b/src/SFML/Network/Sftp.cpp\n@@ -0,0 +1,1347 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/IpAddress.hpp>\n+#include <SFML/Network/Sftp.hpp>\n+#include <SFML/Network/SocketSelector.hpp>\n+#include <SFML/Network/TcpSocket.hpp>\n+\n+#include <SFML/System/Err.hpp>\n+\n+#include <libssh2_sftp.h>\n+\n+#include <algorithm>\n+#include <array>\n+#include <chrono>\n+#include <mutex>\n+#include <ostream>\n+#include <string_view>\n+\n+#include <cassert>\n+#include <cstring>\n+\n+\n+namespace\n+{\n+struct LibSsh2Initializer\n+{\n+ LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ [[maybe_unused]] const auto result = libssh2_init(0);\n+ assert(result == 0);\n+ }\n+\n+ ~LibSsh2Initializer()\n+ {\n+ const std::lock_guard lock(mutex);\n+ libssh2_exit();\n+ }\n+\n+ static inline std::mutex mutex;\n+};\n+\n+struct Ssh2SessionDeleter\n+{\n+ void operator()(LIBSSH2_SESSION* ptr)\n+ {\n+ libssh2_session_free(ptr);\n+ }\n+};\n+\n+struct SftpSessionDeleter\n+{\n+ void operator()(LIBSSH2_SFTP* ptr)\n+ {\n+ libssh2_sftp_shutdown(ptr);\n+ }\n+};\n+\n+int makePermissions(std::filesystem::perms permissions)\n+{\n+ int result{};\n+ const auto add = [&](int i, std::filesystem::perms p)\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\n+ return result;\n+}\n+\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\n+{\n+ sf::Sftp::Attributes attributes{};\n+ attributes.path = std::move(path);\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\n+ attributes.size = input.filesize;\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\n+ {\n+ attributes.userId = input.uid;\n+ attributes.groupId = input.gid;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\n+ {\n+ auto& permissions = attributes.permissions.emplace();\n+\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\n+ permissions |= std::filesystem::perms::owner_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\n+ permissions |= std::filesystem::perms::owner_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\n+ permissions |= std::filesystem::perms::owner_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\n+ permissions |= std::filesystem::perms::group_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\n+ permissions |= std::filesystem::perms::group_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\n+ permissions |= std::filesystem::perms::group_exec;\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\n+ permissions |= std::filesystem::perms::others_read;\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\n+ permissions |= std::filesystem::perms::others_write;\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\n+ permissions |= std::filesystem::perms::others_exec;\n+\n+ auto& type = attributes.type.emplace();\n+\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\n+ type = std::filesystem::file_type::fifo;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\n+ type = std::filesystem::file_type::character;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\n+ type = std::filesystem::file_type::directory;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\n+ type = std::filesystem::file_type::block;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\n+ type = std::filesystem::file_type::regular;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\n+ type = std::filesystem::file_type::symlink;\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\n+ type = std::filesystem::file_type::socket;\n+ }\n+\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\n+ {\n+ attributes.accessTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\n+ attributes.modificationTime = std::filesystem::file_time_type(\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\n+ }\n+\n+ return attributes;\n+}\n+\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ if (!sftp)\n+ return sf::Sftp::Result(Value::Error, \"General error\");\n+\n+ switch (libssh2_sftp_last_error(sftp))\n+ {\n+ case LIBSSH2_FX_EOF:\n+ return sf::Sftp::Result(Value::EndOfFile, \"End of file\");\n+ case LIBSSH2_FX_NO_SUCH_FILE:\n+ return sf::Sftp::Result(Value::NoSuchFile, \"No such file\");\n+ case LIBSSH2_FX_PERMISSION_DENIED:\n+ return sf::Sftp::Result(Value::PermissionDenied, \"Permission denied\");\n+ case LIBSSH2_FX_FAILURE:\n+ return sf::Sftp::Result(Value::Failure, \"Failure\");\n+ case LIBSSH2_FX_BAD_MESSAGE:\n+ return sf::Sftp::Result(Value::BadMessage, \"Bad message\");\n+ case LIBSSH2_FX_NO_CONNECTION:\n+ return sf::Sftp::Result(Value::NoConnection, \"No connection\");\n+ case LIBSSH2_FX_CONNECTION_LOST:\n+ return sf::Sftp::Result(Value::ConnectionLost, \"Connection lost\");\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\n+ return sf::Sftp::Result(Value::OperationUnsupported, \"Operation unsupported\");\n+ case LIBSSH2_FX_INVALID_HANDLE:\n+ return sf::Sftp::Result(Value::InvalidHandle, \"Invalid handle\");\n+ case LIBSSH2_FX_NO_SUCH_PATH:\n+ return sf::Sftp::Result(Value::NoSuchPath, \"No such path\");\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \"File already exists\");\n+ case LIBSSH2_FX_WRITE_PROTECT:\n+ return sf::Sftp::Result(Value::WriteProtect, \"Write protect\");\n+ case LIBSSH2_FX_NO_MEDIA:\n+ return sf::Sftp::Result(Value::NoMedia, \"No media\");\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \"No space on filesystem\");\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\n+ return sf::Sftp::Result(Value::QuotaExceeded, \"Quota exceeded\");\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \"Unknown principal\");\n+ case LIBSSH2_FX_LOCK_CONFLICT:\n+ return sf::Sftp::Result(Value::LockConflict, \"Lock conflict\");\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \"Directory not empty\");\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\n+ return sf::Sftp::Result(Value::NotADirectory, \"Not a directory\");\n+ case LIBSSH2_FX_INVALID_FILENAME:\n+ return sf::Sftp::Result(Value::InvalidFilename, \"Invalid filename\");\n+ case LIBSSH2_FX_LINK_LOOP:\n+ return sf::Sftp::Result(Value::LinkLoop, \"Link loop\");\n+ default:\n+ return sf::Sftp::Result(Value::SftpError, \"General error\");\n+ }\n+}\n+\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\n+{\n+ using Value = sf::Sftp::Result::Value;\n+\n+ char* ptr{};\n+ auto length = 0;\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\n+ const auto size = static_cast<std::size_t>(length);\n+\n+ switch (error)\n+ {\n+ case LIBSSH2_ERROR_BANNER_RECV:\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\n+ case LIBSSH2_ERROR_BANNER_SEND:\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\n+ case LIBSSH2_ERROR_INVALID_MAC:\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\n+ case LIBSSH2_ERROR_KEX_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_ALLOC:\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_SEND:\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\n+ case LIBSSH2_ERROR_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\n+ case LIBSSH2_ERROR_DECRYPT:\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\n+ case LIBSSH2_ERROR_PROTO:\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\n+ case LIBSSH2_ERROR_FILE:\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NONE:\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_ZLIB:\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\n+ return makeSftpError(sftp);\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\n+ case LIBSSH2_ERROR_INVAL:\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_USE:\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\n+ case LIBSSH2_ERROR_COMPRESS:\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\n+ case LIBSSH2_ERROR_SOCKET_RECV:\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\n+ case LIBSSH2_ERROR_ENCRYPT:\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\n+ case LIBSSH2_ERROR_BAD_SOCKET:\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\n+ default:\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\n+ }\n+}\n+} // namespace\n+\n+\n+namespace sf\n+{\n+struct Sftp::Impl : LibSsh2Initializer\n+{\n+ Impl()\n+ {\n+ socket.setBlocking(false);\n+ }\n+\n+ template <typename Callable>\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\n+ {\n+ while (true)\n+ {\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\n+ return result; // Operation completed without having to block\n+\n+ // Wait for socket to become ready\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\n+ {\n+ if (selectorEither.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\n+ {\n+ if (selectorSend.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+ else\n+ {\n+ if (selectorRecv.wait(timeout.getPeriod()))\n+ continue;\n+ }\n+\n+ if (!timeout.getPredicate()())\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\n+ }\n+ }\n+\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\n+ {\n+ const auto result = waitForOperationComplete(\n+ [&]\n+ {\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\n+\n+ if (sftpSession)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t sent{};\n+ const auto result = impl.socket.send(buffer, length, sent);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(sent);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (sent > 0)\n+ return static_cast<ssize_t>(sent);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\n+ {\n+ auto& impl = *static_cast<Impl*>(*implPtr);\n+ std::size_t received{};\n+ const auto result = impl.socket.receive(buffer, length, received);\n+\n+ // Map SFML-specific return values back to POSIX return values\n+ if (result == Socket::Status::Done)\n+ return static_cast<ssize_t>(received);\n+\n+ if (result == Socket::Status::Partial)\n+ {\n+ if (received > 0)\n+ return static_cast<ssize_t>(received);\n+ return -EAGAIN;\n+ }\n+\n+ if (result == Socket::Status::NotReady)\n+ return -EAGAIN;\n+\n+ if (result == Socket::Status::Disconnected)\n+ return 0;\n+\n+ // Socket::Status::Error\n+ return -1;\n+ }\n+\n+ bool posixRenameSupported = true;\n+ std::filesystem::path cachedHomePath;\n+ TcpSocket socket;\n+ sf::SocketSelector selectorRecv;\n+ sf::SocketSelector selectorSend;\n+ sf::SocketSelector selectorEither;\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\n+};\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+bool Sftp::Result::isOk() const\n+{\n+ return m_value == Value::Success;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result::Value Sftp::Result::getValue() const\n+{\n+ return m_value;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::string& Sftp::Result::getMessage() const\n+{\n+ return m_message;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_path = std::move(path);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::filesystem::path& Sftp::PathResult::getPath() const\n+{\n+ return m_path;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_attributes = std::move(attributes);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\n+{\n+ return m_attributes;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\n+{\n+ if (isOk())\n+ m_listing = std::move(listing);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\n+{\n+ return m_listing;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\n+{\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::~Sftp()\n+{\n+ (void)disconnect();\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\n+{\n+ (void)disconnect(timeout);\n+\n+ if (const auto status = m_impl->socket.connect(server, port);\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\n+ return Result(Result::Value::Disconnected);\n+\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\n+\n+ // Wait for the socket to become connected\n+ while (true)\n+ {\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\n+ break;\n+\n+ if (!timeout.getPredicate()())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Timeout);\n+ }\n+ }\n+\n+ // Check if our connection was actually accepted or refused\n+ if (!m_impl->socket.getRemoteAddress().has_value())\n+ {\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+ return Result(Result::Value::Refused);\n+ }\n+\n+ // At this point the TCP connection is established\n+\n+ // Reset POSIX rename supported flag to assume true for new connections\n+ m_impl->posixRenameSupported = true;\n+\n+ // Set up SSH session\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\n+ assert(m_impl->ssh2Session);\n+\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\n+\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_SEND,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\n+#else\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\n+ LIBSSH2_CALLBACK_RECV,\n+ reinterpret_cast<void*>(&Impl::handleReceive));\n+#endif\n+\n+ // Block SIGPIPE\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Enable compression if available\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\n+ return Result(Result::Value::Error);\n+\n+ // Perform handshake\n+ const auto\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\n+{\n+ // Clear the cached home path\n+ m_impl->cachedHomePath.clear();\n+\n+ // Shut down the SFTP session\n+ if (m_impl->sftpSession)\n+ {\n+ auto* sftpSession = m_impl->sftpSession.release();\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ // Disconnect the SSH session\n+ if (m_impl->ssh2Session)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \"\", \"\"); },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\n+ }\n+\n+ // Destroy the SSH session\n+ m_impl->ssh2Session.reset();\n+\n+ // Disconnect the TCP connection\n+ m_impl->selectorRecv.clear();\n+ m_impl->selectorSend.clear();\n+ m_impl->selectorEither.clear();\n+ m_impl->socket.disconnect();\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\n+{\n+ if (!m_impl->ssh2Session)\n+ return std::nullopt;\n+\n+ SessionInfo sessionInfo;\n+\n+ {\n+ std::size_t length{};\n+ auto type = 0;\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\n+\n+ if (length == 0)\n+ return std::nullopt;\n+\n+ SessionInfo::HostKey hostKey;\n+ hostKey.data.resize(length);\n+ std::memcpy(hostKey.data.data(), ptr, length);\n+\n+ switch (type)\n+ {\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\n+ break;\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\n+ break;\n+ default:\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\n+ break;\n+ }\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\n+\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\n+\n+ sessionInfo.hostKey = std::move(hostKey);\n+ }\n+\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\n+ {\n+ if (!session)\n+ return \"\";\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\n+ return result;\n+ err() << \"SFTP: Cannot get session information, session not yet started\" << std::endl;\n+ return \"\";\n+ };\n+\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\n+\n+ return sessionInfo;\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\n+ name.data(),\n+ static_cast<unsigned int>(name.size()),\n+ password.data(),\n+ static_cast<unsigned int>(password.size()),\n+ nullptr);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Perform login\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\n+ name.data(),\n+ name.size(),\n+ publicKeyData,\n+ publicKeyLength,\n+ privateKeyData,\n+ privateKeyLength,\n+ privateKeyPassphrase);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get());\n+ }\n+\n+ // Initialize SFTP session\n+ return m_impl->initializeSftp(timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ // Ensure the passphrase is NULL-terminated\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\n+ return login(name,\n+ publicKeyData.data(),\n+ publicKeyData.length(),\n+ privateKeyData.data(),\n+ privateKeyData.length(),\n+ privateKeyPassphraseString.c_str(),\n+ timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ // Check if we already cached the result for the home path\n+ if ((path == \".\") && !m_impl->cachedHomePath.empty())\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\n+\n+ const auto pathString = path.generic_u8string();\n+ std::array<char, 4096> buffer{};\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ buffer.data(),\n+ static_cast<unsigned int>(buffer.size()),\n+ LIBSSH2_SFTP_REALPATH);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\n+ .generic_u8string();\n+\n+ // Cache the result for the home path\n+ if (path == \".\")\n+ m_impl->cachedHomePath = genericPath;\n+\n+ return {Result(Result::Value::Success), genericPath};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\n+{\n+ return resolvePath(\".\", timeout);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\n+ &attributes);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (result < 0)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ {\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ 0,\n+ 0,\n+ LIBSSH2_SFTP_OPENDIR);\n+\n+ if (handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+\n+ if (!handle)\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\n+ }\n+\n+ std::vector<Attributes> listing;\n+\n+ {\n+ std::array<char, 4096> buffer{};\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\n+ timeout);\n+\n+ if (result > 0)\n+ {\n+ listing.emplace_back(\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\n+ attributes));\n+\n+ continue;\n+ }\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ if (result == 0)\n+ break;\n+ }\n+ }\n+\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return {Result(Result::Value::Timeout), {}};\n+ }\n+\n+ return {Result(Result::Value::Success), std::move(listing)};\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\n+ std::filesystem::perms permissions,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ makePermissions(permissions));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ const auto oldPathString = oldPath.generic_u8string();\n+ const auto newPathString = newPath.generic_u8string();\n+\n+ // POSIX rename is only supported starting from libssh2 1.11.1\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // POSIX rename doesn't support not overwriting\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\n+#endif\n+\n+ while (true)\n+ {\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ if (usePosix)\n+ {\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()));\n+ }\n+#endif\n+\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\n+ oldPathString.data(),\n+ static_cast<unsigned int>(oldPathString.size()),\n+ newPathString.data(),\n+ static_cast<unsigned int>(newPathString.size()),\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\n+ // Retry using normal rename if we find out POSIX rename isn't supported\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\n+ {\n+ m_impl->posixRenameSupported = false;\n+ usePosix = false;\n+ continue;\n+ }\n+#endif\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+ }\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\n+{\n+ const auto pathString = path.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()));\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for reading\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ LIBSSH2_FXF_READ,\n+ 0,\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Read from the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ auto* ptr = buffer.get();\n+ int read{};\n+ std::size_t totalRead{};\n+\n+ while (length > 0)\n+ {\n+ read = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\n+ timeout);\n+\n+ if (read == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (read <= 0)\n+ break;\n+\n+ ptr += read;\n+ length -= static_cast<std::size_t>(read);\n+ totalRead += static_cast<std::size_t>(read);\n+ }\n+\n+ if (read < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ const auto stop = !callback(buffer.get(), totalRead);\n+\n+ // If read is 0 then we have reached EOF\n+ if (stop || (read == 0))\n+ break;\n+\n+ const auto expand = (totalRead == bufferSize);\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+\n+////////////////////////////////////////////////////////////\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions,\n+ bool truncate,\n+ bool append,\n+ std::uint64_t offset,\n+ const TimeoutWithPredicate& timeout)\n+{\n+ if (!callback)\n+ return Result(Result::Value::Error);\n+\n+ LIBSSH2_SFTP_HANDLE* handle{};\n+\n+ // Open the file for writing\n+ {\n+ const auto pathString = remotePath.generic_u8string();\n+ const auto result = m_impl->waitForOperationComplete(\n+ [&]\n+ {\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\n+ pathString.data(),\n+ static_cast<unsigned int>(pathString.size()),\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\n+ makePermissions(permissions),\n+ LIBSSH2_SFTP_OPENFILE);\n+ handle)\n+ return LIBSSH2_ERROR_NONE;\n+\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\n+ },\n+ timeout);\n+\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\n+ return Result(Result::Value::Timeout);\n+\n+ if (!handle)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ // Seek to the offset if one was specified\n+ if (offset > 0)\n+ libssh2_sftp_seek64(handle, offset);\n+\n+ // Write to the file\n+ {\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\n+ auto bufferSize = bufferSizeStart;\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+\n+ while (true)\n+ {\n+ std::size_t length = bufferSize;\n+ const auto stop = !callback(buffer.get(), length);\n+ const auto expand = (length == bufferSize);\n+ const auto* ptr = buffer.get();\n+ int written{};\n+\n+ while (length > 0)\n+ {\n+ written = m_impl->waitForOperationComplete(\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\n+ timeout);\n+\n+ if (written == LIBSSH2_ERROR_EAGAIN)\n+ {\n+ libssh2_sftp_close_handle(handle);\n+ return Result(Result::Value::Timeout);\n+ }\n+\n+ if (written < 0)\n+ break;\n+\n+ ptr += written;\n+ length -= static_cast<std::size_t>(written);\n+ }\n+\n+ if (written < 0)\n+ {\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ libssh2_sftp_close_handle(handle);\n+ return result;\n+ }\n+\n+ if (stop)\n+ break;\n+\n+ if (expand && (bufferSize < bufferSizeMax))\n+ {\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\n+ }\n+ }\n+ }\n+\n+ // Close the file\n+ {\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\n+\n+ if (result == LIBSSH2_ERROR_EAGAIN)\n+ return Result(Result::Value::Timeout);\n+\n+ if (result < 0)\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\n+ }\n+\n+ return Result(Result::Value::Success);\n+}\n+\n+} // namespace sf\n"}],"string":"[\n {\n \"comment\": \"do you think there's value in asserting the length is >= read here?\",\n \"path\": \"src/SFML/Network/Sftp.cpp\",\n \"hunk\": \"@@ -0,0 +1,1377 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+// clang-format off\\n+#include <libssh2_sftp.h>\\n+// clang-format on\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ libssh2_exit();\\n+ }\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+std::shared_ptr<LibSsh2Initializer> makeInitializer()\\n+{\\n+ static std::mutex mutex;\\n+ const std::lock_guard lock(mutex);\\n+\\n+ static std::weak_ptr<LibSsh2Initializer> weakPtr;\\n+ auto sharedPtr = weakPtr.lock();\\n+\\n+ if (sharedPtr)\\n+ return sharedPtr;\\n+\\n+ sharedPtr = std::make_shared<LibSsh2Initializer>();\\n+ weakPtr = sharedPtr;\\n+\\n+ return sharedPtr;\\n+}\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::SftpEndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::SftpNoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::SftpPermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::SftpFailure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::SftpBadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::SftpNoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::SftpConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::SftpOperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::SftpInvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::SftpNoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::SftpFileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::SftpWriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::SftpNoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::SftpNoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SftpQuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::SftpUnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::SftpLockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::SftpDirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::SftpNotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::SftpInvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::SftpLinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorBannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorBannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::SshErrorInvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::SshErrorAllocation, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SshErrorSocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorKeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::SshErrorHostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorDecrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::SshErrorProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::SshErrorPasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::SshErrorFile, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorAuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::SshErrorChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::SshErrorChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::SshErrorChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::SshErrorChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::SshErrorChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::SshErrorZlib, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::SshErrorRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::SshErrorMethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::SshErrorInvalid, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorPublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::SshErrorBufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::SshErrorBadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::SshErrorCompress, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::SshErrorOutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::SshErrorAgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SshErrorSocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::SshErrorEncrypt, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::SshErrorBadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::SshErrorKnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::SshErrorChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::SshErrorKeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::Sftp::TimeoutPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ std::shared_ptr<LibSsh2Initializer> initializer = makeInitializer();\\n+ bool posixRenameSupported = true;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(Time timeout) : m_predicate([] { return false; }), m_period(timeout)\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::TimeoutPredicate::TimeoutPredicate(std::function<bool()> predicate, Time period) :\\n+ m_predicate(std::move(predicate)),\\n+ m_period(period)\\n+{\\n+ if (!m_predicate)\\n+ m_predicate = [] { return false; };\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::function<bool()>& Sftp::TimeoutPredicate::getPredicate() const\\n+{\\n+ return m_predicate;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Time& Sftp::TimeoutPredicate::getPeriod() const\\n+{\\n+ return m_period;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::ReadinessType::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::ReadinessType::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::ReadinessType::Either);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutPredicate& timeout)\\n+{\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length > 0)\\n+ {\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+ else\\n+ {\\n+ return std::nullopt;\\n+ }\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(const std::string& name, const std::string& password, const TimeoutPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ m_impl->sftpSession.reset(libssh2_sftp_init(m_impl->ssh2Session.get()));\\n+\\n+ if (m_impl->sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(const std::string& name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ m_impl->sftpSession.reset(libssh2_sftp_init(m_impl->ssh2Session.get()));\\n+\\n+ if (m_impl->sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success),\\n+ std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string()};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\\n+ &attributes);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ {\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ 0,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENDIR);\\n+\\n+ if (handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (!handle)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+ }\\n+\\n+ std::vector<Attributes> listing;\\n+\\n+ {\\n+ std::array<char, 4096> buffer{};\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\\n+ timeout);\\n+\\n+ if (result > 0)\\n+ {\\n+ listing.emplace_back(\\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\\n+ attributes));\\n+\\n+ continue;\\n+ }\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ if (result == 0)\\n+ break;\\n+ }\\n+ }\\n+\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ return {Result(Result::Value::Success), std::move(listing)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\\n+ std::filesystem::perms permissions,\\n+ const TimeoutPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ makePermissions(permissions));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite,\\n+ const TimeoutPredicate& timeout)\\n+{\\n+ const auto oldPathString = oldPath.generic_u8string();\\n+ const auto newPathString = newPath.generic_u8string();\\n+\\n+ // POSIX rename is only supported starting from libssh2 1.11.1\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // POSIX rename doesn't support not overwriting\\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\\n+#endif\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ if (usePosix)\\n+ {\\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()));\\n+ }\\n+#endif\\n+\\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()),\\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // Retry using normal rename if we find out POSIX rename isn't supported\\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\\n+ {\\n+ m_impl->posixRenameSupported = false;\\n+ usePosix = false;\\n+ continue;\\n+ }\\n+#endif\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset,\\n+ const TimeoutPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for reading\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ LIBSSH2_FXF_READ,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Read from the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ auto* ptr = buffer.get();\\n+ int read{};\\n+ std::size_t totalRead{};\\n+\\n+ while (length > 0)\\n+ {\\n+ read = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (read == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (read <= 0)\\n+ break;\\n+\\n+ ptr += read;\\n+ length -= static_cast<std::size_t>(read);\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp\\nnew file mode 100644\\nindex 0000000000..95ab95a45e\\n--- /dev/null\\n+++ b/src/SFML/Network/Sftp.cpp\\n@@ -0,0 +1,1347 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/IpAddress.hpp>\\n+#include <SFML/Network/Sftp.hpp>\\n+#include <SFML/Network/SocketSelector.hpp>\\n+#include <SFML/Network/TcpSocket.hpp>\\n+\\n+#include <SFML/System/Err.hpp>\\n+\\n+#include <libssh2_sftp.h>\\n+\\n+#include <algorithm>\\n+#include <array>\\n+#include <chrono>\\n+#include <mutex>\\n+#include <ostream>\\n+#include <string_view>\\n+\\n+#include <cassert>\\n+#include <cstring>\\n+\\n+\\n+namespace\\n+{\\n+struct LibSsh2Initializer\\n+{\\n+ LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ [[maybe_unused]] const auto result = libssh2_init(0);\\n+ assert(result == 0);\\n+ }\\n+\\n+ ~LibSsh2Initializer()\\n+ {\\n+ const std::lock_guard lock(mutex);\\n+ libssh2_exit();\\n+ }\\n+\\n+ static inline std::mutex mutex;\\n+};\\n+\\n+struct Ssh2SessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SESSION* ptr)\\n+ {\\n+ libssh2_session_free(ptr);\\n+ }\\n+};\\n+\\n+struct SftpSessionDeleter\\n+{\\n+ void operator()(LIBSSH2_SFTP* ptr)\\n+ {\\n+ libssh2_sftp_shutdown(ptr);\\n+ }\\n+};\\n+\\n+int makePermissions(std::filesystem::perms permissions)\\n+{\\n+ int result{};\\n+ const auto add = [&](int i, std::filesystem::perms p)\\n+ { result |= (((permissions & p) == std::filesystem::perms::none) ? 0 : i); };\\n+ add(LIBSSH2_SFTP_S_IRUSR, std::filesystem::perms::owner_read);\\n+ add(LIBSSH2_SFTP_S_IWUSR, std::filesystem::perms::owner_write);\\n+ add(LIBSSH2_SFTP_S_IXUSR, std::filesystem::perms::owner_exec);\\n+ add(LIBSSH2_SFTP_S_IRGRP, std::filesystem::perms::group_read);\\n+ add(LIBSSH2_SFTP_S_IWGRP, std::filesystem::perms::group_write);\\n+ add(LIBSSH2_SFTP_S_IXGRP, std::filesystem::perms::group_exec);\\n+ add(LIBSSH2_SFTP_S_IROTH, std::filesystem::perms::others_read);\\n+ add(LIBSSH2_SFTP_S_IWOTH, std::filesystem::perms::others_write);\\n+ add(LIBSSH2_SFTP_S_IXOTH, std::filesystem::perms::others_exec);\\n+ return result;\\n+}\\n+\\n+sf::Sftp::Attributes makeAttributes(std::filesystem::path path, const LIBSSH2_SFTP_ATTRIBUTES& input)\\n+{\\n+ sf::Sftp::Attributes attributes{};\\n+ attributes.path = std::move(path);\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_SIZE)\\n+ attributes.size = input.filesize;\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_UIDGID)\\n+ {\\n+ attributes.userId = input.uid;\\n+ attributes.groupId = input.gid;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS)\\n+ {\\n+ auto& permissions = attributes.permissions.emplace();\\n+\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRUSR)\\n+ permissions |= std::filesystem::perms::owner_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWUSR)\\n+ permissions |= std::filesystem::perms::owner_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXUSR)\\n+ permissions |= std::filesystem::perms::owner_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IRGRP)\\n+ permissions |= std::filesystem::perms::group_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWGRP)\\n+ permissions |= std::filesystem::perms::group_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXGRP)\\n+ permissions |= std::filesystem::perms::group_exec;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IROTH)\\n+ permissions |= std::filesystem::perms::others_read;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IWOTH)\\n+ permissions |= std::filesystem::perms::others_write;\\n+ if (input.permissions & LIBSSH2_SFTP_S_IXOTH)\\n+ permissions |= std::filesystem::perms::others_exec;\\n+\\n+ auto& type = attributes.type.emplace();\\n+\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFIFO)\\n+ type = std::filesystem::file_type::fifo;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFCHR)\\n+ type = std::filesystem::file_type::character;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFDIR)\\n+ type = std::filesystem::file_type::directory;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFBLK)\\n+ type = std::filesystem::file_type::block;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFREG)\\n+ type = std::filesystem::file_type::regular;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFLNK)\\n+ type = std::filesystem::file_type::symlink;\\n+ if ((input.permissions & LIBSSH2_SFTP_S_IFMT) == LIBSSH2_SFTP_S_IFSOCK)\\n+ type = std::filesystem::file_type::socket;\\n+ }\\n+\\n+ if (input.flags & LIBSSH2_SFTP_ATTR_ACMODTIME)\\n+ {\\n+ attributes.accessTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.atime)).time_since_epoch());\\n+ attributes.modificationTime = std::filesystem::file_time_type(\\n+ std::chrono::system_clock::from_time_t(static_cast<std::time_t>(input.mtime)).time_since_epoch());\\n+ }\\n+\\n+ return attributes;\\n+}\\n+\\n+sf::Sftp::Result makeSftpError(LIBSSH2_SFTP* sftp)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ if (!sftp)\\n+ return sf::Sftp::Result(Value::Error, \\\"General error\\\");\\n+\\n+ switch (libssh2_sftp_last_error(sftp))\\n+ {\\n+ case LIBSSH2_FX_EOF:\\n+ return sf::Sftp::Result(Value::EndOfFile, \\\"End of file\\\");\\n+ case LIBSSH2_FX_NO_SUCH_FILE:\\n+ return sf::Sftp::Result(Value::NoSuchFile, \\\"No such file\\\");\\n+ case LIBSSH2_FX_PERMISSION_DENIED:\\n+ return sf::Sftp::Result(Value::PermissionDenied, \\\"Permission denied\\\");\\n+ case LIBSSH2_FX_FAILURE:\\n+ return sf::Sftp::Result(Value::Failure, \\\"Failure\\\");\\n+ case LIBSSH2_FX_BAD_MESSAGE:\\n+ return sf::Sftp::Result(Value::BadMessage, \\\"Bad message\\\");\\n+ case LIBSSH2_FX_NO_CONNECTION:\\n+ return sf::Sftp::Result(Value::NoConnection, \\\"No connection\\\");\\n+ case LIBSSH2_FX_CONNECTION_LOST:\\n+ return sf::Sftp::Result(Value::ConnectionLost, \\\"Connection lost\\\");\\n+ case LIBSSH2_FX_OP_UNSUPPORTED:\\n+ return sf::Sftp::Result(Value::OperationUnsupported, \\\"Operation unsupported\\\");\\n+ case LIBSSH2_FX_INVALID_HANDLE:\\n+ return sf::Sftp::Result(Value::InvalidHandle, \\\"Invalid handle\\\");\\n+ case LIBSSH2_FX_NO_SUCH_PATH:\\n+ return sf::Sftp::Result(Value::NoSuchPath, \\\"No such path\\\");\\n+ case LIBSSH2_FX_FILE_ALREADY_EXISTS:\\n+ return sf::Sftp::Result(Value::FileAlreadyExists, \\\"File already exists\\\");\\n+ case LIBSSH2_FX_WRITE_PROTECT:\\n+ return sf::Sftp::Result(Value::WriteProtect, \\\"Write protect\\\");\\n+ case LIBSSH2_FX_NO_MEDIA:\\n+ return sf::Sftp::Result(Value::NoMedia, \\\"No media\\\");\\n+ case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:\\n+ return sf::Sftp::Result(Value::NoSpaceOnFileSystem, \\\"No space on filesystem\\\");\\n+ case LIBSSH2_FX_QUOTA_EXCEEDED:\\n+ return sf::Sftp::Result(Value::QuotaExceeded, \\\"Quota exceeded\\\");\\n+ case LIBSSH2_FX_UNKNOWN_PRINCIPAL:\\n+ return sf::Sftp::Result(Value::UnknownPrincipal, \\\"Unknown principal\\\");\\n+ case LIBSSH2_FX_LOCK_CONFLICT:\\n+ return sf::Sftp::Result(Value::LockConflict, \\\"Lock conflict\\\");\\n+ case LIBSSH2_FX_DIR_NOT_EMPTY:\\n+ return sf::Sftp::Result(Value::DirectoryNotEmpty, \\\"Directory not empty\\\");\\n+ case LIBSSH2_FX_NOT_A_DIRECTORY:\\n+ return sf::Sftp::Result(Value::NotADirectory, \\\"Not a directory\\\");\\n+ case LIBSSH2_FX_INVALID_FILENAME:\\n+ return sf::Sftp::Result(Value::InvalidFilename, \\\"Invalid filename\\\");\\n+ case LIBSSH2_FX_LINK_LOOP:\\n+ return sf::Sftp::Result(Value::LinkLoop, \\\"Link loop\\\");\\n+ default:\\n+ return sf::Sftp::Result(Value::SftpError, \\\"General error\\\");\\n+ }\\n+}\\n+\\n+sf::Sftp::Result makeError(LIBSSH2_SESSION* session, LIBSSH2_SFTP* sftp = nullptr)\\n+{\\n+ using Value = sf::Sftp::Result::Value;\\n+\\n+ char* ptr{};\\n+ auto length = 0;\\n+ const auto error = libssh2_session_last_error(session, &ptr, &length, 0);\\n+ const auto size = static_cast<std::size_t>(length);\\n+\\n+ switch (error)\\n+ {\\n+ case LIBSSH2_ERROR_BANNER_RECV:\\n+ return sf::Sftp::Result(Value::BannerReceive, {ptr, size});\\n+ case LIBSSH2_ERROR_BANNER_SEND:\\n+ return sf::Sftp::Result(Value::BannerSend, {ptr, size});\\n+ case LIBSSH2_ERROR_INVALID_MAC:\\n+ return sf::Sftp::Result(Value::InvalidMac, {ptr, size});\\n+ case LIBSSH2_ERROR_KEX_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_ALLOC:\\n+ return sf::Sftp::Result(Value::AllocationFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_SEND:\\n+ return sf::Sftp::Result(Value::SocketSend, {ptr, size});\\n+ case LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE:\\n+ return sf::Sftp::Result(Value::KeyExchangeFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_INIT:\\n+ return sf::Sftp::Result(Value::HostKeyInitialization, {ptr, size});\\n+ case LIBSSH2_ERROR_HOSTKEY_SIGN:\\n+ return sf::Sftp::Result(Value::HostKeySign, {ptr, size});\\n+ case LIBSSH2_ERROR_DECRYPT:\\n+ return sf::Sftp::Result(Value::DecryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_DISCONNECT:\\n+ return sf::Sftp::Result(Value::Disconnected, {ptr, size});\\n+ case LIBSSH2_ERROR_PROTO:\\n+ return sf::Sftp::Result(Value::ProtocolError, {ptr, size});\\n+ case LIBSSH2_ERROR_PASSWORD_EXPIRED:\\n+ return sf::Sftp::Result(Value::PasswordExpired, {ptr, size});\\n+ case LIBSSH2_ERROR_FILE:\\n+ return sf::Sftp::Result(Value::FileError, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NONE:\\n+ return sf::Sftp::Result(Value::MethodNone, {ptr, size});\\n+ case LIBSSH2_ERROR_AUTHENTICATION_FAILED:\\n+ return sf::Sftp::Result(Value::AuthenticationFailed, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:\\n+ return sf::Sftp::Result(Value::PublicKeyUnverified, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_OUTOFORDER:\\n+ return sf::Sftp::Result(Value::ChannelOutOfOrder, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_FAILURE:\\n+ return sf::Sftp::Result(Value::ChannelFailure, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::ChannelRequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_UNKNOWN:\\n+ return sf::Sftp::Result(Value::ChannelUnknown, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelWindowExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED:\\n+ return sf::Sftp::Result(Value::ChannelPacketExceeded, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_CLOSED:\\n+ return sf::Sftp::Result(Value::ChannelClosed, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_EOF_SENT:\\n+ return sf::Sftp::Result(Value::ChannelEofSent, {ptr, size});\\n+ case LIBSSH2_ERROR_SCP_PROTOCOL:\\n+ return sf::Sftp::Result(Value::ScpProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_ZLIB:\\n+ return sf::Sftp::Result(Value::ZlibError, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_TIMEOUT:\\n+ return sf::Sftp::Result(Value::Timeout, {ptr, size});\\n+ case LIBSSH2_ERROR_SFTP_PROTOCOL:\\n+ return makeSftpError(sftp);\\n+ case LIBSSH2_ERROR_REQUEST_DENIED:\\n+ return sf::Sftp::Result(Value::RequestDenied, {ptr, size});\\n+ case LIBSSH2_ERROR_METHOD_NOT_SUPPORTED:\\n+ return sf::Sftp::Result(Value::MethodNotSupported, {ptr, size});\\n+ case LIBSSH2_ERROR_INVAL:\\n+ return sf::Sftp::Result(Value::InvalidData, {ptr, size});\\n+ case LIBSSH2_ERROR_PUBLICKEY_PROTOCOL:\\n+ return sf::Sftp::Result(Value::PublicKeyProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_BUFFER_TOO_SMALL:\\n+ return sf::Sftp::Result(Value::BufferTooSmall, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_USE:\\n+ return sf::Sftp::Result(Value::BadUse, {ptr, size});\\n+ case LIBSSH2_ERROR_COMPRESS:\\n+ return sf::Sftp::Result(Value::CompressError, {ptr, size});\\n+ case LIBSSH2_ERROR_OUT_OF_BOUNDARY:\\n+ return sf::Sftp::Result(Value::OutOfBoundary, {ptr, size});\\n+ case LIBSSH2_ERROR_AGENT_PROTOCOL:\\n+ return sf::Sftp::Result(Value::AgentProtocol, {ptr, size});\\n+ case LIBSSH2_ERROR_SOCKET_RECV:\\n+ return sf::Sftp::Result(Value::SocketRecv, {ptr, size});\\n+ case LIBSSH2_ERROR_ENCRYPT:\\n+ return sf::Sftp::Result(Value::EncryptError, {ptr, size});\\n+ case LIBSSH2_ERROR_BAD_SOCKET:\\n+ return sf::Sftp::Result(Value::BadSocket, {ptr, size});\\n+ case LIBSSH2_ERROR_KNOWN_HOSTS:\\n+ return sf::Sftp::Result(Value::KnownHosts, {ptr, size});\\n+ case LIBSSH2_ERROR_CHANNEL_WINDOW_FULL:\\n+ return sf::Sftp::Result(Value::ChannelWindowFull, {ptr, size});\\n+ case LIBSSH2_ERROR_KEYFILE_AUTH_FAILED:\\n+ return sf::Sftp::Result(Value::KeyFileAuthenticationFailed, {ptr, size});\\n+ default:\\n+ return sf::Sftp::Result(Value::Error, {ptr, size});\\n+ }\\n+}\\n+} // namespace\\n+\\n+\\n+namespace sf\\n+{\\n+struct Sftp::Impl : LibSsh2Initializer\\n+{\\n+ Impl()\\n+ {\\n+ socket.setBlocking(false);\\n+ }\\n+\\n+ template <typename Callable>\\n+ int waitForOperationComplete(const Callable& operation, const sf::TimeoutWithPredicate& timeout)\\n+ {\\n+ while (true)\\n+ {\\n+ if (const auto result = operation(); result != LIBSSH2_ERROR_EAGAIN)\\n+ return result; // Operation completed without having to block\\n+\\n+ // Wait for socket to become ready\\n+ const auto directions = libssh2_session_block_directions(ssh2Session.get());\\n+ if (directions == (LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND))\\n+ {\\n+ if (selectorEither.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else if (directions == LIBSSH2_SESSION_BLOCK_OUTBOUND)\\n+ {\\n+ if (selectorSend.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+ else\\n+ {\\n+ if (selectorRecv.wait(timeout.getPeriod()))\\n+ continue;\\n+ }\\n+\\n+ if (!timeout.getPredicate()())\\n+ return LIBSSH2_ERROR_EAGAIN; // Gave up waiting\\n+ }\\n+ }\\n+\\n+ Sftp::Result initializeSftp(const TimeoutWithPredicate& timeout)\\n+ {\\n+ const auto result = waitForOperationComplete(\\n+ [&]\\n+ {\\n+ sftpSession.reset(libssh2_sftp_init(ssh2Session.get()));\\n+\\n+ if (sftpSession)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+\\n+ static ssize_t handleSend(libssh2_socket_t, const void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t sent{};\\n+ const auto result = impl.socket.send(buffer, length, sent);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(sent);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (sent > 0)\\n+ return static_cast<ssize_t>(sent);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ static ssize_t handleReceive(libssh2_socket_t, void* buffer, size_t length, int, void** implPtr)\\n+ {\\n+ auto& impl = *static_cast<Impl*>(*implPtr);\\n+ std::size_t received{};\\n+ const auto result = impl.socket.receive(buffer, length, received);\\n+\\n+ // Map SFML-specific return values back to POSIX return values\\n+ if (result == Socket::Status::Done)\\n+ return static_cast<ssize_t>(received);\\n+\\n+ if (result == Socket::Status::Partial)\\n+ {\\n+ if (received > 0)\\n+ return static_cast<ssize_t>(received);\\n+ return -EAGAIN;\\n+ }\\n+\\n+ if (result == Socket::Status::NotReady)\\n+ return -EAGAIN;\\n+\\n+ if (result == Socket::Status::Disconnected)\\n+ return 0;\\n+\\n+ // Socket::Status::Error\\n+ return -1;\\n+ }\\n+\\n+ bool posixRenameSupported = true;\\n+ std::filesystem::path cachedHomePath;\\n+ TcpSocket socket;\\n+ sf::SocketSelector selectorRecv;\\n+ sf::SocketSelector selectorSend;\\n+ sf::SocketSelector selectorEither;\\n+ std::unique_ptr<LIBSSH2_SESSION, Ssh2SessionDeleter> ssh2Session;\\n+ std::unique_ptr<LIBSSH2_SFTP, SftpSessionDeleter> sftpSession;\\n+};\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Result(Value value, std::string message) : m_value(value), m_message(std::move(message))\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+bool Sftp::Result::isOk() const\\n+{\\n+ return m_value == Value::Success;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result::Value Sftp::Result::getValue() const\\n+{\\n+ return m_value;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::string& Sftp::Result::getMessage() const\\n+{\\n+ return m_message;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult::PathResult(const Result& result, std::filesystem::path path) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_path = std::move(path);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::filesystem::path& Sftp::PathResult::getPath() const\\n+{\\n+ return m_path;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult::AttributesResult(const Result& result, Attributes attributes) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_attributes = std::move(attributes);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const Sftp::Attributes& Sftp::AttributesResult::getAttributes() const\\n+{\\n+ return m_attributes;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult::ListingResult(const Result& result, std::vector<Attributes> listing) : Sftp::Result(result)\\n+{\\n+ if (isOk())\\n+ m_listing = std::move(listing);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+const std::vector<Sftp::Attributes>& Sftp::ListingResult::getListing() const\\n+{\\n+ return m_listing;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Sftp() : m_impl(std::make_unique<Impl>())\\n+{\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::~Sftp()\\n+{\\n+ (void)disconnect();\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::connect(IpAddress server, unsigned short port, const TimeoutWithPredicate& timeout)\\n+{\\n+ (void)disconnect(timeout);\\n+\\n+ if (const auto status = m_impl->socket.connect(server, port);\\n+ (status == Socket::Status::Error) || (status == Socket::Status::Disconnected))\\n+ return Result(Result::Value::Disconnected);\\n+\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->selectorRecv.add(m_impl->socket, sf::SocketSelector::Receive);\\n+ m_impl->selectorSend.add(m_impl->socket, sf::SocketSelector::Send);\\n+ m_impl->selectorEither.add(m_impl->socket, sf::SocketSelector::Receive | sf::SocketSelector::Send);\\n+\\n+ // Wait for the socket to become connected\\n+ while (true)\\n+ {\\n+ if (m_impl->selectorSend.wait(timeout.getPeriod()))\\n+ break;\\n+\\n+ if (!timeout.getPredicate()())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+ }\\n+\\n+ // Check if our connection was actually accepted or refused\\n+ if (!m_impl->socket.getRemoteAddress().has_value())\\n+ {\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+ return Result(Result::Value::Refused);\\n+ }\\n+\\n+ // At this point the TCP connection is established\\n+\\n+ // Reset POSIX rename supported flag to assume true for new connections\\n+ m_impl->posixRenameSupported = true;\\n+\\n+ // Set up SSH session\\n+ m_impl->ssh2Session.reset(libssh2_session_init_ex(nullptr, nullptr, nullptr, m_impl.get()));\\n+ assert(m_impl->ssh2Session);\\n+\\n+ // Tell libssh2 we will take care of waiting on socket readiness ourselves\\n+ libssh2_session_set_blocking(m_impl->ssh2Session.get(), 0);\\n+\\n+ // Set send and receive callbacks to make use of TcpSocket as the underlying transport\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_SEND,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleSend));\\n+ libssh2_session_callback_set2(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<libssh2_cb_generic*>(Impl::handleReceive));\\n+#else\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(), LIBSSH2_CALLBACK_SEND, reinterpret_cast<void*>(&Impl::handleSend));\\n+ libssh2_session_callback_set(m_impl->ssh2Session.get(),\\n+ LIBSSH2_CALLBACK_RECV,\\n+ reinterpret_cast<void*>(&Impl::handleReceive));\\n+#endif\\n+\\n+ // Block SIGPIPE\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_SIGPIPE, 0); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Enable compression if available\\n+ if (const auto result = libssh2_session_flag(m_impl->ssh2Session.get(), LIBSSH2_FLAG_COMPRESS, 1); result < 0)\\n+ return Result(Result::Value::Error);\\n+\\n+ // Perform handshake\\n+ const auto\\n+ result = m_impl->waitForOperationComplete([&] { return libssh2_session_handshake(m_impl->ssh2Session.get(), 0); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::disconnect(const TimeoutWithPredicate& timeout)\\n+{\\n+ // Clear the cached home path\\n+ m_impl->cachedHomePath.clear();\\n+\\n+ // Shut down the SFTP session\\n+ if (m_impl->sftpSession)\\n+ {\\n+ auto* sftpSession = m_impl->sftpSession.release();\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_shutdown(sftpSession); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ // Disconnect the SSH session\\n+ if (m_impl->ssh2Session)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ { return libssh2_session_disconnect_ex(m_impl->ssh2Session.get(), SSH_DISCONNECT_BY_APPLICATION, \\\"\\\", \\\"\\\"); },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ // Continue with destroying the SSH session and disconnecting the socket even if an error occurred\\n+ }\\n+\\n+ // Destroy the SSH session\\n+ m_impl->ssh2Session.reset();\\n+\\n+ // Disconnect the TCP connection\\n+ m_impl->selectorRecv.clear();\\n+ m_impl->selectorSend.clear();\\n+ m_impl->selectorEither.clear();\\n+ m_impl->socket.disconnect();\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+std::optional<Sftp::SessionInfo> Sftp::getSessionInfo() const\\n+{\\n+ if (!m_impl->ssh2Session)\\n+ return std::nullopt;\\n+\\n+ SessionInfo sessionInfo;\\n+\\n+ {\\n+ std::size_t length{};\\n+ auto type = 0;\\n+ const auto* const ptr = libssh2_session_hostkey(m_impl->ssh2Session.get(), &length, &type);\\n+\\n+ if (length == 0)\\n+ return std::nullopt;\\n+\\n+ SessionInfo::HostKey hostKey;\\n+ hostKey.data.resize(length);\\n+ std::memcpy(hostKey.data.data(), ptr, length);\\n+\\n+ switch (type)\\n+ {\\n+ case LIBSSH2_HOSTKEY_TYPE_RSA:\\n+ hostKey.type = SessionInfo::HostKey::Type::Rsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_DSS:\\n+ hostKey.type = SessionInfo::HostKey::Type::Dsa;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa256;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa384;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ecdsa521;\\n+ break;\\n+ case LIBSSH2_HOSTKEY_TYPE_ED25519:\\n+ hostKey.type = SessionInfo::HostKey::Type::Ed25519;\\n+ break;\\n+ default:\\n+ hostKey.type = SessionInfo::HostKey::Type::Unknown;\\n+ break;\\n+ }\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA1); hash)\\n+ std::memcpy(hostKey.sha1.data(), hash, hostKey.sha1.size());\\n+\\n+ if (const auto* const hash = libssh2_hostkey_hash(m_impl->ssh2Session.get(), LIBSSH2_HOSTKEY_HASH_SHA256); hash)\\n+ std::memcpy(hostKey.sha256.data(), hash, hostKey.sha256.size());\\n+\\n+ sessionInfo.hostKey = std::move(hostKey);\\n+ }\\n+\\n+ const auto getSessionMethod = [session = m_impl->ssh2Session.get()](int method) -> std::string\\n+ {\\n+ if (!session)\\n+ return \\\"\\\";\\n+ if (const auto* const result = libssh2_session_methods(session, method); result)\\n+ return result;\\n+ err() << \\\"SFTP: Cannot get session information, session not yet started\\\" << std::endl;\\n+ return \\\"\\\";\\n+ };\\n+\\n+ sessionInfo.keyExchangeAlgorithm = getSessionMethod(LIBSSH2_METHOD_KEX);\\n+ sessionInfo.hostKeyAlgorithm = getSessionMethod(LIBSSH2_METHOD_HOSTKEY);\\n+ sessionInfo.clientToServerEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_CS);\\n+ sessionInfo.serverToClientEncryptionAlgorithm = getSessionMethod(LIBSSH2_METHOD_CRYPT_SC);\\n+ sessionInfo.clientToServerMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_CS);\\n+ sessionInfo.serverToClientMacAlgorithm = getSessionMethod(LIBSSH2_METHOD_MAC_SC);\\n+ sessionInfo.clientToServerCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_CS);\\n+ sessionInfo.serverToClientCompressionAlgorithm = getSessionMethod(LIBSSH2_METHOD_COMP_SC);\\n+\\n+ return sessionInfo;\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name, std::string_view password, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_password_ex(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ static_cast<unsigned int>(name.size()),\\n+ password.data(),\\n+ static_cast<unsigned int>(password.size()),\\n+ nullptr);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Perform login\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_userauth_publickey_frommemory(m_impl->ssh2Session.get(),\\n+ name.data(),\\n+ name.size(),\\n+ publicKeyData,\\n+ publicKeyLength,\\n+ privateKeyData,\\n+ privateKeyLength,\\n+ privateKeyPassphrase);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get());\\n+ }\\n+\\n+ // Initialize SFTP session\\n+ return m_impl->initializeSftp(timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ // Ensure the passphrase is NULL-terminated\\n+ const std::string privateKeyPassphraseString(privateKeyPassphrase);\\n+ return login(name,\\n+ publicKeyData.data(),\\n+ publicKeyData.length(),\\n+ privateKeyData.data(),\\n+ privateKeyData.length(),\\n+ privateKeyPassphraseString.c_str(),\\n+ timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ // Check if we already cached the result for the home path\\n+ if ((path == \\\".\\\") && !m_impl->cachedHomePath.empty())\\n+ return {Result(Result::Value::Success), m_impl->cachedHomePath};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ std::array<char, 4096> buffer{};\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_symlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ buffer.data(),\\n+ static_cast<unsigned int>(buffer.size()),\\n+ LIBSSH2_SFTP_REALPATH);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ const auto genericPath = std::filesystem::path(std::string_view(buffer.data(), static_cast<std::size_t>(result)))\\n+ .generic_u8string();\\n+\\n+ // Cache the result for the home path\\n+ if (path == \\\".\\\")\\n+ m_impl->cachedHomePath = genericPath;\\n+\\n+ return {Result(Result::Value::Success), genericPath};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::PathResult Sftp::getWorkingDirectory(const TimeoutWithPredicate& timeout)\\n+{\\n+ return resolvePath(\\\".\\\", timeout);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::AttributesResult Sftp::getAttributes(const std::filesystem::path& path, bool followLinks, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_stat_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ followLinks ? LIBSSH2_SFTP_STAT : LIBSSH2_SFTP_LSTAT,\\n+ &attributes);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (result < 0)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+\\n+ return {Result(Result::Value::Success), makeAttributes(pathString, attributes)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ {\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ 0,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENDIR);\\n+\\n+ if (handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+\\n+ if (!handle)\\n+ return {makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get()), {}};\\n+ }\\n+\\n+ std::vector<Attributes> listing;\\n+\\n+ {\\n+ std::array<char, 4096> buffer{};\\n+ LIBSSH2_SFTP_ATTRIBUTES attributes{};\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&] { return libssh2_sftp_readdir_ex(handle, buffer.data(), buffer.size(), nullptr, 0, &attributes); },\\n+ timeout);\\n+\\n+ if (result > 0)\\n+ {\\n+ listing.emplace_back(\\n+ makeAttributes((path / std::string_view(buffer.data(), static_cast<std::size_t>(result))).generic_u8string(),\\n+ attributes));\\n+\\n+ continue;\\n+ }\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ if (result == 0)\\n+ break;\\n+ }\\n+ }\\n+\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return {Result(Result::Value::Timeout), {}};\\n+ }\\n+\\n+ return {Result(Result::Value::Success), std::move(listing)};\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::createDirectory(const std::filesystem::path& path,\\n+ std::filesystem::perms permissions,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_mkdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ makePermissions(permissions));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_rmdir_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto oldPathString = oldPath.generic_u8string();\\n+ const auto newPathString = newPath.generic_u8string();\\n+\\n+ // POSIX rename is only supported starting from libssh2 1.11.1\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // POSIX rename doesn't support not overwriting\\n+ auto usePosix = overwrite && m_impl->posixRenameSupported;\\n+#endif\\n+\\n+ while (true)\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ if (usePosix)\\n+ {\\n+ return libssh2_sftp_posix_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()));\\n+ }\\n+#endif\\n+\\n+ return libssh2_sftp_rename_ex(m_impl->sftpSession.get(),\\n+ oldPathString.data(),\\n+ static_cast<unsigned int>(oldPathString.size()),\\n+ newPathString.data(),\\n+ static_cast<unsigned int>(newPathString.size()),\\n+ overwrite ? LIBSSH2_SFTP_RENAME_OVERWRITE : 0);\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+#if (LIBSSH2_VERSION_NUM >= 0x010b01)\\n+ // Retry using normal rename if we find out POSIX rename isn't supported\\n+ if (usePosix && (result == LIBSSH2_FX_OP_UNSUPPORTED))\\n+ {\\n+ m_impl->posixRenameSupported = false;\\n+ usePosix = false;\\n+ continue;\\n+ }\\n+#endif\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+ }\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout)\\n+{\\n+ const auto pathString = path.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ return libssh2_sftp_unlink_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()));\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for reading\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ LIBSSH2_FXF_READ,\\n+ 0,\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Read from the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ auto* ptr = buffer.get();\\n+ int read{};\\n+ std::size_t totalRead{};\\n+\\n+ while (length > 0)\\n+ {\\n+ read = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_read(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (read == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (read <= 0)\\n+ break;\\n+\\n+ ptr += read;\\n+ length -= static_cast<std::size_t>(read);\\n+ totalRead += static_cast<std::size_t>(read);\\n+ }\\n+\\n+ if (read < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ const auto stop = !callback(buffer.get(), totalRead);\\n+\\n+ // If read is 0 then we have reached EOF\\n+ if (stop || (read == 0))\\n+ break;\\n+\\n+ const auto expand = (totalRead == bufferSize);\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+Sftp::Result Sftp::upload(const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions,\\n+ bool truncate,\\n+ bool append,\\n+ std::uint64_t offset,\\n+ const TimeoutWithPredicate& timeout)\\n+{\\n+ if (!callback)\\n+ return Result(Result::Value::Error);\\n+\\n+ LIBSSH2_SFTP_HANDLE* handle{};\\n+\\n+ // Open the file for writing\\n+ {\\n+ const auto pathString = remotePath.generic_u8string();\\n+ const auto result = m_impl->waitForOperationComplete(\\n+ [&]\\n+ {\\n+ if (handle = libssh2_sftp_open_ex(m_impl->sftpSession.get(),\\n+ pathString.data(),\\n+ static_cast<unsigned int>(pathString.size()),\\n+ static_cast<unsigned int>(LIBSSH2_FXF_WRITE | LIBSSH2_FXF_CREAT |\\n+ (truncate ? LIBSSH2_FXF_TRUNC : 0) |\\n+ (append ? LIBSSH2_FXF_APPEND : 0)),\\n+ makePermissions(permissions),\\n+ LIBSSH2_SFTP_OPENFILE);\\n+ handle)\\n+ return LIBSSH2_ERROR_NONE;\\n+\\n+ return libssh2_session_last_errno(m_impl->ssh2Session.get());\\n+ },\\n+ timeout);\\n+\\n+ if (!handle && (result == LIBSSH2_ERROR_EAGAIN))\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (!handle)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ // Seek to the offset if one was specified\\n+ if (offset > 0)\\n+ libssh2_sftp_seek64(handle, offset);\\n+\\n+ // Write to the file\\n+ {\\n+ static constexpr auto bufferSizeStart = std::size_t{4 * 1024};\\n+ static constexpr auto bufferSizeMax = std::size_t{1024 * 1024};\\n+ auto bufferSize = bufferSizeStart;\\n+ auto buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+\\n+ while (true)\\n+ {\\n+ std::size_t length = bufferSize;\\n+ const auto stop = !callback(buffer.get(), length);\\n+ const auto expand = (length == bufferSize);\\n+ const auto* ptr = buffer.get();\\n+ int written{};\\n+\\n+ while (length > 0)\\n+ {\\n+ written = m_impl->waitForOperationComplete(\\n+ [&] { return static_cast<int>(libssh2_sftp_write(handle, ptr, length)); },\\n+ timeout);\\n+\\n+ if (written == LIBSSH2_ERROR_EAGAIN)\\n+ {\\n+ libssh2_sftp_close_handle(handle);\\n+ return Result(Result::Value::Timeout);\\n+ }\\n+\\n+ if (written < 0)\\n+ break;\\n+\\n+ ptr += written;\\n+ length -= static_cast<std::size_t>(written);\\n+ }\\n+\\n+ if (written < 0)\\n+ {\\n+ // Get the error before calling libssh2_sftp_close_handle since it could get overwritten\\n+ const auto result = makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ libssh2_sftp_close_handle(handle);\\n+ return result;\\n+ }\\n+\\n+ if (stop)\\n+ break;\\n+\\n+ if (expand && (bufferSize < bufferSizeMax))\\n+ {\\n+ bufferSize = std::min(bufferSize * 3 / 2, bufferSizeMax); // Use a growth factor of 1.5\\n+ buffer = std::make_unique<char[]>(bufferSize); // NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)\\n+ }\\n+ }\\n+ }\\n+\\n+ // Close the file\\n+ {\\n+ const auto result = m_impl->waitForOperationComplete([&] { return libssh2_sftp_close_handle(handle); }, timeout);\\n+\\n+ if (result == LIBSSH2_ERROR_EAGAIN)\\n+ return Result(Result::Value::Timeout);\\n+\\n+ if (result < 0)\\n+ return makeError(m_impl->ssh2Session.get(), m_impl->sftpSession.get());\\n+ }\\n+\\n+ return Result(Result::Value::Success);\\n+}\\n+\\n+} // namespace sf\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10096,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"```suggestion\n /// \\brief Connect to the specified SFTP server\n```"},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/include/SFML/Network/Sftp.hpp b/include/SFML/Network/Sftp.hpp\nnew file mode 100644\nindex 0000000000..9be101d562\n--- /dev/null\n+++ b/include/SFML/Network/Sftp.hpp\n@@ -0,0 +1,987 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+#pragma once\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/Export.hpp>\n+\n+#include <SFML/System/TimeoutWithPredicate.hpp>\n+\n+#include <array>\n+#include <filesystem>\n+#include <memory>\n+#include <optional>\n+#include <string>\n+#include <string_view>\n+#include <vector>\n+\n+#include <cstddef>\n+#include <cstdint>\n+\n+\n+namespace sf\n+{\n+class IpAddress;\n+\n+////////////////////////////////////////////////////////////\n+/// \\brief An SSH File Transfer Protocol (SFTP) client\n+///\n+////////////////////////////////////////////////////////////\n+class SFML_NETWORK_API Sftp\n+{\n+public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief SFTP result\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result values\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ enum class Value\n+ {\n+ // General result values\n+ Success, //!< Operation completed successfully\n+ Disconnected, //!< The TCP socket has been disconnected\n+ Timeout, //!< Operation timed out\n+ Refused, //!< Connection refused\n+ Error, //!< Generic error\n+\n+ // SSH result values\n+ BannerReceive, //!< Error during banner receive\n+ BannerSend, //!< Error during banner send\n+ InvalidMac, //!< Invalid message authentication code\n+ AllocationFailure, //!< Allocation failure\n+ SocketSend, //!< Error sending on socket\n+ KeyExchangeFailure, //!< Key exchange failed\n+ HostKeyInitialization, //!< Host key initialization failed\n+ HostKeySign, //!< Host key signing failed\n+ DecryptError, //!< Decryption failed\n+ ProtocolError, //!< SSH protocol error\n+ PasswordExpired, //!< Password expired\n+ FileError, //!< File error\n+ MethodNone, //!< No method found\n+ AuthenticationFailed, //!< Authentication failed\n+ PublicKeyUnverified, //!< Public key unverified\n+ ChannelOutOfOrder, //!< Channel out of order\n+ ChannelFailure, //!< Channel failure\n+ ChannelRequestDenied, //!< Channel request denied\n+ ChannelUnknown, //!< Channel unknown\n+ ChannelWindowExceeded, //!< Channel window exceeded\n+ ChannelPacketExceeded, //!< Channel packet exceeded\n+ ChannelClosed, //!< Channel closed\n+ ChannelEofSent, //!< Channel EOF sent\n+ ScpProtocol, //!< SCP protocol error\n+ ZlibError, //!< Zlib error\n+ RequestDenied, //!< Request denied\n+ MethodNotSupported, //!< Method not supported\n+ InvalidData, //!< Invalid data\n+ PublicKeyProtocol, //!< Public key protocol error\n+ BufferTooSmall, //!< Buffer too small\n+ BadUse, //!< Bad usage\n+ CompressError, //!< Compression error\n+ OutOfBoundary, //!< Out of boundary\n+ AgentProtocol, //!< Agent protocol error\n+ SocketRecv, //!< Socket receive error\n+ EncryptError, //!< Encryption failed\n+ BadSocket, //!< Bad socket\n+ KnownHosts, //!< Known hosts error\n+ ChannelWindowFull, //!< Channel window full\n+ KeyFileAuthenticationFailed, //!< Key file authentication failed\n+\n+ // SFTP result values\n+ EndOfFile, //!< End of file\n+ NoSuchFile, //!< No such file\n+ PermissionDenied, //!< Permission denied\n+ Failure, //!< Failure\n+ BadMessage, //!< Bad message\n+ NoConnection, //!< No connection\n+ ConnectionLost, //!< Connection lost\n+ OperationUnsupported, //!< Operation unsupported\n+ InvalidHandle, //!< Invalid handle\n+ NoSuchPath, //!< No such path\n+ FileAlreadyExists, //!< File already exists\n+ WriteProtect, //!< Write protect\n+ NoMedia, //!< No media\n+ NoSpaceOnFileSystem, //!< No space on filesystem\n+ QuotaExceeded, //!< Quota exceeded\n+ UnknownPrincipal, //!< Unknown principal\n+ LockConflict, //!< Lock conflict\n+ DirectoryNotEmpty, //!< Directory not empty\n+ NotADirectory, //!< Not a directory\n+ InvalidFilename, //!< Invalid filename\n+ LinkLoop, //!< Link loop\n+ SftpError //!< Generic SFTP error\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// This constructor is used by the SFTP client to build\n+ /// the result.\n+ ///\n+ /// \\param value Result value\n+ /// \\param message Result message\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ explicit Result(Value value, std::string message = \"\");\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Check if the result is a success\n+ ///\n+ /// This function is defined for convenience, it is\n+ /// equivalent to testing if the result value is `Value::Success`.\n+ ///\n+ /// \\return `true` if the result is `Value::Success`, `false` if it is not `Value::Success`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] bool isOk() const;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the result value\n+ ///\n+ /// \\return The result value\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Value getValue() const;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the result message\n+ ///\n+ /// \\return The result message\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const std::string& getMessage() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ Value m_value; //!< The contained value\n+ std::string m_message; //!< The contained message\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result of an operation returning a path\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API PathResult : public Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// \\param result Result\n+ /// \\param path Path\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ PathResult(const Result& result, std::filesystem::path path);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the path\n+ ///\n+ /// \\return The path\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const std::filesystem::path& getPath() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ std::filesystem::path m_path; //!< The contained path\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief File or directory attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ struct Attributes\n+ {\n+ std::filesystem::path path; //!< Path to the entry\n+ std::optional<std::filesystem::file_type> type; //!< Type of the entry\n+ std::optional<std::uint64_t> size; //!< Size of the entry\n+ std::optional<std::filesystem::perms> permissions; //!< Permissions\n+ std::optional<std::uint64_t> userId; //!< Owner user ID\n+ std::optional<std::uint64_t> groupId; //!< Group ID\n+ std::optional<std::filesystem::file_time_type> accessTime; //!< Last access time\n+ std::optional<std::filesystem::file_time_type> modificationTime; //!< Last modification time\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result of an operation returning attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API AttributesResult : public Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// \\param result Result\n+ /// \\param attributes Attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ AttributesResult(const Result& result, Attributes attributes);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the attributes\n+ ///\n+ /// \\return The attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const Attributes& getAttributes() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ Attributes m_attributes; //!< The contained attributes\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result of an operation returning a directory listing\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API ListingResult : public Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// \\param result Result\n+ /// \\param listing Directory listing\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ ListingResult(const Result& result, std::vector<Attributes> listing);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the directory listing\n+ ///\n+ /// \\return The directory listing\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const std::vector<Attributes>& getListing() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ std::vector<Attributes> m_listing; //!< The contained directory listing\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Structure containing information about an active SFTP session\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ struct SessionInfo\n+ {\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Host key used to identify a host\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ struct HostKey\n+ {\n+ enum class Type\n+ {\n+ Unknown, //!< Unknown key type\n+ Rsa, //!< RSA\n+ Dsa, //!< DSA\n+ Ecdsa256, //!< NIST P-256 ECDSA\n+ Ecdsa384, //!< NIST P-384 ECDSA\n+ Ecdsa521, //!< NIST P-521 ECDSA\n+ Ed25519 //!< ED25519\n+ };\n+\n+ Type type = Type::Unknown; //!< Host key type\n+ std::vector<std::byte> data; //!< Host key data\n+ std::array<std::byte, 20> sha1{}; //!< Host key SHA1 hash\n+ std::array<std::byte, 32> sha256{}; //!< Host key SHA256 hash\n+ };\n+\n+ HostKey hostKey; //!< Host key\n+ std::string keyExchangeAlgorithm; //!< Key exchange algorithm used in the session (RFC 4253)\n+ std::string hostKeyAlgorithm; //!< Host key algorithm used in the session (RFC 4253)\n+ std::string clientToServerEncryptionAlgorithm; //!< Client to server encryption algorithm used in the session (RFC 4253)\n+ std::string serverToClientEncryptionAlgorithm; //!< Server to client encryption algorithm used in the session (RFC 4253)\n+ std::string clientToServerMacAlgorithm; //!< Client to server message authentication code algorithm used in the session (RFC 4253)\n+ std::string serverToClientMacAlgorithm; //!< Server to client message authentication code algorithm used in the session (RFC 4253)\n+ std::string clientToServerCompressionAlgorithm; //!< Client to server compression algorithm used in the session (RFC 4253)\n+ std::string serverToClientCompressionAlgorithm; //!< Server to client compression algorithm used in the session (RFC 4253)\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Default constructor\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ Sftp();\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Destructor\n+ ///\n+ /// Automatically closes the connection with the server if\n+ /// it is still opened.\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ ~Sftp();\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Deleted copy constructor\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ Sftp(const Sftp&) = delete;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Deleted copy assignment\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ Sftp& operator=(const Sftp&) = delete;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Connect to the specified SFTP server\n+ ///\n+ /// The port has a default value of 22, which is the standard\n+ /// port used by the SFTP protocol.\n+ /// This function tries to connect to the server so it may take\n+ /// a while to complete, especially if the server is not\n+ /// reachable. To avoid blocking your application for too long,\n+ /// you can use a timeout. The default value, `Time::Zero`, means that the\n+ /// system timeout will be used (which is usually pretty long).\n+ ///\n+ /// \\param server Name or address of the SFTP server to connect to\n+ /// \\param port Port used for the connection\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of the connection attempt\n+ ///\n+ /// \\see `disconnect`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result connect(IpAddress server, unsigned short port = 22, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Disconnect the connection with the server\n+ ///\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of disconnecting the connection with the server\n+ ///\n+ /// \\see `connect`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result disconnect(const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get SSH session information\n+ ///\n+ /// After connecting to the server and before actually\n+ /// logging in the SSH session information of the underlying\n+ /// connection will be available.\n+ ///\n+ /// The session information contains among other things the\n+ /// public key identifying the remote host and the connection\n+ /// parameters such as encryption and compression used. The\n+ /// identifiers used follow the RFC 4253 specification.\n+ ///\n+ /// If the session information is not available `std::nullopt`\n+ /// will be returned.\n+ ///\n+ /// Because SSH was developed as a parallel standard to\n+ /// SSL/TLS and automatic host certificate verification wasn't\n+ /// widespread at the time, relying on the user to check the\n+ /// authenticity of the host key was the typical method used\n+ /// to verify that they were connecting to the legitimate host,\n+ /// assuming the private key of the remote host was not\n+ /// compromised.\n+ ///\n+ /// If connection security is a high priority, examining\n+ /// the parameters and aborting the connection if any weak\n+ /// algorithms are used is also possible.\n+ ///\n+ /// \\return SSH session information or `std::nullopt` if it is not available\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] std::optional<SessionInfo> getSessionInfo() const;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Log in using a username and a password\n+ ///\n+ /// Logging in is mandatory after connecting to the server.\n+ /// Users that are not logged in cannot perform any operation.\n+ ///\n+ /// \\param name User name\n+ /// \\param password Password\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of attempting to log in to the server\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result login(std::string_view name,\n+ std::string_view password,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Log in using a public/private key pair\n+ ///\n+ /// Logging in is mandatory after connecting to the server.\n+ /// Users that are not logged in cannot perform any operation.\n+ ///\n+ /// This overload allows logging into the SFTP server using\n+ /// public key authentication.\n+ ///\n+ /// The public and private key data should be provided in PEM\n+ /// format. PEM encoded data can be easily recognized by their\n+ /// `-----BEGIN ............-----` header and\n+ /// `-----END ............-----` footer.\n+ ///\n+ /// Even though it is technically possible to derive the\n+ /// public key from the private key, due to backend\n+ /// limitations, providing a pre-generated public key as well\n+ /// is necessary for this function to be able to succeed.\n+ ///\n+ /// If the private key is protected by a passphrase the\n+ /// passphrase can be provided as a NULL terminated string.\n+ /// If the private key is not protected by a passphrase the\n+ /// passphrase should be set to the empty string.\n+ ///\n+ /// \\param name User name\n+ /// \\param publicKeyData Public key data\n+ /// \\param publicKeyLength Public key data length\n+ /// \\param privateKeyData Private key data\n+ /// \\param privateKeyLength Private key data length\n+ /// \\param privateKeyPassphrase Private key passphrase, NULL terminated\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of attempting to log in to the server\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase = \"\",\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Log in using a public/private key pair\n+ ///\n+ /// Logging in is mandatory after connecting to the server.\n+ /// Users that are not logged in cannot perform any operation.\n+ ///\n+ /// This overload allows logging into the SFTP server using\n+ /// public key authentication.\n+ ///\n+ /// The public and private key data should be provided in PEM\n+ /// format. PEM encoded data can be easily recognized by their\n+ /// `-----BEGIN ............-----` header and\n+ /// `-----END ............-----` footer.\n+ ///\n+ /// Even though it is technically possible to derive the\n+ /// public key from the private key, due to backend\n+ /// limitations, providing a pre-generated public key as well\n+ /// is necessary for this function to be able to succeed.\n+ ///\n+ /// If the private key is protected by a passphrase the\n+ /// passphrase can be provided as a NULL terminated string.\n+ /// If the private key is not protected by a passphrase the\n+ /// passphrase should be set to the empty string.\n+ ///\n+ /// \\param name User name\n+ /// \\param publicKeyData Public key data\n+ /// \\param privateKeyData Private key data\n+ /// \\param privateKeyPassphrase Private key passphrase\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of attempting to log in to the server\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase = {},\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Resolve a remote path into an absolute remote path\n+ ///\n+ /// Paths can contain links and other reserved path identifiers\n+ /// such as . and .. referring to the current directory and\n+ /// parent directory respectively.\n+ ///\n+ /// When determining the absolute path, which does not contain\n+ /// links or . or .. is necessary, this function can be used.\n+ ///\n+ /// Resolving \".\" will return the absolute path to the current\n+ /// working directory of the user after logging in to the SFTP\n+ /// server.\n+ ///\n+ /// \\param path Path to convert into an absolute path\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of converting the path into an absolute path\n+ ///\n+ /// \\see `getWorkingDirectory`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] PathResult resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the current working directory on the server\n+ ///\n+ /// This is an alias for calling `resolvePath(\".\")`.\n+ ///\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of getting the current working directory\n+ ///\n+ /// \\see `resolvePath`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] PathResult getWorkingDirectory(const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the attributes of a remote file or directory\n+ ///\n+ /// Depending on whether `path` refers to a file or directory,\n+ /// the attributes can contain e.g. the type of file, the file\n+ /// owner, group, file size, modification and access times.\n+ ///\n+ /// If links are not to be followed, `followLinks` can be set\n+ /// to `false`. In this case the attributes of the link itself\n+ /// will be returned.\n+ ///\n+ /// \\param path Path to the remote file or directory whose attributes to get\n+ /// \\param followLinks `true` to follow links, `false` to return attributes of the link itself\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of getting the attributes\n+ ///\n+ /// \\see `getDirectoryListing`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] AttributesResult getAttributes(const std::filesystem::path& path,\n+ bool followLinks = true,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the contents of the given directory\n+ ///\n+ /// This function retrieves the sub-directories and files\n+ /// contained in the given directory. It is not recursive.\n+ ///\n+ /// \\param path Path of the directory whose contents to list\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of getting the contents of the given directory\n+ ///\n+ /// \\see `getAttributes`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] ListingResult getDirectoryListing(const std::filesystem::path& path,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Create a new directory\n+ ///\n+ /// The new directory is created as a child of the current\n+ /// working directory.\n+ ///\n+ /// The default permissions value is equivalent to `rwxr-xr-x`\n+ /// or 0755 in octal notation.\n+ ///\n+ /// \\param path Path of the directory to create\n+ /// \\param permissions Permissions of the directory to create\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of creating the directory\n+ ///\n+ /// \\see `deleteDirectory`, `rename`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result createDirectory(\n+ const std::filesystem::path& path,\n+ std::filesystem::perms permissions = (std::filesystem::perms::owner_all | std::filesystem::perms::group_read |\n+ std::filesystem::perms::group_exec | std::filesystem::perms::others_read |\n+ std::filesystem::perms::others_exec),\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Remove an existing directory\n+ ///\n+ /// Use this function with caution, the directory will\n+ /// be removed permanently!\n+ ///\n+ /// \\param path Path of the directory to remove\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of removing the directory\n+ ///\n+ /// \\see `createDirectory`, `rename`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Rename an existing file or directory\n+ ///\n+ /// In POSIX renaming and moving and synonymous. If you want\n+ /// to move a file or directory from one place to another\n+ /// you rename it from an old to a new path.\n+ ///\n+ /// If a file exists at the specified new path, depending\n+ /// on whether `ovewrite` is set to true, the rename operation\n+ /// will overwrite it or not. If a directory is being moved,\n+ /// the new path must either not point to non-existant\n+ /// directory or a directory that is empty. Non-empty\n+ /// directories cannot be overwritten by this operation.\n+ ///\n+ /// \\param oldPath Old path to the file or directory\n+ /// \\param newPath New path to the file or directory\n+ /// \\param overwrite Set to `true` to allow overwriting a file that exists at `newPath`\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of the operation\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite = false,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Remove an existing file\n+ ///\n+ /// Use this function with caution, the file will be\n+ /// removed permanently!\n+ ///\n+ /// \\param path Path to the file to remove\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of removing the file\n+ ///\n+ /// \\see `rename`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Download a file from the server\n+ ///\n+ /// This function retrieves the data in the file at the\n+ /// remote path.\n+ ///\n+ /// The file data is transferred in sequential blocks. For\n+ /// every block of data transferred, the provided callback\n+ /// is called. The callback is passed a pointer to a data\n+ /// block and the size of the data contained in the current\n+ /// block. This size can change over time so it is important\n+ /// to always check the size value to know how much data is\n+ /// actually available. The callback should return `true` to\n+ /// indicate to the `download` function that it should\n+ /// continue to transfer data. If the data transfer should\n+ /// be aborted earlier, `false` can be returned from the\n+ /// callback.\n+ ///\n+ /// The function returns once all the data in the remote file\n+ /// has been transferred or an error occurs or the function\n+ /// times out.\n+ ///\n+ /// If reading from the remote file should not start at the\n+ /// beginning of the file, you can specify an offset in\n+ /// bytes at which reading should start.\n+ ///\n+ /// \\param remotePath Path of the remote file whose data to download\n+ /// \\param callback Callback to be called for every available data block\n+ /// \\param offset Byte offset into the remote file at which reading should start\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of downloading the file\n+ ///\n+ /// \\see `upload`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset = 0,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Upload a file to the server\n+ ///\n+ /// This function writes data into a file at the remote path.\n+ ///\n+ /// The file data is transferred in sequential blocks. Every\n+ /// time the function wants to send a new block of data the\n+ /// provided callback is called. The callback is passed a\n+ /// pointer to a data block and a reference to the size of\n+ /// the data block. Data to be sent should be copied into\n+ /// the data block using e.g. `std::memcpy` and the size value\n+ /// set to the actual number of bytes copied into the data\n+ /// block. The size of the block can change over time so it\n+ /// is important to check the size value that is passed to\n+ /// the callback to know how many bytes can actually be\n+ /// copied into the data block. The callback should return\n+ /// `true` to indicate to the `upload` function that it\n+ /// should continue to transfer data. Once the data transfer\n+ /// should be stopped e.g. because there is no more data left\n+ /// to send, `false` can be returned from the callback.\n+ ///\n+ /// The function returns once all the data has been sent or\n+ /// an error occurs or the function times out.\n+ ///\n+ /// If a file does not exist at the remote path yet, it will\n+ /// be created with the provided permissions.\n+ ///\n+ /// If a file already exists at the remote path, setting\n+ /// `truncate` to `true` will truncate the existing file\n+ /// i.e. delete all pre-existing data before starting to\n+ /// write the new data into the file.\n+ ///\n+ /// Setting `append` to `true` will append to a file if\n+ /// it already exists.\n+ ///\n+ /// If writing to the remote file should not start at the\n+ /// beginning of the file, you can specify an offset in\n+ /// bytes at which writing should start.\n+ ///\n+ /// The default permissions value is equivalent to `rw-r--r--`\n+ /// or 0644 in octal notation.\n+ ///\n+ /// \\param remotePath Path of the remote file in which to upload the data\n+ /// \\param callback Callback to be called for every available data block\n+ /// \\param permissions Permissions of the remote file if it has to be created\n+ /// \\param truncate Set to `true` to truncate the remote file if it already exists\n+ /// \\param append Set to `true` to append to the remote file if it already exists\n+ /// \\param offset Byte offset into the remote file at which writing should start\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of uploading the file\n+ ///\n+ /// \\see `download`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result upload(\n+ const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions = (std::filesystem::perms::owner_read | std::filesystem::perms::owner_write |\n+ std::filesystem::perms::group_read | std::filesystem::perms::others_read),\n+ bool truncate = true,\n+ bool append = false,\n+ std::uint64_t offset = 0,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ struct Impl;\n+ std::unique_ptr<Impl> m_impl; //!< Implementation\n+};\n+\n+} // namespace sf\n+\n+\n+////////////////////////////////////////////////////////////\n+/// \\class sf::Sftp\n+/// \\ingroup network\n+///\n+/// `sf::Sftp` is a very simple SFTP client that allows you\n+/// to communicate with a SFTP server. The SFTP protocol allows\n+/// you to manipulate a remote file system (list files,\n+/// upload, download, create, remove, ...).\n+///\n+/// Using the SFTP client consists of 4 parts:\n+/// \\li Connecting to the SFTP server\n+/// \\li Logging in (either using username and password or public key authentication)\n+/// \\li Performing file system operations\n+/// \\li Disconnecting (this part can be done implicitly by the destructor)\n+///\n+/// Every operation returns an SFTP result, which contains the\n+/// result code and optionally a message describing the result. Some\n+/// commands such as `getAttributes()` and `getDirectoryListing()`\n+/// return additional data, and use a class derived from\n+/// `sf::Sftp::Result` to provide this data. The commonly used filesystem\n+/// operations are directly provided as member functions.\n+///\n+/// There are three classes of result values: general result values,\n+/// SSH specific result values and SFTP specific result values. General\n+/// result values are returned on success and errors not specific to the\n+/// SSH or SFTP protocols. If an operation manipulating the remote\n+/// filesystem fails, an SFTP specific result will be returned describing\n+/// the reason for the failure. If any error related to the communication\n+/// channel occurs e.g. key exchange failure or authentication failure an\n+/// SSH error will be returned.\n+///\n+/// Because most operations manipulate some part of the remote filesystem\n+/// these operations, especially upload and download, may take some\n+/// time to complete. This is important to know if you don't want\n+/// to block your application while the server is completing\n+/// the task.\n+///\n+/// Every operation that relies on network communication can be passed\n+/// a timeout argument. In the simplest case, this timeout argument can\n+/// just be a fixed time duration after which the operation should time\n+/// out if no progress has been made. Because some operations simply due\n+/// to their nature can take longer than others it might not be possible\n+/// to use the same timeout value for all operations. If it is anticipated\n+/// that an operation could take a longer amount of time to complete due\n+/// to e.g. an unreliable or slow connection, the timeout should be increased\n+/// so the operation still has the possibility to complete successfully.\n+/// Passing `sf::Time::Zero` as a timeout value will cause the operation\n+/// to block until completion or failure.\n+///\n+/// If you want to pass `sf::Time::Zero` to wait indefinitely for an\n+/// operation to complete but still have the possibility to interrupt the\n+/// operation e.g. if the user decides to quit the application or interrupt\n+/// a longer download or upload, the timeout can be constructed from a\n+/// predicate and polling period. The predicate is a callable that takes\n+/// no parameters and returns `true` if the operation should continue or\n+/// `false` if the operation should time out. The time between consecutive\n+/// evaluations of the predicate is specified by the `period` parameter.\n+///\n+/// Example of a `TimeoutWithPredicate`:\n+/// \\code\n+/// bool run = true;\n+/// sf::Sftp::TimeoutWithPredicate timeout([&run]{ return run; }, sf::milliseconds(1));\n+/// \\endcode\n+/// When passed to an operation, the above `TimeoutWithPredicate` object will\n+/// keep the operation running as long as `run` is `true`. The condition\n+/// is checked every 1 millisecond. As soon as `run` is set to `false` the\n+/// operation will terminate with a `Timeout` result.\n+///\n+/// Remember that attempting to modify variables from across threads will\n+/// require proper synchronization using e.g. mutexes or atomics.\n+///\n+/// Because the filesystem operations will be performed on the remote\n+/// system, the paths passed to the operations should be valid paths on\n+/// the remote system. To guarantee portability, generic POSIX paths should\n+/// be used. These use `/` as the path seperator and `.` to refer to the\n+/// current directory and `..` to refer to the parent directory.\n+///\n+/// When logging into the server as a specific user the current directory\n+/// will be set to the home directory that was specified for that user\n+/// account. Because it cannot be assumed that the SFTP user is also allowed\n+/// to log into a shell, changing the current directory from the home\n+/// directory is not always possible and thus not supported. Thus when\n+/// specifying paths, it is preferred to always make use of absolute paths\n+/// when possible. Calling `getWorkingDirectory()` will return the current\n+/// directory as an absolute path. Listing the contents of a directory whose\n+/// path is passed as an absolute path will yield directory listing entries\n+/// whose paths are extentions of the directory's path and thus also absolute\n+/// paths. The `resolvePath()` function can be used to convert relative paths\n+/// or paths containing links into absolute paths without links.\n+///\n+/// Usage example:\n+/// \\code\n+/// // Create a new SFTP client\n+/// sf::Sftp sftp;\n+///\n+/// // Get the address of the server\n+/// const auto addresses = sf::Dns::resolve(\"sftp.myserver.com\");\n+///\n+/// // Check if we have a valid address\n+/// if (!addresses.has_value() || addresses->empty())\n+/// {\n+/// // Handle no valid address...\n+/// }\n+///\n+/// // Connect to the server\n+/// sf::Sftp::Result result = sftp.connect(addresses->front());\n+/// if (result.isOk())\n+/// std::cout << \"Connected\" << std::endl;\n+///\n+/// // Check session information and verify server\n+/// std::optional<sf::Sftp::SessionInfo> info = sftp.getSessionInfo();\n+/// if (info->hostKey.sha256 != expectedSha256)\n+/// {\n+/// std::cout << \"Server untrusted\" << std::endl;\n+/// // Handle untrusted server\n+/// }\n+///\n+/// // Log in\n+/// result = sftp.login(\"sftpuser\", \"dF6Zm89D\");\n+/// if (result.isOk())\n+/// std::cout << \"Logged in\" << std::endl;\n+///\n+/// // Print the working directory\n+/// sf::Sftp::PathResult directory = sftp.getWorkingDirectory();\n+/// if (directory.isOk())\n+/// std::cout << \"Working directory: \" << directory.getPath().string() << std::endl;\n+///\n+/// // Create a new directory\n+/// result = sftp.createDirectory(\"files\");\n+/// if (result.isOk())\n+/// std::cout << \"Created new directory\" << std::endl;\n+///\n+/// // Upload a text file to this new directory\n+/// result = sftp.upload(\"files/newfile.txt\", [](void* data, std::size_t& size)\n+/// {\n+/// // In your own code, ensure size is big enough to store your data\n+/// // We skip the check here for simplicity\n+/// std::memcpy(data, \"Hello World\", 11);\n+/// size = 11;\n+/// return false; // End transfer after this block\n+/// });\n+/// if (response.isOk())\n+/// std::cout << \"File uploaded\" << std::endl;\n+///\n+/// // Rename file\n+/// result = sftp.rename(\"files/newfile.txt\", \"files/newfile2.txt\");\n+/// if (result.isOk())\n+/// std::cout << \"Renamed file\" << std::endl;\n+///\n+/// // Download a text file from this new directory\n+/// std::string text;\n+/// result = sftp.download(\"files/newfile2.txt\", [&text](const void* data, std::size_t size)\n+/// {\n+/// text.append(static_cast<const char*>(data), size);\n+/// return true; // Continue until all data received\n+/// });\n+/// if (response.isOk())\n+/// std::cout << \"File downloaded: \" << text << std::endl;\n+///\n+/// // Delete file\n+/// result = sftp.deleteFile(\"files/newfile2.txt\");\n+/// if (result.isOk())\n+/// std::cout << \"Deleted file\" << std::endl;\n+///\n+/// // Delete directory\n+/// result = sftp.deleteDirectory(\"files\");\n+/// if (result.isOk())\n+/// std::cout << \"Deleted directory\" << std::endl;\n+///\n+/// // Disconnect from the server (optional)\n+/// result = sftp.disconnect();\n+/// if (result.isOk())\n+/// std::cout << \"Disconnected successfully\" << std::endl;\n+/// \\endcode\n+///\n+////////////////////////////////////////////////////////////\n"},"changed_files":{"kind":"list like","value":["include/SFML/Network/Sftp.hpp"],"string":"[\n \"include/SFML/Network/Sftp.hpp\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"```suggestion\n /// \\brief Connect to the specified SFTP server\n```","path":"include/SFML/Network/Sftp.hpp","hunk":"@@ -0,0 +1,998 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+#pragma once\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/Export.hpp>\n+\n+#include <SFML/System/Time.hpp>\n+\n+#include <array>\n+#include <filesystem>\n+#include <functional>\n+#include <memory>\n+#include <optional>\n+#include <string>\n+#include <vector>\n+\n+#include <cstddef>\n+#include <cstdint>\n+\n+\n+namespace sf\n+{\n+class IpAddress;\n+\n+////////////////////////////////////////////////////////////\n+/// \\brief An SSH File Transfer Protocol (SFTP) client\n+///\n+////////////////////////////////////////////////////////////\n+class SFML_NETWORK_API Sftp\n+{\n+public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief SFTP result\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result values\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ enum class Value\n+ {\n+ // General result values\n+ Success, //!< Operation completed successfully\n+ Disconnected, //!< The TCP socket has been disconnected\n+ Timeout, //!< Operation timed out\n+ Refused, //!< Connection refused\n+ Error, //!< Generic error\n+\n+ // SSH result values\n+ SshErrorBannerReceive, //!< Error during banner receive\n+ SshErrorBannerSend, //!< Error during banner send\n+ SshErrorInvalidMac, //!< Invalid message authentication code\n+ SshErrorAllocation, //!< Allocation failure\n+ SshErrorSocketSend, //!< Error sending on socket\n+ SshErrorKeyExchangeFailure, //!< Key exchange failed\n+ SshErrorHostKeyInitialization, //!< Host key initialization failed\n+ SshErrorHostKeySign, //!< Host key signing failed\n+ SshErrorDecrypt, //!< Decryption failed\n+ SshErrorProtocol, //!< SSH protocol error\n+ SshErrorPasswordExpired, //!< Password expired\n+ SshErrorFile, //!< File error\n+ SshErrorMethodNone, //!< No method found\n+ SshErrorAuthenticationFailed, //!< Authentication failed\n+ SshErrorPublicKeyUnverified, //!< Public key unverified\n+ SshErrorChannelOutOfOrder, //!< Channel out of order\n+ SshErrorChannelFailure, //!< Channel failure\n+ SshErrorChannelRequestDenied, //!< Channel request denied\n+ SshErrorChannelUnknown, //!< Channel unknown\n+ SshErrorChannelWindowExceeded, //!< Channel window exceeded\n+ SshErrorChannelPacketExceeded, //!< Channel packet exceeded\n+ SshErrorChannelClosed, //!< Channel closed\n+ SshErrorChannelEofSent, //!< Channel EOF sent\n+ SshErrorScpProtocol, //!< SCP protocol error\n+ SshErrorZlib, //!< Zlib error\n+ SshErrorRequestDenied, //!< Request denied\n+ SshErrorMethodNotSupported, //!< Method not supported\n+ SshErrorInvalid, //!< Invalid data\n+ SshErrorPublicKeyProtocol, //!< Public key protocol error\n+ SshErrorBufferTooSmall, //!< Buffer too small\n+ SshErrorBadUse, //!< Bad usage\n+ SshErrorCompress, //!< Compression error\n+ SshErrorOutOfBoundary, //!< Out of boundary\n+ SshErrorAgentProtocol, //!< Agent protocol error\n+ SshErrorSocketRecv, //!< Socket receive error\n+ SshErrorEncrypt, //!< Encryption failed\n+ SshErrorBadSocket, //!< Bad socket\n+ SshErrorKnownHosts, //!< Known hosts error\n+ SshErrorChannelWindowFull, //!< Channel window full\n+ SshErrorKeyFileAuthenticationFailed, //!< Key file authentication failed\n+\n+ // SFTP result values\n+ SftpEndOfFile, //!< End of file\n+ SftpNoSuchFile, //!< No such file\n+ SftpPermissionDenied, //!< Permission denied\n+ SftpFailure, //!< Failure\n+ SftpBadMessage, //!< Bad message\n+ SftpNoConnection, //!< No connection\n+ SftpConnectionLost, //!< Connection lost\n+ SftpOperationUnsupported, //!< Operation unsupported\n+ SftpInvalidHandle, //!< Invalid handle\n+ SftpNoSuchPath, //!< No such path\n+ SftpFileAlreadyExists, //!< File already exists\n+ SftpWriteProtect, //!< Write protect\n+ SftpNoMedia, //!< No media\n+ SftpNoSpaceOnFileSystem, //!< No space on filesystem\n+ SftpQuotaExceeded, //!< Quota exceeded\n+ SftpUnknownPrincipal, //!< Unknown principal\n+ SftpLockConflict, //!< Lock conflict\n+ SftpDirectoryNotEmpty, //!< Directory not empty\n+ SftpNotADirectory, //!< Not a directory\n+ SftpInvalidFilename, //!< Invalid filename\n+ SftpLinkLoop, //!< Link loop\n+ SftpError //!< Generic SFTP error\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// This constructor is used by the SFTP client to build\n+ /// the result.\n+ ///\n+ /// \\param value Result value\n+ /// \\param message Result message\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ explicit Result(Value value = Value::Error, std::string message = \"\");\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Check if the result is a success\n+ ///\n+ /// This function is defined for convenience, it is\n+ /// equivalent to testing if the result value is `Value::Success`.\n+ ///\n+ /// \\return `true` if the result is `Value::Success`, `false` if it is not `Value::Success`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] bool isOk() const;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the result value\n+ ///\n+ /// \\return The result value\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Value getValue() const;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the result message\n+ ///\n+ /// \\return The result message\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const std::string& getMessage() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ Value m_value; //!< The contained value\n+ std::string m_message; //!< The contained message\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result of an operation returning a path\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API PathResult : public Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// \\param result Result\n+ /// \\param path Path\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ PathResult(const Result& result, std::filesystem::path path);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the path\n+ ///\n+ /// \\return The path\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const std::filesystem::path& getPath() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ std::filesystem::path m_path; //!< The contained path\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief File or directory attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ struct Attributes\n+ {\n+ std::filesystem::path path; //!< Path to the entry\n+ std::optional<std::filesystem::file_type> type; //!< Type of the entry\n+ std::optional<std::uint64_t> size; //!< Size of the entry\n+ std::optional<std::filesystem::perms> permissions; //!< Permissions\n+ std::optional<std::uint64_t> userId; //!< Owner user ID\n+ std::optional<std::uint64_t> groupId; //!< Group ID\n+ std::optional<std::filesystem::file_time_type> accessTime; //!< Last access time\n+ std::optional<std::filesystem::file_time_type> modificationTime; //!< Last modification time\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result of an operation returning attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API AttributesResult : public Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// \\param result Result\n+ /// \\param attributes Attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ AttributesResult(const Result& result, Attributes attributes);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the attributes\n+ ///\n+ /// \\return The attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const Attributes& getAttributes() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ Attributes m_attributes; //!< The contained attributes\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result of an operation returning a directory listing\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API ListingResult : public Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// \\param result Result\n+ /// \\param listing Directory listing\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ ListingResult(const Result& result, std::vector<Attributes> listing);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the directory listing\n+ ///\n+ /// \\return The directory listing\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const std::vector<Attributes>& getListing() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ std::vector<Attributes> m_listing; //!< The contained directory listing\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Hybrid of a timeout and a continuation predicate\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API TimeoutPredicate\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// This constructor constructs an `TimeoutPredicate` object\n+ /// that times out after the given amount of time.\n+ ///\n+ /// \\param timeout Time to timeout after\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ TimeoutPredicate(Time timeout);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// This constructor constructs an `TimeoutPredicate` object\n+ /// that times out when the given predicate returns false.\n+ /// The frequency at which predicate is checked is specified\n+ /// by `period`.\n+ ///\n+ /// If an empty predicate is passed, it will be set to a\n+ /// predicate that returns `false` when called.\n+ ///\n+ /// \\param predicate Predicate that returns `true` to continue or `false` to timeout\n+ /// \\param period The period between checks of the predicate\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ TimeoutPredicate(std::function<bool()> predicate, Time period = milliseconds(1));\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the predicate\n+ ///\n+ /// \\return The predicate\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const std::function<bool()>& getPredicate() const;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the period\n+ ///\n+ /// \\return The period\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const Time& getPeriod() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ std::function<bool()> m_predicate; //!< The contained predicate\n+ Time m_period; //!< The contained period\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Structure containing information about an active SFTP session\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ struct SessionInfo\n+ {\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Host key used to identify a host\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ struct HostKey\n+ {\n+ enum class Type\n+ {\n+ Unknown, //!< Unknown key type\n+ Rsa, //!< RSA\n+ Dsa, //!< DSA\n+ Ecdsa256, //!< NIST P-256 ECDSA\n+ Ecdsa384, //!< NIST P-384 ECDSA\n+ Ecdsa521, //!< NIST P-521 ECDSA\n+ Ed25519 //!< ED25519\n+ };\n+\n+ Type type = Type::Unknown; //!< Host key type\n+ std::vector<std::byte> data; //!< Host key data\n+ std::array<std::byte, 20> sha1{}; //!< Host key SHA1 hash\n+ std::array<std::byte, 32> sha256{}; //!< Host key SHA256 hash\n+ };\n+\n+ HostKey hostKey; //!< Host key\n+ std::string keyExchangeAlgorithm; //!< Key exchange algorithm used in the session (RFC 4253)\n+ std::string hostKeyAlgorithm; //!< Host key algorithm used in the session (RFC 4253)\n+ std::string clientToServerEncryptionAlgorithm; //!< Client to server encryption algorithm used in the session (RFC 4253)\n+ std::string serverToClientEncryptionAlgorithm; //!< Server to client encryption algorithm used in the session (RFC 4253)\n+ std::string clientToServerMacAlgorithm; //!< Client to server message authentication code algorithm used in the session (RFC 4253)\n+ std::string serverToClientMacAlgorithm; //!< Server to client message authentication code algorithm used in the session (RFC 4253)\n+ std::string clientToServerCompressionAlgorithm; //!< Client to server compression algorithm used in the session (RFC 4253)\n+ std::string serverToClientCompressionAlgorithm; //!< Server to client compression algorithm used in the session (RFC 4253)\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Default constructor\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ Sftp();\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Destructor\n+ ///\n+ /// Automatically closes the connection with the server if\n+ /// it is still opened.\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ ~Sftp();\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Deleted copy constructor\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ Sftp(const Sftp&) = delete;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Deleted copy assignment\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ Sftp& operator=(const Sftp&) = delete;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Connect to the specified FTP server","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/include/SFML/Network/Sftp.hpp b/include/SFML/Network/Sftp.hpp\nnew file mode 100644\nindex 0000000000..9be101d562\n--- /dev/null\n+++ b/include/SFML/Network/Sftp.hpp\n@@ -0,0 +1,987 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+#pragma once\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/Export.hpp>\n+\n+#include <SFML/System/TimeoutWithPredicate.hpp>\n+\n+#include <array>\n+#include <filesystem>\n+#include <memory>\n+#include <optional>\n+#include <string>\n+#include <string_view>\n+#include <vector>\n+\n+#include <cstddef>\n+#include <cstdint>\n+\n+\n+namespace sf\n+{\n+class IpAddress;\n+\n+////////////////////////////////////////////////////////////\n+/// \\brief An SSH File Transfer Protocol (SFTP) client\n+///\n+////////////////////////////////////////////////////////////\n+class SFML_NETWORK_API Sftp\n+{\n+public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief SFTP result\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result values\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ enum class Value\n+ {\n+ // General result values\n+ Success, //!< Operation completed successfully\n+ Disconnected, //!< The TCP socket has been disconnected\n+ Timeout, //!< Operation timed out\n+ Refused, //!< Connection refused\n+ Error, //!< Generic error\n+\n+ // SSH result values\n+ BannerReceive, //!< Error during banner receive\n+ BannerSend, //!< Error during banner send\n+ InvalidMac, //!< Invalid message authentication code\n+ AllocationFailure, //!< Allocation failure\n+ SocketSend, //!< Error sending on socket\n+ KeyExchangeFailure, //!< Key exchange failed\n+ HostKeyInitialization, //!< Host key initialization failed\n+ HostKeySign, //!< Host key signing failed\n+ DecryptError, //!< Decryption failed\n+ ProtocolError, //!< SSH protocol error\n+ PasswordExpired, //!< Password expired\n+ FileError, //!< File error\n+ MethodNone, //!< No method found\n+ AuthenticationFailed, //!< Authentication failed\n+ PublicKeyUnverified, //!< Public key unverified\n+ ChannelOutOfOrder, //!< Channel out of order\n+ ChannelFailure, //!< Channel failure\n+ ChannelRequestDenied, //!< Channel request denied\n+ ChannelUnknown, //!< Channel unknown\n+ ChannelWindowExceeded, //!< Channel window exceeded\n+ ChannelPacketExceeded, //!< Channel packet exceeded\n+ ChannelClosed, //!< Channel closed\n+ ChannelEofSent, //!< Channel EOF sent\n+ ScpProtocol, //!< SCP protocol error\n+ ZlibError, //!< Zlib error\n+ RequestDenied, //!< Request denied\n+ MethodNotSupported, //!< Method not supported\n+ InvalidData, //!< Invalid data\n+ PublicKeyProtocol, //!< Public key protocol error\n+ BufferTooSmall, //!< Buffer too small\n+ BadUse, //!< Bad usage\n+ CompressError, //!< Compression error\n+ OutOfBoundary, //!< Out of boundary\n+ AgentProtocol, //!< Agent protocol error\n+ SocketRecv, //!< Socket receive error\n+ EncryptError, //!< Encryption failed\n+ BadSocket, //!< Bad socket\n+ KnownHosts, //!< Known hosts error\n+ ChannelWindowFull, //!< Channel window full\n+ KeyFileAuthenticationFailed, //!< Key file authentication failed\n+\n+ // SFTP result values\n+ EndOfFile, //!< End of file\n+ NoSuchFile, //!< No such file\n+ PermissionDenied, //!< Permission denied\n+ Failure, //!< Failure\n+ BadMessage, //!< Bad message\n+ NoConnection, //!< No connection\n+ ConnectionLost, //!< Connection lost\n+ OperationUnsupported, //!< Operation unsupported\n+ InvalidHandle, //!< Invalid handle\n+ NoSuchPath, //!< No such path\n+ FileAlreadyExists, //!< File already exists\n+ WriteProtect, //!< Write protect\n+ NoMedia, //!< No media\n+ NoSpaceOnFileSystem, //!< No space on filesystem\n+ QuotaExceeded, //!< Quota exceeded\n+ UnknownPrincipal, //!< Unknown principal\n+ LockConflict, //!< Lock conflict\n+ DirectoryNotEmpty, //!< Directory not empty\n+ NotADirectory, //!< Not a directory\n+ InvalidFilename, //!< Invalid filename\n+ LinkLoop, //!< Link loop\n+ SftpError //!< Generic SFTP error\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// This constructor is used by the SFTP client to build\n+ /// the result.\n+ ///\n+ /// \\param value Result value\n+ /// \\param message Result message\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ explicit Result(Value value, std::string message = \"\");\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Check if the result is a success\n+ ///\n+ /// This function is defined for convenience, it is\n+ /// equivalent to testing if the result value is `Value::Success`.\n+ ///\n+ /// \\return `true` if the result is `Value::Success`, `false` if it is not `Value::Success`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] bool isOk() const;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the result value\n+ ///\n+ /// \\return The result value\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Value getValue() const;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the result message\n+ ///\n+ /// \\return The result message\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const std::string& getMessage() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ Value m_value; //!< The contained value\n+ std::string m_message; //!< The contained message\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result of an operation returning a path\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API PathResult : public Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// \\param result Result\n+ /// \\param path Path\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ PathResult(const Result& result, std::filesystem::path path);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the path\n+ ///\n+ /// \\return The path\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const std::filesystem::path& getPath() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ std::filesystem::path m_path; //!< The contained path\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief File or directory attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ struct Attributes\n+ {\n+ std::filesystem::path path; //!< Path to the entry\n+ std::optional<std::filesystem::file_type> type; //!< Type of the entry\n+ std::optional<std::uint64_t> size; //!< Size of the entry\n+ std::optional<std::filesystem::perms> permissions; //!< Permissions\n+ std::optional<std::uint64_t> userId; //!< Owner user ID\n+ std::optional<std::uint64_t> groupId; //!< Group ID\n+ std::optional<std::filesystem::file_time_type> accessTime; //!< Last access time\n+ std::optional<std::filesystem::file_time_type> modificationTime; //!< Last modification time\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result of an operation returning attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API AttributesResult : public Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// \\param result Result\n+ /// \\param attributes Attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ AttributesResult(const Result& result, Attributes attributes);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the attributes\n+ ///\n+ /// \\return The attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const Attributes& getAttributes() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ Attributes m_attributes; //!< The contained attributes\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result of an operation returning a directory listing\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API ListingResult : public Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// \\param result Result\n+ /// \\param listing Directory listing\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ ListingResult(const Result& result, std::vector<Attributes> listing);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the directory listing\n+ ///\n+ /// \\return The directory listing\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const std::vector<Attributes>& getListing() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ std::vector<Attributes> m_listing; //!< The contained directory listing\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Structure containing information about an active SFTP session\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ struct SessionInfo\n+ {\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Host key used to identify a host\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ struct HostKey\n+ {\n+ enum class Type\n+ {\n+ Unknown, //!< Unknown key type\n+ Rsa, //!< RSA\n+ Dsa, //!< DSA\n+ Ecdsa256, //!< NIST P-256 ECDSA\n+ Ecdsa384, //!< NIST P-384 ECDSA\n+ Ecdsa521, //!< NIST P-521 ECDSA\n+ Ed25519 //!< ED25519\n+ };\n+\n+ Type type = Type::Unknown; //!< Host key type\n+ std::vector<std::byte> data; //!< Host key data\n+ std::array<std::byte, 20> sha1{}; //!< Host key SHA1 hash\n+ std::array<std::byte, 32> sha256{}; //!< Host key SHA256 hash\n+ };\n+\n+ HostKey hostKey; //!< Host key\n+ std::string keyExchangeAlgorithm; //!< Key exchange algorithm used in the session (RFC 4253)\n+ std::string hostKeyAlgorithm; //!< Host key algorithm used in the session (RFC 4253)\n+ std::string clientToServerEncryptionAlgorithm; //!< Client to server encryption algorithm used in the session (RFC 4253)\n+ std::string serverToClientEncryptionAlgorithm; //!< Server to client encryption algorithm used in the session (RFC 4253)\n+ std::string clientToServerMacAlgorithm; //!< Client to server message authentication code algorithm used in the session (RFC 4253)\n+ std::string serverToClientMacAlgorithm; //!< Server to client message authentication code algorithm used in the session (RFC 4253)\n+ std::string clientToServerCompressionAlgorithm; //!< Client to server compression algorithm used in the session (RFC 4253)\n+ std::string serverToClientCompressionAlgorithm; //!< Server to client compression algorithm used in the session (RFC 4253)\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Default constructor\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ Sftp();\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Destructor\n+ ///\n+ /// Automatically closes the connection with the server if\n+ /// it is still opened.\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ ~Sftp();\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Deleted copy constructor\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ Sftp(const Sftp&) = delete;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Deleted copy assignment\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ Sftp& operator=(const Sftp&) = delete;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Connect to the specified SFTP server\n+ ///\n+ /// The port has a default value of 22, which is the standard\n+ /// port used by the SFTP protocol.\n+ /// This function tries to connect to the server so it may take\n+ /// a while to complete, especially if the server is not\n+ /// reachable. To avoid blocking your application for too long,\n+ /// you can use a timeout. The default value, `Time::Zero`, means that the\n+ /// system timeout will be used (which is usually pretty long).\n+ ///\n+ /// \\param server Name or address of the SFTP server to connect to\n+ /// \\param port Port used for the connection\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of the connection attempt\n+ ///\n+ /// \\see `disconnect`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result connect(IpAddress server, unsigned short port = 22, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Disconnect the connection with the server\n+ ///\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of disconnecting the connection with the server\n+ ///\n+ /// \\see `connect`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result disconnect(const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get SSH session information\n+ ///\n+ /// After connecting to the server and before actually\n+ /// logging in the SSH session information of the underlying\n+ /// connection will be available.\n+ ///\n+ /// The session information contains among other things the\n+ /// public key identifying the remote host and the connection\n+ /// parameters such as encryption and compression used. The\n+ /// identifiers used follow the RFC 4253 specification.\n+ ///\n+ /// If the session information is not available `std::nullopt`\n+ /// will be returned.\n+ ///\n+ /// Because SSH was developed as a parallel standard to\n+ /// SSL/TLS and automatic host certificate verification wasn't\n+ /// widespread at the time, relying on the user to check the\n+ /// authenticity of the host key was the typical method used\n+ /// to verify that they were connecting to the legitimate host,\n+ /// assuming the private key of the remote host was not\n+ /// compromised.\n+ ///\n+ /// If connection security is a high priority, examining\n+ /// the parameters and aborting the connection if any weak\n+ /// algorithms are used is also possible.\n+ ///\n+ /// \\return SSH session information or `std::nullopt` if it is not available\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] std::optional<SessionInfo> getSessionInfo() const;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Log in using a username and a password\n+ ///\n+ /// Logging in is mandatory after connecting to the server.\n+ /// Users that are not logged in cannot perform any operation.\n+ ///\n+ /// \\param name User name\n+ /// \\param password Password\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of attempting to log in to the server\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result login(std::string_view name,\n+ std::string_view password,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Log in using a public/private key pair\n+ ///\n+ /// Logging in is mandatory after connecting to the server.\n+ /// Users that are not logged in cannot perform any operation.\n+ ///\n+ /// This overload allows logging into the SFTP server using\n+ /// public key authentication.\n+ ///\n+ /// The public and private key data should be provided in PEM\n+ /// format. PEM encoded data can be easily recognized by their\n+ /// `-----BEGIN ............-----` header and\n+ /// `-----END ............-----` footer.\n+ ///\n+ /// Even though it is technically possible to derive the\n+ /// public key from the private key, due to backend\n+ /// limitations, providing a pre-generated public key as well\n+ /// is necessary for this function to be able to succeed.\n+ ///\n+ /// If the private key is protected by a passphrase the\n+ /// passphrase can be provided as a NULL terminated string.\n+ /// If the private key is not protected by a passphrase the\n+ /// passphrase should be set to the empty string.\n+ ///\n+ /// \\param name User name\n+ /// \\param publicKeyData Public key data\n+ /// \\param publicKeyLength Public key data length\n+ /// \\param privateKeyData Private key data\n+ /// \\param privateKeyLength Private key data length\n+ /// \\param privateKeyPassphrase Private key passphrase, NULL terminated\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of attempting to log in to the server\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase = \"\",\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Log in using a public/private key pair\n+ ///\n+ /// Logging in is mandatory after connecting to the server.\n+ /// Users that are not logged in cannot perform any operation.\n+ ///\n+ /// This overload allows logging into the SFTP server using\n+ /// public key authentication.\n+ ///\n+ /// The public and private key data should be provided in PEM\n+ /// format. PEM encoded data can be easily recognized by their\n+ /// `-----BEGIN ............-----` header and\n+ /// `-----END ............-----` footer.\n+ ///\n+ /// Even though it is technically possible to derive the\n+ /// public key from the private key, due to backend\n+ /// limitations, providing a pre-generated public key as well\n+ /// is necessary for this function to be able to succeed.\n+ ///\n+ /// If the private key is protected by a passphrase the\n+ /// passphrase can be provided as a NULL terminated string.\n+ /// If the private key is not protected by a passphrase the\n+ /// passphrase should be set to the empty string.\n+ ///\n+ /// \\param name User name\n+ /// \\param publicKeyData Public key data\n+ /// \\param privateKeyData Private key data\n+ /// \\param privateKeyPassphrase Private key passphrase\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of attempting to log in to the server\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase = {},\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Resolve a remote path into an absolute remote path\n+ ///\n+ /// Paths can contain links and other reserved path identifiers\n+ /// such as . and .. referring to the current directory and\n+ /// parent directory respectively.\n+ ///\n+ /// When determining the absolute path, which does not contain\n+ /// links or . or .. is necessary, this function can be used.\n+ ///\n+ /// Resolving \".\" will return the absolute path to the current\n+ /// working directory of the user after logging in to the SFTP\n+ /// server.\n+ ///\n+ /// \\param path Path to convert into an absolute path\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of converting the path into an absolute path\n+ ///\n+ /// \\see `getWorkingDirectory`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] PathResult resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the current working directory on the server\n+ ///\n+ /// This is an alias for calling `resolvePath(\".\")`.\n+ ///\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of getting the current working directory\n+ ///\n+ /// \\see `resolvePath`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] PathResult getWorkingDirectory(const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the attributes of a remote file or directory\n+ ///\n+ /// Depending on whether `path` refers to a file or directory,\n+ /// the attributes can contain e.g. the type of file, the file\n+ /// owner, group, file size, modification and access times.\n+ ///\n+ /// If links are not to be followed, `followLinks` can be set\n+ /// to `false`. In this case the attributes of the link itself\n+ /// will be returned.\n+ ///\n+ /// \\param path Path to the remote file or directory whose attributes to get\n+ /// \\param followLinks `true` to follow links, `false` to return attributes of the link itself\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of getting the attributes\n+ ///\n+ /// \\see `getDirectoryListing`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] AttributesResult getAttributes(const std::filesystem::path& path,\n+ bool followLinks = true,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the contents of the given directory\n+ ///\n+ /// This function retrieves the sub-directories and files\n+ /// contained in the given directory. It is not recursive.\n+ ///\n+ /// \\param path Path of the directory whose contents to list\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of getting the contents of the given directory\n+ ///\n+ /// \\see `getAttributes`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] ListingResult getDirectoryListing(const std::filesystem::path& path,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Create a new directory\n+ ///\n+ /// The new directory is created as a child of the current\n+ /// working directory.\n+ ///\n+ /// The default permissions value is equivalent to `rwxr-xr-x`\n+ /// or 0755 in octal notation.\n+ ///\n+ /// \\param path Path of the directory to create\n+ /// \\param permissions Permissions of the directory to create\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of creating the directory\n+ ///\n+ /// \\see `deleteDirectory`, `rename`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result createDirectory(\n+ const std::filesystem::path& path,\n+ std::filesystem::perms permissions = (std::filesystem::perms::owner_all | std::filesystem::perms::group_read |\n+ std::filesystem::perms::group_exec | std::filesystem::perms::others_read |\n+ std::filesystem::perms::others_exec),\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Remove an existing directory\n+ ///\n+ /// Use this function with caution, the directory will\n+ /// be removed permanently!\n+ ///\n+ /// \\param path Path of the directory to remove\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of removing the directory\n+ ///\n+ /// \\see `createDirectory`, `rename`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Rename an existing file or directory\n+ ///\n+ /// In POSIX renaming and moving and synonymous. If you want\n+ /// to move a file or directory from one place to another\n+ /// you rename it from an old to a new path.\n+ ///\n+ /// If a file exists at the specified new path, depending\n+ /// on whether `ovewrite` is set to true, the rename operation\n+ /// will overwrite it or not. If a directory is being moved,\n+ /// the new path must either not point to non-existant\n+ /// directory or a directory that is empty. Non-empty\n+ /// directories cannot be overwritten by this operation.\n+ ///\n+ /// \\param oldPath Old path to the file or directory\n+ /// \\param newPath New path to the file or directory\n+ /// \\param overwrite Set to `true` to allow overwriting a file that exists at `newPath`\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of the operation\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite = false,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Remove an existing file\n+ ///\n+ /// Use this function with caution, the file will be\n+ /// removed permanently!\n+ ///\n+ /// \\param path Path to the file to remove\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of removing the file\n+ ///\n+ /// \\see `rename`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Download a file from the server\n+ ///\n+ /// This function retrieves the data in the file at the\n+ /// remote path.\n+ ///\n+ /// The file data is transferred in sequential blocks. For\n+ /// every block of data transferred, the provided callback\n+ /// is called. The callback is passed a pointer to a data\n+ /// block and the size of the data contained in the current\n+ /// block. This size can change over time so it is important\n+ /// to always check the size value to know how much data is\n+ /// actually available. The callback should return `true` to\n+ /// indicate to the `download` function that it should\n+ /// continue to transfer data. If the data transfer should\n+ /// be aborted earlier, `false` can be returned from the\n+ /// callback.\n+ ///\n+ /// The function returns once all the data in the remote file\n+ /// has been transferred or an error occurs or the function\n+ /// times out.\n+ ///\n+ /// If reading from the remote file should not start at the\n+ /// beginning of the file, you can specify an offset in\n+ /// bytes at which reading should start.\n+ ///\n+ /// \\param remotePath Path of the remote file whose data to download\n+ /// \\param callback Callback to be called for every available data block\n+ /// \\param offset Byte offset into the remote file at which reading should start\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of downloading the file\n+ ///\n+ /// \\see `upload`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset = 0,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Upload a file to the server\n+ ///\n+ /// This function writes data into a file at the remote path.\n+ ///\n+ /// The file data is transferred in sequential blocks. Every\n+ /// time the function wants to send a new block of data the\n+ /// provided callback is called. The callback is passed a\n+ /// pointer to a data block and a reference to the size of\n+ /// the data block. Data to be sent should be copied into\n+ /// the data block using e.g. `std::memcpy` and the size value\n+ /// set to the actual number of bytes copied into the data\n+ /// block. The size of the block can change over time so it\n+ /// is important to check the size value that is passed to\n+ /// the callback to know how many bytes can actually be\n+ /// copied into the data block. The callback should return\n+ /// `true` to indicate to the `upload` function that it\n+ /// should continue to transfer data. Once the data transfer\n+ /// should be stopped e.g. because there is no more data left\n+ /// to send, `false` can be returned from the callback.\n+ ///\n+ /// The function returns once all the data has been sent or\n+ /// an error occurs or the function times out.\n+ ///\n+ /// If a file does not exist at the remote path yet, it will\n+ /// be created with the provided permissions.\n+ ///\n+ /// If a file already exists at the remote path, setting\n+ /// `truncate` to `true` will truncate the existing file\n+ /// i.e. delete all pre-existing data before starting to\n+ /// write the new data into the file.\n+ ///\n+ /// Setting `append` to `true` will append to a file if\n+ /// it already exists.\n+ ///\n+ /// If writing to the remote file should not start at the\n+ /// beginning of the file, you can specify an offset in\n+ /// bytes at which writing should start.\n+ ///\n+ /// The default permissions value is equivalent to `rw-r--r--`\n+ /// or 0644 in octal notation.\n+ ///\n+ /// \\param remotePath Path of the remote file in which to upload the data\n+ /// \\param callback Callback to be called for every available data block\n+ /// \\param permissions Permissions of the remote file if it has to be created\n+ /// \\param truncate Set to `true` to truncate the remote file if it already exists\n+ /// \\param append Set to `true` to append to the remote file if it already exists\n+ /// \\param offset Byte offset into the remote file at which writing should start\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of uploading the file\n+ ///\n+ /// \\see `download`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result upload(\n+ const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions = (std::filesystem::perms::owner_read | std::filesystem::perms::owner_write |\n+ std::filesystem::perms::group_read | std::filesystem::perms::others_read),\n+ bool truncate = true,\n+ bool append = false,\n+ std::uint64_t offset = 0,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ struct Impl;\n+ std::unique_ptr<Impl> m_impl; //!< Implementation\n+};\n+\n+} // namespace sf\n+\n+\n+////////////////////////////////////////////////////////////\n+/// \\class sf::Sftp\n+/// \\ingroup network\n+///\n+/// `sf::Sftp` is a very simple SFTP client that allows you\n+/// to communicate with a SFTP server. The SFTP protocol allows\n+/// you to manipulate a remote file system (list files,\n+/// upload, download, create, remove, ...).\n+///\n+/// Using the SFTP client consists of 4 parts:\n+/// \\li Connecting to the SFTP server\n+/// \\li Logging in (either using username and password or public key authentication)\n+/// \\li Performing file system operations\n+/// \\li Disconnecting (this part can be done implicitly by the destructor)\n+///\n+/// Every operation returns an SFTP result, which contains the\n+/// result code and optionally a message describing the result. Some\n+/// commands such as `getAttributes()` and `getDirectoryListing()`\n+/// return additional data, and use a class derived from\n+/// `sf::Sftp::Result` to provide this data. The commonly used filesystem\n+/// operations are directly provided as member functions.\n+///\n+/// There are three classes of result values: general result values,\n+/// SSH specific result values and SFTP specific result values. General\n+/// result values are returned on success and errors not specific to the\n+/// SSH or SFTP protocols. If an operation manipulating the remote\n+/// filesystem fails, an SFTP specific result will be returned describing\n+/// the reason for the failure. If any error related to the communication\n+/// channel occurs e.g. key exchange failure or authentication failure an\n+/// SSH error will be returned.\n+///\n+/// Because most operations manipulate some part of the remote filesystem\n+/// these operations, especially upload and download, may take some\n+/// time to complete. This is important to know if you don't want\n+/// to block your application while the server is completing\n+/// the task.\n+///\n+/// Every operation that relies on network communication can be passed\n+/// a timeout argument. In the simplest case, this timeout argument can\n+/// just be a fixed time duration after which the operation should time\n+/// out if no progress has been made. Because some operations simply due\n+/// to their nature can take longer than others it might not be possible\n+/// to use the same timeout value for all operations. If it is anticipated\n+/// that an operation could take a longer amount of time to complete due\n+/// to e.g. an unreliable or slow connection, the timeout should be increased\n+/// so the operation still has the possibility to complete successfully.\n+/// Passing `sf::Time::Zero` as a timeout value will cause the operation\n+/// to block until completion or failure.\n+///\n+/// If you want to pass `sf::Time::Zero` to wait indefinitely for an\n+/// operation to complete but still have the possibility to interrupt the\n+/// operation e.g. if the user decides to quit the application or interrupt\n+/// a longer download or upload, the timeout can be constructed from a\n+/// predicate and polling period. The predicate is a callable that takes\n+/// no parameters and returns `true` if the operation should continue or\n+/// `false` if the operation should time out. The time between consecutive\n+/// evaluations of the predicate is specified by the `period` parameter.\n+///\n+/// Example of a `TimeoutWithPredicate`:\n+/// \\code\n+/// bool run = true;\n+/// sf::Sftp::TimeoutWithPredicate timeout([&run]{ return run; }, sf::milliseconds(1));\n+/// \\endcode\n+/// When passed to an operation, the above `TimeoutWithPredicate` object will\n+/// keep the operation running as long as `run` is `true`. The condition\n+/// is checked every 1 millisecond. As soon as `run` is set to `false` the\n+/// operation will terminate with a `Timeout` result.\n+///\n+/// Remember that attempting to modify variables from across threads will\n+/// require proper synchronization using e.g. mutexes or atomics.\n+///\n+/// Because the filesystem operations will be performed on the remote\n+/// system, the paths passed to the operations should be valid paths on\n+/// the remote system. To guarantee portability, generic POSIX paths should\n+/// be used. These use `/` as the path seperator and `.` to refer to the\n+/// current directory and `..` to refer to the parent directory.\n+///\n+/// When logging into the server as a specific user the current directory\n+/// will be set to the home directory that was specified for that user\n+/// account. Because it cannot be assumed that the SFTP user is also allowed\n+/// to log into a shell, changing the current directory from the home\n+/// directory is not always possible and thus not supported. Thus when\n+/// specifying paths, it is preferred to always make use of absolute paths\n+/// when possible. Calling `getWorkingDirectory()` will return the current\n+/// directory as an absolute path. Listing the contents of a directory whose\n+/// path is passed as an absolute path will yield directory listing entries\n+/// whose paths are extentions of the directory's path and thus also absolute\n+/// paths. The `resolvePath()` function can be used to convert relative paths\n+/// or paths containing links into absolute paths without links.\n+///\n+/// Usage example:\n+/// \\code\n+/// // Create a new SFTP client\n+/// sf::Sftp sftp;\n+///\n+/// // Get the address of the server\n+/// const auto addresses = sf::Dns::resolve(\"sftp.myserver.com\");\n+///\n+/// // Check if we have a valid address\n+/// if (!addresses.has_value() || addresses->empty())\n+/// {\n+/// // Handle no valid address...\n+/// }\n+///\n+/// // Connect to the server\n+/// sf::Sftp::Result result = sftp.connect(addresses->front());\n+/// if (result.isOk())\n+/// std::cout << \"Connected\" << std::endl;\n+///\n+/// // Check session information and verify server\n+/// std::optional<sf::Sftp::SessionInfo> info = sftp.getSessionInfo();\n+/// if (info->hostKey.sha256 != expectedSha256)\n+/// {\n+/// std::cout << \"Server untrusted\" << std::endl;\n+/// // Handle untrusted server\n+/// }\n+///\n+/// // Log in\n+/// result = sftp.login(\"sftpuser\", \"dF6Zm89D\");\n+/// if (result.isOk())\n+/// std::cout << \"Logged in\" << std::endl;\n+///\n+/// // Print the working directory\n+/// sf::Sftp::PathResult directory = sftp.getWorkingDirectory();\n+/// if (directory.isOk())\n+/// std::cout << \"Working directory: \" << directory.getPath().string() << std::endl;\n+///\n+/// // Create a new directory\n+/// result = sftp.createDirectory(\"files\");\n+/// if (result.isOk())\n+/// std::cout << \"Created new directory\" << std::endl;\n+///\n+/// // Upload a text file to this new directory\n+/// result = sftp.upload(\"files/newfile.txt\", [](void* data, std::size_t& size)\n+/// {\n+/// // In your own code, ensure size is big enough to store your data\n+/// // We skip the check here for simplicity\n+/// std::memcpy(data, \"Hello World\", 11);\n+/// size = 11;\n+/// return false; // End transfer after this block\n+/// });\n+/// if (response.isOk())\n+/// std::cout << \"File uploaded\" << std::endl;\n+///\n+/// // Rename file\n+/// result = sftp.rename(\"files/newfile.txt\", \"files/newfile2.txt\");\n+/// if (result.isOk())\n+/// std::cout << \"Renamed file\" << std::endl;\n+///\n+/// // Download a text file from this new directory\n+/// std::string text;\n+/// result = sftp.download(\"files/newfile2.txt\", [&text](const void* data, std::size_t size)\n+/// {\n+/// text.append(static_cast<const char*>(data), size);\n+/// return true; // Continue until all data received\n+/// });\n+/// if (response.isOk())\n+/// std::cout << \"File downloaded: \" << text << std::endl;\n+///\n+/// // Delete file\n+/// result = sftp.deleteFile(\"files/newfile2.txt\");\n+/// if (result.isOk())\n+/// std::cout << \"Deleted file\" << std::endl;\n+///\n+/// // Delete directory\n+/// result = sftp.deleteDirectory(\"files\");\n+/// if (result.isOk())\n+/// std::cout << \"Deleted directory\" << std::endl;\n+///\n+/// // Disconnect from the server (optional)\n+/// result = sftp.disconnect();\n+/// if (result.isOk())\n+/// std::cout << \"Disconnected successfully\" << std::endl;\n+/// \\endcode\n+///\n+////////////////////////////////////////////////////////////\n"}],"string":"[\n {\n \"comment\": \"```suggestion\\n /// \\\\brief Connect to the specified SFTP server\\n```\",\n \"path\": \"include/SFML/Network/Sftp.hpp\",\n \"hunk\": \"@@ -0,0 +1,998 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+#pragma once\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/Export.hpp>\\n+\\n+#include <SFML/System/Time.hpp>\\n+\\n+#include <array>\\n+#include <filesystem>\\n+#include <functional>\\n+#include <memory>\\n+#include <optional>\\n+#include <string>\\n+#include <vector>\\n+\\n+#include <cstddef>\\n+#include <cstdint>\\n+\\n+\\n+namespace sf\\n+{\\n+class IpAddress;\\n+\\n+////////////////////////////////////////////////////////////\\n+/// \\\\brief An SSH File Transfer Protocol (SFTP) client\\n+///\\n+////////////////////////////////////////////////////////////\\n+class SFML_NETWORK_API Sftp\\n+{\\n+public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief SFTP result\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ class SFML_NETWORK_API Result\\n+ {\\n+ public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Result values\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ enum class Value\\n+ {\\n+ // General result values\\n+ Success, //!< Operation completed successfully\\n+ Disconnected, //!< The TCP socket has been disconnected\\n+ Timeout, //!< Operation timed out\\n+ Refused, //!< Connection refused\\n+ Error, //!< Generic error\\n+\\n+ // SSH result values\\n+ SshErrorBannerReceive, //!< Error during banner receive\\n+ SshErrorBannerSend, //!< Error during banner send\\n+ SshErrorInvalidMac, //!< Invalid message authentication code\\n+ SshErrorAllocation, //!< Allocation failure\\n+ SshErrorSocketSend, //!< Error sending on socket\\n+ SshErrorKeyExchangeFailure, //!< Key exchange failed\\n+ SshErrorHostKeyInitialization, //!< Host key initialization failed\\n+ SshErrorHostKeySign, //!< Host key signing failed\\n+ SshErrorDecrypt, //!< Decryption failed\\n+ SshErrorProtocol, //!< SSH protocol error\\n+ SshErrorPasswordExpired, //!< Password expired\\n+ SshErrorFile, //!< File error\\n+ SshErrorMethodNone, //!< No method found\\n+ SshErrorAuthenticationFailed, //!< Authentication failed\\n+ SshErrorPublicKeyUnverified, //!< Public key unverified\\n+ SshErrorChannelOutOfOrder, //!< Channel out of order\\n+ SshErrorChannelFailure, //!< Channel failure\\n+ SshErrorChannelRequestDenied, //!< Channel request denied\\n+ SshErrorChannelUnknown, //!< Channel unknown\\n+ SshErrorChannelWindowExceeded, //!< Channel window exceeded\\n+ SshErrorChannelPacketExceeded, //!< Channel packet exceeded\\n+ SshErrorChannelClosed, //!< Channel closed\\n+ SshErrorChannelEofSent, //!< Channel EOF sent\\n+ SshErrorScpProtocol, //!< SCP protocol error\\n+ SshErrorZlib, //!< Zlib error\\n+ SshErrorRequestDenied, //!< Request denied\\n+ SshErrorMethodNotSupported, //!< Method not supported\\n+ SshErrorInvalid, //!< Invalid data\\n+ SshErrorPublicKeyProtocol, //!< Public key protocol error\\n+ SshErrorBufferTooSmall, //!< Buffer too small\\n+ SshErrorBadUse, //!< Bad usage\\n+ SshErrorCompress, //!< Compression error\\n+ SshErrorOutOfBoundary, //!< Out of boundary\\n+ SshErrorAgentProtocol, //!< Agent protocol error\\n+ SshErrorSocketRecv, //!< Socket receive error\\n+ SshErrorEncrypt, //!< Encryption failed\\n+ SshErrorBadSocket, //!< Bad socket\\n+ SshErrorKnownHosts, //!< Known hosts error\\n+ SshErrorChannelWindowFull, //!< Channel window full\\n+ SshErrorKeyFileAuthenticationFailed, //!< Key file authentication failed\\n+\\n+ // SFTP result values\\n+ SftpEndOfFile, //!< End of file\\n+ SftpNoSuchFile, //!< No such file\\n+ SftpPermissionDenied, //!< Permission denied\\n+ SftpFailure, //!< Failure\\n+ SftpBadMessage, //!< Bad message\\n+ SftpNoConnection, //!< No connection\\n+ SftpConnectionLost, //!< Connection lost\\n+ SftpOperationUnsupported, //!< Operation unsupported\\n+ SftpInvalidHandle, //!< Invalid handle\\n+ SftpNoSuchPath, //!< No such path\\n+ SftpFileAlreadyExists, //!< File already exists\\n+ SftpWriteProtect, //!< Write protect\\n+ SftpNoMedia, //!< No media\\n+ SftpNoSpaceOnFileSystem, //!< No space on filesystem\\n+ SftpQuotaExceeded, //!< Quota exceeded\\n+ SftpUnknownPrincipal, //!< Unknown principal\\n+ SftpLockConflict, //!< Lock conflict\\n+ SftpDirectoryNotEmpty, //!< Directory not empty\\n+ SftpNotADirectory, //!< Not a directory\\n+ SftpInvalidFilename, //!< Invalid filename\\n+ SftpLinkLoop, //!< Link loop\\n+ SftpError //!< Generic SFTP error\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Constructor\\n+ ///\\n+ /// This constructor is used by the SFTP client to build\\n+ /// the result.\\n+ ///\\n+ /// \\\\param value Result value\\n+ /// \\\\param message Result message\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ explicit Result(Value value = Value::Error, std::string message = \\\"\\\");\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Check if the result is a success\\n+ ///\\n+ /// This function is defined for convenience, it is\\n+ /// equivalent to testing if the result value is `Value::Success`.\\n+ ///\\n+ /// \\\\return `true` if the result is `Value::Success`, `false` if it is not `Value::Success`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] bool isOk() const;\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the result value\\n+ ///\\n+ /// \\\\return The result value\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Value getValue() const;\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the result message\\n+ ///\\n+ /// \\\\return The result message\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] const std::string& getMessage() const;\\n+\\n+ private:\\n+ ////////////////////////////////////////////////////////////\\n+ // Member data\\n+ ////////////////////////////////////////////////////////////\\n+ Value m_value; //!< The contained value\\n+ std::string m_message; //!< The contained message\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Result of an operation returning a path\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ class SFML_NETWORK_API PathResult : public Result\\n+ {\\n+ public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Constructor\\n+ ///\\n+ /// \\\\param result Result\\n+ /// \\\\param path Path\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ PathResult(const Result& result, std::filesystem::path path);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the path\\n+ ///\\n+ /// \\\\return The path\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] const std::filesystem::path& getPath() const;\\n+\\n+ private:\\n+ ////////////////////////////////////////////////////////////\\n+ // Member data\\n+ ////////////////////////////////////////////////////////////\\n+ std::filesystem::path m_path; //!< The contained path\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief File or directory attributes\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ struct Attributes\\n+ {\\n+ std::filesystem::path path; //!< Path to the entry\\n+ std::optional<std::filesystem::file_type> type; //!< Type of the entry\\n+ std::optional<std::uint64_t> size; //!< Size of the entry\\n+ std::optional<std::filesystem::perms> permissions; //!< Permissions\\n+ std::optional<std::uint64_t> userId; //!< Owner user ID\\n+ std::optional<std::uint64_t> groupId; //!< Group ID\\n+ std::optional<std::filesystem::file_time_type> accessTime; //!< Last access time\\n+ std::optional<std::filesystem::file_time_type> modificationTime; //!< Last modification time\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Result of an operation returning attributes\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ class SFML_NETWORK_API AttributesResult : public Result\\n+ {\\n+ public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Constructor\\n+ ///\\n+ /// \\\\param result Result\\n+ /// \\\\param attributes Attributes\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ AttributesResult(const Result& result, Attributes attributes);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the attributes\\n+ ///\\n+ /// \\\\return The attributes\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] const Attributes& getAttributes() const;\\n+\\n+ private:\\n+ ////////////////////////////////////////////////////////////\\n+ // Member data\\n+ ////////////////////////////////////////////////////////////\\n+ Attributes m_attributes; //!< The contained attributes\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Result of an operation returning a directory listing\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ class SFML_NETWORK_API ListingResult : public Result\\n+ {\\n+ public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Constructor\\n+ ///\\n+ /// \\\\param result Result\\n+ /// \\\\param listing Directory listing\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ ListingResult(const Result& result, std::vector<Attributes> listing);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the directory listing\\n+ ///\\n+ /// \\\\return The directory listing\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] const std::vector<Attributes>& getListing() const;\\n+\\n+ private:\\n+ ////////////////////////////////////////////////////////////\\n+ // Member data\\n+ ////////////////////////////////////////////////////////////\\n+ std::vector<Attributes> m_listing; //!< The contained directory listing\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Hybrid of a timeout and a continuation predicate\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ class SFML_NETWORK_API TimeoutPredicate\\n+ {\\n+ public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Constructor\\n+ ///\\n+ /// This constructor constructs an `TimeoutPredicate` object\\n+ /// that times out after the given amount of time.\\n+ ///\\n+ /// \\\\param timeout Time to timeout after\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ TimeoutPredicate(Time timeout);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Constructor\\n+ ///\\n+ /// This constructor constructs an `TimeoutPredicate` object\\n+ /// that times out when the given predicate returns false.\\n+ /// The frequency at which predicate is checked is specified\\n+ /// by `period`.\\n+ ///\\n+ /// If an empty predicate is passed, it will be set to a\\n+ /// predicate that returns `false` when called.\\n+ ///\\n+ /// \\\\param predicate Predicate that returns `true` to continue or `false` to timeout\\n+ /// \\\\param period The period between checks of the predicate\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ TimeoutPredicate(std::function<bool()> predicate, Time period = milliseconds(1));\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the predicate\\n+ ///\\n+ /// \\\\return The predicate\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] const std::function<bool()>& getPredicate() const;\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the period\\n+ ///\\n+ /// \\\\return The period\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] const Time& getPeriod() const;\\n+\\n+ private:\\n+ ////////////////////////////////////////////////////////////\\n+ // Member data\\n+ ////////////////////////////////////////////////////////////\\n+ std::function<bool()> m_predicate; //!< The contained predicate\\n+ Time m_period; //!< The contained period\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Structure containing information about an active SFTP session\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ struct SessionInfo\\n+ {\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Host key used to identify a host\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ struct HostKey\\n+ {\\n+ enum class Type\\n+ {\\n+ Unknown, //!< Unknown key type\\n+ Rsa, //!< RSA\\n+ Dsa, //!< DSA\\n+ Ecdsa256, //!< NIST P-256 ECDSA\\n+ Ecdsa384, //!< NIST P-384 ECDSA\\n+ Ecdsa521, //!< NIST P-521 ECDSA\\n+ Ed25519 //!< ED25519\\n+ };\\n+\\n+ Type type = Type::Unknown; //!< Host key type\\n+ std::vector<std::byte> data; //!< Host key data\\n+ std::array<std::byte, 20> sha1{}; //!< Host key SHA1 hash\\n+ std::array<std::byte, 32> sha256{}; //!< Host key SHA256 hash\\n+ };\\n+\\n+ HostKey hostKey; //!< Host key\\n+ std::string keyExchangeAlgorithm; //!< Key exchange algorithm used in the session (RFC 4253)\\n+ std::string hostKeyAlgorithm; //!< Host key algorithm used in the session (RFC 4253)\\n+ std::string clientToServerEncryptionAlgorithm; //!< Client to server encryption algorithm used in the session (RFC 4253)\\n+ std::string serverToClientEncryptionAlgorithm; //!< Server to client encryption algorithm used in the session (RFC 4253)\\n+ std::string clientToServerMacAlgorithm; //!< Client to server message authentication code algorithm used in the session (RFC 4253)\\n+ std::string serverToClientMacAlgorithm; //!< Server to client message authentication code algorithm used in the session (RFC 4253)\\n+ std::string clientToServerCompressionAlgorithm; //!< Client to server compression algorithm used in the session (RFC 4253)\\n+ std::string serverToClientCompressionAlgorithm; //!< Server to client compression algorithm used in the session (RFC 4253)\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Default constructor\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ Sftp();\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Destructor\\n+ ///\\n+ /// Automatically closes the connection with the server if\\n+ /// it is still opened.\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ ~Sftp();\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Deleted copy constructor\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ Sftp(const Sftp&) = delete;\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Deleted copy assignment\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ Sftp& operator=(const Sftp&) = delete;\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Connect to the specified FTP server\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/include/SFML/Network/Sftp.hpp b/include/SFML/Network/Sftp.hpp\\nnew file mode 100644\\nindex 0000000000..9be101d562\\n--- /dev/null\\n+++ b/include/SFML/Network/Sftp.hpp\\n@@ -0,0 +1,987 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+#pragma once\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/Export.hpp>\\n+\\n+#include <SFML/System/TimeoutWithPredicate.hpp>\\n+\\n+#include <array>\\n+#include <filesystem>\\n+#include <memory>\\n+#include <optional>\\n+#include <string>\\n+#include <string_view>\\n+#include <vector>\\n+\\n+#include <cstddef>\\n+#include <cstdint>\\n+\\n+\\n+namespace sf\\n+{\\n+class IpAddress;\\n+\\n+////////////////////////////////////////////////////////////\\n+/// \\\\brief An SSH File Transfer Protocol (SFTP) client\\n+///\\n+////////////////////////////////////////////////////////////\\n+class SFML_NETWORK_API Sftp\\n+{\\n+public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief SFTP result\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ class SFML_NETWORK_API Result\\n+ {\\n+ public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Result values\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ enum class Value\\n+ {\\n+ // General result values\\n+ Success, //!< Operation completed successfully\\n+ Disconnected, //!< The TCP socket has been disconnected\\n+ Timeout, //!< Operation timed out\\n+ Refused, //!< Connection refused\\n+ Error, //!< Generic error\\n+\\n+ // SSH result values\\n+ BannerReceive, //!< Error during banner receive\\n+ BannerSend, //!< Error during banner send\\n+ InvalidMac, //!< Invalid message authentication code\\n+ AllocationFailure, //!< Allocation failure\\n+ SocketSend, //!< Error sending on socket\\n+ KeyExchangeFailure, //!< Key exchange failed\\n+ HostKeyInitialization, //!< Host key initialization failed\\n+ HostKeySign, //!< Host key signing failed\\n+ DecryptError, //!< Decryption failed\\n+ ProtocolError, //!< SSH protocol error\\n+ PasswordExpired, //!< Password expired\\n+ FileError, //!< File error\\n+ MethodNone, //!< No method found\\n+ AuthenticationFailed, //!< Authentication failed\\n+ PublicKeyUnverified, //!< Public key unverified\\n+ ChannelOutOfOrder, //!< Channel out of order\\n+ ChannelFailure, //!< Channel failure\\n+ ChannelRequestDenied, //!< Channel request denied\\n+ ChannelUnknown, //!< Channel unknown\\n+ ChannelWindowExceeded, //!< Channel window exceeded\\n+ ChannelPacketExceeded, //!< Channel packet exceeded\\n+ ChannelClosed, //!< Channel closed\\n+ ChannelEofSent, //!< Channel EOF sent\\n+ ScpProtocol, //!< SCP protocol error\\n+ ZlibError, //!< Zlib error\\n+ RequestDenied, //!< Request denied\\n+ MethodNotSupported, //!< Method not supported\\n+ InvalidData, //!< Invalid data\\n+ PublicKeyProtocol, //!< Public key protocol error\\n+ BufferTooSmall, //!< Buffer too small\\n+ BadUse, //!< Bad usage\\n+ CompressError, //!< Compression error\\n+ OutOfBoundary, //!< Out of boundary\\n+ AgentProtocol, //!< Agent protocol error\\n+ SocketRecv, //!< Socket receive error\\n+ EncryptError, //!< Encryption failed\\n+ BadSocket, //!< Bad socket\\n+ KnownHosts, //!< Known hosts error\\n+ ChannelWindowFull, //!< Channel window full\\n+ KeyFileAuthenticationFailed, //!< Key file authentication failed\\n+\\n+ // SFTP result values\\n+ EndOfFile, //!< End of file\\n+ NoSuchFile, //!< No such file\\n+ PermissionDenied, //!< Permission denied\\n+ Failure, //!< Failure\\n+ BadMessage, //!< Bad message\\n+ NoConnection, //!< No connection\\n+ ConnectionLost, //!< Connection lost\\n+ OperationUnsupported, //!< Operation unsupported\\n+ InvalidHandle, //!< Invalid handle\\n+ NoSuchPath, //!< No such path\\n+ FileAlreadyExists, //!< File already exists\\n+ WriteProtect, //!< Write protect\\n+ NoMedia, //!< No media\\n+ NoSpaceOnFileSystem, //!< No space on filesystem\\n+ QuotaExceeded, //!< Quota exceeded\\n+ UnknownPrincipal, //!< Unknown principal\\n+ LockConflict, //!< Lock conflict\\n+ DirectoryNotEmpty, //!< Directory not empty\\n+ NotADirectory, //!< Not a directory\\n+ InvalidFilename, //!< Invalid filename\\n+ LinkLoop, //!< Link loop\\n+ SftpError //!< Generic SFTP error\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Constructor\\n+ ///\\n+ /// This constructor is used by the SFTP client to build\\n+ /// the result.\\n+ ///\\n+ /// \\\\param value Result value\\n+ /// \\\\param message Result message\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ explicit Result(Value value, std::string message = \\\"\\\");\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Check if the result is a success\\n+ ///\\n+ /// This function is defined for convenience, it is\\n+ /// equivalent to testing if the result value is `Value::Success`.\\n+ ///\\n+ /// \\\\return `true` if the result is `Value::Success`, `false` if it is not `Value::Success`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] bool isOk() const;\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the result value\\n+ ///\\n+ /// \\\\return The result value\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Value getValue() const;\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the result message\\n+ ///\\n+ /// \\\\return The result message\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] const std::string& getMessage() const;\\n+\\n+ private:\\n+ ////////////////////////////////////////////////////////////\\n+ // Member data\\n+ ////////////////////////////////////////////////////////////\\n+ Value m_value; //!< The contained value\\n+ std::string m_message; //!< The contained message\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Result of an operation returning a path\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ class SFML_NETWORK_API PathResult : public Result\\n+ {\\n+ public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Constructor\\n+ ///\\n+ /// \\\\param result Result\\n+ /// \\\\param path Path\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ PathResult(const Result& result, std::filesystem::path path);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the path\\n+ ///\\n+ /// \\\\return The path\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] const std::filesystem::path& getPath() const;\\n+\\n+ private:\\n+ ////////////////////////////////////////////////////////////\\n+ // Member data\\n+ ////////////////////////////////////////////////////////////\\n+ std::filesystem::path m_path; //!< The contained path\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief File or directory attributes\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ struct Attributes\\n+ {\\n+ std::filesystem::path path; //!< Path to the entry\\n+ std::optional<std::filesystem::file_type> type; //!< Type of the entry\\n+ std::optional<std::uint64_t> size; //!< Size of the entry\\n+ std::optional<std::filesystem::perms> permissions; //!< Permissions\\n+ std::optional<std::uint64_t> userId; //!< Owner user ID\\n+ std::optional<std::uint64_t> groupId; //!< Group ID\\n+ std::optional<std::filesystem::file_time_type> accessTime; //!< Last access time\\n+ std::optional<std::filesystem::file_time_type> modificationTime; //!< Last modification time\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Result of an operation returning attributes\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ class SFML_NETWORK_API AttributesResult : public Result\\n+ {\\n+ public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Constructor\\n+ ///\\n+ /// \\\\param result Result\\n+ /// \\\\param attributes Attributes\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ AttributesResult(const Result& result, Attributes attributes);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the attributes\\n+ ///\\n+ /// \\\\return The attributes\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] const Attributes& getAttributes() const;\\n+\\n+ private:\\n+ ////////////////////////////////////////////////////////////\\n+ // Member data\\n+ ////////////////////////////////////////////////////////////\\n+ Attributes m_attributes; //!< The contained attributes\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Result of an operation returning a directory listing\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ class SFML_NETWORK_API ListingResult : public Result\\n+ {\\n+ public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Constructor\\n+ ///\\n+ /// \\\\param result Result\\n+ /// \\\\param listing Directory listing\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ ListingResult(const Result& result, std::vector<Attributes> listing);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the directory listing\\n+ ///\\n+ /// \\\\return The directory listing\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] const std::vector<Attributes>& getListing() const;\\n+\\n+ private:\\n+ ////////////////////////////////////////////////////////////\\n+ // Member data\\n+ ////////////////////////////////////////////////////////////\\n+ std::vector<Attributes> m_listing; //!< The contained directory listing\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Structure containing information about an active SFTP session\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ struct SessionInfo\\n+ {\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Host key used to identify a host\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ struct HostKey\\n+ {\\n+ enum class Type\\n+ {\\n+ Unknown, //!< Unknown key type\\n+ Rsa, //!< RSA\\n+ Dsa, //!< DSA\\n+ Ecdsa256, //!< NIST P-256 ECDSA\\n+ Ecdsa384, //!< NIST P-384 ECDSA\\n+ Ecdsa521, //!< NIST P-521 ECDSA\\n+ Ed25519 //!< ED25519\\n+ };\\n+\\n+ Type type = Type::Unknown; //!< Host key type\\n+ std::vector<std::byte> data; //!< Host key data\\n+ std::array<std::byte, 20> sha1{}; //!< Host key SHA1 hash\\n+ std::array<std::byte, 32> sha256{}; //!< Host key SHA256 hash\\n+ };\\n+\\n+ HostKey hostKey; //!< Host key\\n+ std::string keyExchangeAlgorithm; //!< Key exchange algorithm used in the session (RFC 4253)\\n+ std::string hostKeyAlgorithm; //!< Host key algorithm used in the session (RFC 4253)\\n+ std::string clientToServerEncryptionAlgorithm; //!< Client to server encryption algorithm used in the session (RFC 4253)\\n+ std::string serverToClientEncryptionAlgorithm; //!< Server to client encryption algorithm used in the session (RFC 4253)\\n+ std::string clientToServerMacAlgorithm; //!< Client to server message authentication code algorithm used in the session (RFC 4253)\\n+ std::string serverToClientMacAlgorithm; //!< Server to client message authentication code algorithm used in the session (RFC 4253)\\n+ std::string clientToServerCompressionAlgorithm; //!< Client to server compression algorithm used in the session (RFC 4253)\\n+ std::string serverToClientCompressionAlgorithm; //!< Server to client compression algorithm used in the session (RFC 4253)\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Default constructor\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ Sftp();\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Destructor\\n+ ///\\n+ /// Automatically closes the connection with the server if\\n+ /// it is still opened.\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ ~Sftp();\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Deleted copy constructor\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ Sftp(const Sftp&) = delete;\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Deleted copy assignment\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ Sftp& operator=(const Sftp&) = delete;\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Connect to the specified SFTP server\\n+ ///\\n+ /// The port has a default value of 22, which is the standard\\n+ /// port used by the SFTP protocol.\\n+ /// This function tries to connect to the server so it may take\\n+ /// a while to complete, especially if the server is not\\n+ /// reachable. To avoid blocking your application for too long,\\n+ /// you can use a timeout. The default value, `Time::Zero`, means that the\\n+ /// system timeout will be used (which is usually pretty long).\\n+ ///\\n+ /// \\\\param server Name or address of the SFTP server to connect to\\n+ /// \\\\param port Port used for the connection\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of the connection attempt\\n+ ///\\n+ /// \\\\see `disconnect`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result connect(IpAddress server, unsigned short port = 22, const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Disconnect the connection with the server\\n+ ///\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of disconnecting the connection with the server\\n+ ///\\n+ /// \\\\see `connect`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result disconnect(const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get SSH session information\\n+ ///\\n+ /// After connecting to the server and before actually\\n+ /// logging in the SSH session information of the underlying\\n+ /// connection will be available.\\n+ ///\\n+ /// The session information contains among other things the\\n+ /// public key identifying the remote host and the connection\\n+ /// parameters such as encryption and compression used. The\\n+ /// identifiers used follow the RFC 4253 specification.\\n+ ///\\n+ /// If the session information is not available `std::nullopt`\\n+ /// will be returned.\\n+ ///\\n+ /// Because SSH was developed as a parallel standard to\\n+ /// SSL/TLS and automatic host certificate verification wasn't\\n+ /// widespread at the time, relying on the user to check the\\n+ /// authenticity of the host key was the typical method used\\n+ /// to verify that they were connecting to the legitimate host,\\n+ /// assuming the private key of the remote host was not\\n+ /// compromised.\\n+ ///\\n+ /// If connection security is a high priority, examining\\n+ /// the parameters and aborting the connection if any weak\\n+ /// algorithms are used is also possible.\\n+ ///\\n+ /// \\\\return SSH session information or `std::nullopt` if it is not available\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] std::optional<SessionInfo> getSessionInfo() const;\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Log in using a username and a password\\n+ ///\\n+ /// Logging in is mandatory after connecting to the server.\\n+ /// Users that are not logged in cannot perform any operation.\\n+ ///\\n+ /// \\\\param name User name\\n+ /// \\\\param password Password\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of attempting to log in to the server\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result login(std::string_view name,\\n+ std::string_view password,\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Log in using a public/private key pair\\n+ ///\\n+ /// Logging in is mandatory after connecting to the server.\\n+ /// Users that are not logged in cannot perform any operation.\\n+ ///\\n+ /// This overload allows logging into the SFTP server using\\n+ /// public key authentication.\\n+ ///\\n+ /// The public and private key data should be provided in PEM\\n+ /// format. PEM encoded data can be easily recognized by their\\n+ /// `-----BEGIN ............-----` header and\\n+ /// `-----END ............-----` footer.\\n+ ///\\n+ /// Even though it is technically possible to derive the\\n+ /// public key from the private key, due to backend\\n+ /// limitations, providing a pre-generated public key as well\\n+ /// is necessary for this function to be able to succeed.\\n+ ///\\n+ /// If the private key is protected by a passphrase the\\n+ /// passphrase can be provided as a NULL terminated string.\\n+ /// If the private key is not protected by a passphrase the\\n+ /// passphrase should be set to the empty string.\\n+ ///\\n+ /// \\\\param name User name\\n+ /// \\\\param publicKeyData Public key data\\n+ /// \\\\param publicKeyLength Public key data length\\n+ /// \\\\param privateKeyData Private key data\\n+ /// \\\\param privateKeyLength Private key data length\\n+ /// \\\\param privateKeyPassphrase Private key passphrase, NULL terminated\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of attempting to log in to the server\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase = \\\"\\\",\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Log in using a public/private key pair\\n+ ///\\n+ /// Logging in is mandatory after connecting to the server.\\n+ /// Users that are not logged in cannot perform any operation.\\n+ ///\\n+ /// This overload allows logging into the SFTP server using\\n+ /// public key authentication.\\n+ ///\\n+ /// The public and private key data should be provided in PEM\\n+ /// format. PEM encoded data can be easily recognized by their\\n+ /// `-----BEGIN ............-----` header and\\n+ /// `-----END ............-----` footer.\\n+ ///\\n+ /// Even though it is technically possible to derive the\\n+ /// public key from the private key, due to backend\\n+ /// limitations, providing a pre-generated public key as well\\n+ /// is necessary for this function to be able to succeed.\\n+ ///\\n+ /// If the private key is protected by a passphrase the\\n+ /// passphrase can be provided as a NULL terminated string.\\n+ /// If the private key is not protected by a passphrase the\\n+ /// passphrase should be set to the empty string.\\n+ ///\\n+ /// \\\\param name User name\\n+ /// \\\\param publicKeyData Public key data\\n+ /// \\\\param privateKeyData Private key data\\n+ /// \\\\param privateKeyPassphrase Private key passphrase\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of attempting to log in to the server\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase = {},\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Resolve a remote path into an absolute remote path\\n+ ///\\n+ /// Paths can contain links and other reserved path identifiers\\n+ /// such as . and .. referring to the current directory and\\n+ /// parent directory respectively.\\n+ ///\\n+ /// When determining the absolute path, which does not contain\\n+ /// links or . or .. is necessary, this function can be used.\\n+ ///\\n+ /// Resolving \\\".\\\" will return the absolute path to the current\\n+ /// working directory of the user after logging in to the SFTP\\n+ /// server.\\n+ ///\\n+ /// \\\\param path Path to convert into an absolute path\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of converting the path into an absolute path\\n+ ///\\n+ /// \\\\see `getWorkingDirectory`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] PathResult resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the current working directory on the server\\n+ ///\\n+ /// This is an alias for calling `resolvePath(\\\".\\\")`.\\n+ ///\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of getting the current working directory\\n+ ///\\n+ /// \\\\see `resolvePath`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] PathResult getWorkingDirectory(const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the attributes of a remote file or directory\\n+ ///\\n+ /// Depending on whether `path` refers to a file or directory,\\n+ /// the attributes can contain e.g. the type of file, the file\\n+ /// owner, group, file size, modification and access times.\\n+ ///\\n+ /// If links are not to be followed, `followLinks` can be set\\n+ /// to `false`. In this case the attributes of the link itself\\n+ /// will be returned.\\n+ ///\\n+ /// \\\\param path Path to the remote file or directory whose attributes to get\\n+ /// \\\\param followLinks `true` to follow links, `false` to return attributes of the link itself\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of getting the attributes\\n+ ///\\n+ /// \\\\see `getDirectoryListing`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] AttributesResult getAttributes(const std::filesystem::path& path,\\n+ bool followLinks = true,\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the contents of the given directory\\n+ ///\\n+ /// This function retrieves the sub-directories and files\\n+ /// contained in the given directory. It is not recursive.\\n+ ///\\n+ /// \\\\param path Path of the directory whose contents to list\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of getting the contents of the given directory\\n+ ///\\n+ /// \\\\see `getAttributes`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] ListingResult getDirectoryListing(const std::filesystem::path& path,\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Create a new directory\\n+ ///\\n+ /// The new directory is created as a child of the current\\n+ /// working directory.\\n+ ///\\n+ /// The default permissions value is equivalent to `rwxr-xr-x`\\n+ /// or 0755 in octal notation.\\n+ ///\\n+ /// \\\\param path Path of the directory to create\\n+ /// \\\\param permissions Permissions of the directory to create\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of creating the directory\\n+ ///\\n+ /// \\\\see `deleteDirectory`, `rename`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result createDirectory(\\n+ const std::filesystem::path& path,\\n+ std::filesystem::perms permissions = (std::filesystem::perms::owner_all | std::filesystem::perms::group_read |\\n+ std::filesystem::perms::group_exec | std::filesystem::perms::others_read |\\n+ std::filesystem::perms::others_exec),\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Remove an existing directory\\n+ ///\\n+ /// Use this function with caution, the directory will\\n+ /// be removed permanently!\\n+ ///\\n+ /// \\\\param path Path of the directory to remove\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of removing the directory\\n+ ///\\n+ /// \\\\see `createDirectory`, `rename`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Rename an existing file or directory\\n+ ///\\n+ /// In POSIX renaming and moving and synonymous. If you want\\n+ /// to move a file or directory from one place to another\\n+ /// you rename it from an old to a new path.\\n+ ///\\n+ /// If a file exists at the specified new path, depending\\n+ /// on whether `ovewrite` is set to true, the rename operation\\n+ /// will overwrite it or not. If a directory is being moved,\\n+ /// the new path must either not point to non-existant\\n+ /// directory or a directory that is empty. Non-empty\\n+ /// directories cannot be overwritten by this operation.\\n+ ///\\n+ /// \\\\param oldPath Old path to the file or directory\\n+ /// \\\\param newPath New path to the file or directory\\n+ /// \\\\param overwrite Set to `true` to allow overwriting a file that exists at `newPath`\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of the operation\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite = false,\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Remove an existing file\\n+ ///\\n+ /// Use this function with caution, the file will be\\n+ /// removed permanently!\\n+ ///\\n+ /// \\\\param path Path to the file to remove\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of removing the file\\n+ ///\\n+ /// \\\\see `rename`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Download a file from the server\\n+ ///\\n+ /// This function retrieves the data in the file at the\\n+ /// remote path.\\n+ ///\\n+ /// The file data is transferred in sequential blocks. For\\n+ /// every block of data transferred, the provided callback\\n+ /// is called. The callback is passed a pointer to a data\\n+ /// block and the size of the data contained in the current\\n+ /// block. This size can change over time so it is important\\n+ /// to always check the size value to know how much data is\\n+ /// actually available. The callback should return `true` to\\n+ /// indicate to the `download` function that it should\\n+ /// continue to transfer data. If the data transfer should\\n+ /// be aborted earlier, `false` can be returned from the\\n+ /// callback.\\n+ ///\\n+ /// The function returns once all the data in the remote file\\n+ /// has been transferred or an error occurs or the function\\n+ /// times out.\\n+ ///\\n+ /// If reading from the remote file should not start at the\\n+ /// beginning of the file, you can specify an offset in\\n+ /// bytes at which reading should start.\\n+ ///\\n+ /// \\\\param remotePath Path of the remote file whose data to download\\n+ /// \\\\param callback Callback to be called for every available data block\\n+ /// \\\\param offset Byte offset into the remote file at which reading should start\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of downloading the file\\n+ ///\\n+ /// \\\\see `upload`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset = 0,\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Upload a file to the server\\n+ ///\\n+ /// This function writes data into a file at the remote path.\\n+ ///\\n+ /// The file data is transferred in sequential blocks. Every\\n+ /// time the function wants to send a new block of data the\\n+ /// provided callback is called. The callback is passed a\\n+ /// pointer to a data block and a reference to the size of\\n+ /// the data block. Data to be sent should be copied into\\n+ /// the data block using e.g. `std::memcpy` and the size value\\n+ /// set to the actual number of bytes copied into the data\\n+ /// block. The size of the block can change over time so it\\n+ /// is important to check the size value that is passed to\\n+ /// the callback to know how many bytes can actually be\\n+ /// copied into the data block. The callback should return\\n+ /// `true` to indicate to the `upload` function that it\\n+ /// should continue to transfer data. Once the data transfer\\n+ /// should be stopped e.g. because there is no more data left\\n+ /// to send, `false` can be returned from the callback.\\n+ ///\\n+ /// The function returns once all the data has been sent or\\n+ /// an error occurs or the function times out.\\n+ ///\\n+ /// If a file does not exist at the remote path yet, it will\\n+ /// be created with the provided permissions.\\n+ ///\\n+ /// If a file already exists at the remote path, setting\\n+ /// `truncate` to `true` will truncate the existing file\\n+ /// i.e. delete all pre-existing data before starting to\\n+ /// write the new data into the file.\\n+ ///\\n+ /// Setting `append` to `true` will append to a file if\\n+ /// it already exists.\\n+ ///\\n+ /// If writing to the remote file should not start at the\\n+ /// beginning of the file, you can specify an offset in\\n+ /// bytes at which writing should start.\\n+ ///\\n+ /// The default permissions value is equivalent to `rw-r--r--`\\n+ /// or 0644 in octal notation.\\n+ ///\\n+ /// \\\\param remotePath Path of the remote file in which to upload the data\\n+ /// \\\\param callback Callback to be called for every available data block\\n+ /// \\\\param permissions Permissions of the remote file if it has to be created\\n+ /// \\\\param truncate Set to `true` to truncate the remote file if it already exists\\n+ /// \\\\param append Set to `true` to append to the remote file if it already exists\\n+ /// \\\\param offset Byte offset into the remote file at which writing should start\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of uploading the file\\n+ ///\\n+ /// \\\\see `download`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result upload(\\n+ const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions = (std::filesystem::perms::owner_read | std::filesystem::perms::owner_write |\\n+ std::filesystem::perms::group_read | std::filesystem::perms::others_read),\\n+ bool truncate = true,\\n+ bool append = false,\\n+ std::uint64_t offset = 0,\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+private:\\n+ ////////////////////////////////////////////////////////////\\n+ // Member data\\n+ ////////////////////////////////////////////////////////////\\n+ struct Impl;\\n+ std::unique_ptr<Impl> m_impl; //!< Implementation\\n+};\\n+\\n+} // namespace sf\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+/// \\\\class sf::Sftp\\n+/// \\\\ingroup network\\n+///\\n+/// `sf::Sftp` is a very simple SFTP client that allows you\\n+/// to communicate with a SFTP server. The SFTP protocol allows\\n+/// you to manipulate a remote file system (list files,\\n+/// upload, download, create, remove, ...).\\n+///\\n+/// Using the SFTP client consists of 4 parts:\\n+/// \\\\li Connecting to the SFTP server\\n+/// \\\\li Logging in (either using username and password or public key authentication)\\n+/// \\\\li Performing file system operations\\n+/// \\\\li Disconnecting (this part can be done implicitly by the destructor)\\n+///\\n+/// Every operation returns an SFTP result, which contains the\\n+/// result code and optionally a message describing the result. Some\\n+/// commands such as `getAttributes()` and `getDirectoryListing()`\\n+/// return additional data, and use a class derived from\\n+/// `sf::Sftp::Result` to provide this data. The commonly used filesystem\\n+/// operations are directly provided as member functions.\\n+///\\n+/// There are three classes of result values: general result values,\\n+/// SSH specific result values and SFTP specific result values. General\\n+/// result values are returned on success and errors not specific to the\\n+/// SSH or SFTP protocols. If an operation manipulating the remote\\n+/// filesystem fails, an SFTP specific result will be returned describing\\n+/// the reason for the failure. If any error related to the communication\\n+/// channel occurs e.g. key exchange failure or authentication failure an\\n+/// SSH error will be returned.\\n+///\\n+/// Because most operations manipulate some part of the remote filesystem\\n+/// these operations, especially upload and download, may take some\\n+/// time to complete. This is important to know if you don't want\\n+/// to block your application while the server is completing\\n+/// the task.\\n+///\\n+/// Every operation that relies on network communication can be passed\\n+/// a timeout argument. In the simplest case, this timeout argument can\\n+/// just be a fixed time duration after which the operation should time\\n+/// out if no progress has been made. Because some operations simply due\\n+/// to their nature can take longer than others it might not be possible\\n+/// to use the same timeout value for all operations. If it is anticipated\\n+/// that an operation could take a longer amount of time to complete due\\n+/// to e.g. an unreliable or slow connection, the timeout should be increased\\n+/// so the operation still has the possibility to complete successfully.\\n+/// Passing `sf::Time::Zero` as a timeout value will cause the operation\\n+/// to block until completion or failure.\\n+///\\n+/// If you want to pass `sf::Time::Zero` to wait indefinitely for an\\n+/// operation to complete but still have the possibility to interrupt the\\n+/// operation e.g. if the user decides to quit the application or interrupt\\n+/// a longer download or upload, the timeout can be constructed from a\\n+/// predicate and polling period. The predicate is a callable that takes\\n+/// no parameters and returns `true` if the operation should continue or\\n+/// `false` if the operation should time out. The time between consecutive\\n+/// evaluations of the predicate is specified by the `period` parameter.\\n+///\\n+/// Example of a `TimeoutWithPredicate`:\\n+/// \\\\code\\n+/// bool run = true;\\n+/// sf::Sftp::TimeoutWithPredicate timeout([&run]{ return run; }, sf::milliseconds(1));\\n+/// \\\\endcode\\n+/// When passed to an operation, the above `TimeoutWithPredicate` object will\\n+/// keep the operation running as long as `run` is `true`. The condition\\n+/// is checked every 1 millisecond. As soon as `run` is set to `false` the\\n+/// operation will terminate with a `Timeout` result.\\n+///\\n+/// Remember that attempting to modify variables from across threads will\\n+/// require proper synchronization using e.g. mutexes or atomics.\\n+///\\n+/// Because the filesystem operations will be performed on the remote\\n+/// system, the paths passed to the operations should be valid paths on\\n+/// the remote system. To guarantee portability, generic POSIX paths should\\n+/// be used. These use `/` as the path seperator and `.` to refer to the\\n+/// current directory and `..` to refer to the parent directory.\\n+///\\n+/// When logging into the server as a specific user the current directory\\n+/// will be set to the home directory that was specified for that user\\n+/// account. Because it cannot be assumed that the SFTP user is also allowed\\n+/// to log into a shell, changing the current directory from the home\\n+/// directory is not always possible and thus not supported. Thus when\\n+/// specifying paths, it is preferred to always make use of absolute paths\\n+/// when possible. Calling `getWorkingDirectory()` will return the current\\n+/// directory as an absolute path. Listing the contents of a directory whose\\n+/// path is passed as an absolute path will yield directory listing entries\\n+/// whose paths are extentions of the directory's path and thus also absolute\\n+/// paths. The `resolvePath()` function can be used to convert relative paths\\n+/// or paths containing links into absolute paths without links.\\n+///\\n+/// Usage example:\\n+/// \\\\code\\n+/// // Create a new SFTP client\\n+/// sf::Sftp sftp;\\n+///\\n+/// // Get the address of the server\\n+/// const auto addresses = sf::Dns::resolve(\\\"sftp.myserver.com\\\");\\n+///\\n+/// // Check if we have a valid address\\n+/// if (!addresses.has_value() || addresses->empty())\\n+/// {\\n+/// // Handle no valid address...\\n+/// }\\n+///\\n+/// // Connect to the server\\n+/// sf::Sftp::Result result = sftp.connect(addresses->front());\\n+/// if (result.isOk())\\n+/// std::cout << \\\"Connected\\\" << std::endl;\\n+///\\n+/// // Check session information and verify server\\n+/// std::optional<sf::Sftp::SessionInfo> info = sftp.getSessionInfo();\\n+/// if (info->hostKey.sha256 != expectedSha256)\\n+/// {\\n+/// std::cout << \\\"Server untrusted\\\" << std::endl;\\n+/// // Handle untrusted server\\n+/// }\\n+///\\n+/// // Log in\\n+/// result = sftp.login(\\\"sftpuser\\\", \\\"dF6Zm89D\\\");\\n+/// if (result.isOk())\\n+/// std::cout << \\\"Logged in\\\" << std::endl;\\n+///\\n+/// // Print the working directory\\n+/// sf::Sftp::PathResult directory = sftp.getWorkingDirectory();\\n+/// if (directory.isOk())\\n+/// std::cout << \\\"Working directory: \\\" << directory.getPath().string() << std::endl;\\n+///\\n+/// // Create a new directory\\n+/// result = sftp.createDirectory(\\\"files\\\");\\n+/// if (result.isOk())\\n+/// std::cout << \\\"Created new directory\\\" << std::endl;\\n+///\\n+/// // Upload a text file to this new directory\\n+/// result = sftp.upload(\\\"files/newfile.txt\\\", [](void* data, std::size_t& size)\\n+/// {\\n+/// // In your own code, ensure size is big enough to store your data\\n+/// // We skip the check here for simplicity\\n+/// std::memcpy(data, \\\"Hello World\\\", 11);\\n+/// size = 11;\\n+/// return false; // End transfer after this block\\n+/// });\\n+/// if (response.isOk())\\n+/// std::cout << \\\"File uploaded\\\" << std::endl;\\n+///\\n+/// // Rename file\\n+/// result = sftp.rename(\\\"files/newfile.txt\\\", \\\"files/newfile2.txt\\\");\\n+/// if (result.isOk())\\n+/// std::cout << \\\"Renamed file\\\" << std::endl;\\n+///\\n+/// // Download a text file from this new directory\\n+/// std::string text;\\n+/// result = sftp.download(\\\"files/newfile2.txt\\\", [&text](const void* data, std::size_t size)\\n+/// {\\n+/// text.append(static_cast<const char*>(data), size);\\n+/// return true; // Continue until all data received\\n+/// });\\n+/// if (response.isOk())\\n+/// std::cout << \\\"File downloaded: \\\" << text << std::endl;\\n+///\\n+/// // Delete file\\n+/// result = sftp.deleteFile(\\\"files/newfile2.txt\\\");\\n+/// if (result.isOk())\\n+/// std::cout << \\\"Deleted file\\\" << std::endl;\\n+///\\n+/// // Delete directory\\n+/// result = sftp.deleteDirectory(\\\"files\\\");\\n+/// if (result.isOk())\\n+/// std::cout << \\\"Deleted directory\\\" << std::endl;\\n+///\\n+/// // Disconnect from the server (optional)\\n+/// result = sftp.disconnect();\\n+/// if (result.isOk())\\n+/// std::cout << \\\"Disconnected successfully\\\" << std::endl;\\n+/// \\\\endcode\\n+///\\n+////////////////////////////////////////////////////////////\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10097,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"Is this being fixed upstream or will users of system packages run into problems with this?"},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/tools/libssh2/PatchLibssh2.cmake b/tools/libssh2/PatchLibssh2.cmake\nnew file mode 100644\nindex 0000000000..9a7f1e8a8d\n--- /dev/null\n+++ b/tools/libssh2/PatchLibssh2.cmake\n@@ -0,0 +1,13 @@\n+# Fix returning a pointer to stack memory by forcing libssh to make a copy of it instead\n+file(READ \"${LIBSSH2_DIR}/src/mbedtls.c\" LIBSSH2_MBEDTLS_CONTENTS)\n+string(REPLACE \"return _libssh2_error(session, LIBSSH2_ERROR_FILE, buf);\" \"return _libssh2_error_flags(session, LIBSSH2_ERROR_FILE, buf, LIBSSH2_ERR_FLAG_DUP);\" LIBSSH2_MBEDTLS_CONTENTS \"${LIBSSH2_MBEDTLS_CONTENTS}\")\n+file(WRITE \"${LIBSSH2_DIR}/src/mbedtls.c\" \"${LIBSSH2_MBEDTLS_CONTENTS}\")\n+\n+# Replace FindMbedTLS.cmake with our own\n+file(READ \"${MODULES_DIR}/FindMbedTLS.cmake\" FINDMBEDTLS_CONTENTS)\n+file(WRITE \"${LIBSSH2_DIR}/cmake/FindMbedTLS.cmake\" \"${FINDMBEDTLS_CONTENTS}\")\n+\n+# Make libssh2-config.cmake search for MbedTLS using CONFIG NO_DEFAULT_PATH\n+file(READ \"${LIBSSH2_DIR}/cmake/libssh2-config.in.cmake\" LIBSSH2_CONFIG_CONTENTS)\n+string(REPLACE \"find_dependency(MbedTLS)\" \"find_dependency(MbedTLS CONFIG NO_DEFAULT_PATH)\" LIBSSH2_CONFIG_CONTENTS \"${LIBSSH2_CONFIG_CONTENTS}\")\n+file(WRITE \"${LIBSSH2_DIR}/cmake/libssh2-config.in.cmake\" \"${LIBSSH2_CONFIG_CONTENTS}\")\n"},"changed_files":{"kind":"list like","value":["tools/libssh2/PatchLibssh2.cmake"],"string":"[\n \"tools/libssh2/PatchLibssh2.cmake\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"Is this being fixed upstream or will users of system packages run into problems with this?","path":"tools/libssh2/PatchLibssh2.cmake","hunk":"@@ -0,0 +1,13 @@\n+# Fix returning a pointer to stack memory by forcing libssh to make a copy of it instead\n+file(READ \"${LIBSSH2_DIR}/src/mbedtls.c\" LIBSSH2_MBEDTLS_CONTENTS)\n+string(REPLACE \"return _libssh2_error(session, LIBSSH2_ERROR_FILE, buf);\" \"return _libssh2_error_flags(session, LIBSSH2_ERROR_FILE, buf, LIBSSH2_ERR_FLAG_DUP);\" LIBSSH2_MBEDTLS_CONTENTS \"${LIBSSH2_MBEDTLS_CONTENTS}\")\n+file(WRITE \"${LIBSSH2_DIR}/src/mbedtls.c\" \"${LIBSSH2_MBEDTLS_CONTENTS}\")","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/tools/libssh2/PatchLibssh2.cmake b/tools/libssh2/PatchLibssh2.cmake\nnew file mode 100644\nindex 0000000000..9a7f1e8a8d\n--- /dev/null\n+++ b/tools/libssh2/PatchLibssh2.cmake\n@@ -0,0 +1,13 @@\n+# Fix returning a pointer to stack memory by forcing libssh to make a copy of it instead\n+file(READ \"${LIBSSH2_DIR}/src/mbedtls.c\" LIBSSH2_MBEDTLS_CONTENTS)\n+string(REPLACE \"return _libssh2_error(session, LIBSSH2_ERROR_FILE, buf);\" \"return _libssh2_error_flags(session, LIBSSH2_ERROR_FILE, buf, LIBSSH2_ERR_FLAG_DUP);\" LIBSSH2_MBEDTLS_CONTENTS \"${LIBSSH2_MBEDTLS_CONTENTS}\")\n+file(WRITE \"${LIBSSH2_DIR}/src/mbedtls.c\" \"${LIBSSH2_MBEDTLS_CONTENTS}\")\n+\n+# Replace FindMbedTLS.cmake with our own\n+file(READ \"${MODULES_DIR}/FindMbedTLS.cmake\" FINDMBEDTLS_CONTENTS)\n+file(WRITE \"${LIBSSH2_DIR}/cmake/FindMbedTLS.cmake\" \"${FINDMBEDTLS_CONTENTS}\")\n+\n+# Make libssh2-config.cmake search for MbedTLS using CONFIG NO_DEFAULT_PATH\n+file(READ \"${LIBSSH2_DIR}/cmake/libssh2-config.in.cmake\" LIBSSH2_CONFIG_CONTENTS)\n+string(REPLACE \"find_dependency(MbedTLS)\" \"find_dependency(MbedTLS CONFIG NO_DEFAULT_PATH)\" LIBSSH2_CONFIG_CONTENTS \"${LIBSSH2_CONFIG_CONTENTS}\")\n+file(WRITE \"${LIBSSH2_DIR}/cmake/libssh2-config.in.cmake\" \"${LIBSSH2_CONFIG_CONTENTS}\")\n"}],"string":"[\n {\n \"comment\": \"Is this being fixed upstream or will users of system packages run into problems with this?\",\n \"path\": \"tools/libssh2/PatchLibssh2.cmake\",\n \"hunk\": \"@@ -0,0 +1,13 @@\\n+# Fix returning a pointer to stack memory by forcing libssh to make a copy of it instead\\n+file(READ \\\"${LIBSSH2_DIR}/src/mbedtls.c\\\" LIBSSH2_MBEDTLS_CONTENTS)\\n+string(REPLACE \\\"return _libssh2_error(session, LIBSSH2_ERROR_FILE, buf);\\\" \\\"return _libssh2_error_flags(session, LIBSSH2_ERROR_FILE, buf, LIBSSH2_ERR_FLAG_DUP);\\\" LIBSSH2_MBEDTLS_CONTENTS \\\"${LIBSSH2_MBEDTLS_CONTENTS}\\\")\\n+file(WRITE \\\"${LIBSSH2_DIR}/src/mbedtls.c\\\" \\\"${LIBSSH2_MBEDTLS_CONTENTS}\\\")\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/tools/libssh2/PatchLibssh2.cmake b/tools/libssh2/PatchLibssh2.cmake\\nnew file mode 100644\\nindex 0000000000..9a7f1e8a8d\\n--- /dev/null\\n+++ b/tools/libssh2/PatchLibssh2.cmake\\n@@ -0,0 +1,13 @@\\n+# Fix returning a pointer to stack memory by forcing libssh to make a copy of it instead\\n+file(READ \\\"${LIBSSH2_DIR}/src/mbedtls.c\\\" LIBSSH2_MBEDTLS_CONTENTS)\\n+string(REPLACE \\\"return _libssh2_error(session, LIBSSH2_ERROR_FILE, buf);\\\" \\\"return _libssh2_error_flags(session, LIBSSH2_ERROR_FILE, buf, LIBSSH2_ERR_FLAG_DUP);\\\" LIBSSH2_MBEDTLS_CONTENTS \\\"${LIBSSH2_MBEDTLS_CONTENTS}\\\")\\n+file(WRITE \\\"${LIBSSH2_DIR}/src/mbedtls.c\\\" \\\"${LIBSSH2_MBEDTLS_CONTENTS}\\\")\\n+\\n+# Replace FindMbedTLS.cmake with our own\\n+file(READ \\\"${MODULES_DIR}/FindMbedTLS.cmake\\\" FINDMBEDTLS_CONTENTS)\\n+file(WRITE \\\"${LIBSSH2_DIR}/cmake/FindMbedTLS.cmake\\\" \\\"${FINDMBEDTLS_CONTENTS}\\\")\\n+\\n+# Make libssh2-config.cmake search for MbedTLS using CONFIG NO_DEFAULT_PATH\\n+file(READ \\\"${LIBSSH2_DIR}/cmake/libssh2-config.in.cmake\\\" LIBSSH2_CONFIG_CONTENTS)\\n+string(REPLACE \\\"find_dependency(MbedTLS)\\\" \\\"find_dependency(MbedTLS CONFIG NO_DEFAULT_PATH)\\\" LIBSSH2_CONFIG_CONTENTS \\\"${LIBSSH2_CONFIG_CONTENTS}\\\")\\n+file(WRITE \\\"${LIBSSH2_DIR}/cmake/libssh2-config.in.cmake\\\" \\\"${LIBSSH2_CONFIG_CONTENTS}\\\")\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10098,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"Should we have separate result sets, instead of using prefixes?"},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/include/SFML/Network/Sftp.hpp b/include/SFML/Network/Sftp.hpp\nnew file mode 100644\nindex 0000000000..9be101d562\n--- /dev/null\n+++ b/include/SFML/Network/Sftp.hpp\n@@ -0,0 +1,987 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+#pragma once\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/Export.hpp>\n+\n+#include <SFML/System/TimeoutWithPredicate.hpp>\n+\n+#include <array>\n+#include <filesystem>\n+#include <memory>\n+#include <optional>\n+#include <string>\n+#include <string_view>\n+#include <vector>\n+\n+#include <cstddef>\n+#include <cstdint>\n+\n+\n+namespace sf\n+{\n+class IpAddress;\n+\n+////////////////////////////////////////////////////////////\n+/// \\brief An SSH File Transfer Protocol (SFTP) client\n+///\n+////////////////////////////////////////////////////////////\n+class SFML_NETWORK_API Sftp\n+{\n+public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief SFTP result\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result values\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ enum class Value\n+ {\n+ // General result values\n+ Success, //!< Operation completed successfully\n+ Disconnected, //!< The TCP socket has been disconnected\n+ Timeout, //!< Operation timed out\n+ Refused, //!< Connection refused\n+ Error, //!< Generic error\n+\n+ // SSH result values\n+ BannerReceive, //!< Error during banner receive\n+ BannerSend, //!< Error during banner send\n+ InvalidMac, //!< Invalid message authentication code\n+ AllocationFailure, //!< Allocation failure\n+ SocketSend, //!< Error sending on socket\n+ KeyExchangeFailure, //!< Key exchange failed\n+ HostKeyInitialization, //!< Host key initialization failed\n+ HostKeySign, //!< Host key signing failed\n+ DecryptError, //!< Decryption failed\n+ ProtocolError, //!< SSH protocol error\n+ PasswordExpired, //!< Password expired\n+ FileError, //!< File error\n+ MethodNone, //!< No method found\n+ AuthenticationFailed, //!< Authentication failed\n+ PublicKeyUnverified, //!< Public key unverified\n+ ChannelOutOfOrder, //!< Channel out of order\n+ ChannelFailure, //!< Channel failure\n+ ChannelRequestDenied, //!< Channel request denied\n+ ChannelUnknown, //!< Channel unknown\n+ ChannelWindowExceeded, //!< Channel window exceeded\n+ ChannelPacketExceeded, //!< Channel packet exceeded\n+ ChannelClosed, //!< Channel closed\n+ ChannelEofSent, //!< Channel EOF sent\n+ ScpProtocol, //!< SCP protocol error\n+ ZlibError, //!< Zlib error\n+ RequestDenied, //!< Request denied\n+ MethodNotSupported, //!< Method not supported\n+ InvalidData, //!< Invalid data\n+ PublicKeyProtocol, //!< Public key protocol error\n+ BufferTooSmall, //!< Buffer too small\n+ BadUse, //!< Bad usage\n+ CompressError, //!< Compression error\n+ OutOfBoundary, //!< Out of boundary\n+ AgentProtocol, //!< Agent protocol error\n+ SocketRecv, //!< Socket receive error\n+ EncryptError, //!< Encryption failed\n+ BadSocket, //!< Bad socket\n+ KnownHosts, //!< Known hosts error\n+ ChannelWindowFull, //!< Channel window full\n+ KeyFileAuthenticationFailed, //!< Key file authentication failed\n+\n+ // SFTP result values\n+ EndOfFile, //!< End of file\n+ NoSuchFile, //!< No such file\n+ PermissionDenied, //!< Permission denied\n+ Failure, //!< Failure\n+ BadMessage, //!< Bad message\n+ NoConnection, //!< No connection\n+ ConnectionLost, //!< Connection lost\n+ OperationUnsupported, //!< Operation unsupported\n+ InvalidHandle, //!< Invalid handle\n+ NoSuchPath, //!< No such path\n+ FileAlreadyExists, //!< File already exists\n+ WriteProtect, //!< Write protect\n+ NoMedia, //!< No media\n+ NoSpaceOnFileSystem, //!< No space on filesystem\n+ QuotaExceeded, //!< Quota exceeded\n+ UnknownPrincipal, //!< Unknown principal\n+ LockConflict, //!< Lock conflict\n+ DirectoryNotEmpty, //!< Directory not empty\n+ NotADirectory, //!< Not a directory\n+ InvalidFilename, //!< Invalid filename\n+ LinkLoop, //!< Link loop\n+ SftpError //!< Generic SFTP error\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// This constructor is used by the SFTP client to build\n+ /// the result.\n+ ///\n+ /// \\param value Result value\n+ /// \\param message Result message\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ explicit Result(Value value, std::string message = \"\");\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Check if the result is a success\n+ ///\n+ /// This function is defined for convenience, it is\n+ /// equivalent to testing if the result value is `Value::Success`.\n+ ///\n+ /// \\return `true` if the result is `Value::Success`, `false` if it is not `Value::Success`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] bool isOk() const;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the result value\n+ ///\n+ /// \\return The result value\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Value getValue() const;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the result message\n+ ///\n+ /// \\return The result message\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const std::string& getMessage() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ Value m_value; //!< The contained value\n+ std::string m_message; //!< The contained message\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result of an operation returning a path\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API PathResult : public Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// \\param result Result\n+ /// \\param path Path\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ PathResult(const Result& result, std::filesystem::path path);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the path\n+ ///\n+ /// \\return The path\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const std::filesystem::path& getPath() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ std::filesystem::path m_path; //!< The contained path\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief File or directory attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ struct Attributes\n+ {\n+ std::filesystem::path path; //!< Path to the entry\n+ std::optional<std::filesystem::file_type> type; //!< Type of the entry\n+ std::optional<std::uint64_t> size; //!< Size of the entry\n+ std::optional<std::filesystem::perms> permissions; //!< Permissions\n+ std::optional<std::uint64_t> userId; //!< Owner user ID\n+ std::optional<std::uint64_t> groupId; //!< Group ID\n+ std::optional<std::filesystem::file_time_type> accessTime; //!< Last access time\n+ std::optional<std::filesystem::file_time_type> modificationTime; //!< Last modification time\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result of an operation returning attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API AttributesResult : public Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// \\param result Result\n+ /// \\param attributes Attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ AttributesResult(const Result& result, Attributes attributes);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the attributes\n+ ///\n+ /// \\return The attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const Attributes& getAttributes() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ Attributes m_attributes; //!< The contained attributes\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result of an operation returning a directory listing\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API ListingResult : public Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// \\param result Result\n+ /// \\param listing Directory listing\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ ListingResult(const Result& result, std::vector<Attributes> listing);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the directory listing\n+ ///\n+ /// \\return The directory listing\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const std::vector<Attributes>& getListing() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ std::vector<Attributes> m_listing; //!< The contained directory listing\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Structure containing information about an active SFTP session\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ struct SessionInfo\n+ {\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Host key used to identify a host\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ struct HostKey\n+ {\n+ enum class Type\n+ {\n+ Unknown, //!< Unknown key type\n+ Rsa, //!< RSA\n+ Dsa, //!< DSA\n+ Ecdsa256, //!< NIST P-256 ECDSA\n+ Ecdsa384, //!< NIST P-384 ECDSA\n+ Ecdsa521, //!< NIST P-521 ECDSA\n+ Ed25519 //!< ED25519\n+ };\n+\n+ Type type = Type::Unknown; //!< Host key type\n+ std::vector<std::byte> data; //!< Host key data\n+ std::array<std::byte, 20> sha1{}; //!< Host key SHA1 hash\n+ std::array<std::byte, 32> sha256{}; //!< Host key SHA256 hash\n+ };\n+\n+ HostKey hostKey; //!< Host key\n+ std::string keyExchangeAlgorithm; //!< Key exchange algorithm used in the session (RFC 4253)\n+ std::string hostKeyAlgorithm; //!< Host key algorithm used in the session (RFC 4253)\n+ std::string clientToServerEncryptionAlgorithm; //!< Client to server encryption algorithm used in the session (RFC 4253)\n+ std::string serverToClientEncryptionAlgorithm; //!< Server to client encryption algorithm used in the session (RFC 4253)\n+ std::string clientToServerMacAlgorithm; //!< Client to server message authentication code algorithm used in the session (RFC 4253)\n+ std::string serverToClientMacAlgorithm; //!< Server to client message authentication code algorithm used in the session (RFC 4253)\n+ std::string clientToServerCompressionAlgorithm; //!< Client to server compression algorithm used in the session (RFC 4253)\n+ std::string serverToClientCompressionAlgorithm; //!< Server to client compression algorithm used in the session (RFC 4253)\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Default constructor\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ Sftp();\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Destructor\n+ ///\n+ /// Automatically closes the connection with the server if\n+ /// it is still opened.\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ ~Sftp();\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Deleted copy constructor\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ Sftp(const Sftp&) = delete;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Deleted copy assignment\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ Sftp& operator=(const Sftp&) = delete;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Connect to the specified SFTP server\n+ ///\n+ /// The port has a default value of 22, which is the standard\n+ /// port used by the SFTP protocol.\n+ /// This function tries to connect to the server so it may take\n+ /// a while to complete, especially if the server is not\n+ /// reachable. To avoid blocking your application for too long,\n+ /// you can use a timeout. The default value, `Time::Zero`, means that the\n+ /// system timeout will be used (which is usually pretty long).\n+ ///\n+ /// \\param server Name or address of the SFTP server to connect to\n+ /// \\param port Port used for the connection\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of the connection attempt\n+ ///\n+ /// \\see `disconnect`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result connect(IpAddress server, unsigned short port = 22, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Disconnect the connection with the server\n+ ///\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of disconnecting the connection with the server\n+ ///\n+ /// \\see `connect`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result disconnect(const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get SSH session information\n+ ///\n+ /// After connecting to the server and before actually\n+ /// logging in the SSH session information of the underlying\n+ /// connection will be available.\n+ ///\n+ /// The session information contains among other things the\n+ /// public key identifying the remote host and the connection\n+ /// parameters such as encryption and compression used. The\n+ /// identifiers used follow the RFC 4253 specification.\n+ ///\n+ /// If the session information is not available `std::nullopt`\n+ /// will be returned.\n+ ///\n+ /// Because SSH was developed as a parallel standard to\n+ /// SSL/TLS and automatic host certificate verification wasn't\n+ /// widespread at the time, relying on the user to check the\n+ /// authenticity of the host key was the typical method used\n+ /// to verify that they were connecting to the legitimate host,\n+ /// assuming the private key of the remote host was not\n+ /// compromised.\n+ ///\n+ /// If connection security is a high priority, examining\n+ /// the parameters and aborting the connection if any weak\n+ /// algorithms are used is also possible.\n+ ///\n+ /// \\return SSH session information or `std::nullopt` if it is not available\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] std::optional<SessionInfo> getSessionInfo() const;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Log in using a username and a password\n+ ///\n+ /// Logging in is mandatory after connecting to the server.\n+ /// Users that are not logged in cannot perform any operation.\n+ ///\n+ /// \\param name User name\n+ /// \\param password Password\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of attempting to log in to the server\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result login(std::string_view name,\n+ std::string_view password,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Log in using a public/private key pair\n+ ///\n+ /// Logging in is mandatory after connecting to the server.\n+ /// Users that are not logged in cannot perform any operation.\n+ ///\n+ /// This overload allows logging into the SFTP server using\n+ /// public key authentication.\n+ ///\n+ /// The public and private key data should be provided in PEM\n+ /// format. PEM encoded data can be easily recognized by their\n+ /// `-----BEGIN ............-----` header and\n+ /// `-----END ............-----` footer.\n+ ///\n+ /// Even though it is technically possible to derive the\n+ /// public key from the private key, due to backend\n+ /// limitations, providing a pre-generated public key as well\n+ /// is necessary for this function to be able to succeed.\n+ ///\n+ /// If the private key is protected by a passphrase the\n+ /// passphrase can be provided as a NULL terminated string.\n+ /// If the private key is not protected by a passphrase the\n+ /// passphrase should be set to the empty string.\n+ ///\n+ /// \\param name User name\n+ /// \\param publicKeyData Public key data\n+ /// \\param publicKeyLength Public key data length\n+ /// \\param privateKeyData Private key data\n+ /// \\param privateKeyLength Private key data length\n+ /// \\param privateKeyPassphrase Private key passphrase, NULL terminated\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of attempting to log in to the server\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase = \"\",\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Log in using a public/private key pair\n+ ///\n+ /// Logging in is mandatory after connecting to the server.\n+ /// Users that are not logged in cannot perform any operation.\n+ ///\n+ /// This overload allows logging into the SFTP server using\n+ /// public key authentication.\n+ ///\n+ /// The public and private key data should be provided in PEM\n+ /// format. PEM encoded data can be easily recognized by their\n+ /// `-----BEGIN ............-----` header and\n+ /// `-----END ............-----` footer.\n+ ///\n+ /// Even though it is technically possible to derive the\n+ /// public key from the private key, due to backend\n+ /// limitations, providing a pre-generated public key as well\n+ /// is necessary for this function to be able to succeed.\n+ ///\n+ /// If the private key is protected by a passphrase the\n+ /// passphrase can be provided as a NULL terminated string.\n+ /// If the private key is not protected by a passphrase the\n+ /// passphrase should be set to the empty string.\n+ ///\n+ /// \\param name User name\n+ /// \\param publicKeyData Public key data\n+ /// \\param privateKeyData Private key data\n+ /// \\param privateKeyPassphrase Private key passphrase\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of attempting to log in to the server\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase = {},\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Resolve a remote path into an absolute remote path\n+ ///\n+ /// Paths can contain links and other reserved path identifiers\n+ /// such as . and .. referring to the current directory and\n+ /// parent directory respectively.\n+ ///\n+ /// When determining the absolute path, which does not contain\n+ /// links or . or .. is necessary, this function can be used.\n+ ///\n+ /// Resolving \".\" will return the absolute path to the current\n+ /// working directory of the user after logging in to the SFTP\n+ /// server.\n+ ///\n+ /// \\param path Path to convert into an absolute path\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of converting the path into an absolute path\n+ ///\n+ /// \\see `getWorkingDirectory`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] PathResult resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the current working directory on the server\n+ ///\n+ /// This is an alias for calling `resolvePath(\".\")`.\n+ ///\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of getting the current working directory\n+ ///\n+ /// \\see `resolvePath`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] PathResult getWorkingDirectory(const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the attributes of a remote file or directory\n+ ///\n+ /// Depending on whether `path` refers to a file or directory,\n+ /// the attributes can contain e.g. the type of file, the file\n+ /// owner, group, file size, modification and access times.\n+ ///\n+ /// If links are not to be followed, `followLinks` can be set\n+ /// to `false`. In this case the attributes of the link itself\n+ /// will be returned.\n+ ///\n+ /// \\param path Path to the remote file or directory whose attributes to get\n+ /// \\param followLinks `true` to follow links, `false` to return attributes of the link itself\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of getting the attributes\n+ ///\n+ /// \\see `getDirectoryListing`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] AttributesResult getAttributes(const std::filesystem::path& path,\n+ bool followLinks = true,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the contents of the given directory\n+ ///\n+ /// This function retrieves the sub-directories and files\n+ /// contained in the given directory. It is not recursive.\n+ ///\n+ /// \\param path Path of the directory whose contents to list\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of getting the contents of the given directory\n+ ///\n+ /// \\see `getAttributes`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] ListingResult getDirectoryListing(const std::filesystem::path& path,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Create a new directory\n+ ///\n+ /// The new directory is created as a child of the current\n+ /// working directory.\n+ ///\n+ /// The default permissions value is equivalent to `rwxr-xr-x`\n+ /// or 0755 in octal notation.\n+ ///\n+ /// \\param path Path of the directory to create\n+ /// \\param permissions Permissions of the directory to create\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of creating the directory\n+ ///\n+ /// \\see `deleteDirectory`, `rename`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result createDirectory(\n+ const std::filesystem::path& path,\n+ std::filesystem::perms permissions = (std::filesystem::perms::owner_all | std::filesystem::perms::group_read |\n+ std::filesystem::perms::group_exec | std::filesystem::perms::others_read |\n+ std::filesystem::perms::others_exec),\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Remove an existing directory\n+ ///\n+ /// Use this function with caution, the directory will\n+ /// be removed permanently!\n+ ///\n+ /// \\param path Path of the directory to remove\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of removing the directory\n+ ///\n+ /// \\see `createDirectory`, `rename`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Rename an existing file or directory\n+ ///\n+ /// In POSIX renaming and moving and synonymous. If you want\n+ /// to move a file or directory from one place to another\n+ /// you rename it from an old to a new path.\n+ ///\n+ /// If a file exists at the specified new path, depending\n+ /// on whether `ovewrite` is set to true, the rename operation\n+ /// will overwrite it or not. If a directory is being moved,\n+ /// the new path must either not point to non-existant\n+ /// directory or a directory that is empty. Non-empty\n+ /// directories cannot be overwritten by this operation.\n+ ///\n+ /// \\param oldPath Old path to the file or directory\n+ /// \\param newPath New path to the file or directory\n+ /// \\param overwrite Set to `true` to allow overwriting a file that exists at `newPath`\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of the operation\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite = false,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Remove an existing file\n+ ///\n+ /// Use this function with caution, the file will be\n+ /// removed permanently!\n+ ///\n+ /// \\param path Path to the file to remove\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of removing the file\n+ ///\n+ /// \\see `rename`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Download a file from the server\n+ ///\n+ /// This function retrieves the data in the file at the\n+ /// remote path.\n+ ///\n+ /// The file data is transferred in sequential blocks. For\n+ /// every block of data transferred, the provided callback\n+ /// is called. The callback is passed a pointer to a data\n+ /// block and the size of the data contained in the current\n+ /// block. This size can change over time so it is important\n+ /// to always check the size value to know how much data is\n+ /// actually available. The callback should return `true` to\n+ /// indicate to the `download` function that it should\n+ /// continue to transfer data. If the data transfer should\n+ /// be aborted earlier, `false` can be returned from the\n+ /// callback.\n+ ///\n+ /// The function returns once all the data in the remote file\n+ /// has been transferred or an error occurs or the function\n+ /// times out.\n+ ///\n+ /// If reading from the remote file should not start at the\n+ /// beginning of the file, you can specify an offset in\n+ /// bytes at which reading should start.\n+ ///\n+ /// \\param remotePath Path of the remote file whose data to download\n+ /// \\param callback Callback to be called for every available data block\n+ /// \\param offset Byte offset into the remote file at which reading should start\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of downloading the file\n+ ///\n+ /// \\see `upload`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset = 0,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Upload a file to the server\n+ ///\n+ /// This function writes data into a file at the remote path.\n+ ///\n+ /// The file data is transferred in sequential blocks. Every\n+ /// time the function wants to send a new block of data the\n+ /// provided callback is called. The callback is passed a\n+ /// pointer to a data block and a reference to the size of\n+ /// the data block. Data to be sent should be copied into\n+ /// the data block using e.g. `std::memcpy` and the size value\n+ /// set to the actual number of bytes copied into the data\n+ /// block. The size of the block can change over time so it\n+ /// is important to check the size value that is passed to\n+ /// the callback to know how many bytes can actually be\n+ /// copied into the data block. The callback should return\n+ /// `true` to indicate to the `upload` function that it\n+ /// should continue to transfer data. Once the data transfer\n+ /// should be stopped e.g. because there is no more data left\n+ /// to send, `false` can be returned from the callback.\n+ ///\n+ /// The function returns once all the data has been sent or\n+ /// an error occurs or the function times out.\n+ ///\n+ /// If a file does not exist at the remote path yet, it will\n+ /// be created with the provided permissions.\n+ ///\n+ /// If a file already exists at the remote path, setting\n+ /// `truncate` to `true` will truncate the existing file\n+ /// i.e. delete all pre-existing data before starting to\n+ /// write the new data into the file.\n+ ///\n+ /// Setting `append` to `true` will append to a file if\n+ /// it already exists.\n+ ///\n+ /// If writing to the remote file should not start at the\n+ /// beginning of the file, you can specify an offset in\n+ /// bytes at which writing should start.\n+ ///\n+ /// The default permissions value is equivalent to `rw-r--r--`\n+ /// or 0644 in octal notation.\n+ ///\n+ /// \\param remotePath Path of the remote file in which to upload the data\n+ /// \\param callback Callback to be called for every available data block\n+ /// \\param permissions Permissions of the remote file if it has to be created\n+ /// \\param truncate Set to `true` to truncate the remote file if it already exists\n+ /// \\param append Set to `true` to append to the remote file if it already exists\n+ /// \\param offset Byte offset into the remote file at which writing should start\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of uploading the file\n+ ///\n+ /// \\see `download`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result upload(\n+ const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions = (std::filesystem::perms::owner_read | std::filesystem::perms::owner_write |\n+ std::filesystem::perms::group_read | std::filesystem::perms::others_read),\n+ bool truncate = true,\n+ bool append = false,\n+ std::uint64_t offset = 0,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ struct Impl;\n+ std::unique_ptr<Impl> m_impl; //!< Implementation\n+};\n+\n+} // namespace sf\n+\n+\n+////////////////////////////////////////////////////////////\n+/// \\class sf::Sftp\n+/// \\ingroup network\n+///\n+/// `sf::Sftp` is a very simple SFTP client that allows you\n+/// to communicate with a SFTP server. The SFTP protocol allows\n+/// you to manipulate a remote file system (list files,\n+/// upload, download, create, remove, ...).\n+///\n+/// Using the SFTP client consists of 4 parts:\n+/// \\li Connecting to the SFTP server\n+/// \\li Logging in (either using username and password or public key authentication)\n+/// \\li Performing file system operations\n+/// \\li Disconnecting (this part can be done implicitly by the destructor)\n+///\n+/// Every operation returns an SFTP result, which contains the\n+/// result code and optionally a message describing the result. Some\n+/// commands such as `getAttributes()` and `getDirectoryListing()`\n+/// return additional data, and use a class derived from\n+/// `sf::Sftp::Result` to provide this data. The commonly used filesystem\n+/// operations are directly provided as member functions.\n+///\n+/// There are three classes of result values: general result values,\n+/// SSH specific result values and SFTP specific result values. General\n+/// result values are returned on success and errors not specific to the\n+/// SSH or SFTP protocols. If an operation manipulating the remote\n+/// filesystem fails, an SFTP specific result will be returned describing\n+/// the reason for the failure. If any error related to the communication\n+/// channel occurs e.g. key exchange failure or authentication failure an\n+/// SSH error will be returned.\n+///\n+/// Because most operations manipulate some part of the remote filesystem\n+/// these operations, especially upload and download, may take some\n+/// time to complete. This is important to know if you don't want\n+/// to block your application while the server is completing\n+/// the task.\n+///\n+/// Every operation that relies on network communication can be passed\n+/// a timeout argument. In the simplest case, this timeout argument can\n+/// just be a fixed time duration after which the operation should time\n+/// out if no progress has been made. Because some operations simply due\n+/// to their nature can take longer than others it might not be possible\n+/// to use the same timeout value for all operations. If it is anticipated\n+/// that an operation could take a longer amount of time to complete due\n+/// to e.g. an unreliable or slow connection, the timeout should be increased\n+/// so the operation still has the possibility to complete successfully.\n+/// Passing `sf::Time::Zero` as a timeout value will cause the operation\n+/// to block until completion or failure.\n+///\n+/// If you want to pass `sf::Time::Zero` to wait indefinitely for an\n+/// operation to complete but still have the possibility to interrupt the\n+/// operation e.g. if the user decides to quit the application or interrupt\n+/// a longer download or upload, the timeout can be constructed from a\n+/// predicate and polling period. The predicate is a callable that takes\n+/// no parameters and returns `true` if the operation should continue or\n+/// `false` if the operation should time out. The time between consecutive\n+/// evaluations of the predicate is specified by the `period` parameter.\n+///\n+/// Example of a `TimeoutWithPredicate`:\n+/// \\code\n+/// bool run = true;\n+/// sf::Sftp::TimeoutWithPredicate timeout([&run]{ return run; }, sf::milliseconds(1));\n+/// \\endcode\n+/// When passed to an operation, the above `TimeoutWithPredicate` object will\n+/// keep the operation running as long as `run` is `true`. The condition\n+/// is checked every 1 millisecond. As soon as `run` is set to `false` the\n+/// operation will terminate with a `Timeout` result.\n+///\n+/// Remember that attempting to modify variables from across threads will\n+/// require proper synchronization using e.g. mutexes or atomics.\n+///\n+/// Because the filesystem operations will be performed on the remote\n+/// system, the paths passed to the operations should be valid paths on\n+/// the remote system. To guarantee portability, generic POSIX paths should\n+/// be used. These use `/` as the path seperator and `.` to refer to the\n+/// current directory and `..` to refer to the parent directory.\n+///\n+/// When logging into the server as a specific user the current directory\n+/// will be set to the home directory that was specified for that user\n+/// account. Because it cannot be assumed that the SFTP user is also allowed\n+/// to log into a shell, changing the current directory from the home\n+/// directory is not always possible and thus not supported. Thus when\n+/// specifying paths, it is preferred to always make use of absolute paths\n+/// when possible. Calling `getWorkingDirectory()` will return the current\n+/// directory as an absolute path. Listing the contents of a directory whose\n+/// path is passed as an absolute path will yield directory listing entries\n+/// whose paths are extentions of the directory's path and thus also absolute\n+/// paths. The `resolvePath()` function can be used to convert relative paths\n+/// or paths containing links into absolute paths without links.\n+///\n+/// Usage example:\n+/// \\code\n+/// // Create a new SFTP client\n+/// sf::Sftp sftp;\n+///\n+/// // Get the address of the server\n+/// const auto addresses = sf::Dns::resolve(\"sftp.myserver.com\");\n+///\n+/// // Check if we have a valid address\n+/// if (!addresses.has_value() || addresses->empty())\n+/// {\n+/// // Handle no valid address...\n+/// }\n+///\n+/// // Connect to the server\n+/// sf::Sftp::Result result = sftp.connect(addresses->front());\n+/// if (result.isOk())\n+/// std::cout << \"Connected\" << std::endl;\n+///\n+/// // Check session information and verify server\n+/// std::optional<sf::Sftp::SessionInfo> info = sftp.getSessionInfo();\n+/// if (info->hostKey.sha256 != expectedSha256)\n+/// {\n+/// std::cout << \"Server untrusted\" << std::endl;\n+/// // Handle untrusted server\n+/// }\n+///\n+/// // Log in\n+/// result = sftp.login(\"sftpuser\", \"dF6Zm89D\");\n+/// if (result.isOk())\n+/// std::cout << \"Logged in\" << std::endl;\n+///\n+/// // Print the working directory\n+/// sf::Sftp::PathResult directory = sftp.getWorkingDirectory();\n+/// if (directory.isOk())\n+/// std::cout << \"Working directory: \" << directory.getPath().string() << std::endl;\n+///\n+/// // Create a new directory\n+/// result = sftp.createDirectory(\"files\");\n+/// if (result.isOk())\n+/// std::cout << \"Created new directory\" << std::endl;\n+///\n+/// // Upload a text file to this new directory\n+/// result = sftp.upload(\"files/newfile.txt\", [](void* data, std::size_t& size)\n+/// {\n+/// // In your own code, ensure size is big enough to store your data\n+/// // We skip the check here for simplicity\n+/// std::memcpy(data, \"Hello World\", 11);\n+/// size = 11;\n+/// return false; // End transfer after this block\n+/// });\n+/// if (response.isOk())\n+/// std::cout << \"File uploaded\" << std::endl;\n+///\n+/// // Rename file\n+/// result = sftp.rename(\"files/newfile.txt\", \"files/newfile2.txt\");\n+/// if (result.isOk())\n+/// std::cout << \"Renamed file\" << std::endl;\n+///\n+/// // Download a text file from this new directory\n+/// std::string text;\n+/// result = sftp.download(\"files/newfile2.txt\", [&text](const void* data, std::size_t size)\n+/// {\n+/// text.append(static_cast<const char*>(data), size);\n+/// return true; // Continue until all data received\n+/// });\n+/// if (response.isOk())\n+/// std::cout << \"File downloaded: \" << text << std::endl;\n+///\n+/// // Delete file\n+/// result = sftp.deleteFile(\"files/newfile2.txt\");\n+/// if (result.isOk())\n+/// std::cout << \"Deleted file\" << std::endl;\n+///\n+/// // Delete directory\n+/// result = sftp.deleteDirectory(\"files\");\n+/// if (result.isOk())\n+/// std::cout << \"Deleted directory\" << std::endl;\n+///\n+/// // Disconnect from the server (optional)\n+/// result = sftp.disconnect();\n+/// if (result.isOk())\n+/// std::cout << \"Disconnected successfully\" << std::endl;\n+/// \\endcode\n+///\n+////////////////////////////////////////////////////////////\n"},"changed_files":{"kind":"list like","value":["include/SFML/Network/Sftp.hpp"],"string":"[\n \"include/SFML/Network/Sftp.hpp\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"Should we have separate result sets, instead of using prefixes?","path":"include/SFML/Network/Sftp.hpp","hunk":"@@ -0,0 +1,998 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+#pragma once\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/Export.hpp>\n+\n+#include <SFML/System/Time.hpp>\n+\n+#include <array>\n+#include <filesystem>\n+#include <functional>\n+#include <memory>\n+#include <optional>\n+#include <string>\n+#include <vector>\n+\n+#include <cstddef>\n+#include <cstdint>\n+\n+\n+namespace sf\n+{\n+class IpAddress;\n+\n+////////////////////////////////////////////////////////////\n+/// \\brief An SSH File Transfer Protocol (SFTP) client\n+///\n+////////////////////////////////////////////////////////////\n+class SFML_NETWORK_API Sftp\n+{\n+public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief SFTP result\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result values\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ enum class Value\n+ {\n+ // General result values\n+ Success, //!< Operation completed successfully\n+ Disconnected, //!< The TCP socket has been disconnected\n+ Timeout, //!< Operation timed out\n+ Refused, //!< Connection refused\n+ Error, //!< Generic error\n+\n+ // SSH result values\n+ SshErrorBannerReceive, //!< Error during banner receive\n+ SshErrorBannerSend, //!< Error during banner send\n+ SshErrorInvalidMac, //!< Invalid message authentication code\n+ SshErrorAllocation, //!< Allocation failure\n+ SshErrorSocketSend, //!< Error sending on socket\n+ SshErrorKeyExchangeFailure, //!< Key exchange failed\n+ SshErrorHostKeyInitialization, //!< Host key initialization failed\n+ SshErrorHostKeySign, //!< Host key signing failed\n+ SshErrorDecrypt, //!< Decryption failed\n+ SshErrorProtocol, //!< SSH protocol error\n+ SshErrorPasswordExpired, //!< Password expired\n+ SshErrorFile, //!< File error\n+ SshErrorMethodNone, //!< No method found\n+ SshErrorAuthenticationFailed, //!< Authentication failed\n+ SshErrorPublicKeyUnverified, //!< Public key unverified\n+ SshErrorChannelOutOfOrder, //!< Channel out of order\n+ SshErrorChannelFailure, //!< Channel failure\n+ SshErrorChannelRequestDenied, //!< Channel request denied\n+ SshErrorChannelUnknown, //!< Channel unknown\n+ SshErrorChannelWindowExceeded, //!< Channel window exceeded\n+ SshErrorChannelPacketExceeded, //!< Channel packet exceeded\n+ SshErrorChannelClosed, //!< Channel closed\n+ SshErrorChannelEofSent, //!< Channel EOF sent\n+ SshErrorScpProtocol, //!< SCP protocol error\n+ SshErrorZlib, //!< Zlib error\n+ SshErrorRequestDenied, //!< Request denied\n+ SshErrorMethodNotSupported, //!< Method not supported\n+ SshErrorInvalid, //!< Invalid data\n+ SshErrorPublicKeyProtocol, //!< Public key protocol error\n+ SshErrorBufferTooSmall, //!< Buffer too small\n+ SshErrorBadUse, //!< Bad usage\n+ SshErrorCompress, //!< Compression error\n+ SshErrorOutOfBoundary, //!< Out of boundary\n+ SshErrorAgentProtocol, //!< Agent protocol error\n+ SshErrorSocketRecv, //!< Socket receive error\n+ SshErrorEncrypt, //!< Encryption failed\n+ SshErrorBadSocket, //!< Bad socket\n+ SshErrorKnownHosts, //!< Known hosts error\n+ SshErrorChannelWindowFull, //!< Channel window full\n+ SshErrorKeyFileAuthenticationFailed, //!< Key file authentication failed\n+\n+ // SFTP result values\n+ SftpEndOfFile, //!< End of file\n+ SftpNoSuchFile, //!< No such file\n+ SftpPermissionDenied, //!< Permission denied\n+ SftpFailure, //!< Failure\n+ SftpBadMessage, //!< Bad message\n+ SftpNoConnection, //!< No connection\n+ SftpConnectionLost, //!< Connection lost\n+ SftpOperationUnsupported, //!< Operation unsupported\n+ SftpInvalidHandle, //!< Invalid handle\n+ SftpNoSuchPath, //!< No such path\n+ SftpFileAlreadyExists, //!< File already exists\n+ SftpWriteProtect, //!< Write protect\n+ SftpNoMedia, //!< No media\n+ SftpNoSpaceOnFileSystem, //!< No space on filesystem\n+ SftpQuotaExceeded, //!< Quota exceeded\n+ SftpUnknownPrincipal, //!< Unknown principal\n+ SftpLockConflict, //!< Lock conflict\n+ SftpDirectoryNotEmpty, //!< Directory not empty\n+ SftpNotADirectory, //!< Not a directory\n+ SftpInvalidFilename, //!< Invalid filename\n+ SftpLinkLoop, //!< Link loop\n+ SftpError //!< Generic SFTP error\n+ };","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/include/SFML/Network/Sftp.hpp b/include/SFML/Network/Sftp.hpp\nnew file mode 100644\nindex 0000000000..9be101d562\n--- /dev/null\n+++ b/include/SFML/Network/Sftp.hpp\n@@ -0,0 +1,987 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+#pragma once\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/Export.hpp>\n+\n+#include <SFML/System/TimeoutWithPredicate.hpp>\n+\n+#include <array>\n+#include <filesystem>\n+#include <memory>\n+#include <optional>\n+#include <string>\n+#include <string_view>\n+#include <vector>\n+\n+#include <cstddef>\n+#include <cstdint>\n+\n+\n+namespace sf\n+{\n+class IpAddress;\n+\n+////////////////////////////////////////////////////////////\n+/// \\brief An SSH File Transfer Protocol (SFTP) client\n+///\n+////////////////////////////////////////////////////////////\n+class SFML_NETWORK_API Sftp\n+{\n+public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief SFTP result\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result values\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ enum class Value\n+ {\n+ // General result values\n+ Success, //!< Operation completed successfully\n+ Disconnected, //!< The TCP socket has been disconnected\n+ Timeout, //!< Operation timed out\n+ Refused, //!< Connection refused\n+ Error, //!< Generic error\n+\n+ // SSH result values\n+ BannerReceive, //!< Error during banner receive\n+ BannerSend, //!< Error during banner send\n+ InvalidMac, //!< Invalid message authentication code\n+ AllocationFailure, //!< Allocation failure\n+ SocketSend, //!< Error sending on socket\n+ KeyExchangeFailure, //!< Key exchange failed\n+ HostKeyInitialization, //!< Host key initialization failed\n+ HostKeySign, //!< Host key signing failed\n+ DecryptError, //!< Decryption failed\n+ ProtocolError, //!< SSH protocol error\n+ PasswordExpired, //!< Password expired\n+ FileError, //!< File error\n+ MethodNone, //!< No method found\n+ AuthenticationFailed, //!< Authentication failed\n+ PublicKeyUnverified, //!< Public key unverified\n+ ChannelOutOfOrder, //!< Channel out of order\n+ ChannelFailure, //!< Channel failure\n+ ChannelRequestDenied, //!< Channel request denied\n+ ChannelUnknown, //!< Channel unknown\n+ ChannelWindowExceeded, //!< Channel window exceeded\n+ ChannelPacketExceeded, //!< Channel packet exceeded\n+ ChannelClosed, //!< Channel closed\n+ ChannelEofSent, //!< Channel EOF sent\n+ ScpProtocol, //!< SCP protocol error\n+ ZlibError, //!< Zlib error\n+ RequestDenied, //!< Request denied\n+ MethodNotSupported, //!< Method not supported\n+ InvalidData, //!< Invalid data\n+ PublicKeyProtocol, //!< Public key protocol error\n+ BufferTooSmall, //!< Buffer too small\n+ BadUse, //!< Bad usage\n+ CompressError, //!< Compression error\n+ OutOfBoundary, //!< Out of boundary\n+ AgentProtocol, //!< Agent protocol error\n+ SocketRecv, //!< Socket receive error\n+ EncryptError, //!< Encryption failed\n+ BadSocket, //!< Bad socket\n+ KnownHosts, //!< Known hosts error\n+ ChannelWindowFull, //!< Channel window full\n+ KeyFileAuthenticationFailed, //!< Key file authentication failed\n+\n+ // SFTP result values\n+ EndOfFile, //!< End of file\n+ NoSuchFile, //!< No such file\n+ PermissionDenied, //!< Permission denied\n+ Failure, //!< Failure\n+ BadMessage, //!< Bad message\n+ NoConnection, //!< No connection\n+ ConnectionLost, //!< Connection lost\n+ OperationUnsupported, //!< Operation unsupported\n+ InvalidHandle, //!< Invalid handle\n+ NoSuchPath, //!< No such path\n+ FileAlreadyExists, //!< File already exists\n+ WriteProtect, //!< Write protect\n+ NoMedia, //!< No media\n+ NoSpaceOnFileSystem, //!< No space on filesystem\n+ QuotaExceeded, //!< Quota exceeded\n+ UnknownPrincipal, //!< Unknown principal\n+ LockConflict, //!< Lock conflict\n+ DirectoryNotEmpty, //!< Directory not empty\n+ NotADirectory, //!< Not a directory\n+ InvalidFilename, //!< Invalid filename\n+ LinkLoop, //!< Link loop\n+ SftpError //!< Generic SFTP error\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// This constructor is used by the SFTP client to build\n+ /// the result.\n+ ///\n+ /// \\param value Result value\n+ /// \\param message Result message\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ explicit Result(Value value, std::string message = \"\");\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Check if the result is a success\n+ ///\n+ /// This function is defined for convenience, it is\n+ /// equivalent to testing if the result value is `Value::Success`.\n+ ///\n+ /// \\return `true` if the result is `Value::Success`, `false` if it is not `Value::Success`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] bool isOk() const;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the result value\n+ ///\n+ /// \\return The result value\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Value getValue() const;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the result message\n+ ///\n+ /// \\return The result message\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const std::string& getMessage() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ Value m_value; //!< The contained value\n+ std::string m_message; //!< The contained message\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result of an operation returning a path\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API PathResult : public Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// \\param result Result\n+ /// \\param path Path\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ PathResult(const Result& result, std::filesystem::path path);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the path\n+ ///\n+ /// \\return The path\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const std::filesystem::path& getPath() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ std::filesystem::path m_path; //!< The contained path\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief File or directory attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ struct Attributes\n+ {\n+ std::filesystem::path path; //!< Path to the entry\n+ std::optional<std::filesystem::file_type> type; //!< Type of the entry\n+ std::optional<std::uint64_t> size; //!< Size of the entry\n+ std::optional<std::filesystem::perms> permissions; //!< Permissions\n+ std::optional<std::uint64_t> userId; //!< Owner user ID\n+ std::optional<std::uint64_t> groupId; //!< Group ID\n+ std::optional<std::filesystem::file_time_type> accessTime; //!< Last access time\n+ std::optional<std::filesystem::file_time_type> modificationTime; //!< Last modification time\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result of an operation returning attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API AttributesResult : public Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// \\param result Result\n+ /// \\param attributes Attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ AttributesResult(const Result& result, Attributes attributes);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the attributes\n+ ///\n+ /// \\return The attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const Attributes& getAttributes() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ Attributes m_attributes; //!< The contained attributes\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result of an operation returning a directory listing\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API ListingResult : public Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// \\param result Result\n+ /// \\param listing Directory listing\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ ListingResult(const Result& result, std::vector<Attributes> listing);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the directory listing\n+ ///\n+ /// \\return The directory listing\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const std::vector<Attributes>& getListing() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ std::vector<Attributes> m_listing; //!< The contained directory listing\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Structure containing information about an active SFTP session\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ struct SessionInfo\n+ {\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Host key used to identify a host\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ struct HostKey\n+ {\n+ enum class Type\n+ {\n+ Unknown, //!< Unknown key type\n+ Rsa, //!< RSA\n+ Dsa, //!< DSA\n+ Ecdsa256, //!< NIST P-256 ECDSA\n+ Ecdsa384, //!< NIST P-384 ECDSA\n+ Ecdsa521, //!< NIST P-521 ECDSA\n+ Ed25519 //!< ED25519\n+ };\n+\n+ Type type = Type::Unknown; //!< Host key type\n+ std::vector<std::byte> data; //!< Host key data\n+ std::array<std::byte, 20> sha1{}; //!< Host key SHA1 hash\n+ std::array<std::byte, 32> sha256{}; //!< Host key SHA256 hash\n+ };\n+\n+ HostKey hostKey; //!< Host key\n+ std::string keyExchangeAlgorithm; //!< Key exchange algorithm used in the session (RFC 4253)\n+ std::string hostKeyAlgorithm; //!< Host key algorithm used in the session (RFC 4253)\n+ std::string clientToServerEncryptionAlgorithm; //!< Client to server encryption algorithm used in the session (RFC 4253)\n+ std::string serverToClientEncryptionAlgorithm; //!< Server to client encryption algorithm used in the session (RFC 4253)\n+ std::string clientToServerMacAlgorithm; //!< Client to server message authentication code algorithm used in the session (RFC 4253)\n+ std::string serverToClientMacAlgorithm; //!< Server to client message authentication code algorithm used in the session (RFC 4253)\n+ std::string clientToServerCompressionAlgorithm; //!< Client to server compression algorithm used in the session (RFC 4253)\n+ std::string serverToClientCompressionAlgorithm; //!< Server to client compression algorithm used in the session (RFC 4253)\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Default constructor\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ Sftp();\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Destructor\n+ ///\n+ /// Automatically closes the connection with the server if\n+ /// it is still opened.\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ ~Sftp();\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Deleted copy constructor\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ Sftp(const Sftp&) = delete;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Deleted copy assignment\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ Sftp& operator=(const Sftp&) = delete;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Connect to the specified SFTP server\n+ ///\n+ /// The port has a default value of 22, which is the standard\n+ /// port used by the SFTP protocol.\n+ /// This function tries to connect to the server so it may take\n+ /// a while to complete, especially if the server is not\n+ /// reachable. To avoid blocking your application for too long,\n+ /// you can use a timeout. The default value, `Time::Zero`, means that the\n+ /// system timeout will be used (which is usually pretty long).\n+ ///\n+ /// \\param server Name or address of the SFTP server to connect to\n+ /// \\param port Port used for the connection\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of the connection attempt\n+ ///\n+ /// \\see `disconnect`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result connect(IpAddress server, unsigned short port = 22, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Disconnect the connection with the server\n+ ///\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of disconnecting the connection with the server\n+ ///\n+ /// \\see `connect`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result disconnect(const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get SSH session information\n+ ///\n+ /// After connecting to the server and before actually\n+ /// logging in the SSH session information of the underlying\n+ /// connection will be available.\n+ ///\n+ /// The session information contains among other things the\n+ /// public key identifying the remote host and the connection\n+ /// parameters such as encryption and compression used. The\n+ /// identifiers used follow the RFC 4253 specification.\n+ ///\n+ /// If the session information is not available `std::nullopt`\n+ /// will be returned.\n+ ///\n+ /// Because SSH was developed as a parallel standard to\n+ /// SSL/TLS and automatic host certificate verification wasn't\n+ /// widespread at the time, relying on the user to check the\n+ /// authenticity of the host key was the typical method used\n+ /// to verify that they were connecting to the legitimate host,\n+ /// assuming the private key of the remote host was not\n+ /// compromised.\n+ ///\n+ /// If connection security is a high priority, examining\n+ /// the parameters and aborting the connection if any weak\n+ /// algorithms are used is also possible.\n+ ///\n+ /// \\return SSH session information or `std::nullopt` if it is not available\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] std::optional<SessionInfo> getSessionInfo() const;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Log in using a username and a password\n+ ///\n+ /// Logging in is mandatory after connecting to the server.\n+ /// Users that are not logged in cannot perform any operation.\n+ ///\n+ /// \\param name User name\n+ /// \\param password Password\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of attempting to log in to the server\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result login(std::string_view name,\n+ std::string_view password,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Log in using a public/private key pair\n+ ///\n+ /// Logging in is mandatory after connecting to the server.\n+ /// Users that are not logged in cannot perform any operation.\n+ ///\n+ /// This overload allows logging into the SFTP server using\n+ /// public key authentication.\n+ ///\n+ /// The public and private key data should be provided in PEM\n+ /// format. PEM encoded data can be easily recognized by their\n+ /// `-----BEGIN ............-----` header and\n+ /// `-----END ............-----` footer.\n+ ///\n+ /// Even though it is technically possible to derive the\n+ /// public key from the private key, due to backend\n+ /// limitations, providing a pre-generated public key as well\n+ /// is necessary for this function to be able to succeed.\n+ ///\n+ /// If the private key is protected by a passphrase the\n+ /// passphrase can be provided as a NULL terminated string.\n+ /// If the private key is not protected by a passphrase the\n+ /// passphrase should be set to the empty string.\n+ ///\n+ /// \\param name User name\n+ /// \\param publicKeyData Public key data\n+ /// \\param publicKeyLength Public key data length\n+ /// \\param privateKeyData Private key data\n+ /// \\param privateKeyLength Private key data length\n+ /// \\param privateKeyPassphrase Private key passphrase, NULL terminated\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of attempting to log in to the server\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase = \"\",\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Log in using a public/private key pair\n+ ///\n+ /// Logging in is mandatory after connecting to the server.\n+ /// Users that are not logged in cannot perform any operation.\n+ ///\n+ /// This overload allows logging into the SFTP server using\n+ /// public key authentication.\n+ ///\n+ /// The public and private key data should be provided in PEM\n+ /// format. PEM encoded data can be easily recognized by their\n+ /// `-----BEGIN ............-----` header and\n+ /// `-----END ............-----` footer.\n+ ///\n+ /// Even though it is technically possible to derive the\n+ /// public key from the private key, due to backend\n+ /// limitations, providing a pre-generated public key as well\n+ /// is necessary for this function to be able to succeed.\n+ ///\n+ /// If the private key is protected by a passphrase the\n+ /// passphrase can be provided as a NULL terminated string.\n+ /// If the private key is not protected by a passphrase the\n+ /// passphrase should be set to the empty string.\n+ ///\n+ /// \\param name User name\n+ /// \\param publicKeyData Public key data\n+ /// \\param privateKeyData Private key data\n+ /// \\param privateKeyPassphrase Private key passphrase\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of attempting to log in to the server\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase = {},\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Resolve a remote path into an absolute remote path\n+ ///\n+ /// Paths can contain links and other reserved path identifiers\n+ /// such as . and .. referring to the current directory and\n+ /// parent directory respectively.\n+ ///\n+ /// When determining the absolute path, which does not contain\n+ /// links or . or .. is necessary, this function can be used.\n+ ///\n+ /// Resolving \".\" will return the absolute path to the current\n+ /// working directory of the user after logging in to the SFTP\n+ /// server.\n+ ///\n+ /// \\param path Path to convert into an absolute path\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of converting the path into an absolute path\n+ ///\n+ /// \\see `getWorkingDirectory`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] PathResult resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the current working directory on the server\n+ ///\n+ /// This is an alias for calling `resolvePath(\".\")`.\n+ ///\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of getting the current working directory\n+ ///\n+ /// \\see `resolvePath`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] PathResult getWorkingDirectory(const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the attributes of a remote file or directory\n+ ///\n+ /// Depending on whether `path` refers to a file or directory,\n+ /// the attributes can contain e.g. the type of file, the file\n+ /// owner, group, file size, modification and access times.\n+ ///\n+ /// If links are not to be followed, `followLinks` can be set\n+ /// to `false`. In this case the attributes of the link itself\n+ /// will be returned.\n+ ///\n+ /// \\param path Path to the remote file or directory whose attributes to get\n+ /// \\param followLinks `true` to follow links, `false` to return attributes of the link itself\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of getting the attributes\n+ ///\n+ /// \\see `getDirectoryListing`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] AttributesResult getAttributes(const std::filesystem::path& path,\n+ bool followLinks = true,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the contents of the given directory\n+ ///\n+ /// This function retrieves the sub-directories and files\n+ /// contained in the given directory. It is not recursive.\n+ ///\n+ /// \\param path Path of the directory whose contents to list\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of getting the contents of the given directory\n+ ///\n+ /// \\see `getAttributes`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] ListingResult getDirectoryListing(const std::filesystem::path& path,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Create a new directory\n+ ///\n+ /// The new directory is created as a child of the current\n+ /// working directory.\n+ ///\n+ /// The default permissions value is equivalent to `rwxr-xr-x`\n+ /// or 0755 in octal notation.\n+ ///\n+ /// \\param path Path of the directory to create\n+ /// \\param permissions Permissions of the directory to create\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of creating the directory\n+ ///\n+ /// \\see `deleteDirectory`, `rename`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result createDirectory(\n+ const std::filesystem::path& path,\n+ std::filesystem::perms permissions = (std::filesystem::perms::owner_all | std::filesystem::perms::group_read |\n+ std::filesystem::perms::group_exec | std::filesystem::perms::others_read |\n+ std::filesystem::perms::others_exec),\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Remove an existing directory\n+ ///\n+ /// Use this function with caution, the directory will\n+ /// be removed permanently!\n+ ///\n+ /// \\param path Path of the directory to remove\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of removing the directory\n+ ///\n+ /// \\see `createDirectory`, `rename`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Rename an existing file or directory\n+ ///\n+ /// In POSIX renaming and moving and synonymous. If you want\n+ /// to move a file or directory from one place to another\n+ /// you rename it from an old to a new path.\n+ ///\n+ /// If a file exists at the specified new path, depending\n+ /// on whether `ovewrite` is set to true, the rename operation\n+ /// will overwrite it or not. If a directory is being moved,\n+ /// the new path must either not point to non-existant\n+ /// directory or a directory that is empty. Non-empty\n+ /// directories cannot be overwritten by this operation.\n+ ///\n+ /// \\param oldPath Old path to the file or directory\n+ /// \\param newPath New path to the file or directory\n+ /// \\param overwrite Set to `true` to allow overwriting a file that exists at `newPath`\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of the operation\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite = false,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Remove an existing file\n+ ///\n+ /// Use this function with caution, the file will be\n+ /// removed permanently!\n+ ///\n+ /// \\param path Path to the file to remove\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of removing the file\n+ ///\n+ /// \\see `rename`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Download a file from the server\n+ ///\n+ /// This function retrieves the data in the file at the\n+ /// remote path.\n+ ///\n+ /// The file data is transferred in sequential blocks. For\n+ /// every block of data transferred, the provided callback\n+ /// is called. The callback is passed a pointer to a data\n+ /// block and the size of the data contained in the current\n+ /// block. This size can change over time so it is important\n+ /// to always check the size value to know how much data is\n+ /// actually available. The callback should return `true` to\n+ /// indicate to the `download` function that it should\n+ /// continue to transfer data. If the data transfer should\n+ /// be aborted earlier, `false` can be returned from the\n+ /// callback.\n+ ///\n+ /// The function returns once all the data in the remote file\n+ /// has been transferred or an error occurs or the function\n+ /// times out.\n+ ///\n+ /// If reading from the remote file should not start at the\n+ /// beginning of the file, you can specify an offset in\n+ /// bytes at which reading should start.\n+ ///\n+ /// \\param remotePath Path of the remote file whose data to download\n+ /// \\param callback Callback to be called for every available data block\n+ /// \\param offset Byte offset into the remote file at which reading should start\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of downloading the file\n+ ///\n+ /// \\see `upload`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset = 0,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Upload a file to the server\n+ ///\n+ /// This function writes data into a file at the remote path.\n+ ///\n+ /// The file data is transferred in sequential blocks. Every\n+ /// time the function wants to send a new block of data the\n+ /// provided callback is called. The callback is passed a\n+ /// pointer to a data block and a reference to the size of\n+ /// the data block. Data to be sent should be copied into\n+ /// the data block using e.g. `std::memcpy` and the size value\n+ /// set to the actual number of bytes copied into the data\n+ /// block. The size of the block can change over time so it\n+ /// is important to check the size value that is passed to\n+ /// the callback to know how many bytes can actually be\n+ /// copied into the data block. The callback should return\n+ /// `true` to indicate to the `upload` function that it\n+ /// should continue to transfer data. Once the data transfer\n+ /// should be stopped e.g. because there is no more data left\n+ /// to send, `false` can be returned from the callback.\n+ ///\n+ /// The function returns once all the data has been sent or\n+ /// an error occurs or the function times out.\n+ ///\n+ /// If a file does not exist at the remote path yet, it will\n+ /// be created with the provided permissions.\n+ ///\n+ /// If a file already exists at the remote path, setting\n+ /// `truncate` to `true` will truncate the existing file\n+ /// i.e. delete all pre-existing data before starting to\n+ /// write the new data into the file.\n+ ///\n+ /// Setting `append` to `true` will append to a file if\n+ /// it already exists.\n+ ///\n+ /// If writing to the remote file should not start at the\n+ /// beginning of the file, you can specify an offset in\n+ /// bytes at which writing should start.\n+ ///\n+ /// The default permissions value is equivalent to `rw-r--r--`\n+ /// or 0644 in octal notation.\n+ ///\n+ /// \\param remotePath Path of the remote file in which to upload the data\n+ /// \\param callback Callback to be called for every available data block\n+ /// \\param permissions Permissions of the remote file if it has to be created\n+ /// \\param truncate Set to `true` to truncate the remote file if it already exists\n+ /// \\param append Set to `true` to append to the remote file if it already exists\n+ /// \\param offset Byte offset into the remote file at which writing should start\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of uploading the file\n+ ///\n+ /// \\see `download`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result upload(\n+ const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions = (std::filesystem::perms::owner_read | std::filesystem::perms::owner_write |\n+ std::filesystem::perms::group_read | std::filesystem::perms::others_read),\n+ bool truncate = true,\n+ bool append = false,\n+ std::uint64_t offset = 0,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ struct Impl;\n+ std::unique_ptr<Impl> m_impl; //!< Implementation\n+};\n+\n+} // namespace sf\n+\n+\n+////////////////////////////////////////////////////////////\n+/// \\class sf::Sftp\n+/// \\ingroup network\n+///\n+/// `sf::Sftp` is a very simple SFTP client that allows you\n+/// to communicate with a SFTP server. The SFTP protocol allows\n+/// you to manipulate a remote file system (list files,\n+/// upload, download, create, remove, ...).\n+///\n+/// Using the SFTP client consists of 4 parts:\n+/// \\li Connecting to the SFTP server\n+/// \\li Logging in (either using username and password or public key authentication)\n+/// \\li Performing file system operations\n+/// \\li Disconnecting (this part can be done implicitly by the destructor)\n+///\n+/// Every operation returns an SFTP result, which contains the\n+/// result code and optionally a message describing the result. Some\n+/// commands such as `getAttributes()` and `getDirectoryListing()`\n+/// return additional data, and use a class derived from\n+/// `sf::Sftp::Result` to provide this data. The commonly used filesystem\n+/// operations are directly provided as member functions.\n+///\n+/// There are three classes of result values: general result values,\n+/// SSH specific result values and SFTP specific result values. General\n+/// result values are returned on success and errors not specific to the\n+/// SSH or SFTP protocols. If an operation manipulating the remote\n+/// filesystem fails, an SFTP specific result will be returned describing\n+/// the reason for the failure. If any error related to the communication\n+/// channel occurs e.g. key exchange failure or authentication failure an\n+/// SSH error will be returned.\n+///\n+/// Because most operations manipulate some part of the remote filesystem\n+/// these operations, especially upload and download, may take some\n+/// time to complete. This is important to know if you don't want\n+/// to block your application while the server is completing\n+/// the task.\n+///\n+/// Every operation that relies on network communication can be passed\n+/// a timeout argument. In the simplest case, this timeout argument can\n+/// just be a fixed time duration after which the operation should time\n+/// out if no progress has been made. Because some operations simply due\n+/// to their nature can take longer than others it might not be possible\n+/// to use the same timeout value for all operations. If it is anticipated\n+/// that an operation could take a longer amount of time to complete due\n+/// to e.g. an unreliable or slow connection, the timeout should be increased\n+/// so the operation still has the possibility to complete successfully.\n+/// Passing `sf::Time::Zero` as a timeout value will cause the operation\n+/// to block until completion or failure.\n+///\n+/// If you want to pass `sf::Time::Zero` to wait indefinitely for an\n+/// operation to complete but still have the possibility to interrupt the\n+/// operation e.g. if the user decides to quit the application or interrupt\n+/// a longer download or upload, the timeout can be constructed from a\n+/// predicate and polling period. The predicate is a callable that takes\n+/// no parameters and returns `true` if the operation should continue or\n+/// `false` if the operation should time out. The time between consecutive\n+/// evaluations of the predicate is specified by the `period` parameter.\n+///\n+/// Example of a `TimeoutWithPredicate`:\n+/// \\code\n+/// bool run = true;\n+/// sf::Sftp::TimeoutWithPredicate timeout([&run]{ return run; }, sf::milliseconds(1));\n+/// \\endcode\n+/// When passed to an operation, the above `TimeoutWithPredicate` object will\n+/// keep the operation running as long as `run` is `true`. The condition\n+/// is checked every 1 millisecond. As soon as `run` is set to `false` the\n+/// operation will terminate with a `Timeout` result.\n+///\n+/// Remember that attempting to modify variables from across threads will\n+/// require proper synchronization using e.g. mutexes or atomics.\n+///\n+/// Because the filesystem operations will be performed on the remote\n+/// system, the paths passed to the operations should be valid paths on\n+/// the remote system. To guarantee portability, generic POSIX paths should\n+/// be used. These use `/` as the path seperator and `.` to refer to the\n+/// current directory and `..` to refer to the parent directory.\n+///\n+/// When logging into the server as a specific user the current directory\n+/// will be set to the home directory that was specified for that user\n+/// account. Because it cannot be assumed that the SFTP user is also allowed\n+/// to log into a shell, changing the current directory from the home\n+/// directory is not always possible and thus not supported. Thus when\n+/// specifying paths, it is preferred to always make use of absolute paths\n+/// when possible. Calling `getWorkingDirectory()` will return the current\n+/// directory as an absolute path. Listing the contents of a directory whose\n+/// path is passed as an absolute path will yield directory listing entries\n+/// whose paths are extentions of the directory's path and thus also absolute\n+/// paths. The `resolvePath()` function can be used to convert relative paths\n+/// or paths containing links into absolute paths without links.\n+///\n+/// Usage example:\n+/// \\code\n+/// // Create a new SFTP client\n+/// sf::Sftp sftp;\n+///\n+/// // Get the address of the server\n+/// const auto addresses = sf::Dns::resolve(\"sftp.myserver.com\");\n+///\n+/// // Check if we have a valid address\n+/// if (!addresses.has_value() || addresses->empty())\n+/// {\n+/// // Handle no valid address...\n+/// }\n+///\n+/// // Connect to the server\n+/// sf::Sftp::Result result = sftp.connect(addresses->front());\n+/// if (result.isOk())\n+/// std::cout << \"Connected\" << std::endl;\n+///\n+/// // Check session information and verify server\n+/// std::optional<sf::Sftp::SessionInfo> info = sftp.getSessionInfo();\n+/// if (info->hostKey.sha256 != expectedSha256)\n+/// {\n+/// std::cout << \"Server untrusted\" << std::endl;\n+/// // Handle untrusted server\n+/// }\n+///\n+/// // Log in\n+/// result = sftp.login(\"sftpuser\", \"dF6Zm89D\");\n+/// if (result.isOk())\n+/// std::cout << \"Logged in\" << std::endl;\n+///\n+/// // Print the working directory\n+/// sf::Sftp::PathResult directory = sftp.getWorkingDirectory();\n+/// if (directory.isOk())\n+/// std::cout << \"Working directory: \" << directory.getPath().string() << std::endl;\n+///\n+/// // Create a new directory\n+/// result = sftp.createDirectory(\"files\");\n+/// if (result.isOk())\n+/// std::cout << \"Created new directory\" << std::endl;\n+///\n+/// // Upload a text file to this new directory\n+/// result = sftp.upload(\"files/newfile.txt\", [](void* data, std::size_t& size)\n+/// {\n+/// // In your own code, ensure size is big enough to store your data\n+/// // We skip the check here for simplicity\n+/// std::memcpy(data, \"Hello World\", 11);\n+/// size = 11;\n+/// return false; // End transfer after this block\n+/// });\n+/// if (response.isOk())\n+/// std::cout << \"File uploaded\" << std::endl;\n+///\n+/// // Rename file\n+/// result = sftp.rename(\"files/newfile.txt\", \"files/newfile2.txt\");\n+/// if (result.isOk())\n+/// std::cout << \"Renamed file\" << std::endl;\n+///\n+/// // Download a text file from this new directory\n+/// std::string text;\n+/// result = sftp.download(\"files/newfile2.txt\", [&text](const void* data, std::size_t size)\n+/// {\n+/// text.append(static_cast<const char*>(data), size);\n+/// return true; // Continue until all data received\n+/// });\n+/// if (response.isOk())\n+/// std::cout << \"File downloaded: \" << text << std::endl;\n+///\n+/// // Delete file\n+/// result = sftp.deleteFile(\"files/newfile2.txt\");\n+/// if (result.isOk())\n+/// std::cout << \"Deleted file\" << std::endl;\n+///\n+/// // Delete directory\n+/// result = sftp.deleteDirectory(\"files\");\n+/// if (result.isOk())\n+/// std::cout << \"Deleted directory\" << std::endl;\n+///\n+/// // Disconnect from the server (optional)\n+/// result = sftp.disconnect();\n+/// if (result.isOk())\n+/// std::cout << \"Disconnected successfully\" << std::endl;\n+/// \\endcode\n+///\n+////////////////////////////////////////////////////////////\n"}],"string":"[\n {\n \"comment\": \"Should we have separate result sets, instead of using prefixes?\",\n \"path\": \"include/SFML/Network/Sftp.hpp\",\n \"hunk\": \"@@ -0,0 +1,998 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+#pragma once\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/Export.hpp>\\n+\\n+#include <SFML/System/Time.hpp>\\n+\\n+#include <array>\\n+#include <filesystem>\\n+#include <functional>\\n+#include <memory>\\n+#include <optional>\\n+#include <string>\\n+#include <vector>\\n+\\n+#include <cstddef>\\n+#include <cstdint>\\n+\\n+\\n+namespace sf\\n+{\\n+class IpAddress;\\n+\\n+////////////////////////////////////////////////////////////\\n+/// \\\\brief An SSH File Transfer Protocol (SFTP) client\\n+///\\n+////////////////////////////////////////////////////////////\\n+class SFML_NETWORK_API Sftp\\n+{\\n+public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief SFTP result\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ class SFML_NETWORK_API Result\\n+ {\\n+ public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Result values\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ enum class Value\\n+ {\\n+ // General result values\\n+ Success, //!< Operation completed successfully\\n+ Disconnected, //!< The TCP socket has been disconnected\\n+ Timeout, //!< Operation timed out\\n+ Refused, //!< Connection refused\\n+ Error, //!< Generic error\\n+\\n+ // SSH result values\\n+ SshErrorBannerReceive, //!< Error during banner receive\\n+ SshErrorBannerSend, //!< Error during banner send\\n+ SshErrorInvalidMac, //!< Invalid message authentication code\\n+ SshErrorAllocation, //!< Allocation failure\\n+ SshErrorSocketSend, //!< Error sending on socket\\n+ SshErrorKeyExchangeFailure, //!< Key exchange failed\\n+ SshErrorHostKeyInitialization, //!< Host key initialization failed\\n+ SshErrorHostKeySign, //!< Host key signing failed\\n+ SshErrorDecrypt, //!< Decryption failed\\n+ SshErrorProtocol, //!< SSH protocol error\\n+ SshErrorPasswordExpired, //!< Password expired\\n+ SshErrorFile, //!< File error\\n+ SshErrorMethodNone, //!< No method found\\n+ SshErrorAuthenticationFailed, //!< Authentication failed\\n+ SshErrorPublicKeyUnverified, //!< Public key unverified\\n+ SshErrorChannelOutOfOrder, //!< Channel out of order\\n+ SshErrorChannelFailure, //!< Channel failure\\n+ SshErrorChannelRequestDenied, //!< Channel request denied\\n+ SshErrorChannelUnknown, //!< Channel unknown\\n+ SshErrorChannelWindowExceeded, //!< Channel window exceeded\\n+ SshErrorChannelPacketExceeded, //!< Channel packet exceeded\\n+ SshErrorChannelClosed, //!< Channel closed\\n+ SshErrorChannelEofSent, //!< Channel EOF sent\\n+ SshErrorScpProtocol, //!< SCP protocol error\\n+ SshErrorZlib, //!< Zlib error\\n+ SshErrorRequestDenied, //!< Request denied\\n+ SshErrorMethodNotSupported, //!< Method not supported\\n+ SshErrorInvalid, //!< Invalid data\\n+ SshErrorPublicKeyProtocol, //!< Public key protocol error\\n+ SshErrorBufferTooSmall, //!< Buffer too small\\n+ SshErrorBadUse, //!< Bad usage\\n+ SshErrorCompress, //!< Compression error\\n+ SshErrorOutOfBoundary, //!< Out of boundary\\n+ SshErrorAgentProtocol, //!< Agent protocol error\\n+ SshErrorSocketRecv, //!< Socket receive error\\n+ SshErrorEncrypt, //!< Encryption failed\\n+ SshErrorBadSocket, //!< Bad socket\\n+ SshErrorKnownHosts, //!< Known hosts error\\n+ SshErrorChannelWindowFull, //!< Channel window full\\n+ SshErrorKeyFileAuthenticationFailed, //!< Key file authentication failed\\n+\\n+ // SFTP result values\\n+ SftpEndOfFile, //!< End of file\\n+ SftpNoSuchFile, //!< No such file\\n+ SftpPermissionDenied, //!< Permission denied\\n+ SftpFailure, //!< Failure\\n+ SftpBadMessage, //!< Bad message\\n+ SftpNoConnection, //!< No connection\\n+ SftpConnectionLost, //!< Connection lost\\n+ SftpOperationUnsupported, //!< Operation unsupported\\n+ SftpInvalidHandle, //!< Invalid handle\\n+ SftpNoSuchPath, //!< No such path\\n+ SftpFileAlreadyExists, //!< File already exists\\n+ SftpWriteProtect, //!< Write protect\\n+ SftpNoMedia, //!< No media\\n+ SftpNoSpaceOnFileSystem, //!< No space on filesystem\\n+ SftpQuotaExceeded, //!< Quota exceeded\\n+ SftpUnknownPrincipal, //!< Unknown principal\\n+ SftpLockConflict, //!< Lock conflict\\n+ SftpDirectoryNotEmpty, //!< Directory not empty\\n+ SftpNotADirectory, //!< Not a directory\\n+ SftpInvalidFilename, //!< Invalid filename\\n+ SftpLinkLoop, //!< Link loop\\n+ SftpError //!< Generic SFTP error\\n+ };\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/include/SFML/Network/Sftp.hpp b/include/SFML/Network/Sftp.hpp\\nnew file mode 100644\\nindex 0000000000..9be101d562\\n--- /dev/null\\n+++ b/include/SFML/Network/Sftp.hpp\\n@@ -0,0 +1,987 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+#pragma once\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/Export.hpp>\\n+\\n+#include <SFML/System/TimeoutWithPredicate.hpp>\\n+\\n+#include <array>\\n+#include <filesystem>\\n+#include <memory>\\n+#include <optional>\\n+#include <string>\\n+#include <string_view>\\n+#include <vector>\\n+\\n+#include <cstddef>\\n+#include <cstdint>\\n+\\n+\\n+namespace sf\\n+{\\n+class IpAddress;\\n+\\n+////////////////////////////////////////////////////////////\\n+/// \\\\brief An SSH File Transfer Protocol (SFTP) client\\n+///\\n+////////////////////////////////////////////////////////////\\n+class SFML_NETWORK_API Sftp\\n+{\\n+public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief SFTP result\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ class SFML_NETWORK_API Result\\n+ {\\n+ public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Result values\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ enum class Value\\n+ {\\n+ // General result values\\n+ Success, //!< Operation completed successfully\\n+ Disconnected, //!< The TCP socket has been disconnected\\n+ Timeout, //!< Operation timed out\\n+ Refused, //!< Connection refused\\n+ Error, //!< Generic error\\n+\\n+ // SSH result values\\n+ BannerReceive, //!< Error during banner receive\\n+ BannerSend, //!< Error during banner send\\n+ InvalidMac, //!< Invalid message authentication code\\n+ AllocationFailure, //!< Allocation failure\\n+ SocketSend, //!< Error sending on socket\\n+ KeyExchangeFailure, //!< Key exchange failed\\n+ HostKeyInitialization, //!< Host key initialization failed\\n+ HostKeySign, //!< Host key signing failed\\n+ DecryptError, //!< Decryption failed\\n+ ProtocolError, //!< SSH protocol error\\n+ PasswordExpired, //!< Password expired\\n+ FileError, //!< File error\\n+ MethodNone, //!< No method found\\n+ AuthenticationFailed, //!< Authentication failed\\n+ PublicKeyUnverified, //!< Public key unverified\\n+ ChannelOutOfOrder, //!< Channel out of order\\n+ ChannelFailure, //!< Channel failure\\n+ ChannelRequestDenied, //!< Channel request denied\\n+ ChannelUnknown, //!< Channel unknown\\n+ ChannelWindowExceeded, //!< Channel window exceeded\\n+ ChannelPacketExceeded, //!< Channel packet exceeded\\n+ ChannelClosed, //!< Channel closed\\n+ ChannelEofSent, //!< Channel EOF sent\\n+ ScpProtocol, //!< SCP protocol error\\n+ ZlibError, //!< Zlib error\\n+ RequestDenied, //!< Request denied\\n+ MethodNotSupported, //!< Method not supported\\n+ InvalidData, //!< Invalid data\\n+ PublicKeyProtocol, //!< Public key protocol error\\n+ BufferTooSmall, //!< Buffer too small\\n+ BadUse, //!< Bad usage\\n+ CompressError, //!< Compression error\\n+ OutOfBoundary, //!< Out of boundary\\n+ AgentProtocol, //!< Agent protocol error\\n+ SocketRecv, //!< Socket receive error\\n+ EncryptError, //!< Encryption failed\\n+ BadSocket, //!< Bad socket\\n+ KnownHosts, //!< Known hosts error\\n+ ChannelWindowFull, //!< Channel window full\\n+ KeyFileAuthenticationFailed, //!< Key file authentication failed\\n+\\n+ // SFTP result values\\n+ EndOfFile, //!< End of file\\n+ NoSuchFile, //!< No such file\\n+ PermissionDenied, //!< Permission denied\\n+ Failure, //!< Failure\\n+ BadMessage, //!< Bad message\\n+ NoConnection, //!< No connection\\n+ ConnectionLost, //!< Connection lost\\n+ OperationUnsupported, //!< Operation unsupported\\n+ InvalidHandle, //!< Invalid handle\\n+ NoSuchPath, //!< No such path\\n+ FileAlreadyExists, //!< File already exists\\n+ WriteProtect, //!< Write protect\\n+ NoMedia, //!< No media\\n+ NoSpaceOnFileSystem, //!< No space on filesystem\\n+ QuotaExceeded, //!< Quota exceeded\\n+ UnknownPrincipal, //!< Unknown principal\\n+ LockConflict, //!< Lock conflict\\n+ DirectoryNotEmpty, //!< Directory not empty\\n+ NotADirectory, //!< Not a directory\\n+ InvalidFilename, //!< Invalid filename\\n+ LinkLoop, //!< Link loop\\n+ SftpError //!< Generic SFTP error\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Constructor\\n+ ///\\n+ /// This constructor is used by the SFTP client to build\\n+ /// the result.\\n+ ///\\n+ /// \\\\param value Result value\\n+ /// \\\\param message Result message\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ explicit Result(Value value, std::string message = \\\"\\\");\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Check if the result is a success\\n+ ///\\n+ /// This function is defined for convenience, it is\\n+ /// equivalent to testing if the result value is `Value::Success`.\\n+ ///\\n+ /// \\\\return `true` if the result is `Value::Success`, `false` if it is not `Value::Success`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] bool isOk() const;\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the result value\\n+ ///\\n+ /// \\\\return The result value\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Value getValue() const;\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the result message\\n+ ///\\n+ /// \\\\return The result message\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] const std::string& getMessage() const;\\n+\\n+ private:\\n+ ////////////////////////////////////////////////////////////\\n+ // Member data\\n+ ////////////////////////////////////////////////////////////\\n+ Value m_value; //!< The contained value\\n+ std::string m_message; //!< The contained message\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Result of an operation returning a path\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ class SFML_NETWORK_API PathResult : public Result\\n+ {\\n+ public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Constructor\\n+ ///\\n+ /// \\\\param result Result\\n+ /// \\\\param path Path\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ PathResult(const Result& result, std::filesystem::path path);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the path\\n+ ///\\n+ /// \\\\return The path\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] const std::filesystem::path& getPath() const;\\n+\\n+ private:\\n+ ////////////////////////////////////////////////////////////\\n+ // Member data\\n+ ////////////////////////////////////////////////////////////\\n+ std::filesystem::path m_path; //!< The contained path\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief File or directory attributes\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ struct Attributes\\n+ {\\n+ std::filesystem::path path; //!< Path to the entry\\n+ std::optional<std::filesystem::file_type> type; //!< Type of the entry\\n+ std::optional<std::uint64_t> size; //!< Size of the entry\\n+ std::optional<std::filesystem::perms> permissions; //!< Permissions\\n+ std::optional<std::uint64_t> userId; //!< Owner user ID\\n+ std::optional<std::uint64_t> groupId; //!< Group ID\\n+ std::optional<std::filesystem::file_time_type> accessTime; //!< Last access time\\n+ std::optional<std::filesystem::file_time_type> modificationTime; //!< Last modification time\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Result of an operation returning attributes\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ class SFML_NETWORK_API AttributesResult : public Result\\n+ {\\n+ public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Constructor\\n+ ///\\n+ /// \\\\param result Result\\n+ /// \\\\param attributes Attributes\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ AttributesResult(const Result& result, Attributes attributes);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the attributes\\n+ ///\\n+ /// \\\\return The attributes\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] const Attributes& getAttributes() const;\\n+\\n+ private:\\n+ ////////////////////////////////////////////////////////////\\n+ // Member data\\n+ ////////////////////////////////////////////////////////////\\n+ Attributes m_attributes; //!< The contained attributes\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Result of an operation returning a directory listing\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ class SFML_NETWORK_API ListingResult : public Result\\n+ {\\n+ public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Constructor\\n+ ///\\n+ /// \\\\param result Result\\n+ /// \\\\param listing Directory listing\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ ListingResult(const Result& result, std::vector<Attributes> listing);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the directory listing\\n+ ///\\n+ /// \\\\return The directory listing\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] const std::vector<Attributes>& getListing() const;\\n+\\n+ private:\\n+ ////////////////////////////////////////////////////////////\\n+ // Member data\\n+ ////////////////////////////////////////////////////////////\\n+ std::vector<Attributes> m_listing; //!< The contained directory listing\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Structure containing information about an active SFTP session\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ struct SessionInfo\\n+ {\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Host key used to identify a host\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ struct HostKey\\n+ {\\n+ enum class Type\\n+ {\\n+ Unknown, //!< Unknown key type\\n+ Rsa, //!< RSA\\n+ Dsa, //!< DSA\\n+ Ecdsa256, //!< NIST P-256 ECDSA\\n+ Ecdsa384, //!< NIST P-384 ECDSA\\n+ Ecdsa521, //!< NIST P-521 ECDSA\\n+ Ed25519 //!< ED25519\\n+ };\\n+\\n+ Type type = Type::Unknown; //!< Host key type\\n+ std::vector<std::byte> data; //!< Host key data\\n+ std::array<std::byte, 20> sha1{}; //!< Host key SHA1 hash\\n+ std::array<std::byte, 32> sha256{}; //!< Host key SHA256 hash\\n+ };\\n+\\n+ HostKey hostKey; //!< Host key\\n+ std::string keyExchangeAlgorithm; //!< Key exchange algorithm used in the session (RFC 4253)\\n+ std::string hostKeyAlgorithm; //!< Host key algorithm used in the session (RFC 4253)\\n+ std::string clientToServerEncryptionAlgorithm; //!< Client to server encryption algorithm used in the session (RFC 4253)\\n+ std::string serverToClientEncryptionAlgorithm; //!< Server to client encryption algorithm used in the session (RFC 4253)\\n+ std::string clientToServerMacAlgorithm; //!< Client to server message authentication code algorithm used in the session (RFC 4253)\\n+ std::string serverToClientMacAlgorithm; //!< Server to client message authentication code algorithm used in the session (RFC 4253)\\n+ std::string clientToServerCompressionAlgorithm; //!< Client to server compression algorithm used in the session (RFC 4253)\\n+ std::string serverToClientCompressionAlgorithm; //!< Server to client compression algorithm used in the session (RFC 4253)\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Default constructor\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ Sftp();\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Destructor\\n+ ///\\n+ /// Automatically closes the connection with the server if\\n+ /// it is still opened.\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ ~Sftp();\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Deleted copy constructor\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ Sftp(const Sftp&) = delete;\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Deleted copy assignment\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ Sftp& operator=(const Sftp&) = delete;\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Connect to the specified SFTP server\\n+ ///\\n+ /// The port has a default value of 22, which is the standard\\n+ /// port used by the SFTP protocol.\\n+ /// This function tries to connect to the server so it may take\\n+ /// a while to complete, especially if the server is not\\n+ /// reachable. To avoid blocking your application for too long,\\n+ /// you can use a timeout. The default value, `Time::Zero`, means that the\\n+ /// system timeout will be used (which is usually pretty long).\\n+ ///\\n+ /// \\\\param server Name or address of the SFTP server to connect to\\n+ /// \\\\param port Port used for the connection\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of the connection attempt\\n+ ///\\n+ /// \\\\see `disconnect`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result connect(IpAddress server, unsigned short port = 22, const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Disconnect the connection with the server\\n+ ///\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of disconnecting the connection with the server\\n+ ///\\n+ /// \\\\see `connect`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result disconnect(const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get SSH session information\\n+ ///\\n+ /// After connecting to the server and before actually\\n+ /// logging in the SSH session information of the underlying\\n+ /// connection will be available.\\n+ ///\\n+ /// The session information contains among other things the\\n+ /// public key identifying the remote host and the connection\\n+ /// parameters such as encryption and compression used. The\\n+ /// identifiers used follow the RFC 4253 specification.\\n+ ///\\n+ /// If the session information is not available `std::nullopt`\\n+ /// will be returned.\\n+ ///\\n+ /// Because SSH was developed as a parallel standard to\\n+ /// SSL/TLS and automatic host certificate verification wasn't\\n+ /// widespread at the time, relying on the user to check the\\n+ /// authenticity of the host key was the typical method used\\n+ /// to verify that they were connecting to the legitimate host,\\n+ /// assuming the private key of the remote host was not\\n+ /// compromised.\\n+ ///\\n+ /// If connection security is a high priority, examining\\n+ /// the parameters and aborting the connection if any weak\\n+ /// algorithms are used is also possible.\\n+ ///\\n+ /// \\\\return SSH session information or `std::nullopt` if it is not available\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] std::optional<SessionInfo> getSessionInfo() const;\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Log in using a username and a password\\n+ ///\\n+ /// Logging in is mandatory after connecting to the server.\\n+ /// Users that are not logged in cannot perform any operation.\\n+ ///\\n+ /// \\\\param name User name\\n+ /// \\\\param password Password\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of attempting to log in to the server\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result login(std::string_view name,\\n+ std::string_view password,\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Log in using a public/private key pair\\n+ ///\\n+ /// Logging in is mandatory after connecting to the server.\\n+ /// Users that are not logged in cannot perform any operation.\\n+ ///\\n+ /// This overload allows logging into the SFTP server using\\n+ /// public key authentication.\\n+ ///\\n+ /// The public and private key data should be provided in PEM\\n+ /// format. PEM encoded data can be easily recognized by their\\n+ /// `-----BEGIN ............-----` header and\\n+ /// `-----END ............-----` footer.\\n+ ///\\n+ /// Even though it is technically possible to derive the\\n+ /// public key from the private key, due to backend\\n+ /// limitations, providing a pre-generated public key as well\\n+ /// is necessary for this function to be able to succeed.\\n+ ///\\n+ /// If the private key is protected by a passphrase the\\n+ /// passphrase can be provided as a NULL terminated string.\\n+ /// If the private key is not protected by a passphrase the\\n+ /// passphrase should be set to the empty string.\\n+ ///\\n+ /// \\\\param name User name\\n+ /// \\\\param publicKeyData Public key data\\n+ /// \\\\param publicKeyLength Public key data length\\n+ /// \\\\param privateKeyData Private key data\\n+ /// \\\\param privateKeyLength Private key data length\\n+ /// \\\\param privateKeyPassphrase Private key passphrase, NULL terminated\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of attempting to log in to the server\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase = \\\"\\\",\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Log in using a public/private key pair\\n+ ///\\n+ /// Logging in is mandatory after connecting to the server.\\n+ /// Users that are not logged in cannot perform any operation.\\n+ ///\\n+ /// This overload allows logging into the SFTP server using\\n+ /// public key authentication.\\n+ ///\\n+ /// The public and private key data should be provided in PEM\\n+ /// format. PEM encoded data can be easily recognized by their\\n+ /// `-----BEGIN ............-----` header and\\n+ /// `-----END ............-----` footer.\\n+ ///\\n+ /// Even though it is technically possible to derive the\\n+ /// public key from the private key, due to backend\\n+ /// limitations, providing a pre-generated public key as well\\n+ /// is necessary for this function to be able to succeed.\\n+ ///\\n+ /// If the private key is protected by a passphrase the\\n+ /// passphrase can be provided as a NULL terminated string.\\n+ /// If the private key is not protected by a passphrase the\\n+ /// passphrase should be set to the empty string.\\n+ ///\\n+ /// \\\\param name User name\\n+ /// \\\\param publicKeyData Public key data\\n+ /// \\\\param privateKeyData Private key data\\n+ /// \\\\param privateKeyPassphrase Private key passphrase\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of attempting to log in to the server\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase = {},\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Resolve a remote path into an absolute remote path\\n+ ///\\n+ /// Paths can contain links and other reserved path identifiers\\n+ /// such as . and .. referring to the current directory and\\n+ /// parent directory respectively.\\n+ ///\\n+ /// When determining the absolute path, which does not contain\\n+ /// links or . or .. is necessary, this function can be used.\\n+ ///\\n+ /// Resolving \\\".\\\" will return the absolute path to the current\\n+ /// working directory of the user after logging in to the SFTP\\n+ /// server.\\n+ ///\\n+ /// \\\\param path Path to convert into an absolute path\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of converting the path into an absolute path\\n+ ///\\n+ /// \\\\see `getWorkingDirectory`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] PathResult resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the current working directory on the server\\n+ ///\\n+ /// This is an alias for calling `resolvePath(\\\".\\\")`.\\n+ ///\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of getting the current working directory\\n+ ///\\n+ /// \\\\see `resolvePath`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] PathResult getWorkingDirectory(const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the attributes of a remote file or directory\\n+ ///\\n+ /// Depending on whether `path` refers to a file or directory,\\n+ /// the attributes can contain e.g. the type of file, the file\\n+ /// owner, group, file size, modification and access times.\\n+ ///\\n+ /// If links are not to be followed, `followLinks` can be set\\n+ /// to `false`. In this case the attributes of the link itself\\n+ /// will be returned.\\n+ ///\\n+ /// \\\\param path Path to the remote file or directory whose attributes to get\\n+ /// \\\\param followLinks `true` to follow links, `false` to return attributes of the link itself\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of getting the attributes\\n+ ///\\n+ /// \\\\see `getDirectoryListing`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] AttributesResult getAttributes(const std::filesystem::path& path,\\n+ bool followLinks = true,\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the contents of the given directory\\n+ ///\\n+ /// This function retrieves the sub-directories and files\\n+ /// contained in the given directory. It is not recursive.\\n+ ///\\n+ /// \\\\param path Path of the directory whose contents to list\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of getting the contents of the given directory\\n+ ///\\n+ /// \\\\see `getAttributes`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] ListingResult getDirectoryListing(const std::filesystem::path& path,\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Create a new directory\\n+ ///\\n+ /// The new directory is created as a child of the current\\n+ /// working directory.\\n+ ///\\n+ /// The default permissions value is equivalent to `rwxr-xr-x`\\n+ /// or 0755 in octal notation.\\n+ ///\\n+ /// \\\\param path Path of the directory to create\\n+ /// \\\\param permissions Permissions of the directory to create\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of creating the directory\\n+ ///\\n+ /// \\\\see `deleteDirectory`, `rename`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result createDirectory(\\n+ const std::filesystem::path& path,\\n+ std::filesystem::perms permissions = (std::filesystem::perms::owner_all | std::filesystem::perms::group_read |\\n+ std::filesystem::perms::group_exec | std::filesystem::perms::others_read |\\n+ std::filesystem::perms::others_exec),\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Remove an existing directory\\n+ ///\\n+ /// Use this function with caution, the directory will\\n+ /// be removed permanently!\\n+ ///\\n+ /// \\\\param path Path of the directory to remove\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of removing the directory\\n+ ///\\n+ /// \\\\see `createDirectory`, `rename`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Rename an existing file or directory\\n+ ///\\n+ /// In POSIX renaming and moving and synonymous. If you want\\n+ /// to move a file or directory from one place to another\\n+ /// you rename it from an old to a new path.\\n+ ///\\n+ /// If a file exists at the specified new path, depending\\n+ /// on whether `ovewrite` is set to true, the rename operation\\n+ /// will overwrite it or not. If a directory is being moved,\\n+ /// the new path must either not point to non-existant\\n+ /// directory or a directory that is empty. Non-empty\\n+ /// directories cannot be overwritten by this operation.\\n+ ///\\n+ /// \\\\param oldPath Old path to the file or directory\\n+ /// \\\\param newPath New path to the file or directory\\n+ /// \\\\param overwrite Set to `true` to allow overwriting a file that exists at `newPath`\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of the operation\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite = false,\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Remove an existing file\\n+ ///\\n+ /// Use this function with caution, the file will be\\n+ /// removed permanently!\\n+ ///\\n+ /// \\\\param path Path to the file to remove\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of removing the file\\n+ ///\\n+ /// \\\\see `rename`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Download a file from the server\\n+ ///\\n+ /// This function retrieves the data in the file at the\\n+ /// remote path.\\n+ ///\\n+ /// The file data is transferred in sequential blocks. For\\n+ /// every block of data transferred, the provided callback\\n+ /// is called. The callback is passed a pointer to a data\\n+ /// block and the size of the data contained in the current\\n+ /// block. This size can change over time so it is important\\n+ /// to always check the size value to know how much data is\\n+ /// actually available. The callback should return `true` to\\n+ /// indicate to the `download` function that it should\\n+ /// continue to transfer data. If the data transfer should\\n+ /// be aborted earlier, `false` can be returned from the\\n+ /// callback.\\n+ ///\\n+ /// The function returns once all the data in the remote file\\n+ /// has been transferred or an error occurs or the function\\n+ /// times out.\\n+ ///\\n+ /// If reading from the remote file should not start at the\\n+ /// beginning of the file, you can specify an offset in\\n+ /// bytes at which reading should start.\\n+ ///\\n+ /// \\\\param remotePath Path of the remote file whose data to download\\n+ /// \\\\param callback Callback to be called for every available data block\\n+ /// \\\\param offset Byte offset into the remote file at which reading should start\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of downloading the file\\n+ ///\\n+ /// \\\\see `upload`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset = 0,\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Upload a file to the server\\n+ ///\\n+ /// This function writes data into a file at the remote path.\\n+ ///\\n+ /// The file data is transferred in sequential blocks. Every\\n+ /// time the function wants to send a new block of data the\\n+ /// provided callback is called. The callback is passed a\\n+ /// pointer to a data block and a reference to the size of\\n+ /// the data block. Data to be sent should be copied into\\n+ /// the data block using e.g. `std::memcpy` and the size value\\n+ /// set to the actual number of bytes copied into the data\\n+ /// block. The size of the block can change over time so it\\n+ /// is important to check the size value that is passed to\\n+ /// the callback to know how many bytes can actually be\\n+ /// copied into the data block. The callback should return\\n+ /// `true` to indicate to the `upload` function that it\\n+ /// should continue to transfer data. Once the data transfer\\n+ /// should be stopped e.g. because there is no more data left\\n+ /// to send, `false` can be returned from the callback.\\n+ ///\\n+ /// The function returns once all the data has been sent or\\n+ /// an error occurs or the function times out.\\n+ ///\\n+ /// If a file does not exist at the remote path yet, it will\\n+ /// be created with the provided permissions.\\n+ ///\\n+ /// If a file already exists at the remote path, setting\\n+ /// `truncate` to `true` will truncate the existing file\\n+ /// i.e. delete all pre-existing data before starting to\\n+ /// write the new data into the file.\\n+ ///\\n+ /// Setting `append` to `true` will append to a file if\\n+ /// it already exists.\\n+ ///\\n+ /// If writing to the remote file should not start at the\\n+ /// beginning of the file, you can specify an offset in\\n+ /// bytes at which writing should start.\\n+ ///\\n+ /// The default permissions value is equivalent to `rw-r--r--`\\n+ /// or 0644 in octal notation.\\n+ ///\\n+ /// \\\\param remotePath Path of the remote file in which to upload the data\\n+ /// \\\\param callback Callback to be called for every available data block\\n+ /// \\\\param permissions Permissions of the remote file if it has to be created\\n+ /// \\\\param truncate Set to `true` to truncate the remote file if it already exists\\n+ /// \\\\param append Set to `true` to append to the remote file if it already exists\\n+ /// \\\\param offset Byte offset into the remote file at which writing should start\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of uploading the file\\n+ ///\\n+ /// \\\\see `download`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result upload(\\n+ const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions = (std::filesystem::perms::owner_read | std::filesystem::perms::owner_write |\\n+ std::filesystem::perms::group_read | std::filesystem::perms::others_read),\\n+ bool truncate = true,\\n+ bool append = false,\\n+ std::uint64_t offset = 0,\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+private:\\n+ ////////////////////////////////////////////////////////////\\n+ // Member data\\n+ ////////////////////////////////////////////////////////////\\n+ struct Impl;\\n+ std::unique_ptr<Impl> m_impl; //!< Implementation\\n+};\\n+\\n+} // namespace sf\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+/// \\\\class sf::Sftp\\n+/// \\\\ingroup network\\n+///\\n+/// `sf::Sftp` is a very simple SFTP client that allows you\\n+/// to communicate with a SFTP server. The SFTP protocol allows\\n+/// you to manipulate a remote file system (list files,\\n+/// upload, download, create, remove, ...).\\n+///\\n+/// Using the SFTP client consists of 4 parts:\\n+/// \\\\li Connecting to the SFTP server\\n+/// \\\\li Logging in (either using username and password or public key authentication)\\n+/// \\\\li Performing file system operations\\n+/// \\\\li Disconnecting (this part can be done implicitly by the destructor)\\n+///\\n+/// Every operation returns an SFTP result, which contains the\\n+/// result code and optionally a message describing the result. Some\\n+/// commands such as `getAttributes()` and `getDirectoryListing()`\\n+/// return additional data, and use a class derived from\\n+/// `sf::Sftp::Result` to provide this data. The commonly used filesystem\\n+/// operations are directly provided as member functions.\\n+///\\n+/// There are three classes of result values: general result values,\\n+/// SSH specific result values and SFTP specific result values. General\\n+/// result values are returned on success and errors not specific to the\\n+/// SSH or SFTP protocols. If an operation manipulating the remote\\n+/// filesystem fails, an SFTP specific result will be returned describing\\n+/// the reason for the failure. If any error related to the communication\\n+/// channel occurs e.g. key exchange failure or authentication failure an\\n+/// SSH error will be returned.\\n+///\\n+/// Because most operations manipulate some part of the remote filesystem\\n+/// these operations, especially upload and download, may take some\\n+/// time to complete. This is important to know if you don't want\\n+/// to block your application while the server is completing\\n+/// the task.\\n+///\\n+/// Every operation that relies on network communication can be passed\\n+/// a timeout argument. In the simplest case, this timeout argument can\\n+/// just be a fixed time duration after which the operation should time\\n+/// out if no progress has been made. Because some operations simply due\\n+/// to their nature can take longer than others it might not be possible\\n+/// to use the same timeout value for all operations. If it is anticipated\\n+/// that an operation could take a longer amount of time to complete due\\n+/// to e.g. an unreliable or slow connection, the timeout should be increased\\n+/// so the operation still has the possibility to complete successfully.\\n+/// Passing `sf::Time::Zero` as a timeout value will cause the operation\\n+/// to block until completion or failure.\\n+///\\n+/// If you want to pass `sf::Time::Zero` to wait indefinitely for an\\n+/// operation to complete but still have the possibility to interrupt the\\n+/// operation e.g. if the user decides to quit the application or interrupt\\n+/// a longer download or upload, the timeout can be constructed from a\\n+/// predicate and polling period. The predicate is a callable that takes\\n+/// no parameters and returns `true` if the operation should continue or\\n+/// `false` if the operation should time out. The time between consecutive\\n+/// evaluations of the predicate is specified by the `period` parameter.\\n+///\\n+/// Example of a `TimeoutWithPredicate`:\\n+/// \\\\code\\n+/// bool run = true;\\n+/// sf::Sftp::TimeoutWithPredicate timeout([&run]{ return run; }, sf::milliseconds(1));\\n+/// \\\\endcode\\n+/// When passed to an operation, the above `TimeoutWithPredicate` object will\\n+/// keep the operation running as long as `run` is `true`. The condition\\n+/// is checked every 1 millisecond. As soon as `run` is set to `false` the\\n+/// operation will terminate with a `Timeout` result.\\n+///\\n+/// Remember that attempting to modify variables from across threads will\\n+/// require proper synchronization using e.g. mutexes or atomics.\\n+///\\n+/// Because the filesystem operations will be performed on the remote\\n+/// system, the paths passed to the operations should be valid paths on\\n+/// the remote system. To guarantee portability, generic POSIX paths should\\n+/// be used. These use `/` as the path seperator and `.` to refer to the\\n+/// current directory and `..` to refer to the parent directory.\\n+///\\n+/// When logging into the server as a specific user the current directory\\n+/// will be set to the home directory that was specified for that user\\n+/// account. Because it cannot be assumed that the SFTP user is also allowed\\n+/// to log into a shell, changing the current directory from the home\\n+/// directory is not always possible and thus not supported. Thus when\\n+/// specifying paths, it is preferred to always make use of absolute paths\\n+/// when possible. Calling `getWorkingDirectory()` will return the current\\n+/// directory as an absolute path. Listing the contents of a directory whose\\n+/// path is passed as an absolute path will yield directory listing entries\\n+/// whose paths are extentions of the directory's path and thus also absolute\\n+/// paths. The `resolvePath()` function can be used to convert relative paths\\n+/// or paths containing links into absolute paths without links.\\n+///\\n+/// Usage example:\\n+/// \\\\code\\n+/// // Create a new SFTP client\\n+/// sf::Sftp sftp;\\n+///\\n+/// // Get the address of the server\\n+/// const auto addresses = sf::Dns::resolve(\\\"sftp.myserver.com\\\");\\n+///\\n+/// // Check if we have a valid address\\n+/// if (!addresses.has_value() || addresses->empty())\\n+/// {\\n+/// // Handle no valid address...\\n+/// }\\n+///\\n+/// // Connect to the server\\n+/// sf::Sftp::Result result = sftp.connect(addresses->front());\\n+/// if (result.isOk())\\n+/// std::cout << \\\"Connected\\\" << std::endl;\\n+///\\n+/// // Check session information and verify server\\n+/// std::optional<sf::Sftp::SessionInfo> info = sftp.getSessionInfo();\\n+/// if (info->hostKey.sha256 != expectedSha256)\\n+/// {\\n+/// std::cout << \\\"Server untrusted\\\" << std::endl;\\n+/// // Handle untrusted server\\n+/// }\\n+///\\n+/// // Log in\\n+/// result = sftp.login(\\\"sftpuser\\\", \\\"dF6Zm89D\\\");\\n+/// if (result.isOk())\\n+/// std::cout << \\\"Logged in\\\" << std::endl;\\n+///\\n+/// // Print the working directory\\n+/// sf::Sftp::PathResult directory = sftp.getWorkingDirectory();\\n+/// if (directory.isOk())\\n+/// std::cout << \\\"Working directory: \\\" << directory.getPath().string() << std::endl;\\n+///\\n+/// // Create a new directory\\n+/// result = sftp.createDirectory(\\\"files\\\");\\n+/// if (result.isOk())\\n+/// std::cout << \\\"Created new directory\\\" << std::endl;\\n+///\\n+/// // Upload a text file to this new directory\\n+/// result = sftp.upload(\\\"files/newfile.txt\\\", [](void* data, std::size_t& size)\\n+/// {\\n+/// // In your own code, ensure size is big enough to store your data\\n+/// // We skip the check here for simplicity\\n+/// std::memcpy(data, \\\"Hello World\\\", 11);\\n+/// size = 11;\\n+/// return false; // End transfer after this block\\n+/// });\\n+/// if (response.isOk())\\n+/// std::cout << \\\"File uploaded\\\" << std::endl;\\n+///\\n+/// // Rename file\\n+/// result = sftp.rename(\\\"files/newfile.txt\\\", \\\"files/newfile2.txt\\\");\\n+/// if (result.isOk())\\n+/// std::cout << \\\"Renamed file\\\" << std::endl;\\n+///\\n+/// // Download a text file from this new directory\\n+/// std::string text;\\n+/// result = sftp.download(\\\"files/newfile2.txt\\\", [&text](const void* data, std::size_t size)\\n+/// {\\n+/// text.append(static_cast<const char*>(data), size);\\n+/// return true; // Continue until all data received\\n+/// });\\n+/// if (response.isOk())\\n+/// std::cout << \\\"File downloaded: \\\" << text << std::endl;\\n+///\\n+/// // Delete file\\n+/// result = sftp.deleteFile(\\\"files/newfile2.txt\\\");\\n+/// if (result.isOk())\\n+/// std::cout << \\\"Deleted file\\\" << std::endl;\\n+///\\n+/// // Delete directory\\n+/// result = sftp.deleteDirectory(\\\"files\\\");\\n+/// if (result.isOk())\\n+/// std::cout << \\\"Deleted directory\\\" << std::endl;\\n+///\\n+/// // Disconnect from the server (optional)\\n+/// result = sftp.disconnect();\\n+/// if (result.isOk())\\n+/// std::cout << \\\"Disconnected successfully\\\" << std::endl;\\n+/// \\\\endcode\\n+///\\n+////////////////////////////////////////////////////////////\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}},{"rowIdx":10099,"cells":{"repo":{"kind":"string","value":"SFML/SFML"},"pr_number":{"kind":"number","value":3675,"string":"3,675"},"task_type":{"kind":"string","value":"comment_to_fix"},"issue_text":{"kind":"string","value":""},"pr_title":{"kind":"string","value":"Added support for SFTP as a replacement for FTP"},"pr_body":{"kind":"string","value":"Should we have default values? What's the use case of constructing an \"empty\" Result set?"},"base_sha":{"kind":"string","value":"ae01ab9e7137da4dce9feb4b0db52e30910499e9"},"head_sha":{"kind":"string","value":"c33977a7e4e78d6d368598e1a6063aea606abd66"},"gold_diff":{"kind":"string","value":"diff --git a/include/SFML/Network/Sftp.hpp b/include/SFML/Network/Sftp.hpp\nnew file mode 100644\nindex 0000000000..9be101d562\n--- /dev/null\n+++ b/include/SFML/Network/Sftp.hpp\n@@ -0,0 +1,987 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+#pragma once\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/Export.hpp>\n+\n+#include <SFML/System/TimeoutWithPredicate.hpp>\n+\n+#include <array>\n+#include <filesystem>\n+#include <memory>\n+#include <optional>\n+#include <string>\n+#include <string_view>\n+#include <vector>\n+\n+#include <cstddef>\n+#include <cstdint>\n+\n+\n+namespace sf\n+{\n+class IpAddress;\n+\n+////////////////////////////////////////////////////////////\n+/// \\brief An SSH File Transfer Protocol (SFTP) client\n+///\n+////////////////////////////////////////////////////////////\n+class SFML_NETWORK_API Sftp\n+{\n+public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief SFTP result\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result values\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ enum class Value\n+ {\n+ // General result values\n+ Success, //!< Operation completed successfully\n+ Disconnected, //!< The TCP socket has been disconnected\n+ Timeout, //!< Operation timed out\n+ Refused, //!< Connection refused\n+ Error, //!< Generic error\n+\n+ // SSH result values\n+ BannerReceive, //!< Error during banner receive\n+ BannerSend, //!< Error during banner send\n+ InvalidMac, //!< Invalid message authentication code\n+ AllocationFailure, //!< Allocation failure\n+ SocketSend, //!< Error sending on socket\n+ KeyExchangeFailure, //!< Key exchange failed\n+ HostKeyInitialization, //!< Host key initialization failed\n+ HostKeySign, //!< Host key signing failed\n+ DecryptError, //!< Decryption failed\n+ ProtocolError, //!< SSH protocol error\n+ PasswordExpired, //!< Password expired\n+ FileError, //!< File error\n+ MethodNone, //!< No method found\n+ AuthenticationFailed, //!< Authentication failed\n+ PublicKeyUnverified, //!< Public key unverified\n+ ChannelOutOfOrder, //!< Channel out of order\n+ ChannelFailure, //!< Channel failure\n+ ChannelRequestDenied, //!< Channel request denied\n+ ChannelUnknown, //!< Channel unknown\n+ ChannelWindowExceeded, //!< Channel window exceeded\n+ ChannelPacketExceeded, //!< Channel packet exceeded\n+ ChannelClosed, //!< Channel closed\n+ ChannelEofSent, //!< Channel EOF sent\n+ ScpProtocol, //!< SCP protocol error\n+ ZlibError, //!< Zlib error\n+ RequestDenied, //!< Request denied\n+ MethodNotSupported, //!< Method not supported\n+ InvalidData, //!< Invalid data\n+ PublicKeyProtocol, //!< Public key protocol error\n+ BufferTooSmall, //!< Buffer too small\n+ BadUse, //!< Bad usage\n+ CompressError, //!< Compression error\n+ OutOfBoundary, //!< Out of boundary\n+ AgentProtocol, //!< Agent protocol error\n+ SocketRecv, //!< Socket receive error\n+ EncryptError, //!< Encryption failed\n+ BadSocket, //!< Bad socket\n+ KnownHosts, //!< Known hosts error\n+ ChannelWindowFull, //!< Channel window full\n+ KeyFileAuthenticationFailed, //!< Key file authentication failed\n+\n+ // SFTP result values\n+ EndOfFile, //!< End of file\n+ NoSuchFile, //!< No such file\n+ PermissionDenied, //!< Permission denied\n+ Failure, //!< Failure\n+ BadMessage, //!< Bad message\n+ NoConnection, //!< No connection\n+ ConnectionLost, //!< Connection lost\n+ OperationUnsupported, //!< Operation unsupported\n+ InvalidHandle, //!< Invalid handle\n+ NoSuchPath, //!< No such path\n+ FileAlreadyExists, //!< File already exists\n+ WriteProtect, //!< Write protect\n+ NoMedia, //!< No media\n+ NoSpaceOnFileSystem, //!< No space on filesystem\n+ QuotaExceeded, //!< Quota exceeded\n+ UnknownPrincipal, //!< Unknown principal\n+ LockConflict, //!< Lock conflict\n+ DirectoryNotEmpty, //!< Directory not empty\n+ NotADirectory, //!< Not a directory\n+ InvalidFilename, //!< Invalid filename\n+ LinkLoop, //!< Link loop\n+ SftpError //!< Generic SFTP error\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// This constructor is used by the SFTP client to build\n+ /// the result.\n+ ///\n+ /// \\param value Result value\n+ /// \\param message Result message\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ explicit Result(Value value, std::string message = \"\");\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Check if the result is a success\n+ ///\n+ /// This function is defined for convenience, it is\n+ /// equivalent to testing if the result value is `Value::Success`.\n+ ///\n+ /// \\return `true` if the result is `Value::Success`, `false` if it is not `Value::Success`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] bool isOk() const;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the result value\n+ ///\n+ /// \\return The result value\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Value getValue() const;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the result message\n+ ///\n+ /// \\return The result message\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const std::string& getMessage() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ Value m_value; //!< The contained value\n+ std::string m_message; //!< The contained message\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result of an operation returning a path\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API PathResult : public Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// \\param result Result\n+ /// \\param path Path\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ PathResult(const Result& result, std::filesystem::path path);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the path\n+ ///\n+ /// \\return The path\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const std::filesystem::path& getPath() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ std::filesystem::path m_path; //!< The contained path\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief File or directory attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ struct Attributes\n+ {\n+ std::filesystem::path path; //!< Path to the entry\n+ std::optional<std::filesystem::file_type> type; //!< Type of the entry\n+ std::optional<std::uint64_t> size; //!< Size of the entry\n+ std::optional<std::filesystem::perms> permissions; //!< Permissions\n+ std::optional<std::uint64_t> userId; //!< Owner user ID\n+ std::optional<std::uint64_t> groupId; //!< Group ID\n+ std::optional<std::filesystem::file_time_type> accessTime; //!< Last access time\n+ std::optional<std::filesystem::file_time_type> modificationTime; //!< Last modification time\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result of an operation returning attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API AttributesResult : public Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// \\param result Result\n+ /// \\param attributes Attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ AttributesResult(const Result& result, Attributes attributes);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the attributes\n+ ///\n+ /// \\return The attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const Attributes& getAttributes() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ Attributes m_attributes; //!< The contained attributes\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result of an operation returning a directory listing\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API ListingResult : public Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// \\param result Result\n+ /// \\param listing Directory listing\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ ListingResult(const Result& result, std::vector<Attributes> listing);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the directory listing\n+ ///\n+ /// \\return The directory listing\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const std::vector<Attributes>& getListing() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ std::vector<Attributes> m_listing; //!< The contained directory listing\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Structure containing information about an active SFTP session\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ struct SessionInfo\n+ {\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Host key used to identify a host\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ struct HostKey\n+ {\n+ enum class Type\n+ {\n+ Unknown, //!< Unknown key type\n+ Rsa, //!< RSA\n+ Dsa, //!< DSA\n+ Ecdsa256, //!< NIST P-256 ECDSA\n+ Ecdsa384, //!< NIST P-384 ECDSA\n+ Ecdsa521, //!< NIST P-521 ECDSA\n+ Ed25519 //!< ED25519\n+ };\n+\n+ Type type = Type::Unknown; //!< Host key type\n+ std::vector<std::byte> data; //!< Host key data\n+ std::array<std::byte, 20> sha1{}; //!< Host key SHA1 hash\n+ std::array<std::byte, 32> sha256{}; //!< Host key SHA256 hash\n+ };\n+\n+ HostKey hostKey; //!< Host key\n+ std::string keyExchangeAlgorithm; //!< Key exchange algorithm used in the session (RFC 4253)\n+ std::string hostKeyAlgorithm; //!< Host key algorithm used in the session (RFC 4253)\n+ std::string clientToServerEncryptionAlgorithm; //!< Client to server encryption algorithm used in the session (RFC 4253)\n+ std::string serverToClientEncryptionAlgorithm; //!< Server to client encryption algorithm used in the session (RFC 4253)\n+ std::string clientToServerMacAlgorithm; //!< Client to server message authentication code algorithm used in the session (RFC 4253)\n+ std::string serverToClientMacAlgorithm; //!< Server to client message authentication code algorithm used in the session (RFC 4253)\n+ std::string clientToServerCompressionAlgorithm; //!< Client to server compression algorithm used in the session (RFC 4253)\n+ std::string serverToClientCompressionAlgorithm; //!< Server to client compression algorithm used in the session (RFC 4253)\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Default constructor\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ Sftp();\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Destructor\n+ ///\n+ /// Automatically closes the connection with the server if\n+ /// it is still opened.\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ ~Sftp();\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Deleted copy constructor\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ Sftp(const Sftp&) = delete;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Deleted copy assignment\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ Sftp& operator=(const Sftp&) = delete;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Connect to the specified SFTP server\n+ ///\n+ /// The port has a default value of 22, which is the standard\n+ /// port used by the SFTP protocol.\n+ /// This function tries to connect to the server so it may take\n+ /// a while to complete, especially if the server is not\n+ /// reachable. To avoid blocking your application for too long,\n+ /// you can use a timeout. The default value, `Time::Zero`, means that the\n+ /// system timeout will be used (which is usually pretty long).\n+ ///\n+ /// \\param server Name or address of the SFTP server to connect to\n+ /// \\param port Port used for the connection\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of the connection attempt\n+ ///\n+ /// \\see `disconnect`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result connect(IpAddress server, unsigned short port = 22, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Disconnect the connection with the server\n+ ///\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of disconnecting the connection with the server\n+ ///\n+ /// \\see `connect`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result disconnect(const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get SSH session information\n+ ///\n+ /// After connecting to the server and before actually\n+ /// logging in the SSH session information of the underlying\n+ /// connection will be available.\n+ ///\n+ /// The session information contains among other things the\n+ /// public key identifying the remote host and the connection\n+ /// parameters such as encryption and compression used. The\n+ /// identifiers used follow the RFC 4253 specification.\n+ ///\n+ /// If the session information is not available `std::nullopt`\n+ /// will be returned.\n+ ///\n+ /// Because SSH was developed as a parallel standard to\n+ /// SSL/TLS and automatic host certificate verification wasn't\n+ /// widespread at the time, relying on the user to check the\n+ /// authenticity of the host key was the typical method used\n+ /// to verify that they were connecting to the legitimate host,\n+ /// assuming the private key of the remote host was not\n+ /// compromised.\n+ ///\n+ /// If connection security is a high priority, examining\n+ /// the parameters and aborting the connection if any weak\n+ /// algorithms are used is also possible.\n+ ///\n+ /// \\return SSH session information or `std::nullopt` if it is not available\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] std::optional<SessionInfo> getSessionInfo() const;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Log in using a username and a password\n+ ///\n+ /// Logging in is mandatory after connecting to the server.\n+ /// Users that are not logged in cannot perform any operation.\n+ ///\n+ /// \\param name User name\n+ /// \\param password Password\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of attempting to log in to the server\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result login(std::string_view name,\n+ std::string_view password,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Log in using a public/private key pair\n+ ///\n+ /// Logging in is mandatory after connecting to the server.\n+ /// Users that are not logged in cannot perform any operation.\n+ ///\n+ /// This overload allows logging into the SFTP server using\n+ /// public key authentication.\n+ ///\n+ /// The public and private key data should be provided in PEM\n+ /// format. PEM encoded data can be easily recognized by their\n+ /// `-----BEGIN ............-----` header and\n+ /// `-----END ............-----` footer.\n+ ///\n+ /// Even though it is technically possible to derive the\n+ /// public key from the private key, due to backend\n+ /// limitations, providing a pre-generated public key as well\n+ /// is necessary for this function to be able to succeed.\n+ ///\n+ /// If the private key is protected by a passphrase the\n+ /// passphrase can be provided as a NULL terminated string.\n+ /// If the private key is not protected by a passphrase the\n+ /// passphrase should be set to the empty string.\n+ ///\n+ /// \\param name User name\n+ /// \\param publicKeyData Public key data\n+ /// \\param publicKeyLength Public key data length\n+ /// \\param privateKeyData Private key data\n+ /// \\param privateKeyLength Private key data length\n+ /// \\param privateKeyPassphrase Private key passphrase, NULL terminated\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of attempting to log in to the server\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase = \"\",\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Log in using a public/private key pair\n+ ///\n+ /// Logging in is mandatory after connecting to the server.\n+ /// Users that are not logged in cannot perform any operation.\n+ ///\n+ /// This overload allows logging into the SFTP server using\n+ /// public key authentication.\n+ ///\n+ /// The public and private key data should be provided in PEM\n+ /// format. PEM encoded data can be easily recognized by their\n+ /// `-----BEGIN ............-----` header and\n+ /// `-----END ............-----` footer.\n+ ///\n+ /// Even though it is technically possible to derive the\n+ /// public key from the private key, due to backend\n+ /// limitations, providing a pre-generated public key as well\n+ /// is necessary for this function to be able to succeed.\n+ ///\n+ /// If the private key is protected by a passphrase the\n+ /// passphrase can be provided as a NULL terminated string.\n+ /// If the private key is not protected by a passphrase the\n+ /// passphrase should be set to the empty string.\n+ ///\n+ /// \\param name User name\n+ /// \\param publicKeyData Public key data\n+ /// \\param privateKeyData Private key data\n+ /// \\param privateKeyPassphrase Private key passphrase\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of attempting to log in to the server\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase = {},\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Resolve a remote path into an absolute remote path\n+ ///\n+ /// Paths can contain links and other reserved path identifiers\n+ /// such as . and .. referring to the current directory and\n+ /// parent directory respectively.\n+ ///\n+ /// When determining the absolute path, which does not contain\n+ /// links or . or .. is necessary, this function can be used.\n+ ///\n+ /// Resolving \".\" will return the absolute path to the current\n+ /// working directory of the user after logging in to the SFTP\n+ /// server.\n+ ///\n+ /// \\param path Path to convert into an absolute path\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of converting the path into an absolute path\n+ ///\n+ /// \\see `getWorkingDirectory`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] PathResult resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the current working directory on the server\n+ ///\n+ /// This is an alias for calling `resolvePath(\".\")`.\n+ ///\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of getting the current working directory\n+ ///\n+ /// \\see `resolvePath`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] PathResult getWorkingDirectory(const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the attributes of a remote file or directory\n+ ///\n+ /// Depending on whether `path` refers to a file or directory,\n+ /// the attributes can contain e.g. the type of file, the file\n+ /// owner, group, file size, modification and access times.\n+ ///\n+ /// If links are not to be followed, `followLinks` can be set\n+ /// to `false`. In this case the attributes of the link itself\n+ /// will be returned.\n+ ///\n+ /// \\param path Path to the remote file or directory whose attributes to get\n+ /// \\param followLinks `true` to follow links, `false` to return attributes of the link itself\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of getting the attributes\n+ ///\n+ /// \\see `getDirectoryListing`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] AttributesResult getAttributes(const std::filesystem::path& path,\n+ bool followLinks = true,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the contents of the given directory\n+ ///\n+ /// This function retrieves the sub-directories and files\n+ /// contained in the given directory. It is not recursive.\n+ ///\n+ /// \\param path Path of the directory whose contents to list\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of getting the contents of the given directory\n+ ///\n+ /// \\see `getAttributes`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] ListingResult getDirectoryListing(const std::filesystem::path& path,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Create a new directory\n+ ///\n+ /// The new directory is created as a child of the current\n+ /// working directory.\n+ ///\n+ /// The default permissions value is equivalent to `rwxr-xr-x`\n+ /// or 0755 in octal notation.\n+ ///\n+ /// \\param path Path of the directory to create\n+ /// \\param permissions Permissions of the directory to create\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of creating the directory\n+ ///\n+ /// \\see `deleteDirectory`, `rename`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result createDirectory(\n+ const std::filesystem::path& path,\n+ std::filesystem::perms permissions = (std::filesystem::perms::owner_all | std::filesystem::perms::group_read |\n+ std::filesystem::perms::group_exec | std::filesystem::perms::others_read |\n+ std::filesystem::perms::others_exec),\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Remove an existing directory\n+ ///\n+ /// Use this function with caution, the directory will\n+ /// be removed permanently!\n+ ///\n+ /// \\param path Path of the directory to remove\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of removing the directory\n+ ///\n+ /// \\see `createDirectory`, `rename`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Rename an existing file or directory\n+ ///\n+ /// In POSIX renaming and moving and synonymous. If you want\n+ /// to move a file or directory from one place to another\n+ /// you rename it from an old to a new path.\n+ ///\n+ /// If a file exists at the specified new path, depending\n+ /// on whether `ovewrite` is set to true, the rename operation\n+ /// will overwrite it or not. If a directory is being moved,\n+ /// the new path must either not point to non-existant\n+ /// directory or a directory that is empty. Non-empty\n+ /// directories cannot be overwritten by this operation.\n+ ///\n+ /// \\param oldPath Old path to the file or directory\n+ /// \\param newPath New path to the file or directory\n+ /// \\param overwrite Set to `true` to allow overwriting a file that exists at `newPath`\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of the operation\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite = false,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Remove an existing file\n+ ///\n+ /// Use this function with caution, the file will be\n+ /// removed permanently!\n+ ///\n+ /// \\param path Path to the file to remove\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of removing the file\n+ ///\n+ /// \\see `rename`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Download a file from the server\n+ ///\n+ /// This function retrieves the data in the file at the\n+ /// remote path.\n+ ///\n+ /// The file data is transferred in sequential blocks. For\n+ /// every block of data transferred, the provided callback\n+ /// is called. The callback is passed a pointer to a data\n+ /// block and the size of the data contained in the current\n+ /// block. This size can change over time so it is important\n+ /// to always check the size value to know how much data is\n+ /// actually available. The callback should return `true` to\n+ /// indicate to the `download` function that it should\n+ /// continue to transfer data. If the data transfer should\n+ /// be aborted earlier, `false` can be returned from the\n+ /// callback.\n+ ///\n+ /// The function returns once all the data in the remote file\n+ /// has been transferred or an error occurs or the function\n+ /// times out.\n+ ///\n+ /// If reading from the remote file should not start at the\n+ /// beginning of the file, you can specify an offset in\n+ /// bytes at which reading should start.\n+ ///\n+ /// \\param remotePath Path of the remote file whose data to download\n+ /// \\param callback Callback to be called for every available data block\n+ /// \\param offset Byte offset into the remote file at which reading should start\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of downloading the file\n+ ///\n+ /// \\see `upload`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset = 0,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Upload a file to the server\n+ ///\n+ /// This function writes data into a file at the remote path.\n+ ///\n+ /// The file data is transferred in sequential blocks. Every\n+ /// time the function wants to send a new block of data the\n+ /// provided callback is called. The callback is passed a\n+ /// pointer to a data block and a reference to the size of\n+ /// the data block. Data to be sent should be copied into\n+ /// the data block using e.g. `std::memcpy` and the size value\n+ /// set to the actual number of bytes copied into the data\n+ /// block. The size of the block can change over time so it\n+ /// is important to check the size value that is passed to\n+ /// the callback to know how many bytes can actually be\n+ /// copied into the data block. The callback should return\n+ /// `true` to indicate to the `upload` function that it\n+ /// should continue to transfer data. Once the data transfer\n+ /// should be stopped e.g. because there is no more data left\n+ /// to send, `false` can be returned from the callback.\n+ ///\n+ /// The function returns once all the data has been sent or\n+ /// an error occurs or the function times out.\n+ ///\n+ /// If a file does not exist at the remote path yet, it will\n+ /// be created with the provided permissions.\n+ ///\n+ /// If a file already exists at the remote path, setting\n+ /// `truncate` to `true` will truncate the existing file\n+ /// i.e. delete all pre-existing data before starting to\n+ /// write the new data into the file.\n+ ///\n+ /// Setting `append` to `true` will append to a file if\n+ /// it already exists.\n+ ///\n+ /// If writing to the remote file should not start at the\n+ /// beginning of the file, you can specify an offset in\n+ /// bytes at which writing should start.\n+ ///\n+ /// The default permissions value is equivalent to `rw-r--r--`\n+ /// or 0644 in octal notation.\n+ ///\n+ /// \\param remotePath Path of the remote file in which to upload the data\n+ /// \\param callback Callback to be called for every available data block\n+ /// \\param permissions Permissions of the remote file if it has to be created\n+ /// \\param truncate Set to `true` to truncate the remote file if it already exists\n+ /// \\param append Set to `true` to append to the remote file if it already exists\n+ /// \\param offset Byte offset into the remote file at which writing should start\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of uploading the file\n+ ///\n+ /// \\see `download`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result upload(\n+ const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions = (std::filesystem::perms::owner_read | std::filesystem::perms::owner_write |\n+ std::filesystem::perms::group_read | std::filesystem::perms::others_read),\n+ bool truncate = true,\n+ bool append = false,\n+ std::uint64_t offset = 0,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ struct Impl;\n+ std::unique_ptr<Impl> m_impl; //!< Implementation\n+};\n+\n+} // namespace sf\n+\n+\n+////////////////////////////////////////////////////////////\n+/// \\class sf::Sftp\n+/// \\ingroup network\n+///\n+/// `sf::Sftp` is a very simple SFTP client that allows you\n+/// to communicate with a SFTP server. The SFTP protocol allows\n+/// you to manipulate a remote file system (list files,\n+/// upload, download, create, remove, ...).\n+///\n+/// Using the SFTP client consists of 4 parts:\n+/// \\li Connecting to the SFTP server\n+/// \\li Logging in (either using username and password or public key authentication)\n+/// \\li Performing file system operations\n+/// \\li Disconnecting (this part can be done implicitly by the destructor)\n+///\n+/// Every operation returns an SFTP result, which contains the\n+/// result code and optionally a message describing the result. Some\n+/// commands such as `getAttributes()` and `getDirectoryListing()`\n+/// return additional data, and use a class derived from\n+/// `sf::Sftp::Result` to provide this data. The commonly used filesystem\n+/// operations are directly provided as member functions.\n+///\n+/// There are three classes of result values: general result values,\n+/// SSH specific result values and SFTP specific result values. General\n+/// result values are returned on success and errors not specific to the\n+/// SSH or SFTP protocols. If an operation manipulating the remote\n+/// filesystem fails, an SFTP specific result will be returned describing\n+/// the reason for the failure. If any error related to the communication\n+/// channel occurs e.g. key exchange failure or authentication failure an\n+/// SSH error will be returned.\n+///\n+/// Because most operations manipulate some part of the remote filesystem\n+/// these operations, especially upload and download, may take some\n+/// time to complete. This is important to know if you don't want\n+/// to block your application while the server is completing\n+/// the task.\n+///\n+/// Every operation that relies on network communication can be passed\n+/// a timeout argument. In the simplest case, this timeout argument can\n+/// just be a fixed time duration after which the operation should time\n+/// out if no progress has been made. Because some operations simply due\n+/// to their nature can take longer than others it might not be possible\n+/// to use the same timeout value for all operations. If it is anticipated\n+/// that an operation could take a longer amount of time to complete due\n+/// to e.g. an unreliable or slow connection, the timeout should be increased\n+/// so the operation still has the possibility to complete successfully.\n+/// Passing `sf::Time::Zero` as a timeout value will cause the operation\n+/// to block until completion or failure.\n+///\n+/// If you want to pass `sf::Time::Zero` to wait indefinitely for an\n+/// operation to complete but still have the possibility to interrupt the\n+/// operation e.g. if the user decides to quit the application or interrupt\n+/// a longer download or upload, the timeout can be constructed from a\n+/// predicate and polling period. The predicate is a callable that takes\n+/// no parameters and returns `true` if the operation should continue or\n+/// `false` if the operation should time out. The time between consecutive\n+/// evaluations of the predicate is specified by the `period` parameter.\n+///\n+/// Example of a `TimeoutWithPredicate`:\n+/// \\code\n+/// bool run = true;\n+/// sf::Sftp::TimeoutWithPredicate timeout([&run]{ return run; }, sf::milliseconds(1));\n+/// \\endcode\n+/// When passed to an operation, the above `TimeoutWithPredicate` object will\n+/// keep the operation running as long as `run` is `true`. The condition\n+/// is checked every 1 millisecond. As soon as `run` is set to `false` the\n+/// operation will terminate with a `Timeout` result.\n+///\n+/// Remember that attempting to modify variables from across threads will\n+/// require proper synchronization using e.g. mutexes or atomics.\n+///\n+/// Because the filesystem operations will be performed on the remote\n+/// system, the paths passed to the operations should be valid paths on\n+/// the remote system. To guarantee portability, generic POSIX paths should\n+/// be used. These use `/` as the path seperator and `.` to refer to the\n+/// current directory and `..` to refer to the parent directory.\n+///\n+/// When logging into the server as a specific user the current directory\n+/// will be set to the home directory that was specified for that user\n+/// account. Because it cannot be assumed that the SFTP user is also allowed\n+/// to log into a shell, changing the current directory from the home\n+/// directory is not always possible and thus not supported. Thus when\n+/// specifying paths, it is preferred to always make use of absolute paths\n+/// when possible. Calling `getWorkingDirectory()` will return the current\n+/// directory as an absolute path. Listing the contents of a directory whose\n+/// path is passed as an absolute path will yield directory listing entries\n+/// whose paths are extentions of the directory's path and thus also absolute\n+/// paths. The `resolvePath()` function can be used to convert relative paths\n+/// or paths containing links into absolute paths without links.\n+///\n+/// Usage example:\n+/// \\code\n+/// // Create a new SFTP client\n+/// sf::Sftp sftp;\n+///\n+/// // Get the address of the server\n+/// const auto addresses = sf::Dns::resolve(\"sftp.myserver.com\");\n+///\n+/// // Check if we have a valid address\n+/// if (!addresses.has_value() || addresses->empty())\n+/// {\n+/// // Handle no valid address...\n+/// }\n+///\n+/// // Connect to the server\n+/// sf::Sftp::Result result = sftp.connect(addresses->front());\n+/// if (result.isOk())\n+/// std::cout << \"Connected\" << std::endl;\n+///\n+/// // Check session information and verify server\n+/// std::optional<sf::Sftp::SessionInfo> info = sftp.getSessionInfo();\n+/// if (info->hostKey.sha256 != expectedSha256)\n+/// {\n+/// std::cout << \"Server untrusted\" << std::endl;\n+/// // Handle untrusted server\n+/// }\n+///\n+/// // Log in\n+/// result = sftp.login(\"sftpuser\", \"dF6Zm89D\");\n+/// if (result.isOk())\n+/// std::cout << \"Logged in\" << std::endl;\n+///\n+/// // Print the working directory\n+/// sf::Sftp::PathResult directory = sftp.getWorkingDirectory();\n+/// if (directory.isOk())\n+/// std::cout << \"Working directory: \" << directory.getPath().string() << std::endl;\n+///\n+/// // Create a new directory\n+/// result = sftp.createDirectory(\"files\");\n+/// if (result.isOk())\n+/// std::cout << \"Created new directory\" << std::endl;\n+///\n+/// // Upload a text file to this new directory\n+/// result = sftp.upload(\"files/newfile.txt\", [](void* data, std::size_t& size)\n+/// {\n+/// // In your own code, ensure size is big enough to store your data\n+/// // We skip the check here for simplicity\n+/// std::memcpy(data, \"Hello World\", 11);\n+/// size = 11;\n+/// return false; // End transfer after this block\n+/// });\n+/// if (response.isOk())\n+/// std::cout << \"File uploaded\" << std::endl;\n+///\n+/// // Rename file\n+/// result = sftp.rename(\"files/newfile.txt\", \"files/newfile2.txt\");\n+/// if (result.isOk())\n+/// std::cout << \"Renamed file\" << std::endl;\n+///\n+/// // Download a text file from this new directory\n+/// std::string text;\n+/// result = sftp.download(\"files/newfile2.txt\", [&text](const void* data, std::size_t size)\n+/// {\n+/// text.append(static_cast<const char*>(data), size);\n+/// return true; // Continue until all data received\n+/// });\n+/// if (response.isOk())\n+/// std::cout << \"File downloaded: \" << text << std::endl;\n+///\n+/// // Delete file\n+/// result = sftp.deleteFile(\"files/newfile2.txt\");\n+/// if (result.isOk())\n+/// std::cout << \"Deleted file\" << std::endl;\n+///\n+/// // Delete directory\n+/// result = sftp.deleteDirectory(\"files\");\n+/// if (result.isOk())\n+/// std::cout << \"Deleted directory\" << std::endl;\n+///\n+/// // Disconnect from the server (optional)\n+/// result = sftp.disconnect();\n+/// if (result.isOk())\n+/// std::cout << \"Disconnected successfully\" << std::endl;\n+/// \\endcode\n+///\n+////////////////////////////////////////////////////////////\n"},"changed_files":{"kind":"list like","value":["include/SFML/Network/Sftp.hpp"],"string":"[\n \"include/SFML/Network/Sftp.hpp\"\n]","isConversational":false},"review_threads":{"kind":"list like","value":[{"comment":"Should we have default values? What's the use case of constructing an \"empty\" Result set?","path":"include/SFML/Network/Sftp.hpp","hunk":"@@ -0,0 +1,998 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+#pragma once\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/Export.hpp>\n+\n+#include <SFML/System/Time.hpp>\n+\n+#include <array>\n+#include <filesystem>\n+#include <functional>\n+#include <memory>\n+#include <optional>\n+#include <string>\n+#include <vector>\n+\n+#include <cstddef>\n+#include <cstdint>\n+\n+\n+namespace sf\n+{\n+class IpAddress;\n+\n+////////////////////////////////////////////////////////////\n+/// \\brief An SSH File Transfer Protocol (SFTP) client\n+///\n+////////////////////////////////////////////////////////////\n+class SFML_NETWORK_API Sftp\n+{\n+public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief SFTP result\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result values\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ enum class Value\n+ {\n+ // General result values\n+ Success, //!< Operation completed successfully\n+ Disconnected, //!< The TCP socket has been disconnected\n+ Timeout, //!< Operation timed out\n+ Refused, //!< Connection refused\n+ Error, //!< Generic error\n+\n+ // SSH result values\n+ SshErrorBannerReceive, //!< Error during banner receive\n+ SshErrorBannerSend, //!< Error during banner send\n+ SshErrorInvalidMac, //!< Invalid message authentication code\n+ SshErrorAllocation, //!< Allocation failure\n+ SshErrorSocketSend, //!< Error sending on socket\n+ SshErrorKeyExchangeFailure, //!< Key exchange failed\n+ SshErrorHostKeyInitialization, //!< Host key initialization failed\n+ SshErrorHostKeySign, //!< Host key signing failed\n+ SshErrorDecrypt, //!< Decryption failed\n+ SshErrorProtocol, //!< SSH protocol error\n+ SshErrorPasswordExpired, //!< Password expired\n+ SshErrorFile, //!< File error\n+ SshErrorMethodNone, //!< No method found\n+ SshErrorAuthenticationFailed, //!< Authentication failed\n+ SshErrorPublicKeyUnverified, //!< Public key unverified\n+ SshErrorChannelOutOfOrder, //!< Channel out of order\n+ SshErrorChannelFailure, //!< Channel failure\n+ SshErrorChannelRequestDenied, //!< Channel request denied\n+ SshErrorChannelUnknown, //!< Channel unknown\n+ SshErrorChannelWindowExceeded, //!< Channel window exceeded\n+ SshErrorChannelPacketExceeded, //!< Channel packet exceeded\n+ SshErrorChannelClosed, //!< Channel closed\n+ SshErrorChannelEofSent, //!< Channel EOF sent\n+ SshErrorScpProtocol, //!< SCP protocol error\n+ SshErrorZlib, //!< Zlib error\n+ SshErrorRequestDenied, //!< Request denied\n+ SshErrorMethodNotSupported, //!< Method not supported\n+ SshErrorInvalid, //!< Invalid data\n+ SshErrorPublicKeyProtocol, //!< Public key protocol error\n+ SshErrorBufferTooSmall, //!< Buffer too small\n+ SshErrorBadUse, //!< Bad usage\n+ SshErrorCompress, //!< Compression error\n+ SshErrorOutOfBoundary, //!< Out of boundary\n+ SshErrorAgentProtocol, //!< Agent protocol error\n+ SshErrorSocketRecv, //!< Socket receive error\n+ SshErrorEncrypt, //!< Encryption failed\n+ SshErrorBadSocket, //!< Bad socket\n+ SshErrorKnownHosts, //!< Known hosts error\n+ SshErrorChannelWindowFull, //!< Channel window full\n+ SshErrorKeyFileAuthenticationFailed, //!< Key file authentication failed\n+\n+ // SFTP result values\n+ SftpEndOfFile, //!< End of file\n+ SftpNoSuchFile, //!< No such file\n+ SftpPermissionDenied, //!< Permission denied\n+ SftpFailure, //!< Failure\n+ SftpBadMessage, //!< Bad message\n+ SftpNoConnection, //!< No connection\n+ SftpConnectionLost, //!< Connection lost\n+ SftpOperationUnsupported, //!< Operation unsupported\n+ SftpInvalidHandle, //!< Invalid handle\n+ SftpNoSuchPath, //!< No such path\n+ SftpFileAlreadyExists, //!< File already exists\n+ SftpWriteProtect, //!< Write protect\n+ SftpNoMedia, //!< No media\n+ SftpNoSpaceOnFileSystem, //!< No space on filesystem\n+ SftpQuotaExceeded, //!< Quota exceeded\n+ SftpUnknownPrincipal, //!< Unknown principal\n+ SftpLockConflict, //!< Lock conflict\n+ SftpDirectoryNotEmpty, //!< Directory not empty\n+ SftpNotADirectory, //!< Not a directory\n+ SftpInvalidFilename, //!< Invalid filename\n+ SftpLinkLoop, //!< Link loop\n+ SftpError //!< Generic SFTP error\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// This constructor is used by the SFTP client to build\n+ /// the result.\n+ ///\n+ /// \\param value Result value\n+ /// \\param message Result message\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ explicit Result(Value value = Value::Error, std::string message = \"\");","resolving_sha":"c33977a7e4e78d6d368598e1a6063aea606abd66","resolving_diff":"diff --git a/include/SFML/Network/Sftp.hpp b/include/SFML/Network/Sftp.hpp\nnew file mode 100644\nindex 0000000000..9be101d562\n--- /dev/null\n+++ b/include/SFML/Network/Sftp.hpp\n@@ -0,0 +1,987 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+//\n+// This software is provided 'as-is', without any express or implied warranty.\n+// In no event will the authors be held liable for any damages arising from the use of this software.\n+//\n+// Permission is granted to anyone to use this software for any purpose,\n+// including commercial applications, and to alter it and redistribute it freely,\n+// subject to the following restrictions:\n+//\n+// 1. The origin of this software must not be misrepresented;\n+// you must not claim that you wrote the original software.\n+// If you use this software in a product, an acknowledgment\n+// in the product documentation would be appreciated but is not required.\n+//\n+// 2. Altered source versions must be plainly marked as such,\n+// and must not be misrepresented as being the original software.\n+//\n+// 3. This notice may not be removed or altered from any source distribution.\n+//\n+////////////////////////////////////////////////////////////\n+\n+#pragma once\n+\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////////////////\n+#include <SFML/Network/Export.hpp>\n+\n+#include <SFML/System/TimeoutWithPredicate.hpp>\n+\n+#include <array>\n+#include <filesystem>\n+#include <memory>\n+#include <optional>\n+#include <string>\n+#include <string_view>\n+#include <vector>\n+\n+#include <cstddef>\n+#include <cstdint>\n+\n+\n+namespace sf\n+{\n+class IpAddress;\n+\n+////////////////////////////////////////////////////////////\n+/// \\brief An SSH File Transfer Protocol (SFTP) client\n+///\n+////////////////////////////////////////////////////////////\n+class SFML_NETWORK_API Sftp\n+{\n+public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief SFTP result\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result values\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ enum class Value\n+ {\n+ // General result values\n+ Success, //!< Operation completed successfully\n+ Disconnected, //!< The TCP socket has been disconnected\n+ Timeout, //!< Operation timed out\n+ Refused, //!< Connection refused\n+ Error, //!< Generic error\n+\n+ // SSH result values\n+ BannerReceive, //!< Error during banner receive\n+ BannerSend, //!< Error during banner send\n+ InvalidMac, //!< Invalid message authentication code\n+ AllocationFailure, //!< Allocation failure\n+ SocketSend, //!< Error sending on socket\n+ KeyExchangeFailure, //!< Key exchange failed\n+ HostKeyInitialization, //!< Host key initialization failed\n+ HostKeySign, //!< Host key signing failed\n+ DecryptError, //!< Decryption failed\n+ ProtocolError, //!< SSH protocol error\n+ PasswordExpired, //!< Password expired\n+ FileError, //!< File error\n+ MethodNone, //!< No method found\n+ AuthenticationFailed, //!< Authentication failed\n+ PublicKeyUnverified, //!< Public key unverified\n+ ChannelOutOfOrder, //!< Channel out of order\n+ ChannelFailure, //!< Channel failure\n+ ChannelRequestDenied, //!< Channel request denied\n+ ChannelUnknown, //!< Channel unknown\n+ ChannelWindowExceeded, //!< Channel window exceeded\n+ ChannelPacketExceeded, //!< Channel packet exceeded\n+ ChannelClosed, //!< Channel closed\n+ ChannelEofSent, //!< Channel EOF sent\n+ ScpProtocol, //!< SCP protocol error\n+ ZlibError, //!< Zlib error\n+ RequestDenied, //!< Request denied\n+ MethodNotSupported, //!< Method not supported\n+ InvalidData, //!< Invalid data\n+ PublicKeyProtocol, //!< Public key protocol error\n+ BufferTooSmall, //!< Buffer too small\n+ BadUse, //!< Bad usage\n+ CompressError, //!< Compression error\n+ OutOfBoundary, //!< Out of boundary\n+ AgentProtocol, //!< Agent protocol error\n+ SocketRecv, //!< Socket receive error\n+ EncryptError, //!< Encryption failed\n+ BadSocket, //!< Bad socket\n+ KnownHosts, //!< Known hosts error\n+ ChannelWindowFull, //!< Channel window full\n+ KeyFileAuthenticationFailed, //!< Key file authentication failed\n+\n+ // SFTP result values\n+ EndOfFile, //!< End of file\n+ NoSuchFile, //!< No such file\n+ PermissionDenied, //!< Permission denied\n+ Failure, //!< Failure\n+ BadMessage, //!< Bad message\n+ NoConnection, //!< No connection\n+ ConnectionLost, //!< Connection lost\n+ OperationUnsupported, //!< Operation unsupported\n+ InvalidHandle, //!< Invalid handle\n+ NoSuchPath, //!< No such path\n+ FileAlreadyExists, //!< File already exists\n+ WriteProtect, //!< Write protect\n+ NoMedia, //!< No media\n+ NoSpaceOnFileSystem, //!< No space on filesystem\n+ QuotaExceeded, //!< Quota exceeded\n+ UnknownPrincipal, //!< Unknown principal\n+ LockConflict, //!< Lock conflict\n+ DirectoryNotEmpty, //!< Directory not empty\n+ NotADirectory, //!< Not a directory\n+ InvalidFilename, //!< Invalid filename\n+ LinkLoop, //!< Link loop\n+ SftpError //!< Generic SFTP error\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// This constructor is used by the SFTP client to build\n+ /// the result.\n+ ///\n+ /// \\param value Result value\n+ /// \\param message Result message\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ explicit Result(Value value, std::string message = \"\");\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Check if the result is a success\n+ ///\n+ /// This function is defined for convenience, it is\n+ /// equivalent to testing if the result value is `Value::Success`.\n+ ///\n+ /// \\return `true` if the result is `Value::Success`, `false` if it is not `Value::Success`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] bool isOk() const;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the result value\n+ ///\n+ /// \\return The result value\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Value getValue() const;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the result message\n+ ///\n+ /// \\return The result message\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const std::string& getMessage() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ Value m_value; //!< The contained value\n+ std::string m_message; //!< The contained message\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result of an operation returning a path\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API PathResult : public Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// \\param result Result\n+ /// \\param path Path\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ PathResult(const Result& result, std::filesystem::path path);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the path\n+ ///\n+ /// \\return The path\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const std::filesystem::path& getPath() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ std::filesystem::path m_path; //!< The contained path\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief File or directory attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ struct Attributes\n+ {\n+ std::filesystem::path path; //!< Path to the entry\n+ std::optional<std::filesystem::file_type> type; //!< Type of the entry\n+ std::optional<std::uint64_t> size; //!< Size of the entry\n+ std::optional<std::filesystem::perms> permissions; //!< Permissions\n+ std::optional<std::uint64_t> userId; //!< Owner user ID\n+ std::optional<std::uint64_t> groupId; //!< Group ID\n+ std::optional<std::filesystem::file_time_type> accessTime; //!< Last access time\n+ std::optional<std::filesystem::file_time_type> modificationTime; //!< Last modification time\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result of an operation returning attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API AttributesResult : public Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// \\param result Result\n+ /// \\param attributes Attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ AttributesResult(const Result& result, Attributes attributes);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the attributes\n+ ///\n+ /// \\return The attributes\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const Attributes& getAttributes() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ Attributes m_attributes; //!< The contained attributes\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Result of an operation returning a directory listing\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ class SFML_NETWORK_API ListingResult : public Result\n+ {\n+ public:\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Constructor\n+ ///\n+ /// \\param result Result\n+ /// \\param listing Directory listing\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ ListingResult(const Result& result, std::vector<Attributes> listing);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the directory listing\n+ ///\n+ /// \\return The directory listing\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] const std::vector<Attributes>& getListing() const;\n+\n+ private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ std::vector<Attributes> m_listing; //!< The contained directory listing\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Structure containing information about an active SFTP session\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ struct SessionInfo\n+ {\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Host key used to identify a host\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ struct HostKey\n+ {\n+ enum class Type\n+ {\n+ Unknown, //!< Unknown key type\n+ Rsa, //!< RSA\n+ Dsa, //!< DSA\n+ Ecdsa256, //!< NIST P-256 ECDSA\n+ Ecdsa384, //!< NIST P-384 ECDSA\n+ Ecdsa521, //!< NIST P-521 ECDSA\n+ Ed25519 //!< ED25519\n+ };\n+\n+ Type type = Type::Unknown; //!< Host key type\n+ std::vector<std::byte> data; //!< Host key data\n+ std::array<std::byte, 20> sha1{}; //!< Host key SHA1 hash\n+ std::array<std::byte, 32> sha256{}; //!< Host key SHA256 hash\n+ };\n+\n+ HostKey hostKey; //!< Host key\n+ std::string keyExchangeAlgorithm; //!< Key exchange algorithm used in the session (RFC 4253)\n+ std::string hostKeyAlgorithm; //!< Host key algorithm used in the session (RFC 4253)\n+ std::string clientToServerEncryptionAlgorithm; //!< Client to server encryption algorithm used in the session (RFC 4253)\n+ std::string serverToClientEncryptionAlgorithm; //!< Server to client encryption algorithm used in the session (RFC 4253)\n+ std::string clientToServerMacAlgorithm; //!< Client to server message authentication code algorithm used in the session (RFC 4253)\n+ std::string serverToClientMacAlgorithm; //!< Server to client message authentication code algorithm used in the session (RFC 4253)\n+ std::string clientToServerCompressionAlgorithm; //!< Client to server compression algorithm used in the session (RFC 4253)\n+ std::string serverToClientCompressionAlgorithm; //!< Server to client compression algorithm used in the session (RFC 4253)\n+ };\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Default constructor\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ Sftp();\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Destructor\n+ ///\n+ /// Automatically closes the connection with the server if\n+ /// it is still opened.\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ ~Sftp();\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Deleted copy constructor\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ Sftp(const Sftp&) = delete;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Deleted copy assignment\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ Sftp& operator=(const Sftp&) = delete;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Connect to the specified SFTP server\n+ ///\n+ /// The port has a default value of 22, which is the standard\n+ /// port used by the SFTP protocol.\n+ /// This function tries to connect to the server so it may take\n+ /// a while to complete, especially if the server is not\n+ /// reachable. To avoid blocking your application for too long,\n+ /// you can use a timeout. The default value, `Time::Zero`, means that the\n+ /// system timeout will be used (which is usually pretty long).\n+ ///\n+ /// \\param server Name or address of the SFTP server to connect to\n+ /// \\param port Port used for the connection\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of the connection attempt\n+ ///\n+ /// \\see `disconnect`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result connect(IpAddress server, unsigned short port = 22, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Disconnect the connection with the server\n+ ///\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of disconnecting the connection with the server\n+ ///\n+ /// \\see `connect`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result disconnect(const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get SSH session information\n+ ///\n+ /// After connecting to the server and before actually\n+ /// logging in the SSH session information of the underlying\n+ /// connection will be available.\n+ ///\n+ /// The session information contains among other things the\n+ /// public key identifying the remote host and the connection\n+ /// parameters such as encryption and compression used. The\n+ /// identifiers used follow the RFC 4253 specification.\n+ ///\n+ /// If the session information is not available `std::nullopt`\n+ /// will be returned.\n+ ///\n+ /// Because SSH was developed as a parallel standard to\n+ /// SSL/TLS and automatic host certificate verification wasn't\n+ /// widespread at the time, relying on the user to check the\n+ /// authenticity of the host key was the typical method used\n+ /// to verify that they were connecting to the legitimate host,\n+ /// assuming the private key of the remote host was not\n+ /// compromised.\n+ ///\n+ /// If connection security is a high priority, examining\n+ /// the parameters and aborting the connection if any weak\n+ /// algorithms are used is also possible.\n+ ///\n+ /// \\return SSH session information or `std::nullopt` if it is not available\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] std::optional<SessionInfo> getSessionInfo() const;\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Log in using a username and a password\n+ ///\n+ /// Logging in is mandatory after connecting to the server.\n+ /// Users that are not logged in cannot perform any operation.\n+ ///\n+ /// \\param name User name\n+ /// \\param password Password\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of attempting to log in to the server\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result login(std::string_view name,\n+ std::string_view password,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Log in using a public/private key pair\n+ ///\n+ /// Logging in is mandatory after connecting to the server.\n+ /// Users that are not logged in cannot perform any operation.\n+ ///\n+ /// This overload allows logging into the SFTP server using\n+ /// public key authentication.\n+ ///\n+ /// The public and private key data should be provided in PEM\n+ /// format. PEM encoded data can be easily recognized by their\n+ /// `-----BEGIN ............-----` header and\n+ /// `-----END ............-----` footer.\n+ ///\n+ /// Even though it is technically possible to derive the\n+ /// public key from the private key, due to backend\n+ /// limitations, providing a pre-generated public key as well\n+ /// is necessary for this function to be able to succeed.\n+ ///\n+ /// If the private key is protected by a passphrase the\n+ /// passphrase can be provided as a NULL terminated string.\n+ /// If the private key is not protected by a passphrase the\n+ /// passphrase should be set to the empty string.\n+ ///\n+ /// \\param name User name\n+ /// \\param publicKeyData Public key data\n+ /// \\param publicKeyLength Public key data length\n+ /// \\param privateKeyData Private key data\n+ /// \\param privateKeyLength Private key data length\n+ /// \\param privateKeyPassphrase Private key passphrase, NULL terminated\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of attempting to log in to the server\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result login(std::string_view name,\n+ const char* publicKeyData,\n+ std::size_t publicKeyLength,\n+ const char* privateKeyData,\n+ std::size_t privateKeyLength,\n+ const char* privateKeyPassphrase = \"\",\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Log in using a public/private key pair\n+ ///\n+ /// Logging in is mandatory after connecting to the server.\n+ /// Users that are not logged in cannot perform any operation.\n+ ///\n+ /// This overload allows logging into the SFTP server using\n+ /// public key authentication.\n+ ///\n+ /// The public and private key data should be provided in PEM\n+ /// format. PEM encoded data can be easily recognized by their\n+ /// `-----BEGIN ............-----` header and\n+ /// `-----END ............-----` footer.\n+ ///\n+ /// Even though it is technically possible to derive the\n+ /// public key from the private key, due to backend\n+ /// limitations, providing a pre-generated public key as well\n+ /// is necessary for this function to be able to succeed.\n+ ///\n+ /// If the private key is protected by a passphrase the\n+ /// passphrase can be provided as a NULL terminated string.\n+ /// If the private key is not protected by a passphrase the\n+ /// passphrase should be set to the empty string.\n+ ///\n+ /// \\param name User name\n+ /// \\param publicKeyData Public key data\n+ /// \\param privateKeyData Private key data\n+ /// \\param privateKeyPassphrase Private key passphrase\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of attempting to log in to the server\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result login(std::string_view name,\n+ std::string_view publicKeyData,\n+ std::string_view privateKeyData,\n+ std::string_view privateKeyPassphrase = {},\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Resolve a remote path into an absolute remote path\n+ ///\n+ /// Paths can contain links and other reserved path identifiers\n+ /// such as . and .. referring to the current directory and\n+ /// parent directory respectively.\n+ ///\n+ /// When determining the absolute path, which does not contain\n+ /// links or . or .. is necessary, this function can be used.\n+ ///\n+ /// Resolving \".\" will return the absolute path to the current\n+ /// working directory of the user after logging in to the SFTP\n+ /// server.\n+ ///\n+ /// \\param path Path to convert into an absolute path\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of converting the path into an absolute path\n+ ///\n+ /// \\see `getWorkingDirectory`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] PathResult resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the current working directory on the server\n+ ///\n+ /// This is an alias for calling `resolvePath(\".\")`.\n+ ///\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of getting the current working directory\n+ ///\n+ /// \\see `resolvePath`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] PathResult getWorkingDirectory(const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the attributes of a remote file or directory\n+ ///\n+ /// Depending on whether `path` refers to a file or directory,\n+ /// the attributes can contain e.g. the type of file, the file\n+ /// owner, group, file size, modification and access times.\n+ ///\n+ /// If links are not to be followed, `followLinks` can be set\n+ /// to `false`. In this case the attributes of the link itself\n+ /// will be returned.\n+ ///\n+ /// \\param path Path to the remote file or directory whose attributes to get\n+ /// \\param followLinks `true` to follow links, `false` to return attributes of the link itself\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of getting the attributes\n+ ///\n+ /// \\see `getDirectoryListing`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] AttributesResult getAttributes(const std::filesystem::path& path,\n+ bool followLinks = true,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Get the contents of the given directory\n+ ///\n+ /// This function retrieves the sub-directories and files\n+ /// contained in the given directory. It is not recursive.\n+ ///\n+ /// \\param path Path of the directory whose contents to list\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of getting the contents of the given directory\n+ ///\n+ /// \\see `getAttributes`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] ListingResult getDirectoryListing(const std::filesystem::path& path,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Create a new directory\n+ ///\n+ /// The new directory is created as a child of the current\n+ /// working directory.\n+ ///\n+ /// The default permissions value is equivalent to `rwxr-xr-x`\n+ /// or 0755 in octal notation.\n+ ///\n+ /// \\param path Path of the directory to create\n+ /// \\param permissions Permissions of the directory to create\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of creating the directory\n+ ///\n+ /// \\see `deleteDirectory`, `rename`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result createDirectory(\n+ const std::filesystem::path& path,\n+ std::filesystem::perms permissions = (std::filesystem::perms::owner_all | std::filesystem::perms::group_read |\n+ std::filesystem::perms::group_exec | std::filesystem::perms::others_read |\n+ std::filesystem::perms::others_exec),\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Remove an existing directory\n+ ///\n+ /// Use this function with caution, the directory will\n+ /// be removed permanently!\n+ ///\n+ /// \\param path Path of the directory to remove\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of removing the directory\n+ ///\n+ /// \\see `createDirectory`, `rename`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Rename an existing file or directory\n+ ///\n+ /// In POSIX renaming and moving and synonymous. If you want\n+ /// to move a file or directory from one place to another\n+ /// you rename it from an old to a new path.\n+ ///\n+ /// If a file exists at the specified new path, depending\n+ /// on whether `ovewrite` is set to true, the rename operation\n+ /// will overwrite it or not. If a directory is being moved,\n+ /// the new path must either not point to non-existant\n+ /// directory or a directory that is empty. Non-empty\n+ /// directories cannot be overwritten by this operation.\n+ ///\n+ /// \\param oldPath Old path to the file or directory\n+ /// \\param newPath New path to the file or directory\n+ /// \\param overwrite Set to `true` to allow overwriting a file that exists at `newPath`\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of the operation\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result rename(const std::filesystem::path& oldPath,\n+ const std::filesystem::path& newPath,\n+ bool overwrite = false,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Remove an existing file\n+ ///\n+ /// Use this function with caution, the file will be\n+ /// removed permanently!\n+ ///\n+ /// \\param path Path to the file to remove\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of removing the file\n+ ///\n+ /// \\see `rename`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Download a file from the server\n+ ///\n+ /// This function retrieves the data in the file at the\n+ /// remote path.\n+ ///\n+ /// The file data is transferred in sequential blocks. For\n+ /// every block of data transferred, the provided callback\n+ /// is called. The callback is passed a pointer to a data\n+ /// block and the size of the data contained in the current\n+ /// block. This size can change over time so it is important\n+ /// to always check the size value to know how much data is\n+ /// actually available. The callback should return `true` to\n+ /// indicate to the `download` function that it should\n+ /// continue to transfer data. If the data transfer should\n+ /// be aborted earlier, `false` can be returned from the\n+ /// callback.\n+ ///\n+ /// The function returns once all the data in the remote file\n+ /// has been transferred or an error occurs or the function\n+ /// times out.\n+ ///\n+ /// If reading from the remote file should not start at the\n+ /// beginning of the file, you can specify an offset in\n+ /// bytes at which reading should start.\n+ ///\n+ /// \\param remotePath Path of the remote file whose data to download\n+ /// \\param callback Callback to be called for every available data block\n+ /// \\param offset Byte offset into the remote file at which reading should start\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of downloading the file\n+ ///\n+ /// \\see `upload`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result download(const std::filesystem::path& remotePath,\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\n+ std::uint64_t offset = 0,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+ ////////////////////////////////////////////////////////////\n+ /// \\brief Upload a file to the server\n+ ///\n+ /// This function writes data into a file at the remote path.\n+ ///\n+ /// The file data is transferred in sequential blocks. Every\n+ /// time the function wants to send a new block of data the\n+ /// provided callback is called. The callback is passed a\n+ /// pointer to a data block and a reference to the size of\n+ /// the data block. Data to be sent should be copied into\n+ /// the data block using e.g. `std::memcpy` and the size value\n+ /// set to the actual number of bytes copied into the data\n+ /// block. The size of the block can change over time so it\n+ /// is important to check the size value that is passed to\n+ /// the callback to know how many bytes can actually be\n+ /// copied into the data block. The callback should return\n+ /// `true` to indicate to the `upload` function that it\n+ /// should continue to transfer data. Once the data transfer\n+ /// should be stopped e.g. because there is no more data left\n+ /// to send, `false` can be returned from the callback.\n+ ///\n+ /// The function returns once all the data has been sent or\n+ /// an error occurs or the function times out.\n+ ///\n+ /// If a file does not exist at the remote path yet, it will\n+ /// be created with the provided permissions.\n+ ///\n+ /// If a file already exists at the remote path, setting\n+ /// `truncate` to `true` will truncate the existing file\n+ /// i.e. delete all pre-existing data before starting to\n+ /// write the new data into the file.\n+ ///\n+ /// Setting `append` to `true` will append to a file if\n+ /// it already exists.\n+ ///\n+ /// If writing to the remote file should not start at the\n+ /// beginning of the file, you can specify an offset in\n+ /// bytes at which writing should start.\n+ ///\n+ /// The default permissions value is equivalent to `rw-r--r--`\n+ /// or 0644 in octal notation.\n+ ///\n+ /// \\param remotePath Path of the remote file in which to upload the data\n+ /// \\param callback Callback to be called for every available data block\n+ /// \\param permissions Permissions of the remote file if it has to be created\n+ /// \\param truncate Set to `true` to truncate the remote file if it already exists\n+ /// \\param append Set to `true` to append to the remote file if it already exists\n+ /// \\param offset Byte offset into the remote file at which writing should start\n+ /// \\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\n+ ///\n+ /// \\return Result of uploading the file\n+ ///\n+ /// \\see `download`\n+ ///\n+ ////////////////////////////////////////////////////////////\n+ [[nodiscard]] Result upload(\n+ const std::filesystem::path& remotePath,\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\n+ std::filesystem::perms permissions = (std::filesystem::perms::owner_read | std::filesystem::perms::owner_write |\n+ std::filesystem::perms::group_read | std::filesystem::perms::others_read),\n+ bool truncate = true,\n+ bool append = false,\n+ std::uint64_t offset = 0,\n+ const TimeoutWithPredicate& timeout = Time::Zero);\n+\n+private:\n+ ////////////////////////////////////////////////////////////\n+ // Member data\n+ ////////////////////////////////////////////////////////////\n+ struct Impl;\n+ std::unique_ptr<Impl> m_impl; //!< Implementation\n+};\n+\n+} // namespace sf\n+\n+\n+////////////////////////////////////////////////////////////\n+/// \\class sf::Sftp\n+/// \\ingroup network\n+///\n+/// `sf::Sftp` is a very simple SFTP client that allows you\n+/// to communicate with a SFTP server. The SFTP protocol allows\n+/// you to manipulate a remote file system (list files,\n+/// upload, download, create, remove, ...).\n+///\n+/// Using the SFTP client consists of 4 parts:\n+/// \\li Connecting to the SFTP server\n+/// \\li Logging in (either using username and password or public key authentication)\n+/// \\li Performing file system operations\n+/// \\li Disconnecting (this part can be done implicitly by the destructor)\n+///\n+/// Every operation returns an SFTP result, which contains the\n+/// result code and optionally a message describing the result. Some\n+/// commands such as `getAttributes()` and `getDirectoryListing()`\n+/// return additional data, and use a class derived from\n+/// `sf::Sftp::Result` to provide this data. The commonly used filesystem\n+/// operations are directly provided as member functions.\n+///\n+/// There are three classes of result values: general result values,\n+/// SSH specific result values and SFTP specific result values. General\n+/// result values are returned on success and errors not specific to the\n+/// SSH or SFTP protocols. If an operation manipulating the remote\n+/// filesystem fails, an SFTP specific result will be returned describing\n+/// the reason for the failure. If any error related to the communication\n+/// channel occurs e.g. key exchange failure or authentication failure an\n+/// SSH error will be returned.\n+///\n+/// Because most operations manipulate some part of the remote filesystem\n+/// these operations, especially upload and download, may take some\n+/// time to complete. This is important to know if you don't want\n+/// to block your application while the server is completing\n+/// the task.\n+///\n+/// Every operation that relies on network communication can be passed\n+/// a timeout argument. In the simplest case, this timeout argument can\n+/// just be a fixed time duration after which the operation should time\n+/// out if no progress has been made. Because some operations simply due\n+/// to their nature can take longer than others it might not be possible\n+/// to use the same timeout value for all operations. If it is anticipated\n+/// that an operation could take a longer amount of time to complete due\n+/// to e.g. an unreliable or slow connection, the timeout should be increased\n+/// so the operation still has the possibility to complete successfully.\n+/// Passing `sf::Time::Zero` as a timeout value will cause the operation\n+/// to block until completion or failure.\n+///\n+/// If you want to pass `sf::Time::Zero` to wait indefinitely for an\n+/// operation to complete but still have the possibility to interrupt the\n+/// operation e.g. if the user decides to quit the application or interrupt\n+/// a longer download or upload, the timeout can be constructed from a\n+/// predicate and polling period. The predicate is a callable that takes\n+/// no parameters and returns `true` if the operation should continue or\n+/// `false` if the operation should time out. The time between consecutive\n+/// evaluations of the predicate is specified by the `period` parameter.\n+///\n+/// Example of a `TimeoutWithPredicate`:\n+/// \\code\n+/// bool run = true;\n+/// sf::Sftp::TimeoutWithPredicate timeout([&run]{ return run; }, sf::milliseconds(1));\n+/// \\endcode\n+/// When passed to an operation, the above `TimeoutWithPredicate` object will\n+/// keep the operation running as long as `run` is `true`. The condition\n+/// is checked every 1 millisecond. As soon as `run` is set to `false` the\n+/// operation will terminate with a `Timeout` result.\n+///\n+/// Remember that attempting to modify variables from across threads will\n+/// require proper synchronization using e.g. mutexes or atomics.\n+///\n+/// Because the filesystem operations will be performed on the remote\n+/// system, the paths passed to the operations should be valid paths on\n+/// the remote system. To guarantee portability, generic POSIX paths should\n+/// be used. These use `/` as the path seperator and `.` to refer to the\n+/// current directory and `..` to refer to the parent directory.\n+///\n+/// When logging into the server as a specific user the current directory\n+/// will be set to the home directory that was specified for that user\n+/// account. Because it cannot be assumed that the SFTP user is also allowed\n+/// to log into a shell, changing the current directory from the home\n+/// directory is not always possible and thus not supported. Thus when\n+/// specifying paths, it is preferred to always make use of absolute paths\n+/// when possible. Calling `getWorkingDirectory()` will return the current\n+/// directory as an absolute path. Listing the contents of a directory whose\n+/// path is passed as an absolute path will yield directory listing entries\n+/// whose paths are extentions of the directory's path and thus also absolute\n+/// paths. The `resolvePath()` function can be used to convert relative paths\n+/// or paths containing links into absolute paths without links.\n+///\n+/// Usage example:\n+/// \\code\n+/// // Create a new SFTP client\n+/// sf::Sftp sftp;\n+///\n+/// // Get the address of the server\n+/// const auto addresses = sf::Dns::resolve(\"sftp.myserver.com\");\n+///\n+/// // Check if we have a valid address\n+/// if (!addresses.has_value() || addresses->empty())\n+/// {\n+/// // Handle no valid address...\n+/// }\n+///\n+/// // Connect to the server\n+/// sf::Sftp::Result result = sftp.connect(addresses->front());\n+/// if (result.isOk())\n+/// std::cout << \"Connected\" << std::endl;\n+///\n+/// // Check session information and verify server\n+/// std::optional<sf::Sftp::SessionInfo> info = sftp.getSessionInfo();\n+/// if (info->hostKey.sha256 != expectedSha256)\n+/// {\n+/// std::cout << \"Server untrusted\" << std::endl;\n+/// // Handle untrusted server\n+/// }\n+///\n+/// // Log in\n+/// result = sftp.login(\"sftpuser\", \"dF6Zm89D\");\n+/// if (result.isOk())\n+/// std::cout << \"Logged in\" << std::endl;\n+///\n+/// // Print the working directory\n+/// sf::Sftp::PathResult directory = sftp.getWorkingDirectory();\n+/// if (directory.isOk())\n+/// std::cout << \"Working directory: \" << directory.getPath().string() << std::endl;\n+///\n+/// // Create a new directory\n+/// result = sftp.createDirectory(\"files\");\n+/// if (result.isOk())\n+/// std::cout << \"Created new directory\" << std::endl;\n+///\n+/// // Upload a text file to this new directory\n+/// result = sftp.upload(\"files/newfile.txt\", [](void* data, std::size_t& size)\n+/// {\n+/// // In your own code, ensure size is big enough to store your data\n+/// // We skip the check here for simplicity\n+/// std::memcpy(data, \"Hello World\", 11);\n+/// size = 11;\n+/// return false; // End transfer after this block\n+/// });\n+/// if (response.isOk())\n+/// std::cout << \"File uploaded\" << std::endl;\n+///\n+/// // Rename file\n+/// result = sftp.rename(\"files/newfile.txt\", \"files/newfile2.txt\");\n+/// if (result.isOk())\n+/// std::cout << \"Renamed file\" << std::endl;\n+///\n+/// // Download a text file from this new directory\n+/// std::string text;\n+/// result = sftp.download(\"files/newfile2.txt\", [&text](const void* data, std::size_t size)\n+/// {\n+/// text.append(static_cast<const char*>(data), size);\n+/// return true; // Continue until all data received\n+/// });\n+/// if (response.isOk())\n+/// std::cout << \"File downloaded: \" << text << std::endl;\n+///\n+/// // Delete file\n+/// result = sftp.deleteFile(\"files/newfile2.txt\");\n+/// if (result.isOk())\n+/// std::cout << \"Deleted file\" << std::endl;\n+///\n+/// // Delete directory\n+/// result = sftp.deleteDirectory(\"files\");\n+/// if (result.isOk())\n+/// std::cout << \"Deleted directory\" << std::endl;\n+///\n+/// // Disconnect from the server (optional)\n+/// result = sftp.disconnect();\n+/// if (result.isOk())\n+/// std::cout << \"Disconnected successfully\" << std::endl;\n+/// \\endcode\n+///\n+////////////////////////////////////////////////////////////\n"}],"string":"[\n {\n \"comment\": \"Should we have default values? What's the use case of constructing an \\\"empty\\\" Result set?\",\n \"path\": \"include/SFML/Network/Sftp.hpp\",\n \"hunk\": \"@@ -0,0 +1,998 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+#pragma once\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/Export.hpp>\\n+\\n+#include <SFML/System/Time.hpp>\\n+\\n+#include <array>\\n+#include <filesystem>\\n+#include <functional>\\n+#include <memory>\\n+#include <optional>\\n+#include <string>\\n+#include <vector>\\n+\\n+#include <cstddef>\\n+#include <cstdint>\\n+\\n+\\n+namespace sf\\n+{\\n+class IpAddress;\\n+\\n+////////////////////////////////////////////////////////////\\n+/// \\\\brief An SSH File Transfer Protocol (SFTP) client\\n+///\\n+////////////////////////////////////////////////////////////\\n+class SFML_NETWORK_API Sftp\\n+{\\n+public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief SFTP result\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ class SFML_NETWORK_API Result\\n+ {\\n+ public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Result values\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ enum class Value\\n+ {\\n+ // General result values\\n+ Success, //!< Operation completed successfully\\n+ Disconnected, //!< The TCP socket has been disconnected\\n+ Timeout, //!< Operation timed out\\n+ Refused, //!< Connection refused\\n+ Error, //!< Generic error\\n+\\n+ // SSH result values\\n+ SshErrorBannerReceive, //!< Error during banner receive\\n+ SshErrorBannerSend, //!< Error during banner send\\n+ SshErrorInvalidMac, //!< Invalid message authentication code\\n+ SshErrorAllocation, //!< Allocation failure\\n+ SshErrorSocketSend, //!< Error sending on socket\\n+ SshErrorKeyExchangeFailure, //!< Key exchange failed\\n+ SshErrorHostKeyInitialization, //!< Host key initialization failed\\n+ SshErrorHostKeySign, //!< Host key signing failed\\n+ SshErrorDecrypt, //!< Decryption failed\\n+ SshErrorProtocol, //!< SSH protocol error\\n+ SshErrorPasswordExpired, //!< Password expired\\n+ SshErrorFile, //!< File error\\n+ SshErrorMethodNone, //!< No method found\\n+ SshErrorAuthenticationFailed, //!< Authentication failed\\n+ SshErrorPublicKeyUnverified, //!< Public key unverified\\n+ SshErrorChannelOutOfOrder, //!< Channel out of order\\n+ SshErrorChannelFailure, //!< Channel failure\\n+ SshErrorChannelRequestDenied, //!< Channel request denied\\n+ SshErrorChannelUnknown, //!< Channel unknown\\n+ SshErrorChannelWindowExceeded, //!< Channel window exceeded\\n+ SshErrorChannelPacketExceeded, //!< Channel packet exceeded\\n+ SshErrorChannelClosed, //!< Channel closed\\n+ SshErrorChannelEofSent, //!< Channel EOF sent\\n+ SshErrorScpProtocol, //!< SCP protocol error\\n+ SshErrorZlib, //!< Zlib error\\n+ SshErrorRequestDenied, //!< Request denied\\n+ SshErrorMethodNotSupported, //!< Method not supported\\n+ SshErrorInvalid, //!< Invalid data\\n+ SshErrorPublicKeyProtocol, //!< Public key protocol error\\n+ SshErrorBufferTooSmall, //!< Buffer too small\\n+ SshErrorBadUse, //!< Bad usage\\n+ SshErrorCompress, //!< Compression error\\n+ SshErrorOutOfBoundary, //!< Out of boundary\\n+ SshErrorAgentProtocol, //!< Agent protocol error\\n+ SshErrorSocketRecv, //!< Socket receive error\\n+ SshErrorEncrypt, //!< Encryption failed\\n+ SshErrorBadSocket, //!< Bad socket\\n+ SshErrorKnownHosts, //!< Known hosts error\\n+ SshErrorChannelWindowFull, //!< Channel window full\\n+ SshErrorKeyFileAuthenticationFailed, //!< Key file authentication failed\\n+\\n+ // SFTP result values\\n+ SftpEndOfFile, //!< End of file\\n+ SftpNoSuchFile, //!< No such file\\n+ SftpPermissionDenied, //!< Permission denied\\n+ SftpFailure, //!< Failure\\n+ SftpBadMessage, //!< Bad message\\n+ SftpNoConnection, //!< No connection\\n+ SftpConnectionLost, //!< Connection lost\\n+ SftpOperationUnsupported, //!< Operation unsupported\\n+ SftpInvalidHandle, //!< Invalid handle\\n+ SftpNoSuchPath, //!< No such path\\n+ SftpFileAlreadyExists, //!< File already exists\\n+ SftpWriteProtect, //!< Write protect\\n+ SftpNoMedia, //!< No media\\n+ SftpNoSpaceOnFileSystem, //!< No space on filesystem\\n+ SftpQuotaExceeded, //!< Quota exceeded\\n+ SftpUnknownPrincipal, //!< Unknown principal\\n+ SftpLockConflict, //!< Lock conflict\\n+ SftpDirectoryNotEmpty, //!< Directory not empty\\n+ SftpNotADirectory, //!< Not a directory\\n+ SftpInvalidFilename, //!< Invalid filename\\n+ SftpLinkLoop, //!< Link loop\\n+ SftpError //!< Generic SFTP error\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Constructor\\n+ ///\\n+ /// This constructor is used by the SFTP client to build\\n+ /// the result.\\n+ ///\\n+ /// \\\\param value Result value\\n+ /// \\\\param message Result message\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ explicit Result(Value value = Value::Error, std::string message = \\\"\\\");\",\n \"resolving_sha\": \"c33977a7e4e78d6d368598e1a6063aea606abd66\",\n \"resolving_diff\": \"diff --git a/include/SFML/Network/Sftp.hpp b/include/SFML/Network/Sftp.hpp\\nnew file mode 100644\\nindex 0000000000..9be101d562\\n--- /dev/null\\n+++ b/include/SFML/Network/Sftp.hpp\\n@@ -0,0 +1,987 @@\\n+////////////////////////////////////////////////////////////\\n+//\\n+// SFML - Simple and Fast Multimedia Library\\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\\n+//\\n+// This software is provided 'as-is', without any express or implied warranty.\\n+// In no event will the authors be held liable for any damages arising from the use of this software.\\n+//\\n+// Permission is granted to anyone to use this software for any purpose,\\n+// including commercial applications, and to alter it and redistribute it freely,\\n+// subject to the following restrictions:\\n+//\\n+// 1. The origin of this software must not be misrepresented;\\n+// you must not claim that you wrote the original software.\\n+// If you use this software in a product, an acknowledgment\\n+// in the product documentation would be appreciated but is not required.\\n+//\\n+// 2. Altered source versions must be plainly marked as such,\\n+// and must not be misrepresented as being the original software.\\n+//\\n+// 3. This notice may not be removed or altered from any source distribution.\\n+//\\n+////////////////////////////////////////////////////////////\\n+\\n+#pragma once\\n+\\n+////////////////////////////////////////////////////////////\\n+// Headers\\n+////////////////////////////////////////////////////////////\\n+#include <SFML/Network/Export.hpp>\\n+\\n+#include <SFML/System/TimeoutWithPredicate.hpp>\\n+\\n+#include <array>\\n+#include <filesystem>\\n+#include <memory>\\n+#include <optional>\\n+#include <string>\\n+#include <string_view>\\n+#include <vector>\\n+\\n+#include <cstddef>\\n+#include <cstdint>\\n+\\n+\\n+namespace sf\\n+{\\n+class IpAddress;\\n+\\n+////////////////////////////////////////////////////////////\\n+/// \\\\brief An SSH File Transfer Protocol (SFTP) client\\n+///\\n+////////////////////////////////////////////////////////////\\n+class SFML_NETWORK_API Sftp\\n+{\\n+public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief SFTP result\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ class SFML_NETWORK_API Result\\n+ {\\n+ public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Result values\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ enum class Value\\n+ {\\n+ // General result values\\n+ Success, //!< Operation completed successfully\\n+ Disconnected, //!< The TCP socket has been disconnected\\n+ Timeout, //!< Operation timed out\\n+ Refused, //!< Connection refused\\n+ Error, //!< Generic error\\n+\\n+ // SSH result values\\n+ BannerReceive, //!< Error during banner receive\\n+ BannerSend, //!< Error during banner send\\n+ InvalidMac, //!< Invalid message authentication code\\n+ AllocationFailure, //!< Allocation failure\\n+ SocketSend, //!< Error sending on socket\\n+ KeyExchangeFailure, //!< Key exchange failed\\n+ HostKeyInitialization, //!< Host key initialization failed\\n+ HostKeySign, //!< Host key signing failed\\n+ DecryptError, //!< Decryption failed\\n+ ProtocolError, //!< SSH protocol error\\n+ PasswordExpired, //!< Password expired\\n+ FileError, //!< File error\\n+ MethodNone, //!< No method found\\n+ AuthenticationFailed, //!< Authentication failed\\n+ PublicKeyUnverified, //!< Public key unverified\\n+ ChannelOutOfOrder, //!< Channel out of order\\n+ ChannelFailure, //!< Channel failure\\n+ ChannelRequestDenied, //!< Channel request denied\\n+ ChannelUnknown, //!< Channel unknown\\n+ ChannelWindowExceeded, //!< Channel window exceeded\\n+ ChannelPacketExceeded, //!< Channel packet exceeded\\n+ ChannelClosed, //!< Channel closed\\n+ ChannelEofSent, //!< Channel EOF sent\\n+ ScpProtocol, //!< SCP protocol error\\n+ ZlibError, //!< Zlib error\\n+ RequestDenied, //!< Request denied\\n+ MethodNotSupported, //!< Method not supported\\n+ InvalidData, //!< Invalid data\\n+ PublicKeyProtocol, //!< Public key protocol error\\n+ BufferTooSmall, //!< Buffer too small\\n+ BadUse, //!< Bad usage\\n+ CompressError, //!< Compression error\\n+ OutOfBoundary, //!< Out of boundary\\n+ AgentProtocol, //!< Agent protocol error\\n+ SocketRecv, //!< Socket receive error\\n+ EncryptError, //!< Encryption failed\\n+ BadSocket, //!< Bad socket\\n+ KnownHosts, //!< Known hosts error\\n+ ChannelWindowFull, //!< Channel window full\\n+ KeyFileAuthenticationFailed, //!< Key file authentication failed\\n+\\n+ // SFTP result values\\n+ EndOfFile, //!< End of file\\n+ NoSuchFile, //!< No such file\\n+ PermissionDenied, //!< Permission denied\\n+ Failure, //!< Failure\\n+ BadMessage, //!< Bad message\\n+ NoConnection, //!< No connection\\n+ ConnectionLost, //!< Connection lost\\n+ OperationUnsupported, //!< Operation unsupported\\n+ InvalidHandle, //!< Invalid handle\\n+ NoSuchPath, //!< No such path\\n+ FileAlreadyExists, //!< File already exists\\n+ WriteProtect, //!< Write protect\\n+ NoMedia, //!< No media\\n+ NoSpaceOnFileSystem, //!< No space on filesystem\\n+ QuotaExceeded, //!< Quota exceeded\\n+ UnknownPrincipal, //!< Unknown principal\\n+ LockConflict, //!< Lock conflict\\n+ DirectoryNotEmpty, //!< Directory not empty\\n+ NotADirectory, //!< Not a directory\\n+ InvalidFilename, //!< Invalid filename\\n+ LinkLoop, //!< Link loop\\n+ SftpError //!< Generic SFTP error\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Constructor\\n+ ///\\n+ /// This constructor is used by the SFTP client to build\\n+ /// the result.\\n+ ///\\n+ /// \\\\param value Result value\\n+ /// \\\\param message Result message\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ explicit Result(Value value, std::string message = \\\"\\\");\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Check if the result is a success\\n+ ///\\n+ /// This function is defined for convenience, it is\\n+ /// equivalent to testing if the result value is `Value::Success`.\\n+ ///\\n+ /// \\\\return `true` if the result is `Value::Success`, `false` if it is not `Value::Success`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] bool isOk() const;\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the result value\\n+ ///\\n+ /// \\\\return The result value\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Value getValue() const;\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the result message\\n+ ///\\n+ /// \\\\return The result message\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] const std::string& getMessage() const;\\n+\\n+ private:\\n+ ////////////////////////////////////////////////////////////\\n+ // Member data\\n+ ////////////////////////////////////////////////////////////\\n+ Value m_value; //!< The contained value\\n+ std::string m_message; //!< The contained message\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Result of an operation returning a path\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ class SFML_NETWORK_API PathResult : public Result\\n+ {\\n+ public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Constructor\\n+ ///\\n+ /// \\\\param result Result\\n+ /// \\\\param path Path\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ PathResult(const Result& result, std::filesystem::path path);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the path\\n+ ///\\n+ /// \\\\return The path\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] const std::filesystem::path& getPath() const;\\n+\\n+ private:\\n+ ////////////////////////////////////////////////////////////\\n+ // Member data\\n+ ////////////////////////////////////////////////////////////\\n+ std::filesystem::path m_path; //!< The contained path\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief File or directory attributes\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ struct Attributes\\n+ {\\n+ std::filesystem::path path; //!< Path to the entry\\n+ std::optional<std::filesystem::file_type> type; //!< Type of the entry\\n+ std::optional<std::uint64_t> size; //!< Size of the entry\\n+ std::optional<std::filesystem::perms> permissions; //!< Permissions\\n+ std::optional<std::uint64_t> userId; //!< Owner user ID\\n+ std::optional<std::uint64_t> groupId; //!< Group ID\\n+ std::optional<std::filesystem::file_time_type> accessTime; //!< Last access time\\n+ std::optional<std::filesystem::file_time_type> modificationTime; //!< Last modification time\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Result of an operation returning attributes\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ class SFML_NETWORK_API AttributesResult : public Result\\n+ {\\n+ public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Constructor\\n+ ///\\n+ /// \\\\param result Result\\n+ /// \\\\param attributes Attributes\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ AttributesResult(const Result& result, Attributes attributes);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the attributes\\n+ ///\\n+ /// \\\\return The attributes\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] const Attributes& getAttributes() const;\\n+\\n+ private:\\n+ ////////////////////////////////////////////////////////////\\n+ // Member data\\n+ ////////////////////////////////////////////////////////////\\n+ Attributes m_attributes; //!< The contained attributes\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Result of an operation returning a directory listing\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ class SFML_NETWORK_API ListingResult : public Result\\n+ {\\n+ public:\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Constructor\\n+ ///\\n+ /// \\\\param result Result\\n+ /// \\\\param listing Directory listing\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ ListingResult(const Result& result, std::vector<Attributes> listing);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the directory listing\\n+ ///\\n+ /// \\\\return The directory listing\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] const std::vector<Attributes>& getListing() const;\\n+\\n+ private:\\n+ ////////////////////////////////////////////////////////////\\n+ // Member data\\n+ ////////////////////////////////////////////////////////////\\n+ std::vector<Attributes> m_listing; //!< The contained directory listing\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Structure containing information about an active SFTP session\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ struct SessionInfo\\n+ {\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Host key used to identify a host\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ struct HostKey\\n+ {\\n+ enum class Type\\n+ {\\n+ Unknown, //!< Unknown key type\\n+ Rsa, //!< RSA\\n+ Dsa, //!< DSA\\n+ Ecdsa256, //!< NIST P-256 ECDSA\\n+ Ecdsa384, //!< NIST P-384 ECDSA\\n+ Ecdsa521, //!< NIST P-521 ECDSA\\n+ Ed25519 //!< ED25519\\n+ };\\n+\\n+ Type type = Type::Unknown; //!< Host key type\\n+ std::vector<std::byte> data; //!< Host key data\\n+ std::array<std::byte, 20> sha1{}; //!< Host key SHA1 hash\\n+ std::array<std::byte, 32> sha256{}; //!< Host key SHA256 hash\\n+ };\\n+\\n+ HostKey hostKey; //!< Host key\\n+ std::string keyExchangeAlgorithm; //!< Key exchange algorithm used in the session (RFC 4253)\\n+ std::string hostKeyAlgorithm; //!< Host key algorithm used in the session (RFC 4253)\\n+ std::string clientToServerEncryptionAlgorithm; //!< Client to server encryption algorithm used in the session (RFC 4253)\\n+ std::string serverToClientEncryptionAlgorithm; //!< Server to client encryption algorithm used in the session (RFC 4253)\\n+ std::string clientToServerMacAlgorithm; //!< Client to server message authentication code algorithm used in the session (RFC 4253)\\n+ std::string serverToClientMacAlgorithm; //!< Server to client message authentication code algorithm used in the session (RFC 4253)\\n+ std::string clientToServerCompressionAlgorithm; //!< Client to server compression algorithm used in the session (RFC 4253)\\n+ std::string serverToClientCompressionAlgorithm; //!< Server to client compression algorithm used in the session (RFC 4253)\\n+ };\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Default constructor\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ Sftp();\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Destructor\\n+ ///\\n+ /// Automatically closes the connection with the server if\\n+ /// it is still opened.\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ ~Sftp();\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Deleted copy constructor\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ Sftp(const Sftp&) = delete;\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Deleted copy assignment\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ Sftp& operator=(const Sftp&) = delete;\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Connect to the specified SFTP server\\n+ ///\\n+ /// The port has a default value of 22, which is the standard\\n+ /// port used by the SFTP protocol.\\n+ /// This function tries to connect to the server so it may take\\n+ /// a while to complete, especially if the server is not\\n+ /// reachable. To avoid blocking your application for too long,\\n+ /// you can use a timeout. The default value, `Time::Zero`, means that the\\n+ /// system timeout will be used (which is usually pretty long).\\n+ ///\\n+ /// \\\\param server Name or address of the SFTP server to connect to\\n+ /// \\\\param port Port used for the connection\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of the connection attempt\\n+ ///\\n+ /// \\\\see `disconnect`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result connect(IpAddress server, unsigned short port = 22, const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Disconnect the connection with the server\\n+ ///\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of disconnecting the connection with the server\\n+ ///\\n+ /// \\\\see `connect`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result disconnect(const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get SSH session information\\n+ ///\\n+ /// After connecting to the server and before actually\\n+ /// logging in the SSH session information of the underlying\\n+ /// connection will be available.\\n+ ///\\n+ /// The session information contains among other things the\\n+ /// public key identifying the remote host and the connection\\n+ /// parameters such as encryption and compression used. The\\n+ /// identifiers used follow the RFC 4253 specification.\\n+ ///\\n+ /// If the session information is not available `std::nullopt`\\n+ /// will be returned.\\n+ ///\\n+ /// Because SSH was developed as a parallel standard to\\n+ /// SSL/TLS and automatic host certificate verification wasn't\\n+ /// widespread at the time, relying on the user to check the\\n+ /// authenticity of the host key was the typical method used\\n+ /// to verify that they were connecting to the legitimate host,\\n+ /// assuming the private key of the remote host was not\\n+ /// compromised.\\n+ ///\\n+ /// If connection security is a high priority, examining\\n+ /// the parameters and aborting the connection if any weak\\n+ /// algorithms are used is also possible.\\n+ ///\\n+ /// \\\\return SSH session information or `std::nullopt` if it is not available\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] std::optional<SessionInfo> getSessionInfo() const;\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Log in using a username and a password\\n+ ///\\n+ /// Logging in is mandatory after connecting to the server.\\n+ /// Users that are not logged in cannot perform any operation.\\n+ ///\\n+ /// \\\\param name User name\\n+ /// \\\\param password Password\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of attempting to log in to the server\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result login(std::string_view name,\\n+ std::string_view password,\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Log in using a public/private key pair\\n+ ///\\n+ /// Logging in is mandatory after connecting to the server.\\n+ /// Users that are not logged in cannot perform any operation.\\n+ ///\\n+ /// This overload allows logging into the SFTP server using\\n+ /// public key authentication.\\n+ ///\\n+ /// The public and private key data should be provided in PEM\\n+ /// format. PEM encoded data can be easily recognized by their\\n+ /// `-----BEGIN ............-----` header and\\n+ /// `-----END ............-----` footer.\\n+ ///\\n+ /// Even though it is technically possible to derive the\\n+ /// public key from the private key, due to backend\\n+ /// limitations, providing a pre-generated public key as well\\n+ /// is necessary for this function to be able to succeed.\\n+ ///\\n+ /// If the private key is protected by a passphrase the\\n+ /// passphrase can be provided as a NULL terminated string.\\n+ /// If the private key is not protected by a passphrase the\\n+ /// passphrase should be set to the empty string.\\n+ ///\\n+ /// \\\\param name User name\\n+ /// \\\\param publicKeyData Public key data\\n+ /// \\\\param publicKeyLength Public key data length\\n+ /// \\\\param privateKeyData Private key data\\n+ /// \\\\param privateKeyLength Private key data length\\n+ /// \\\\param privateKeyPassphrase Private key passphrase, NULL terminated\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of attempting to log in to the server\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result login(std::string_view name,\\n+ const char* publicKeyData,\\n+ std::size_t publicKeyLength,\\n+ const char* privateKeyData,\\n+ std::size_t privateKeyLength,\\n+ const char* privateKeyPassphrase = \\\"\\\",\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Log in using a public/private key pair\\n+ ///\\n+ /// Logging in is mandatory after connecting to the server.\\n+ /// Users that are not logged in cannot perform any operation.\\n+ ///\\n+ /// This overload allows logging into the SFTP server using\\n+ /// public key authentication.\\n+ ///\\n+ /// The public and private key data should be provided in PEM\\n+ /// format. PEM encoded data can be easily recognized by their\\n+ /// `-----BEGIN ............-----` header and\\n+ /// `-----END ............-----` footer.\\n+ ///\\n+ /// Even though it is technically possible to derive the\\n+ /// public key from the private key, due to backend\\n+ /// limitations, providing a pre-generated public key as well\\n+ /// is necessary for this function to be able to succeed.\\n+ ///\\n+ /// If the private key is protected by a passphrase the\\n+ /// passphrase can be provided as a NULL terminated string.\\n+ /// If the private key is not protected by a passphrase the\\n+ /// passphrase should be set to the empty string.\\n+ ///\\n+ /// \\\\param name User name\\n+ /// \\\\param publicKeyData Public key data\\n+ /// \\\\param privateKeyData Private key data\\n+ /// \\\\param privateKeyPassphrase Private key passphrase\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of attempting to log in to the server\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result login(std::string_view name,\\n+ std::string_view publicKeyData,\\n+ std::string_view privateKeyData,\\n+ std::string_view privateKeyPassphrase = {},\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Resolve a remote path into an absolute remote path\\n+ ///\\n+ /// Paths can contain links and other reserved path identifiers\\n+ /// such as . and .. referring to the current directory and\\n+ /// parent directory respectively.\\n+ ///\\n+ /// When determining the absolute path, which does not contain\\n+ /// links or . or .. is necessary, this function can be used.\\n+ ///\\n+ /// Resolving \\\".\\\" will return the absolute path to the current\\n+ /// working directory of the user after logging in to the SFTP\\n+ /// server.\\n+ ///\\n+ /// \\\\param path Path to convert into an absolute path\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of converting the path into an absolute path\\n+ ///\\n+ /// \\\\see `getWorkingDirectory`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] PathResult resolvePath(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the current working directory on the server\\n+ ///\\n+ /// This is an alias for calling `resolvePath(\\\".\\\")`.\\n+ ///\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of getting the current working directory\\n+ ///\\n+ /// \\\\see `resolvePath`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] PathResult getWorkingDirectory(const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the attributes of a remote file or directory\\n+ ///\\n+ /// Depending on whether `path` refers to a file or directory,\\n+ /// the attributes can contain e.g. the type of file, the file\\n+ /// owner, group, file size, modification and access times.\\n+ ///\\n+ /// If links are not to be followed, `followLinks` can be set\\n+ /// to `false`. In this case the attributes of the link itself\\n+ /// will be returned.\\n+ ///\\n+ /// \\\\param path Path to the remote file or directory whose attributes to get\\n+ /// \\\\param followLinks `true` to follow links, `false` to return attributes of the link itself\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of getting the attributes\\n+ ///\\n+ /// \\\\see `getDirectoryListing`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] AttributesResult getAttributes(const std::filesystem::path& path,\\n+ bool followLinks = true,\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Get the contents of the given directory\\n+ ///\\n+ /// This function retrieves the sub-directories and files\\n+ /// contained in the given directory. It is not recursive.\\n+ ///\\n+ /// \\\\param path Path of the directory whose contents to list\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of getting the contents of the given directory\\n+ ///\\n+ /// \\\\see `getAttributes`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] ListingResult getDirectoryListing(const std::filesystem::path& path,\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Create a new directory\\n+ ///\\n+ /// The new directory is created as a child of the current\\n+ /// working directory.\\n+ ///\\n+ /// The default permissions value is equivalent to `rwxr-xr-x`\\n+ /// or 0755 in octal notation.\\n+ ///\\n+ /// \\\\param path Path of the directory to create\\n+ /// \\\\param permissions Permissions of the directory to create\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of creating the directory\\n+ ///\\n+ /// \\\\see `deleteDirectory`, `rename`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result createDirectory(\\n+ const std::filesystem::path& path,\\n+ std::filesystem::perms permissions = (std::filesystem::perms::owner_all | std::filesystem::perms::group_read |\\n+ std::filesystem::perms::group_exec | std::filesystem::perms::others_read |\\n+ std::filesystem::perms::others_exec),\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Remove an existing directory\\n+ ///\\n+ /// Use this function with caution, the directory will\\n+ /// be removed permanently!\\n+ ///\\n+ /// \\\\param path Path of the directory to remove\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of removing the directory\\n+ ///\\n+ /// \\\\see `createDirectory`, `rename`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result deleteDirectory(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Rename an existing file or directory\\n+ ///\\n+ /// In POSIX renaming and moving and synonymous. If you want\\n+ /// to move a file or directory from one place to another\\n+ /// you rename it from an old to a new path.\\n+ ///\\n+ /// If a file exists at the specified new path, depending\\n+ /// on whether `ovewrite` is set to true, the rename operation\\n+ /// will overwrite it or not. If a directory is being moved,\\n+ /// the new path must either not point to non-existant\\n+ /// directory or a directory that is empty. Non-empty\\n+ /// directories cannot be overwritten by this operation.\\n+ ///\\n+ /// \\\\param oldPath Old path to the file or directory\\n+ /// \\\\param newPath New path to the file or directory\\n+ /// \\\\param overwrite Set to `true` to allow overwriting a file that exists at `newPath`\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of the operation\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result rename(const std::filesystem::path& oldPath,\\n+ const std::filesystem::path& newPath,\\n+ bool overwrite = false,\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Remove an existing file\\n+ ///\\n+ /// Use this function with caution, the file will be\\n+ /// removed permanently!\\n+ ///\\n+ /// \\\\param path Path to the file to remove\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of removing the file\\n+ ///\\n+ /// \\\\see `rename`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result deleteFile(const std::filesystem::path& path, const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Download a file from the server\\n+ ///\\n+ /// This function retrieves the data in the file at the\\n+ /// remote path.\\n+ ///\\n+ /// The file data is transferred in sequential blocks. For\\n+ /// every block of data transferred, the provided callback\\n+ /// is called. The callback is passed a pointer to a data\\n+ /// block and the size of the data contained in the current\\n+ /// block. This size can change over time so it is important\\n+ /// to always check the size value to know how much data is\\n+ /// actually available. The callback should return `true` to\\n+ /// indicate to the `download` function that it should\\n+ /// continue to transfer data. If the data transfer should\\n+ /// be aborted earlier, `false` can be returned from the\\n+ /// callback.\\n+ ///\\n+ /// The function returns once all the data in the remote file\\n+ /// has been transferred or an error occurs or the function\\n+ /// times out.\\n+ ///\\n+ /// If reading from the remote file should not start at the\\n+ /// beginning of the file, you can specify an offset in\\n+ /// bytes at which reading should start.\\n+ ///\\n+ /// \\\\param remotePath Path of the remote file whose data to download\\n+ /// \\\\param callback Callback to be called for every available data block\\n+ /// \\\\param offset Byte offset into the remote file at which reading should start\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of downloading the file\\n+ ///\\n+ /// \\\\see `upload`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result download(const std::filesystem::path& remotePath,\\n+ const std::function<bool(const void* data, std::size_t size)>& callback,\\n+ std::uint64_t offset = 0,\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+ ////////////////////////////////////////////////////////////\\n+ /// \\\\brief Upload a file to the server\\n+ ///\\n+ /// This function writes data into a file at the remote path.\\n+ ///\\n+ /// The file data is transferred in sequential blocks. Every\\n+ /// time the function wants to send a new block of data the\\n+ /// provided callback is called. The callback is passed a\\n+ /// pointer to a data block and a reference to the size of\\n+ /// the data block. Data to be sent should be copied into\\n+ /// the data block using e.g. `std::memcpy` and the size value\\n+ /// set to the actual number of bytes copied into the data\\n+ /// block. The size of the block can change over time so it\\n+ /// is important to check the size value that is passed to\\n+ /// the callback to know how many bytes can actually be\\n+ /// copied into the data block. The callback should return\\n+ /// `true` to indicate to the `upload` function that it\\n+ /// should continue to transfer data. Once the data transfer\\n+ /// should be stopped e.g. because there is no more data left\\n+ /// to send, `false` can be returned from the callback.\\n+ ///\\n+ /// The function returns once all the data has been sent or\\n+ /// an error occurs or the function times out.\\n+ ///\\n+ /// If a file does not exist at the remote path yet, it will\\n+ /// be created with the provided permissions.\\n+ ///\\n+ /// If a file already exists at the remote path, setting\\n+ /// `truncate` to `true` will truncate the existing file\\n+ /// i.e. delete all pre-existing data before starting to\\n+ /// write the new data into the file.\\n+ ///\\n+ /// Setting `append` to `true` will append to a file if\\n+ /// it already exists.\\n+ ///\\n+ /// If writing to the remote file should not start at the\\n+ /// beginning of the file, you can specify an offset in\\n+ /// bytes at which writing should start.\\n+ ///\\n+ /// The default permissions value is equivalent to `rw-r--r--`\\n+ /// or 0644 in octal notation.\\n+ ///\\n+ /// \\\\param remotePath Path of the remote file in which to upload the data\\n+ /// \\\\param callback Callback to be called for every available data block\\n+ /// \\\\param permissions Permissions of the remote file if it has to be created\\n+ /// \\\\param truncate Set to `true` to truncate the remote file if it already exists\\n+ /// \\\\param append Set to `true` to append to the remote file if it already exists\\n+ /// \\\\param offset Byte offset into the remote file at which writing should start\\n+ /// \\\\param timeout Maximum time to wait, optionally a predicate can be provided for more fine-grained control\\n+ ///\\n+ /// \\\\return Result of uploading the file\\n+ ///\\n+ /// \\\\see `download`\\n+ ///\\n+ ////////////////////////////////////////////////////////////\\n+ [[nodiscard]] Result upload(\\n+ const std::filesystem::path& remotePath,\\n+ const std::function<bool(void* data, std::size_t& size)>& callback,\\n+ std::filesystem::perms permissions = (std::filesystem::perms::owner_read | std::filesystem::perms::owner_write |\\n+ std::filesystem::perms::group_read | std::filesystem::perms::others_read),\\n+ bool truncate = true,\\n+ bool append = false,\\n+ std::uint64_t offset = 0,\\n+ const TimeoutWithPredicate& timeout = Time::Zero);\\n+\\n+private:\\n+ ////////////////////////////////////////////////////////////\\n+ // Member data\\n+ ////////////////////////////////////////////////////////////\\n+ struct Impl;\\n+ std::unique_ptr<Impl> m_impl; //!< Implementation\\n+};\\n+\\n+} // namespace sf\\n+\\n+\\n+////////////////////////////////////////////////////////////\\n+/// \\\\class sf::Sftp\\n+/// \\\\ingroup network\\n+///\\n+/// `sf::Sftp` is a very simple SFTP client that allows you\\n+/// to communicate with a SFTP server. The SFTP protocol allows\\n+/// you to manipulate a remote file system (list files,\\n+/// upload, download, create, remove, ...).\\n+///\\n+/// Using the SFTP client consists of 4 parts:\\n+/// \\\\li Connecting to the SFTP server\\n+/// \\\\li Logging in (either using username and password or public key authentication)\\n+/// \\\\li Performing file system operations\\n+/// \\\\li Disconnecting (this part can be done implicitly by the destructor)\\n+///\\n+/// Every operation returns an SFTP result, which contains the\\n+/// result code and optionally a message describing the result. Some\\n+/// commands such as `getAttributes()` and `getDirectoryListing()`\\n+/// return additional data, and use a class derived from\\n+/// `sf::Sftp::Result` to provide this data. The commonly used filesystem\\n+/// operations are directly provided as member functions.\\n+///\\n+/// There are three classes of result values: general result values,\\n+/// SSH specific result values and SFTP specific result values. General\\n+/// result values are returned on success and errors not specific to the\\n+/// SSH or SFTP protocols. If an operation manipulating the remote\\n+/// filesystem fails, an SFTP specific result will be returned describing\\n+/// the reason for the failure. If any error related to the communication\\n+/// channel occurs e.g. key exchange failure or authentication failure an\\n+/// SSH error will be returned.\\n+///\\n+/// Because most operations manipulate some part of the remote filesystem\\n+/// these operations, especially upload and download, may take some\\n+/// time to complete. This is important to know if you don't want\\n+/// to block your application while the server is completing\\n+/// the task.\\n+///\\n+/// Every operation that relies on network communication can be passed\\n+/// a timeout argument. In the simplest case, this timeout argument can\\n+/// just be a fixed time duration after which the operation should time\\n+/// out if no progress has been made. Because some operations simply due\\n+/// to their nature can take longer than others it might not be possible\\n+/// to use the same timeout value for all operations. If it is anticipated\\n+/// that an operation could take a longer amount of time to complete due\\n+/// to e.g. an unreliable or slow connection, the timeout should be increased\\n+/// so the operation still has the possibility to complete successfully.\\n+/// Passing `sf::Time::Zero` as a timeout value will cause the operation\\n+/// to block until completion or failure.\\n+///\\n+/// If you want to pass `sf::Time::Zero` to wait indefinitely for an\\n+/// operation to complete but still have the possibility to interrupt the\\n+/// operation e.g. if the user decides to quit the application or interrupt\\n+/// a longer download or upload, the timeout can be constructed from a\\n+/// predicate and polling period. The predicate is a callable that takes\\n+/// no parameters and returns `true` if the operation should continue or\\n+/// `false` if the operation should time out. The time between consecutive\\n+/// evaluations of the predicate is specified by the `period` parameter.\\n+///\\n+/// Example of a `TimeoutWithPredicate`:\\n+/// \\\\code\\n+/// bool run = true;\\n+/// sf::Sftp::TimeoutWithPredicate timeout([&run]{ return run; }, sf::milliseconds(1));\\n+/// \\\\endcode\\n+/// When passed to an operation, the above `TimeoutWithPredicate` object will\\n+/// keep the operation running as long as `run` is `true`. The condition\\n+/// is checked every 1 millisecond. As soon as `run` is set to `false` the\\n+/// operation will terminate with a `Timeout` result.\\n+///\\n+/// Remember that attempting to modify variables from across threads will\\n+/// require proper synchronization using e.g. mutexes or atomics.\\n+///\\n+/// Because the filesystem operations will be performed on the remote\\n+/// system, the paths passed to the operations should be valid paths on\\n+/// the remote system. To guarantee portability, generic POSIX paths should\\n+/// be used. These use `/` as the path seperator and `.` to refer to the\\n+/// current directory and `..` to refer to the parent directory.\\n+///\\n+/// When logging into the server as a specific user the current directory\\n+/// will be set to the home directory that was specified for that user\\n+/// account. Because it cannot be assumed that the SFTP user is also allowed\\n+/// to log into a shell, changing the current directory from the home\\n+/// directory is not always possible and thus not supported. Thus when\\n+/// specifying paths, it is preferred to always make use of absolute paths\\n+/// when possible. Calling `getWorkingDirectory()` will return the current\\n+/// directory as an absolute path. Listing the contents of a directory whose\\n+/// path is passed as an absolute path will yield directory listing entries\\n+/// whose paths are extentions of the directory's path and thus also absolute\\n+/// paths. The `resolvePath()` function can be used to convert relative paths\\n+/// or paths containing links into absolute paths without links.\\n+///\\n+/// Usage example:\\n+/// \\\\code\\n+/// // Create a new SFTP client\\n+/// sf::Sftp sftp;\\n+///\\n+/// // Get the address of the server\\n+/// const auto addresses = sf::Dns::resolve(\\\"sftp.myserver.com\\\");\\n+///\\n+/// // Check if we have a valid address\\n+/// if (!addresses.has_value() || addresses->empty())\\n+/// {\\n+/// // Handle no valid address...\\n+/// }\\n+///\\n+/// // Connect to the server\\n+/// sf::Sftp::Result result = sftp.connect(addresses->front());\\n+/// if (result.isOk())\\n+/// std::cout << \\\"Connected\\\" << std::endl;\\n+///\\n+/// // Check session information and verify server\\n+/// std::optional<sf::Sftp::SessionInfo> info = sftp.getSessionInfo();\\n+/// if (info->hostKey.sha256 != expectedSha256)\\n+/// {\\n+/// std::cout << \\\"Server untrusted\\\" << std::endl;\\n+/// // Handle untrusted server\\n+/// }\\n+///\\n+/// // Log in\\n+/// result = sftp.login(\\\"sftpuser\\\", \\\"dF6Zm89D\\\");\\n+/// if (result.isOk())\\n+/// std::cout << \\\"Logged in\\\" << std::endl;\\n+///\\n+/// // Print the working directory\\n+/// sf::Sftp::PathResult directory = sftp.getWorkingDirectory();\\n+/// if (directory.isOk())\\n+/// std::cout << \\\"Working directory: \\\" << directory.getPath().string() << std::endl;\\n+///\\n+/// // Create a new directory\\n+/// result = sftp.createDirectory(\\\"files\\\");\\n+/// if (result.isOk())\\n+/// std::cout << \\\"Created new directory\\\" << std::endl;\\n+///\\n+/// // Upload a text file to this new directory\\n+/// result = sftp.upload(\\\"files/newfile.txt\\\", [](void* data, std::size_t& size)\\n+/// {\\n+/// // In your own code, ensure size is big enough to store your data\\n+/// // We skip the check here for simplicity\\n+/// std::memcpy(data, \\\"Hello World\\\", 11);\\n+/// size = 11;\\n+/// return false; // End transfer after this block\\n+/// });\\n+/// if (response.isOk())\\n+/// std::cout << \\\"File uploaded\\\" << std::endl;\\n+///\\n+/// // Rename file\\n+/// result = sftp.rename(\\\"files/newfile.txt\\\", \\\"files/newfile2.txt\\\");\\n+/// if (result.isOk())\\n+/// std::cout << \\\"Renamed file\\\" << std::endl;\\n+///\\n+/// // Download a text file from this new directory\\n+/// std::string text;\\n+/// result = sftp.download(\\\"files/newfile2.txt\\\", [&text](const void* data, std::size_t size)\\n+/// {\\n+/// text.append(static_cast<const char*>(data), size);\\n+/// return true; // Continue until all data received\\n+/// });\\n+/// if (response.isOk())\\n+/// std::cout << \\\"File downloaded: \\\" << text << std::endl;\\n+///\\n+/// // Delete file\\n+/// result = sftp.deleteFile(\\\"files/newfile2.txt\\\");\\n+/// if (result.isOk())\\n+/// std::cout << \\\"Deleted file\\\" << std::endl;\\n+///\\n+/// // Delete directory\\n+/// result = sftp.deleteDirectory(\\\"files\\\");\\n+/// if (result.isOk())\\n+/// std::cout << \\\"Deleted directory\\\" << std::endl;\\n+///\\n+/// // Disconnect from the server (optional)\\n+/// result = sftp.disconnect();\\n+/// if (result.isOk())\\n+/// std::cout << \\\"Disconnected successfully\\\" << std::endl;\\n+/// \\\\endcode\\n+///\\n+////////////////////////////////////////////////////////////\\n\"\n }\n]","isConversational":false},"test_patch":{"kind":"string","value":""},"merged":{"kind":"bool","value":true,"string":"true"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":100,"numItemsPerPage":100,"numTotalItems":87912,"offset":10000,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4Njc0Mjc2NiwianRpIjoiMzdlODE3OTItN2MzNS00NTNkLWEzNTgtMGQxZDg2MzE2YjFhIiwic3ViIjoiL2RhdGFzZXRzL1BvdGF0b0hEL2dpdGh1Yi1wci1yZXNvbHZlIiwiZXhwIjoxNzg2NzQ2MzY2LCJpc3MiOiJodHRwczovL2h1Z2dpbmdmYWNlLmNvIn0.uFYPpV7MALiLwNfOazmHO9yHG-Z0gZmpAbYqs05rpTqIR6C-CFEcUN9ZGYHmHwa5Oq_zGZqBq-mu7yngAXhxCQ","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":87912,"numBytesParquet":1412740926}]},"discussionsStats":{"closed":0,"open":0,"total":0},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
repo stringlengths 5 53 | pr_number int32 1 321k | task_type stringclasses 2
values | issue_text stringlengths 0 81.2k | pr_title stringlengths 1 319 | pr_body stringlengths 0 105k | base_sha stringlengths 40 40 | head_sha stringlengths 40 40 | gold_diff stringlengths 0 202M | changed_files listlengths 0 100 | review_threads listlengths 0 100 | test_patch stringlengths 0 23.4M | merged bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | TODO: remove this include | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/System/Android/Activity.hpp b/src/SFML/System/Android/Activity.hpp
index 965888e5ca..b8d02c097d 100644
--- a/src/SFML/System/Android/Activity.hpp
+++ b/src/SFML/System/Android/Activity.hpp
@@ -29,6 +29,7 @@
////////////////////////////////////////////////////////////
#include <SFML/Window/EglCon... | [
"src/SFML/System/Android/Activity.hpp"
] | [
{
"comment": "TODO: remove this include",
"path": "src/SFML/System/Android/Activity.hpp",
"hunk": "@@ -40,6 +41,7 @@\n #include <string>\n #include <unordered_map>\n #include <vector>\n+#include <map>",
"resolving_sha": "9d185f2160182c63dec9339365ce446775a2c730",
"resolving_diff": "diff --git a/... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | TODO: move JNI helpers to a dedicated file | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JoystickImpl.cpp b/src/SFML/Window/Android/JoystickImpl.cpp
index aad1aaf10d..f61c13bbc4 100644
--- a/src/SFML/Window/Android/JoystickImpl.cpp
+++ b/src/SFML/Window/Android/JoystickImpl.cpp
@@ -25,37 +25,154 @@
////////////////////////////////////////////////////////////
// Header... | [
"src/SFML/Window/Android/JoystickImpl.cpp"
] | [
{
"comment": "TODO: move JNI helpers to a dedicated file",
"path": "src/SFML/Window/Android/JoystickImpl.cpp",
"hunk": "@@ -26,52 +26,264 @@\n // Headers\n ////////////////////////////////////////////////////////////\n #include <SFML/Window/JoystickImpl.hpp>\n+#include <SFML/System/Err.hpp>\n+#include <... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | ```suggestion
Jni(Jni&& other) noexcept
{
std::swap(m_vm, other.m_vm);
}
Jni(const Jni&&) = delete;
~Jni()
{
if (m_vm)
m_vm->DetachCurrentThread();
}
``` | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JniHelper.hpp b/src/SFML/Window/Android/JniHelper.hpp
new file mode 100644
index 0000000000..3b543fe320
--- /dev/null
+++ b/src/SFML/Window/Android/JniHelper.hpp
@@ -0,0 +1,224 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia... | [
"src/SFML/Window/Android/JniHelper.hpp"
] | [
{
"comment": "```suggestion\r\n Jni(Jni&& other) noexcept\r\n {\r\n std::swap(m_vm, other.m_vm);\r\n }\r\n\r\n Jni(const Jni&&) = delete;\r\n\r\n ~Jni()\r\n {\r\n if (m_vm)\r\n m_vm->DetachCurrentThread();\r\n }\r\n```",
"path": "src/SFML/Window/Android/JniHelpe... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | Won't this cause issues with the indexing? Meaning, shouldn't this be `return true` instead?
What if I call `open(3)` twice in a row? Wouldn't it first register it and then on the second call register a different device for the same index, because we don't return here? | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JoystickImpl.cpp b/src/SFML/Window/Android/JoystickImpl.cpp
index aad1aaf10d..f61c13bbc4 100644
--- a/src/SFML/Window/Android/JoystickImpl.cpp
+++ b/src/SFML/Window/Android/JoystickImpl.cpp
@@ -25,37 +25,154 @@
////////////////////////////////////////////////////////////
// Header... | [
"src/SFML/Window/Android/JoystickImpl.cpp"
] | [
{
"comment": "Won't this cause issues with the indexing? Meaning, shouldn't this be `return true` instead?\r\n\r\nWhat if I call `open(3)` twice in a row? Wouldn't it first register it and then on the second call register a different device for the same index, because we don't return here?",
"path": "src/SF... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | In what scenarios can `getCapabilitiesFromJni` fail and is the right option to ignore this device? Or would it be better to call `return false` here? | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JoystickImpl.cpp b/src/SFML/Window/Android/JoystickImpl.cpp
index aad1aaf10d..f61c13bbc4 100644
--- a/src/SFML/Window/Android/JoystickImpl.cpp
+++ b/src/SFML/Window/Android/JoystickImpl.cpp
@@ -25,37 +25,154 @@
////////////////////////////////////////////////////////////
// Header... | [
"src/SFML/Window/Android/JoystickImpl.cpp"
] | [
{
"comment": "In what scenarios can `getCapabilitiesFromJni` fail and is the right option to ignore this device? Or would it be better to call `return false` here?",
"path": "src/SFML/Window/Android/JoystickImpl.cpp",
"hunk": "@@ -25,53 +25,147 @@\n //////////////////////////////////////////////////////... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | It's a bit more work, but it would align better with SFML's way to separating code, by having only declarations in the header, move the template implementations into an *.inl file and have the non-template implementation in the *.cpp file.
At least it should be consistent and not mixed as it currently is. | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JniHelper.hpp b/src/SFML/Window/Android/JniHelper.hpp
new file mode 100644
index 0000000000..3b543fe320
--- /dev/null
+++ b/src/SFML/Window/Android/JniHelper.hpp
@@ -0,0 +1,224 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia... | [
"src/SFML/Window/Android/JniHelper.hpp"
] | [
{
"comment": "It's a bit more work, but it would align better with SFML's way to separating code, by having only declarations in the header, move the template implementations into an *.inl file and have the non-template implementation in the *.cpp file.\r\n\r\nAt least it should be consistent and not mixed as i... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | ```suggestion
err() << "Failed to initialize JNI" << std::endl;
```
Copy-paste from `WindowImplAndroid::getUnicode` | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/WindowImplAndroid.cpp b/src/SFML/Window/Android/WindowImplAndroid.cpp
index 66fd3a0d0d..01cf6404e1 100644
--- a/src/SFML/Window/Android/WindowImplAndroid.cpp
+++ b/src/SFML/Window/Android/WindowImplAndroid.cpp
@@ -26,6 +26,7 @@
//////////////////////////////////////////////////////... | [
"src/SFML/Window/Android/WindowImplAndroid.cpp"
] | [
{
"comment": "```suggestion\r\n err() << \"Failed to initialize JNI\" << std::endl;\r\n```\r\n\r\nCopy-paste from `WindowImplAndroid::getUnicode`",
"path": "src/SFML/Window/Android/WindowImplAndroid.cpp",
"hunk": "@@ -330,19 +331,9 @@ int WindowImplAndroid::processEvent(int /* fd */, int /* event... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | No need for judgmental comments 😉
This is how the SFML API defines it and isn't Windows specific.
```suggestion
const float factor = 100.f; // SFML normalizes axis to the range <-100, 100> instead of <-1, 1>
``` | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/WindowImplAndroid.cpp b/src/SFML/Window/Android/WindowImplAndroid.cpp
index 66fd3a0d0d..01cf6404e1 100644
--- a/src/SFML/Window/Android/WindowImplAndroid.cpp
+++ b/src/SFML/Window/Android/WindowImplAndroid.cpp
@@ -26,6 +26,7 @@
//////////////////////////////////////////////////////... | [
"src/SFML/Window/Android/WindowImplAndroid.cpp"
] | [
{
"comment": "No need for judgmental comments 😉 \r\n\r\nThis is how the SFML API defines it and isn't Windows specific.\r\n\r\n```suggestion\r\n const float factor = 100.f; // SFML normalizes axis to the range <-100, 100> instead of <-1, 1>\r\n```",
"path": "src/SFML/Window/Android/WindowImplAnd... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | ```suggestion
/// \brief Convert a Android key to SFML key code / joystick button code
``` | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/WindowImplAndroid.hpp b/src/SFML/Window/Android/WindowImplAndroid.hpp
index e77acd95d9..98db3a79f1 100644
--- a/src/SFML/Window/Android/WindowImplAndroid.hpp
+++ b/src/SFML/Window/Android/WindowImplAndroid.hpp
@@ -27,6 +27,7 @@
//////////////////////////////////////////////////////... | [
"src/SFML/Window/Android/WindowImplAndroid.hpp"
] | [
{
"comment": "```suggestion\r\n /// \\brief Convert a Android key to SFML key code / joystick button code\r\n```",
"path": "src/SFML/Window/Android/WindowImplAndroid.hpp",
"hunk": "@@ -228,18 +230,23 @@ class WindowImplAndroid : public WindowImpl\n \n static int processScrollEvent(AInputEvent* in... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | What happens if `sfAxisToAndroid` returns `-1`? | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/WindowImplAndroid.cpp b/src/SFML/Window/Android/WindowImplAndroid.cpp
index 66fd3a0d0d..01cf6404e1 100644
--- a/src/SFML/Window/Android/WindowImplAndroid.cpp
+++ b/src/SFML/Window/Android/WindowImplAndroid.cpp
@@ -26,6 +26,7 @@
//////////////////////////////////////////////////////... | [
"src/SFML/Window/Android/WindowImplAndroid.cpp"
] | [
{
"comment": "What happens if `sfAxisToAndroid` returns `-1`?",
"path": "src/SFML/Window/Android/WindowImplAndroid.cpp",
"hunk": "@@ -492,6 +503,34 @@ int WindowImplAndroid::processMotionEvent(AInputEvent* inputEvent, ActivityState\n \n states.touchEvents[id] = touchMoved.position;\n ... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | ```suggestion
// There seems to be no direct mapping between input event and the ID of the device that
// caused the event. However, as the single input event contains all axii changes, it's possible
// to poll values for all axii in a single loop iteration.
//
... | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/WindowImplAndroid.cpp b/src/SFML/Window/Android/WindowImplAndroid.cpp
index 66fd3a0d0d..01cf6404e1 100644
--- a/src/SFML/Window/Android/WindowImplAndroid.cpp
+++ b/src/SFML/Window/Android/WindowImplAndroid.cpp
@@ -26,6 +26,7 @@
//////////////////////////////////////////////////////... | [
"src/SFML/Window/Android/WindowImplAndroid.cpp"
] | [
{
"comment": "```suggestion\r\n // There seems to be no direct mapping between input event and the ID of the device that\r\n // caused the event. However, as the single input event contains all axii changes, it's possible\r\n // to poll values for all axii in a single loop itera... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | We're missing a namespace here, wouldn't want to put this into the global namespace, even if it shouldn't be an issue.
I suggest: `namespace sf::priv` | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JniHelper.hpp b/src/SFML/Window/Android/JniHelper.hpp
new file mode 100644
index 0000000000..3b543fe320
--- /dev/null
+++ b/src/SFML/Window/Android/JniHelper.hpp
@@ -0,0 +1,224 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia... | [
"src/SFML/Window/Android/JniHelper.hpp"
] | [
{
"comment": "We're missing a namespace here, wouldn't want to put this into the global namespace, even if it shouldn't be an issue.\r\n\r\nI suggest: `namespace sf::priv`",
"path": "src/SFML/Window/Android/JniHelper.hpp",
"hunk": "@@ -0,0 +1,204 @@\n+////////////////////////////////////////////////////... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | Maybe instead of using `-1` as surrogate, we could use `std::optional` instead. | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JoystickImpl.hpp b/src/SFML/Window/Android/JoystickImpl.hpp
index e8c0c774e4..7c598d96fb 100644
--- a/src/SFML/Window/Android/JoystickImpl.hpp
+++ b/src/SFML/Window/Android/JoystickImpl.hpp
@@ -24,6 +24,13 @@
#pragma once
+///////////////////////////////////////////////////////... | [
"src/SFML/Window/Android/JoystickImpl.hpp"
] | [
{
"comment": "Maybe instead of using `-1` as surrogate, we could use `std::optional` instead.",
"path": "src/SFML/Window/Android/JoystickImpl.hpp",
"hunk": "@@ -94,13 +94,19 @@ class JoystickImpl\n /// \\return Joystick state\n ///\n //////////////////////////////////////////////////////////... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | Direct access should be fine, as we just check it above
```suggestion
states.joystickStates[m_currentDeviceIdx].axes,
states.joystickStates[m_currentDeviceIdx].buttons};
``` | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JoystickImpl.cpp b/src/SFML/Window/Android/JoystickImpl.cpp
index aad1aaf10d..f61c13bbc4 100644
--- a/src/SFML/Window/Android/JoystickImpl.cpp
+++ b/src/SFML/Window/Android/JoystickImpl.cpp
@@ -25,37 +25,154 @@
////////////////////////////////////////////////////////////
// Header... | [
"src/SFML/Window/Android/JoystickImpl.cpp"
] | [
{
"comment": "Direct access should be fine, as we just check it above\r\n\r\n```suggestion\r\n states.joystickStates[m_currentDeviceIdx].axes,\r\n states.joystickStates[m_currentDeviceIdx].buttons};\r\n```",
"path": "src/SFML/Window/Android/JoystickImpl.cpp",
"hunk": "@@ -83,10 +17... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | Direct access should be fine here, as we just checked it above:
```suggestion
auto& axes = states.joystickStates[deviceId].axes;
``` | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/WindowImplAndroid.cpp b/src/SFML/Window/Android/WindowImplAndroid.cpp
index 66fd3a0d0d..01cf6404e1 100644
--- a/src/SFML/Window/Android/WindowImplAndroid.cpp
+++ b/src/SFML/Window/Android/WindowImplAndroid.cpp
@@ -26,6 +26,7 @@
//////////////////////////////////////////////////////... | [
"src/SFML/Window/Android/WindowImplAndroid.cpp"
] | [
{
"comment": "Direct access should be fine here, as we just checked it above:\r\n\r\n```suggestion\r\n auto& axes = states.joystickStates[deviceId].axes;\r\n```",
"path": "src/SFML/Window/Android/WindowImplAndroid.cpp",
"hunk": "@@ -492,6 +503,28 @@ int WindowImplAndroid::processMotio... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | Direct access should be fine here, as we just checked it above:
```suggestion
states.joystickStates[deviceId].buttons[buttonIdx] = action == AKEY_EVENT_ACTION_DOWN;
``` | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/WindowImplAndroid.cpp b/src/SFML/Window/Android/WindowImplAndroid.cpp
index 66fd3a0d0d..01cf6404e1 100644
--- a/src/SFML/Window/Android/WindowImplAndroid.cpp
+++ b/src/SFML/Window/Android/WindowImplAndroid.cpp
@@ -26,6 +26,7 @@
//////////////////////////////////////////////////////... | [
"src/SFML/Window/Android/WindowImplAndroid.cpp"
] | [
{
"comment": "Direct access should be fine here, as we just checked it above:\r\n\r\n```suggestion\r\n states.joystickStates[deviceId].buttons[buttonIdx] = action == AKEY_EVENT_ACTION_DOWN;\r\n```",
"path": "src/SFML/Window/Android/WindowImplAndroid.cpp",
"hunk": "@@ -461,6 +458,20 @@ int WindowImplA... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | What's with all the private constructors and friend classes? Why not just use public constructors and drop the friends? What are we protecting against by doing this? | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JniHelper.hpp b/src/SFML/Window/Android/JniHelper.hpp
new file mode 100644
index 0000000000..3b543fe320
--- /dev/null
+++ b/src/SFML/Window/Android/JniHelper.hpp
@@ -0,0 +1,224 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia... | [
"src/SFML/Window/Android/JniHelper.hpp"
] | [
{
"comment": "What's with all the private constructors and friend classes? Why not just use public constructors and drop the friends? What are we protecting against by doing this?",
"path": "src/SFML/Window/Android/JniHelper.hpp",
"hunk": "@@ -0,0 +1,199 @@\n+////////////////////////////////////////////... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | Instead of using a pointer param and asserting it's not null, let's just use a `JNIEnv&` param. | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JniHelper.cpp b/src/SFML/Window/Android/JniHelper.cpp
new file mode 100644
index 0000000000..8c4b2f4f92
--- /dev/null
+++ b/src/SFML/Window/Android/JniHelper.cpp
@@ -0,0 +1,290 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia... | [
"src/SFML/Window/Android/JniHelper.cpp"
] | [
{
"comment": "Instead of using a pointer param and asserting it's not null, let's just use a `JNIEnv&` param. ",
"path": "src/SFML/Window/Android/JniHelper.cpp",
"hunk": "@@ -0,0 +1,286 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | See previous comment about using reference params instead of pointers. | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JniHelper.cpp b/src/SFML/Window/Android/JniHelper.cpp
new file mode 100644
index 0000000000..8c4b2f4f92
--- /dev/null
+++ b/src/SFML/Window/Android/JniHelper.cpp
@@ -0,0 +1,290 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia... | [
"src/SFML/Window/Android/JniHelper.cpp"
] | [
{
"comment": "See previous comment about using reference params instead of pointers.",
"path": "src/SFML/Window/Android/JniHelper.cpp",
"hunk": "@@ -0,0 +1,286 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-20... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | I'm not asking you to change how data is stored in the class. If it's important that these classes be reassignable, we can keep using a pointer instead of a reference. | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JniHelper.hpp b/src/SFML/Window/Android/JniHelper.hpp
new file mode 100644
index 0000000000..3b543fe320
--- /dev/null
+++ b/src/SFML/Window/Android/JniHelper.hpp
@@ -0,0 +1,224 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia... | [
"src/SFML/Window/Android/JniHelper.hpp"
] | [
{
"comment": "I'm not asking you to change how data is stored in the class. If it's important that these classes be reassignable, we can keep using a pointer instead of a reference.",
"path": "src/SFML/Window/Android/JniHelper.hpp",
"hunk": "@@ -145,16 +145,16 @@ class JniInputDevice\n class JniInputDev... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | There is no need to change the value of data members in a destructor. This is just dead code. I went ahead and removed this line. | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JniHelper.cpp b/src/SFML/Window/Android/JniHelper.cpp
new file mode 100644
index 0000000000..8c4b2f4f92
--- /dev/null
+++ b/src/SFML/Window/Android/JniHelper.cpp
@@ -0,0 +1,290 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia... | [
"src/SFML/Window/Android/JniHelper.cpp"
] | [
{
"comment": "There is no need to change the value of data members in a destructor. This is just dead code. I went ahead and removed this line.",
"path": "src/SFML/Window/Android/JniHelper.cpp",
"hunk": "@@ -242,39 +242,49 @@ std::optional<JniList<JniMotionRange, JniMotionRangeClass>> JniInputDevice::ge... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | Is there a situation where `m_vm` would be null upon destruction? I believe this pointer is guaranteed to be non-null to added an `assert` to enforce this. Do we want to store a reference internally here? | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JniHelper.cpp b/src/SFML/Window/Android/JniHelper.cpp
new file mode 100644
index 0000000000..8c4b2f4f92
--- /dev/null
+++ b/src/SFML/Window/Android/JniHelper.cpp
@@ -0,0 +1,290 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia... | [
"src/SFML/Window/Android/JniHelper.cpp"
] | [
{
"comment": "Is there a situation where `m_vm` would be null upon destruction? I believe this pointer is guaranteed to be non-null to added an `assert` to enforce this. Do we want to store a reference internally here? ",
"path": "src/SFML/Window/Android/JniHelper.cpp",
"hunk": "@@ -242,39 +242,49 @@ st... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | What was the reasoning for adding `getEnv`? It appears that anywhere we use `getEnv` we could also access the environment through `states.activity`. | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/WindowImplAndroid.cpp b/src/SFML/Window/Android/WindowImplAndroid.cpp
index 66fd3a0d0d..01cf6404e1 100644
--- a/src/SFML/Window/Android/WindowImplAndroid.cpp
+++ b/src/SFML/Window/Android/WindowImplAndroid.cpp
@@ -26,6 +26,7 @@
//////////////////////////////////////////////////////... | [
"src/SFML/Window/Android/WindowImplAndroid.cpp"
] | [
{
"comment": "What was the reasoning for adding `getEnv`? It appears that anywhere we use `getEnv` we could also access the environment through `states.activity`.",
"path": "src/SFML/Window/Android/WindowImplAndroid.cpp",
"hunk": "@@ -716,11 +717,12 @@ char32_t WindowImplAndroid::getUnicode(AInputEvent*... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | Name should match declaration in header:
```suggestion
bool JoystickImpl::open(unsigned int index)
``` | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JoystickImpl.cpp b/src/SFML/Window/Android/JoystickImpl.cpp
index aad1aaf10d..f61c13bbc4 100644
--- a/src/SFML/Window/Android/JoystickImpl.cpp
+++ b/src/SFML/Window/Android/JoystickImpl.cpp
@@ -25,37 +25,154 @@
////////////////////////////////////////////////////////////
// Header... | [
"src/SFML/Window/Android/JoystickImpl.cpp"
] | [
{
"comment": "Name should match declaration in header:\n\n\n```suggestion\nbool JoystickImpl::open(unsigned int index)\n```",
"path": "src/SFML/Window/Android/JoystickImpl.cpp",
"hunk": "@@ -25,53 +25,173 @@\n ////////////////////////////////////////////////////////////\n // Headers\n //////////////////... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | We're looping here, should we give up on the first missing capability or try to continue? | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JoystickImpl.cpp b/src/SFML/Window/Android/JoystickImpl.cpp
index aad1aaf10d..f61c13bbc4 100644
--- a/src/SFML/Window/Android/JoystickImpl.cpp
+++ b/src/SFML/Window/Android/JoystickImpl.cpp
@@ -25,37 +25,154 @@
////////////////////////////////////////////////////////////
// Header... | [
"src/SFML/Window/Android/JoystickImpl.cpp"
] | [
{
"comment": "We're looping here, should we give up on the first missing capability or try to continue?",
"path": "src/SFML/Window/Android/JoystickImpl.cpp",
"hunk": "@@ -25,53 +25,173 @@\n ////////////////////////////////////////////////////////////\n // Headers\n //////////////////////////////////////... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | Do we need to reset `m_currentDeviceIdx`? | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JoystickImpl.cpp b/src/SFML/Window/Android/JoystickImpl.cpp
index aad1aaf10d..f61c13bbc4 100644
--- a/src/SFML/Window/Android/JoystickImpl.cpp
+++ b/src/SFML/Window/Android/JoystickImpl.cpp
@@ -25,37 +25,154 @@
////////////////////////////////////////////////////////////
// Header... | [
"src/SFML/Window/Android/JoystickImpl.cpp"
] | [
{
"comment": "Do we need to reset `m_currentDeviceIdx`?",
"path": "src/SFML/Window/Android/JoystickImpl.cpp",
"hunk": "@@ -25,53 +25,173 @@\n ////////////////////////////////////////////////////////////\n // Headers\n ////////////////////////////////////////////////////////////\n+#include <SFML/Window/A... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | Can we align the type to be `ref` or `ptr` across the different classes? | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JniHelper.inl b/src/SFML/Window/Android/JniHelper.inl
new file mode 100644
index 0000000000..66ecce685b
--- /dev/null
+++ b/src/SFML/Window/Android/JniHelper.inl
@@ -0,0 +1,153 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia... | [
"src/SFML/Window/Android/JniHelper.inl"
] | [
{
"comment": "Can we align the type to be `ref` or `ptr` across the different classes?",
"path": "src/SFML/Window/Android/JniHelper.inl",
"hunk": "@@ -0,0 +1,149 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | Don't think there's a good reason to make `Jni` movable | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JniHelper.hpp b/src/SFML/Window/Android/JniHelper.hpp
new file mode 100644
index 0000000000..3b543fe320
--- /dev/null
+++ b/src/SFML/Window/Android/JniHelper.hpp
@@ -0,0 +1,224 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia... | [
"src/SFML/Window/Android/JniHelper.hpp"
] | [
{
"comment": "Don't think there's a good reason to make `Jni` movable",
"path": "src/SFML/Window/Android/JniHelper.hpp",
"hunk": "@@ -0,0 +1,224 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomi... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | Year needs to be updated everyhwere | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JoystickButton.hpp b/src/SFML/Window/Android/JoystickButton.hpp
new file mode 100644
index 0000000000..6a04da5553
--- /dev/null
+++ b/src/SFML/Window/Android/JoystickButton.hpp
@@ -0,0 +1,61 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and F... | [
"src/SFML/Window/Android/JoystickButton.hpp"
] | [
{
"comment": "Year needs to be updated everyhwere",
"path": "src/SFML/Window/Android/JoystickButton.hpp",
"hunk": "@@ -0,0 +1,61 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | This should actually be
```suggestion
assert(idx < m_length);
``` | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JniHelper.inl b/src/SFML/Window/Android/JniHelper.inl
new file mode 100644
index 0000000000..66ecce685b
--- /dev/null
+++ b/src/SFML/Window/Android/JniHelper.inl
@@ -0,0 +1,153 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia... | [
"src/SFML/Window/Android/JniHelper.inl"
] | [
{
"comment": "This should actually be\n```suggestion\n assert(idx < m_length);\n```",
"path": "src/SFML/Window/Android/JniHelper.inl",
"hunk": "@@ -0,0 +1,149 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | Missing `return 0;` statement | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/WindowImplAndroid.cpp b/src/SFML/Window/Android/WindowImplAndroid.cpp
index 66fd3a0d0d..01cf6404e1 100644
--- a/src/SFML/Window/Android/WindowImplAndroid.cpp
+++ b/src/SFML/Window/Android/WindowImplAndroid.cpp
@@ -26,6 +26,7 @@
//////////////////////////////////////////////////////... | [
"src/SFML/Window/Android/WindowImplAndroid.cpp"
] | [
{
"comment": "Missing `return 0;` statement",
"path": "src/SFML/Window/Android/WindowImplAndroid.cpp",
"hunk": "@@ -810,22 +849,13 @@ char32_t WindowImplAndroid::getUnicode(AInputEvent* event)\n ActivityStates& states = getActivity();\n const std::lock_guard lock(states.mutex);\n \n- //... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | I think Thrasher already hinted at that, but this will lead to the moved-from object to retain a valid pointer, that could potentially corrupt the moved-to object, once the destructor is called.
```suggestion
Jni::Jni(Jni&& other) noexcept :
m_vm(other.m_vm),
m_env(other.m_env)
{
other.m_vm = nullptr;
... | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JniHelper.cpp b/src/SFML/Window/Android/JniHelper.cpp
new file mode 100644
index 0000000000..8c4b2f4f92
--- /dev/null
+++ b/src/SFML/Window/Android/JniHelper.cpp
@@ -0,0 +1,290 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia... | [
"src/SFML/Window/Android/JniHelper.cpp"
] | [
{
"comment": "I think Thrasher already hinted at that, but this will lead to the moved-from object to retain a valid pointer, that could potentially corrupt the moved-to object, once the destructor is called.\n\n\n```suggestion\nJni::Jni(Jni&& other) noexcept :\n m_vm(other.m_vm),\n m_env(other.m_env)\n{\... | true | ||
SFML/SFML | 3,497 | comment_to_fix | Feature: Android joystick support | Same issue as with the Jni class
```suggestion
JniArray(JniArray&& other) noexcept :
m_env(other.m_env),
m_array(other.m_array),
m_length(other.m_length),
m_data(other.m_data)
{
other.m_env = nullptr;
other.m_array = nullptr;
other.m_length = 0;
o... | 3577f199477afadb547d6088b26d971023db998a | 9d185f2160182c63dec9339365ce446775a2c730 | diff --git a/src/SFML/Window/Android/JniHelper.inl b/src/SFML/Window/Android/JniHelper.inl
new file mode 100644
index 0000000000..66ecce685b
--- /dev/null
+++ b/src/SFML/Window/Android/JniHelper.inl
@@ -0,0 +1,153 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia... | [
"src/SFML/Window/Android/JniHelper.inl"
] | [
{
"comment": "Same issue as with the Jni class\n\n```suggestion\n JniArray(JniArray&& other) noexcept :\n m_env(other.m_env),\n m_array(other.m_array),\n m_length(other.m_length),\n m_data(other.m_data)\n {\n other.m_env = nullptr;\n other.m_array = nullptr;\n ... | true | ||
SFML/SFML | 3,704 | issue_to_patch | Add deprecations for the documentation | ## Description
- Makes it visible in the doxygen documentation
- Lists it under the deprecation in the doxygen documentation
## How to test this PR?
- Documentation should build
- Should be visible in the documentation | 08996418f52315b4ec8d85be089b13fec1f96613 | 7868817f8d691c3cc7e33370c720dc9c88fbdb22 | diff --git a/include/SFML/Graphics/Text.hpp b/include/SFML/Graphics/Text.hpp
index aa0b7c8c4a..39edc48db6 100644
--- a/include/SFML/Graphics/Text.hpp
+++ b/include/SFML/Graphics/Text.hpp
@@ -478,6 +478,8 @@ class SFML_GRAPHICS_API Text : public Drawable, public Transformable
///////////////////////////////////////... | [
"include/SFML/Graphics/Text.hpp",
"include/SFML/Network/Ftp.hpp",
"include/SFML/Network/IpAddress.hpp"
] | [] | true | ||
SFML/SFML | 3,703 | issue_to_patch | Disable HarfBuzz GPU library, was SFML doesn't use it yet | ## Description
[Version 14.0.0](https://github.com/harfbuzz/harfbuzz/releases/tag/14.0.0) introduced libharfbuzz-gpu with the Slug algorithm, but as we're not using it (yet?!), there's no need in building said library.
## How to test this PR?
CI should pass | 01071fa097301ccb364a943db4fd3fd9ebbd8768 | 39481f6894252b1e32a23ea9ef9dd0c1277f5f2a | diff --git a/src/SFML/Graphics/CMakeLists.txt b/src/SFML/Graphics/CMakeLists.txt
index f5a234d837..bba99cd738 100644
--- a/src/SFML/Graphics/CMakeLists.txt
+++ b/src/SFML/Graphics/CMakeLists.txt
@@ -152,6 +152,7 @@ else()
set(HB_BUILD_SUBSET OFF)
set(HB_BUILD_RASTER OFF)
set(HB_BUILD_VECTOR O... | [
"src/SFML/Graphics/CMakeLists.txt"
] | [] | true | ||
SFML/SFML | 3,702 | issue_to_patch | Fixed audio issues | This changeset fixes 2 minor issues:
- The sample rate used by the sound effects example was incorrectly using the sample rate of the source audio data and not the sample rate of the playback device which is the sample rate of the data passed to the processing callback
- The size of the audio frame buffer that was au... | 97fa81b43c8d6cabf5fbacb957dd75b991923062 | 33f04e49ed439b943749089425fd250dc4357f19 | diff --git a/examples/sound_effects/SoundEffects.cpp b/examples/sound_effects/SoundEffects.cpp
index 49edace91e..647e568e31 100644
--- a/examples/sound_effects/SoundEffects.cpp
+++ b/examples/sound_effects/SoundEffects.cpp
@@ -811,7 +811,8 @@ struct HighPassFilter : BiquadFilter
{
static constexpr auto cu... | [
"examples/sound_effects/SoundEffects.cpp",
"include/SFML/Audio/SoundSource.hpp",
"src/SFML/Audio/AudioDevice.cpp"
] | [] | true | ||
SFML/SFML | 3,701 | issue_to_patch | Update dependencies | ## Description
- Update miniaudio to v0.11.25
- Update ogg to v1.3.6
- Update FLAC to v1.5.0
- Update FreeType to v2.14.3
- Update HarfBuzz to v14.1.0
- Update all GitHub Actions
## How to test this PR?
- CI should pass
- Test text rendering
- Test OGG loading / saving
- Test FLAC loading / saving
- T... | 548cdb9c394da1b08e563a1d7f6fa6225a6f3ece | a5b0eeef674b5f772a1b545f058de33e42eb9b41 | diff --git a/.github/workflows/analyze.yml b/.github/workflows/analyze.yml
index 6f686d6ca6..dd5136a9c3 100644
--- a/.github/workflows/analyze.yml
+++ b/.github/workflows/analyze.yml
@@ -32,7 +32,7 @@ jobs:
steps:
- name: Checkout Code
- uses: actions/checkout@v4
+ uses: actions/checkout@v6
... | [
".github/workflows/analyze.yml",
".github/workflows/build.yml",
".github/workflows/docs.yml",
".github/workflows/format.yml",
".github/workflows/release.yml",
"extlibs/headers/miniaudio/miniaudio.h",
"src/SFML/Audio/CMakeLists.txt",
"src/SFML/Graphics/CMakeLists.txt",
"tools/flac/PatchFLAC.cmake",
... | [] | true | ||
SFML/SFML | 3,700 | issue_to_patch | Avoid symbol conflict when static linking with a lib shipping own QOI | ## Description
When several libraries linked statically into the project ship an "implementation header" C library/functions, the linker may end up with multiple symbols conflict, especially when the original sources were tweaked.
With SFML, this happens e.g. when linking statically with the KTX library or Basis Un... | 765d790f4ccdad20ca7aef5ad4d8588a4629a4b5 | 1577de07ed0d97c3d5fd07d5e8c935740a9507af | diff --git a/src/SFML/Graphics/Image.cpp b/src/SFML/Graphics/Image.cpp
index aeefc4b48b..c592140393 100644
--- a/src/SFML/Graphics/Image.cpp
+++ b/src/SFML/Graphics/Image.cpp
@@ -37,6 +37,10 @@
#endif
#define QOI_IMPLEMENTATION
+#define qoi_decode sf_qoi_decode
+#define qoi_encode sf_qoi_encode
+#define qoi_read ... | [
"src/SFML/Graphics/Image.cpp"
] | [] | true | ||
SFML/SFML | 3,696 | issue_to_patch | Allow configuring the default CA store at build time
### Prerequisite Checklist
- [x] I searched for [existing issues](https://github.com/search?q=repo%3ASFML%2FSFML&type=issues) to prevent duplicates
- [x] I searched for [existing discussions on the forum](https://www.google.com/search?q=site%3Ahttps%3A%2F%2Fen.sfml... | Allow loading a CA bundle from a custom path using the SFML_CA_BUNDLE_PATH CMake option | Title.
Some users may want to specify a specific CA bundle file to populate the CA certificate store, see #3694.
When the user sets the `SFML_CA_PATH` CMake option on the applicable systems, it is used instead of the built-in search directories to load system certificates from.
Fixes #3694
@jcowgill | 9120eeb6a36186961b80efece608caaba606d64e | 2e02996ea98e7ac44cfd434b1453feb0b60d70fe | diff --git a/src/SFML/Network/CMakeLists.txt b/src/SFML/Network/CMakeLists.txt
index d62e802b76..cf77462186 100644
--- a/src/SFML/Network/CMakeLists.txt
+++ b/src/SFML/Network/CMakeLists.txt
@@ -139,3 +139,10 @@ endif()
if(SFML_OS_MACOS)
target_link_libraries(sfml-network PRIVATE "-framework Security" "-framework... | [
"src/SFML/Network/CMakeLists.txt",
"src/SFML/Network/TcpSocket.cpp"
] | [
{
"comment": "Any reason to go with `#ifdef` here instead of `#if defined()` as with the other defs?",
"path": "src/SFML/Network/TcpSocket.cpp",
"hunk": "@@ -154,6 +154,19 @@ bool loadSystemCertificates([[maybe_unused]] mbedtls_x509_crt* x509crt, [[maybe_\n return loadStore(\"ROOT\") && loadStore(\"... | true | |
SFML/SFML | 3,696 | comment_to_fix | Allow loading a CA bundle from a custom path using the SFML_CA_BUNDLE_PATH CMake option | Any reason to go with `#ifdef` here instead of `#if defined()` as with the other defs? | 9120eeb6a36186961b80efece608caaba606d64e | 2e02996ea98e7ac44cfd434b1453feb0b60d70fe | diff --git a/src/SFML/Network/TcpSocket.cpp b/src/SFML/Network/TcpSocket.cpp
index 52703b9a4a..f4f1b59da5 100644
--- a/src/SFML/Network/TcpSocket.cpp
+++ b/src/SFML/Network/TcpSocket.cpp
@@ -154,6 +154,36 @@ bool loadSystemCertificates([[maybe_unused]] mbedtls_x509_crt* x509crt, [[maybe_
return loadStore("ROOT") &... | [
"src/SFML/Network/TcpSocket.cpp"
] | [
{
"comment": "Any reason to go with `#ifdef` here instead of `#if defined()` as with the other defs?",
"path": "src/SFML/Network/TcpSocket.cpp",
"hunk": "@@ -154,6 +154,19 @@ bool loadSystemCertificates([[maybe_unused]] mbedtls_x509_crt* x509crt, [[maybe_\n return loadStore(\"ROOT\") && loadStore(\"... | true | ||
SFML/SFML | 3,696 | comment_to_fix | Allow loading a CA bundle from a custom path using the SFML_CA_BUNDLE_PATH CMake option | Should we add a check, that validates the path first or do we delegate that to MbedTls? | 9120eeb6a36186961b80efece608caaba606d64e | 2e02996ea98e7ac44cfd434b1453feb0b60d70fe | diff --git a/src/SFML/Network/TcpSocket.cpp b/src/SFML/Network/TcpSocket.cpp
index 52703b9a4a..f4f1b59da5 100644
--- a/src/SFML/Network/TcpSocket.cpp
+++ b/src/SFML/Network/TcpSocket.cpp
@@ -154,6 +154,36 @@ bool loadSystemCertificates([[maybe_unused]] mbedtls_x509_crt* x509crt, [[maybe_
return loadStore("ROOT") &... | [
"src/SFML/Network/TcpSocket.cpp"
] | [
{
"comment": "Should we add a check, that validates the path first or do we delegate that to MbedTls?",
"path": "src/SFML/Network/TcpSocket.cpp",
"hunk": "@@ -154,6 +154,19 @@ bool loadSystemCertificates([[maybe_unused]] mbedtls_x509_crt* x509crt, [[maybe_\n return loadStore(\"ROOT\") && loadStore(\... | true | ||
SFML/SFML | 3,519 | issue_to_patch | Use const ref instead of cloning channelMap | getChannelMap was cloning the data unnecessarily. It wasn't building the data in the function, so I saw no reason why it had to pass by value instead of simply passing by const reference.
This is just a proposal, so nothing too serious. The one major benefit is simply being more consistent. There are other uses of t... | 406ad93700dc0e241af0948f8443fb39d883f081 | 12ce307c36675c07dc5a5eee10d39a0918876180 | diff --git a/include/SFML/Audio/SoundBuffer.hpp b/include/SFML/Audio/SoundBuffer.hpp
index 3fa2484b63..c071bcfe28 100644
--- a/include/SFML/Audio/SoundBuffer.hpp
+++ b/include/SFML/Audio/SoundBuffer.hpp
@@ -291,7 +291,7 @@ class SFML_AUDIO_API SoundBuffer
/// \see `getSampleRate`, `getChannelCount`, `getDuration`
... | [
"include/SFML/Audio/SoundBuffer.hpp",
"include/SFML/Audio/SoundStream.hpp",
"src/SFML/Audio/SoundBuffer.cpp",
"src/SFML/Audio/SoundStream.cpp"
] | [] | true | ||
SFML/SFML | 3,697 | issue_to_patch | [Android] portable linker rule to keep symbol `ANativeActivity_onCreate` | ## Fixes
Without this, the `ANativeActivity_onCreate` was being stripped and the app would crash at launch.
After the fix, the sfml android app launches and runs as expected.
## Description
Retains `-u` behavior by using recommended cmake `"LINKER:<expr>"` expression format while building for android with dif... | 9120eeb6a36186961b80efece608caaba606d64e | c9138de729f81cde8ee5a6d80bcda4d8043f4b5c | diff --git a/src/SFML/Main/CMakeLists.txt b/src/SFML/Main/CMakeLists.txt
index 22630ebda9..d536646f0f 100644
--- a/src/SFML/Main/CMakeLists.txt
+++ b/src/SFML/Main/CMakeLists.txt
@@ -30,7 +30,7 @@ if(SFML_OS_ANDROID)
target_link_libraries(sfml-main PRIVATE android)
# Ensure this method is not stripped
- ... | [
"src/SFML/Main/CMakeLists.txt"
] | [] | true | ||
SFML/SFML | 3,691 | issue_to_patch | Added support for retrieving the library version that is loaded at runtime via sf::version() | Title.
If application code relies on the `SFML_VERSION_` `#define`s to output the library version during runtime e.g. for diagnostic or error reporting purposes it will always output the version of the headers that were included when the application was built. When running an application that is dynamically linked, ... | 9120eeb6a36186961b80efece608caaba606d64e | bc6f11261ac5996173b0060af7dbac71e03cf115 | diff --git a/examples/text/Text.cpp b/examples/text/Text.cpp
index b459fbfc86..3c173f8a7b 100644
--- a/examples/text/Text.cpp
+++ b/examples/text/Text.cpp
@@ -15,14 +15,6 @@
#include <cmath>
-#define STR_HELPER(x) #x
-#define STR(x) STR_HELPER(x)
-
-// SFML version string wrapped in unicode directional form... | [
"examples/text/Text.cpp",
"include/SFML/System.hpp",
"include/SFML/System/Version.hpp",
"src/SFML/Network/TcpSocket.cpp",
"src/SFML/System/CMakeLists.txt",
"src/SFML/System/Version.cpp",
"test/System/CMakeLists.txt",
"test/System/Version.test.cpp"
] | [
{
"comment": "Just like the Config.hpp tests, we can get the exact version numbers from CMake to make these tests more precise.",
"path": "test/System/Version.test.cpp",
"hunk": "@@ -0,0 +1,12 @@\n+#include <SFML/System/Version.hpp>\n+\n+#include <catch2/catch_test_macros.hpp>\n+\n+TEST_CASE(\"[System] ... | diff --git a/test/System/CMakeLists.txt b/test/System/CMakeLists.txt
index 5647ebef45..7cc632b95d 100644
--- a/test/System/CMakeLists.txt
+++ b/test/System/CMakeLists.txt
@@ -13,6 +13,7 @@ set(SYSTEM_SRC
Utf.test.cpp
Vector2.test.cpp
Vector3.test.cpp
+ Version.test.cpp
)
sfml_add_test(test-sfml-syst... | true | |
SFML/SFML | 3,691 | comment_to_fix | Added support for retrieving the library version that is loaded at runtime via sf::version() | Just like the Config.hpp tests, we can get the exact version numbers from CMake to make these tests more precise. | 9120eeb6a36186961b80efece608caaba606d64e | bc6f11261ac5996173b0060af7dbac71e03cf115 | diff --git a/test/System/Version.test.cpp b/test/System/Version.test.cpp
new file mode 100644
index 0000000000..02d071135f
--- /dev/null
+++ b/test/System/Version.test.cpp
@@ -0,0 +1,23 @@
+#include <SFML/System/Version.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+
+TEST_CASE("[System] sf::version")
+{
+ const a... | [
"test/System/Version.test.cpp"
] | [
{
"comment": "Just like the Config.hpp tests, we can get the exact version numbers from CMake to make these tests more precise.",
"path": "test/System/Version.test.cpp",
"hunk": "@@ -0,0 +1,12 @@\n+#include <SFML/System/Version.hpp>\n+\n+#include <catch2/catch_test_macros.hpp>\n+\n+TEST_CASE(\"[System] ... | true | ||
SFML/SFML | 3,691 | comment_to_fix | Added support for retrieving the library version that is loaded at runtime via sf::version() | I’d slightly prefer omitting `-release` from official releases, but I can live with this. | 9120eeb6a36186961b80efece608caaba606d64e | bc6f11261ac5996173b0060af7dbac71e03cf115 | diff --git a/src/SFML/System/Version.cpp b/src/SFML/System/Version.cpp
new file mode 100644
index 0000000000..020f021c0c
--- /dev/null
+++ b/src/SFML/System/Version.cpp
@@ -0,0 +1,50 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007... | [
"src/SFML/System/Version.cpp"
] | [
{
"comment": "I’d slightly prefer omitting `-release` from official releases, but I can live with this.",
"path": "src/SFML/System/Version.cpp",
"hunk": "@@ -0,0 +1,50 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C)... | true | ||
SFML/SFML | 3,691 | comment_to_fix | Added support for retrieving the library version that is loaded at runtime via sf::version() | Maybe use a smaller int type to micro optimize memory usage and because SFML will likely not reach major version numbers greater than 255 😅
Fixed width ints are marginally more ABI stable which is usually not something I’d think twice about, but this API is motivated by a use case that relies on stable-ish ABIs so it... | 9120eeb6a36186961b80efece608caaba606d64e | bc6f11261ac5996173b0060af7dbac71e03cf115 | diff --git a/include/SFML/System/Version.hpp b/include/SFML/System/Version.hpp
new file mode 100644
index 0000000000..ebcd5f22b5
--- /dev/null
+++ b/include/SFML/System/Version.hpp
@@ -0,0 +1,71 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyri... | [
"include/SFML/System/Version.hpp"
] | [
{
"comment": "Maybe use a smaller int type to micro optimize memory usage and because SFML will likely not reach major version numbers greater than 255 😅\n\nFixed width ints are marginally more ABI stable which is usually not something I’d think twice about, but this API is motivated by a use case that relies ... | true | ||
SFML/SFML | 3,691 | comment_to_fix | Added support for retrieving the library version that is loaded at runtime via sf::version() | Does this clang-tidy check fire even when using the codepoint inside a string? The docs are a bit light on this check so it’s hard to tell how it behaves inside of strings. It only provides an example of using this outside of a string. | 9120eeb6a36186961b80efece608caaba606d64e | bc6f11261ac5996173b0060af7dbac71e03cf115 | diff --git a/examples/text/Text.cpp b/examples/text/Text.cpp
index b459fbfc86..3c173f8a7b 100644
--- a/examples/text/Text.cpp
+++ b/examples/text/Text.cpp
@@ -15,14 +15,6 @@
#include <cmath>
-#define STR_HELPER(x) #x
-#define STR(x) STR_HELPER(x)
-
-// SFML version string wrapped in unicode directional form... | [
"examples/text/Text.cpp"
] | [
{
"comment": "Does this clang-tidy check fire even when using the codepoint inside a string? The docs are a bit light on this check so it’s hard to tell how it behaves inside of strings. It only provides an example of using this outside of a string.",
"path": "examples/text/Text.cpp",
"hunk": "@@ -37,6 ... | true | ||
SFML/SFML | 3,691 | comment_to_fix | Added support for retrieving the library version that is loaded at runtime via sf::version() | This macro is not used anymore. | 9120eeb6a36186961b80efece608caaba606d64e | bc6f11261ac5996173b0060af7dbac71e03cf115 | diff --git a/src/SFML/Network/TcpSocket.cpp b/src/SFML/Network/TcpSocket.cpp
index 52703b9a4a..f0533dbef9 100644
--- a/src/SFML/Network/TcpSocket.cpp
+++ b/src/SFML/Network/TcpSocket.cpp
@@ -33,6 +33,7 @@
#include <SFML/System/Err.hpp>
#include <SFML/System/String.hpp>
+#include <SFML/System/Version.hpp>
#includ... | [
"src/SFML/Network/TcpSocket.cpp"
] | [
{
"comment": "This macro is not used anymore.",
"path": "src/SFML/Network/TcpSocket.cpp",
"hunk": "@@ -323,9 +324,8 @@ struct MbedTlsSharedState\n #define SFML_NUMBER_TO_STRING_HELPER(x) #x\n #define SFML_NUMBER_TO_STRING(x) SFML_NUMBER_TO_STRING_HELPER(x)",
"resolving_sha": "bc6f11261ac59961... | true | ||
SFML/SFML | 3,691 | comment_to_fix | Added support for retrieving the library version that is loaded at runtime via sf::version() | ```suggestion
/// which SFML version is currently loaded at runtime, it
``` | 9120eeb6a36186961b80efece608caaba606d64e | bc6f11261ac5996173b0060af7dbac71e03cf115 | diff --git a/include/SFML/System/Version.hpp b/include/SFML/System/Version.hpp
new file mode 100644
index 0000000000..ebcd5f22b5
--- /dev/null
+++ b/include/SFML/System/Version.hpp
@@ -0,0 +1,71 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyri... | [
"include/SFML/System/Version.hpp"
] | [
{
"comment": "```suggestion\n/// which SFML version is currently loaded at runtime, it\n```",
"path": "include/SFML/System/Version.hpp",
"hunk": "@@ -0,0 +1,71 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-20... | true | ||
SFML/SFML | 3,695 | issue_to_patch | SocketSelector test fails with the default open file descriptor limit
### Prerequisite Checklist
- [x] I searched for [existing issues](https://github.com/search?q=repo%3ASFML%2FSFML&type=issues) to prevent duplicates
- [x] I searched for [existing discussions on the forum](https://www.google.com/search?q=site%3Ahttp... | Allow configuring the maximum number of file descriptors opened during network tests | Title.
Some users might have their ulimit for nofds set to the common value of 1024. This means that a single process cannot open more than 1024 file descriptors (this includes sockets). The recently added socket selector tests assumed that this limit would be increased by users who intended to run those tests on th... | 9120eeb6a36186961b80efece608caaba606d64e | 27d6e4c2edc2cf56abe8f7d56cfec1406642f455 | diff --git a/.github/workflows/analyze.yml b/.github/workflows/analyze.yml
index 7fe8e4d60a..6f686d6ca6 100644
--- a/.github/workflows/analyze.yml
+++ b/.github/workflows/analyze.yml
@@ -59,7 +59,7 @@ jobs:
echo "$(brew --prefix llvm@18)/bin" >> $GITHUB_PATH
- name: Configure
- run: cmake --preset ... | [
".github/workflows/analyze.yml",
".github/workflows/build.yml",
"test/Network/CMakeLists.txt",
"test/Network/SocketSelector.test.cpp"
] | [
{
"comment": "Is it okay to use `std::cout` in a test? Does Catch2 provide a \"logging\" interface?",
"path": "test/Network/SocketSelector.test.cpp",
"hunk": "@@ -36,8 +37,12 @@ TEST_CASE(\"[Network] sf::SocketSelector\")\n \n TEST_CASE(\"[Network] sf::SocketSelector Many Connections\", runIpV4LoopbackT... | diff --git a/test/Network/CMakeLists.txt b/test/Network/CMakeLists.txt
index 83b69737f7..7e8a11c83e 100644
--- a/test/Network/CMakeLists.txt
+++ b/test/Network/CMakeLists.txt
@@ -13,6 +13,10 @@ set(NETWORK_SRC
UdpSocket.test.cpp
)
sfml_add_test(test-sfml-network "${NETWORK_SRC}" SFML::Network)
+
+sfml_set_option... | true |
SFML/SFML | 3,695 | comment_to_fix | Allow configuring the maximum number of file descriptors opened during network tests | Is it okay to use `std::cout` in a test? Does Catch2 provide a "logging" interface? | 9120eeb6a36186961b80efece608caaba606d64e | 27d6e4c2edc2cf56abe8f7d56cfec1406642f455 | diff --git a/test/Network/SocketSelector.test.cpp b/test/Network/SocketSelector.test.cpp
index b8d86e63e6..39b3f3201c 100644
--- a/test/Network/SocketSelector.test.cpp
+++ b/test/Network/SocketSelector.test.cpp
@@ -9,6 +9,7 @@
#include <NetworkUtil.hpp>
#include <algorithm>
+#include <iostream>
#include <list>
#i... | [
"test/Network/SocketSelector.test.cpp"
] | [
{
"comment": "Is it okay to use `std::cout` in a test? Does Catch2 provide a \"logging\" interface?",
"path": "test/Network/SocketSelector.test.cpp",
"hunk": "@@ -36,8 +37,12 @@ TEST_CASE(\"[Network] sf::SocketSelector\")\n \n TEST_CASE(\"[Network] sf::SocketSelector Many Connections\", runIpV4LoopbackT... | true | ||
SFML/SFML | 3,695 | comment_to_fix | Allow configuring the maximum number of file descriptors opened during network tests | Should we have a fallback in C++ code or is it good enough to rely on CMake providing the def? | 9120eeb6a36186961b80efece608caaba606d64e | 27d6e4c2edc2cf56abe8f7d56cfec1406642f455 | diff --git a/test/Network/SocketSelector.test.cpp b/test/Network/SocketSelector.test.cpp
index b8d86e63e6..39b3f3201c 100644
--- a/test/Network/SocketSelector.test.cpp
+++ b/test/Network/SocketSelector.test.cpp
@@ -9,6 +9,7 @@
#include <NetworkUtil.hpp>
#include <algorithm>
+#include <iostream>
#include <list>
#i... | [
"test/Network/SocketSelector.test.cpp"
] | [
{
"comment": "Should we have a fallback in C++ code or is it good enough to rely on CMake providing the def?",
"path": "test/Network/SocketSelector.test.cpp",
"hunk": "@@ -36,8 +37,12 @@ TEST_CASE(\"[Network] sf::SocketSelector\")\n \n TEST_CASE(\"[Network] sf::SocketSelector Many Connections\", runIpV4... | true | ||
SFML/SFML | 3,684 | issue_to_patch | (Linux) Window Close Event not triggered with sf::Style None, Titlebar, Resize
### Prerequisite Checklist
- [X] I searched for [existing issues](https://github.com/search?q=repo%3ASFML%2FSFML&type=issues) to prevent duplicates
- [X] I searched for [existing discussions on the forum](https://www.google.com/search?q=si... | Fixed and improved multiple issues with the X11 window implementation. | From the commit message:
- Removed forced centering of windows when they are created (the implementation was broken anyway)
- Make use of `PPosition` instead of `USPosition` when we have to set the fullscreen window position
- Fixed window properties being completely overwritten when only a subset of their fiel... | 140be9c2f44f0733a3c40700bc3ec4b2bf8041f2 | 0a1b0fad68c4136379598873039a5d66383052da | diff --git a/include/SFML/Window/WindowEnums.hpp b/include/SFML/Window/WindowEnums.hpp
index cd9a8fb94d..c52abf5473 100644
--- a/include/SFML/Window/WindowEnums.hpp
+++ b/include/SFML/Window/WindowEnums.hpp
@@ -33,13 +33,18 @@ namespace Style
/// \ingroup window
/// \brief Enumeration of the window styles
///
+/// N... | [
"include/SFML/Window/WindowEnums.hpp",
"src/SFML/Window/Unix/WindowImplX11.cpp",
"src/SFML/Window/Unix/WindowImplX11.hpp"
] | [] | true | |
SFML/SFML | 3,687 | issue_to_patch | Use `generic_string()` instead on libssh2 calls | <!--
Thanks a lot for making a contribution to SFML! 🙂
Please make sure you are targetting the correct branch. No more features are planned for the 2.x branches! (See [the readme](https://github.com/SFML/SFML#state-of-development))
Before creating the pull request, we ask you to check the following boxes: (For ... | 140be9c2f44f0733a3c40700bc3ec4b2bf8041f2 | 0dd58c4f2dc5d68960d9cf45719387adf68d5cb2 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
index a789194129..cc74750d18 100644
--- a/src/SFML/Network/Sftp.cpp
+++ b/src/SFML/Network/Sftp.cpp
@@ -81,6 +81,23 @@ struct SftpSessionDeleter
}
};
+// Portable UTF-8 string conversions for C++17/C++20 compatibility
+// See: https://www.open-s... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "All of this could probably be replaced by a simple template function.\n```cpp\ntemplate <typename T>\nstd::string fromUtf8String(const T& s)\n{\n return std::string(s.begin(), s.end());\n}\n```\nThe reason why they provide 3 overloads in the paper is because they were trying to optimize perform... | true | ||
SFML/SFML | 3,687 | comment_to_fix | Use `generic_string()` instead on libssh2 calls | All of this could probably be replaced by a simple template function.
```cpp
template <typename T>
std::string fromUtf8String(const T& s)
{
return std::string(s.begin(), s.end());
}
```
The reason why they provide 3 overloads in the paper is because they were trying to optimize performance in every scenario. Since ... | 140be9c2f44f0733a3c40700bc3ec4b2bf8041f2 | 0dd58c4f2dc5d68960d9cf45719387adf68d5cb2 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
index a789194129..cc74750d18 100644
--- a/src/SFML/Network/Sftp.cpp
+++ b/src/SFML/Network/Sftp.cpp
@@ -81,6 +81,23 @@ struct SftpSessionDeleter
}
};
+// Portable UTF-8 string conversions for C++17/C++20 compatibility
+// See: https://www.open-s... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "All of this could probably be replaced by a simple template function.\n```cpp\ntemplate <typename T>\nstd::string fromUtf8String(const T& s)\n{\n return std::string(s.begin(), s.end());\n}\n```\nThe reason why they provide 3 overloads in the paper is because they were trying to optimize perform... | true | ||
SFML/SFML | 3,687 | comment_to_fix | Use `generic_string()` instead on libssh2 calls | Because `char8_t` and thus `std::u8string` didn't exist yet in C++17, the standard provided another way for developers to inform `std::filesystem` that the path should be constructed from UTF-8 input: `std::filesystem::u8path`. `std::filesystem::u8path` is deprecated in C++20 for obviously reasons, but in C++17 it is t... | 140be9c2f44f0733a3c40700bc3ec4b2bf8041f2 | 0dd58c4f2dc5d68960d9cf45719387adf68d5cb2 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
index a789194129..cc74750d18 100644
--- a/src/SFML/Network/Sftp.cpp
+++ b/src/SFML/Network/Sftp.cpp
@@ -81,6 +81,23 @@ struct SftpSessionDeleter
}
};
+// Portable UTF-8 string conversions for C++17/C++20 compatibility
+// See: https://www.open-s... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "Because `char8_t` and thus `std::u8string` didn't exist yet in C++17, the standard provided another way for developers to inform `std::filesystem` that the path should be constructed from UTF-8 input: `std::filesystem::u8path`. `std::filesystem::u8path` is deprecated in C++20 for obviously reasons... | true | ||
SFML/SFML | 3,687 | comment_to_fix | Use `generic_string()` instead on libssh2 calls | This function could also take a `std::string_view` instead of `const std::string&`. This allows us to save constructing a temporary `std::string` object when constructing the path from a data buffer as we do in this file. | 140be9c2f44f0733a3c40700bc3ec4b2bf8041f2 | 0dd58c4f2dc5d68960d9cf45719387adf68d5cb2 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
index a789194129..cc74750d18 100644
--- a/src/SFML/Network/Sftp.cpp
+++ b/src/SFML/Network/Sftp.cpp
@@ -81,6 +81,23 @@ struct SftpSessionDeleter
}
};
+// Portable UTF-8 string conversions for C++17/C++20 compatibility
+// See: https://www.open-s... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "This function could also take a `std::string_view` instead of `const std::string&`. This allows us to save constructing a temporary `std::string` object when constructing the path from a data buffer as we do in this file.",
"path": "src/SFML/Network/Sftp.cpp",
"hunk": "@@ -81,6 +81,34 @@ s... | true | ||
SFML/SFML | 3,687 | comment_to_fix | Use `generic_string()` instead on libssh2 calls | We could pass a `std::string_view` instead of `std::string` here. | 140be9c2f44f0733a3c40700bc3ec4b2bf8041f2 | 0dd58c4f2dc5d68960d9cf45719387adf68d5cb2 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
index a789194129..cc74750d18 100644
--- a/src/SFML/Network/Sftp.cpp
+++ b/src/SFML/Network/Sftp.cpp
@@ -81,6 +81,23 @@ struct SftpSessionDeleter
}
};
+// Portable UTF-8 string conversions for C++17/C++20 compatibility
+// See: https://www.open-s... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "We could pass a `std::string_view` instead of `std::string` here.",
"path": "src/SFML/Network/Sftp.cpp",
"hunk": "@@ -865,14 +882,14 @@ Sftp::PathResult Sftp::resolvePath(const std::filesystem::path& path, const Time\n if (result < 0)\n return {makeError(m_impl->ssh2Session.get... | true | ||
SFML/SFML | 3,687 | comment_to_fix | Use `generic_string()` instead on libssh2 calls | We could pass a `std::string_view` instead of `std::string` here. | 140be9c2f44f0733a3c40700bc3ec4b2bf8041f2 | 0dd58c4f2dc5d68960d9cf45719387adf68d5cb2 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
index a789194129..cc74750d18 100644
--- a/src/SFML/Network/Sftp.cpp
+++ b/src/SFML/Network/Sftp.cpp
@@ -81,6 +81,23 @@ struct SftpSessionDeleter
}
};
+// Portable UTF-8 string conversions for C++17/C++20 compatibility
+// See: https://www.open-s... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "We could pass a `std::string_view` instead of `std::string` here.",
"path": "src/SFML/Network/Sftp.cpp",
"hunk": "@@ -955,8 +972,9 @@ Sftp::ListingResult Sftp::getDirectoryListing(const std::filesystem::path& path,\n \n if (result > 0)\n {\n+ // The f... | true | ||
SFML/SFML | 3,681 | issue_to_patch | [macOS] Heap-buffer-overflow in JoystickImpl / stringFromCFString when joystick is connected
### Prerequisite Checklist
- [x] I searched for [existing issues](https://github.com/search?q=repo%3ASFML%2FSFML&type=issues) to prevent duplicates
- [x] I searched for [existing discussions on the forum](https://www.google.c... | Fixed allocated buffer being too small when converting CFStringRef to std::string in the macOS joystick implementation. | Title.
`CFStringGetLength()` retrieves the string length in UTF-16 codepoints.
`CFStringGetMaximumSizeForEncoding(length, kCFStringEncodingUTF8)` retrieves the maximum UTF-8 byte count of the UTF-16 string.
If we use the UTF-16 length to allocate a buffer into which we write up to UTF-8 length bytes we will over... | c267bbaa908e39ca60ca78202f1f80f9598ce094 | 3dd39403d3a2b7b170e925bb7de773940356d187 | diff --git a/src/SFML/Window/macOS/JoystickImpl.cpp b/src/SFML/Window/macOS/JoystickImpl.cpp
index 1aab576430..030a1c83a0 100644
--- a/src/SFML/Window/macOS/JoystickImpl.cpp
+++ b/src/SFML/Window/macOS/JoystickImpl.cpp
@@ -43,9 +43,8 @@ namespace
// Convert a CFStringRef to std::string
std::string stringFromCFString(... | [
"src/SFML/Window/macOS/JoystickImpl.cpp"
] | [] | true | |
SFML/SFML | 3,675 | issue_to_patch | Added support for SFTP as a replacement for FTP | Title.
There are numerous problems/limitations of FTP (without extensions):
- FTP was not designed to be a secure protocol, both the control and data streams are unencrypted and unauthenticated
- When the data stream is opened using the PASV command (which is what SFML currently uses), IPv6 is not supported
- FTP... | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/.clang-format b/.clang-format
index b67ec43da3..3f7116035d 100644
--- a/.clang-format
+++ b/.clang-format
@@ -112,7 +112,7 @@ IncludeCategories:
- Priority: 8
Regex: '^<SFML\/System'
- Priority: 9
- Regex: '^<(glad|gl|X11|jni|android|stb_|GLES2|vorbis|miniaudio|catch2)'
+ Regex: '^<(glad|g... | [
".clang-format",
".github/workflows/analyze.yml",
".github/workflows/build.yml",
"cmake/Modules/FindLibssh2.cmake",
"examples/CMakeLists.txt",
"examples/ftp/Ftp.cpp",
"examples/sftp/CMakeLists.txt",
"examples/sftp/Sftp.cpp",
"include/SFML/Network.hpp",
"include/SFML/Network/Ftp.hpp",
"include/SF... | [
{
"comment": "[possible scoping issue] Should this not be `target_sources`?",
"path": "examples/sftp/CMakeLists.txt",
"hunk": "@@ -0,0 +1,7 @@\n+# all source files\n+set(SRC Sftp.cpp)",
"resolving_sha": "c33977a7e4e78d6d368598e1a6063aea606abd66",
"resolving_diff": "diff --git a/examples/sftp/CMa... | diff --git a/test/Network/CMakeLists.txt b/test/Network/CMakeLists.txt
index 483c826d3c..83b69737f7 100644
--- a/test/Network/CMakeLists.txt
+++ b/test/Network/CMakeLists.txt
@@ -4,6 +4,7 @@ set(NETWORK_SRC
Http.test.cpp
IpAddress.test.cpp
Packet.test.cpp
+ Sftp.test.cpp
Socket.test.cpp
Sock... | true | |
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | [possible scoping issue] Should this not be `target_sources`? | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/examples/sftp/CMakeLists.txt b/examples/sftp/CMakeLists.txt
new file mode 100644
index 0000000000..2d2865c070
--- /dev/null
+++ b/examples/sftp/CMakeLists.txt
@@ -0,0 +1,7 @@
+# all source files
+set(SRC Sftp.cpp)
+
+# define the sftp target
+sfml_add_example(sftp
+ SOURCES ${SRC}
+ ... | [
"examples/sftp/CMakeLists.txt"
] | [
{
"comment": "[possible scoping issue] Should this not be `target_sources`?",
"path": "examples/sftp/CMakeLists.txt",
"hunk": "@@ -0,0 +1,7 @@\n+# all source files\n+set(SRC Sftp.cpp)",
"resolving_sha": "c33977a7e4e78d6d368598e1a6063aea606abd66",
"resolving_diff": "diff --git a/examples/sftp/CMa... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | [nitpick] perhaps not the best choice of signal number given it's often used to Control + C out of a program (should this somehow get stuck). | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/examples/sftp/Sftp.cpp b/examples/sftp/Sftp.cpp
new file mode 100644
index 0000000000..2c3858deb3
--- /dev/null
+++ b/examples/sftp/Sftp.cpp
@@ -0,0 +1,461 @@
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <S... | [
"examples/sftp/Sftp.cpp"
] | [
{
"comment": "[nitpick] perhaps not the best choice of signal number given it's often used to Control + C out of a program (should this somehow get stuck).",
"path": "examples/sftp/Sftp.cpp",
"hunk": "@@ -0,0 +1,454 @@\n+////////////////////////////////////////////////////////////\n+// Headers\n+///////... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | [opinion] it's generally better to avoid default captures so that it's clear what a lambda is using. | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/examples/sftp/Sftp.cpp b/examples/sftp/Sftp.cpp
new file mode 100644
index 0000000000..2c3858deb3
--- /dev/null
+++ b/examples/sftp/Sftp.cpp
@@ -0,0 +1,461 @@
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <S... | [
"examples/sftp/Sftp.cpp"
] | [
{
"comment": "[opinion] it's generally better to avoid default captures so that it's clear what a lambda is using.",
"path": "examples/sftp/Sftp.cpp",
"hunk": "@@ -0,0 +1,454 @@\n+////////////////////////////////////////////////////////////\n+// Headers\n+////////////////////////////////////////////////... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | I'd argue this class should be either:
- marked as `final`
- given a virtual destructor
- given a protected destructor
Otherwise anyone deriving from this and deleting a base pointer is going hit UB.
This is probably also a style issue (it's not in the style guide but might want to be), so I'd be interested in the in... | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/include/SFML/Network/Sftp.hpp b/include/SFML/Network/Sftp.hpp
new file mode 100644
index 0000000000..9be101d562
--- /dev/null
+++ b/include/SFML/Network/Sftp.hpp
@@ -0,0 +1,987 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (... | [
"include/SFML/Network/Sftp.hpp"
] | [
{
"comment": "I'd argue this class should be either:\n- marked as `final`\n- given a virtual destructor\n- given a protected destructor\n\nOtherwise anyone deriving from this and deleting a base pointer is going hit UB.\n\nThis is probably also a style issue (it's not in the style guide but might want to be), s... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | There's some potential UB on the user's side here since Result doesn't have a virtual or protected destructor. See other comment for more info.
Other types have a similar issue. | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/include/SFML/Network/Sftp.hpp b/include/SFML/Network/Sftp.hpp
new file mode 100644
index 0000000000..9be101d562
--- /dev/null
+++ b/include/SFML/Network/Sftp.hpp
@@ -0,0 +1,987 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (... | [
"include/SFML/Network/Sftp.hpp"
] | [
{
"comment": "There's some potential UB on the user's side here since Result doesn't have a virtual or protected destructor. See other comment for more info.\n\nOther types have a similar issue.",
"path": "include/SFML/Network/Sftp.hpp",
"hunk": "@@ -0,0 +1,998 @@\n+/////////////////////////////////////... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | Should this be marked as explicit? | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/include/SFML/Network/Sftp.hpp b/include/SFML/Network/Sftp.hpp
new file mode 100644
index 0000000000..9be101d562
--- /dev/null
+++ b/include/SFML/Network/Sftp.hpp
@@ -0,0 +1,987 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (... | [
"include/SFML/Network/Sftp.hpp"
] | [
{
"comment": "Should this be marked as explicit?",
"path": "include/SFML/Network/Sftp.hpp",
"hunk": "@@ -0,0 +1,998 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)\n+/... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | You should include a deleted copy constructor as well. | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/include/SFML/Network/Sftp.hpp b/include/SFML/Network/Sftp.hpp
new file mode 100644
index 0000000000..9be101d562
--- /dev/null
+++ b/include/SFML/Network/Sftp.hpp
@@ -0,0 +1,987 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (... | [
"include/SFML/Network/Sftp.hpp"
] | [
{
"comment": "You should include a deleted copy constructor as well.",
"path": "include/SFML/Network/Sftp.hpp",
"hunk": "@@ -0,0 +1,998 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laure... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | It might be wise to decide how to move operations should work since you're declaring the related copy operations too. | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/include/SFML/Network/Sftp.hpp b/include/SFML/Network/Sftp.hpp
new file mode 100644
index 0000000000..9be101d562
--- /dev/null
+++ b/include/SFML/Network/Sftp.hpp
@@ -0,0 +1,987 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (... | [
"include/SFML/Network/Sftp.hpp"
] | [
{
"comment": "It might be wise to decide how to move operations should work since you're declaring the related copy operations too.",
"path": "include/SFML/Network/Sftp.hpp",
"hunk": "@@ -0,0 +1,998 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multim... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | Better to use a string_view here and for the private key data. | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/include/SFML/Network/Sftp.hpp b/include/SFML/Network/Sftp.hpp
new file mode 100644
index 0000000000..9be101d562
--- /dev/null
+++ b/include/SFML/Network/Sftp.hpp
@@ -0,0 +1,987 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (... | [
"include/SFML/Network/Sftp.hpp"
] | [
{
"comment": "Better to use a string_view here and for the private key data.",
"path": "include/SFML/Network/Sftp.hpp",
"hunk": "@@ -0,0 +1,998 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomil... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | This is unbounded and could result in buffer overruns. | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/include/SFML/Network/Sftp.hpp b/include/SFML/Network/Sftp.hpp
new file mode 100644
index 0000000000..9be101d562
--- /dev/null
+++ b/include/SFML/Network/Sftp.hpp
@@ -0,0 +1,987 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (... | [
"include/SFML/Network/Sftp.hpp"
] | [
{
"comment": "This is unbounded and could result in buffer overruns.",
"path": "include/SFML/Network/Sftp.hpp",
"hunk": "@@ -0,0 +1,998 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laure... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | Considering this section is RE shared libraries, how come you're referring to the static lib here? | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/CMakeLists.txt b/src/SFML/Network/CMakeLists.txt
index 076b4459e9..d62e802b76 100644
--- a/src/SFML/Network/CMakeLists.txt
+++ b/src/SFML/Network/CMakeLists.txt
@@ -14,6 +14,8 @@ set(SRC
${INCROOT}/IpAddress.hpp
${SRCROOT}/Packet.cpp
${INCROOT}/Packet.hpp
+ ${SRCROOT}/Sft... | [
"src/SFML/Network/CMakeLists.txt"
] | [
{
"comment": "Considering this section is RE shared libraries, how come you're referring to the static lib here?",
"path": "src/SFML/Network/CMakeLists.txt",
"hunk": "@@ -78,23 +82,55 @@ else()\n FetchContent_MakeAvailable(MbedTLS)\n endblock()\n \n- set_target_properties(mbedtls mbedcryp... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | I would move these into their own headers - reviewing is quite difficult with it all lumped together. | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/include/SFML/Network/Sftp.hpp b/include/SFML/Network/Sftp.hpp
new file mode 100644
index 0000000000..9be101d562
--- /dev/null
+++ b/include/SFML/Network/Sftp.hpp
@@ -0,0 +1,987 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (... | [
"include/SFML/Network/Sftp.hpp"
] | [
{
"comment": "I would move these into their own headers - reviewing is quite difficult with it all lumped together.",
"path": "include/SFML/Network/Sftp.hpp",
"hunk": "@@ -0,0 +1,998 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+/... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | Why not use the enum instead?
If there's a good reason, you should static_assert instead of a comment.
This will help make sure it's always true / doesn't rot over time, unlikely as that may be. | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
new file mode 100644
index 0000000000..95ab95a45e
--- /dev/null
+++ b/src/SFML/Network/Sftp.cpp
@@ -0,0 +1,1347 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-202... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "Why not use the enum instead?\nIf there's a good reason, you should static_assert instead of a comment.\nThis will help make sure it's always true / doesn't rot over time, unlikely as that may be.",
"path": "src/SFML/Network/Sftp.cpp",
"hunk": "@@ -0,0 +1,1377 @@\n+////////////////////////... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | This function / pattern is far more complex than it needs to be.
We don't need a special object to store the initialisation, although I think I see the purpose of the mutex given we don't know what the client code will do and libssh2_init is not thread safe.
However, it would be much easier to reason about by...
- re... | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
new file mode 100644
index 0000000000..95ab95a45e
--- /dev/null
+++ b/src/SFML/Network/Sftp.cpp
@@ -0,0 +1,1347 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-202... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "This function / pattern is far more complex than it needs to be.\n\nWe don't need a special object to store the initialisation, although I think I see the purpose of the mutex given we don't know what the client code will do and libssh2_init is not thread safe.\n\nHowever, it would be much easier ... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | This is a bit obtuse to read and there's more standard ones available. I think this should be replaced with `std::filesystem::perm_options`. This reduces the risk of small typos completely changing the meaning, esp. in such a dense piece of code. | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
new file mode 100644
index 0000000000..95ab95a45e
--- /dev/null
+++ b/src/SFML/Network/Sftp.cpp
@@ -0,0 +1,1347 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-202... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "This is a bit obtuse to read and there's more standard ones available. I think this should be replaced with `std::filesystem::perm_options`. This reduces the risk of small typos completely changing the meaning, esp. in such a dense piece of code.",
"path": "src/SFML/Network/Sftp.cpp",
"hun... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | How come? | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/CMakeLists.txt b/src/SFML/Network/CMakeLists.txt
index 076b4459e9..d62e802b76 100644
--- a/src/SFML/Network/CMakeLists.txt
+++ b/src/SFML/Network/CMakeLists.txt
@@ -14,6 +14,8 @@ set(SRC
${INCROOT}/IpAddress.hpp
${SRCROOT}/Packet.cpp
${INCROOT}/Packet.hpp
+ ${SRCROOT}/Sft... | [
"src/SFML/Network/CMakeLists.txt"
] | [
{
"comment": "How come?",
"path": "src/SFML/Network/CMakeLists.txt",
"hunk": "@@ -69,6 +72,7 @@ else()\n URL https://github.com/Mbed-TLS/mbedtls/releases/download/mbedtls-3.6.5/mbedtls-3.6.5.tar.bz2\n URL_HASH SHA256=4a11f1777bb95bf4ad96721cac945a26e04bf19f57d905f241fe77ebeddf46d... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | these should be scoped to a target | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/CMakeLists.txt b/src/SFML/Network/CMakeLists.txt
index 076b4459e9..d62e802b76 100644
--- a/src/SFML/Network/CMakeLists.txt
+++ b/src/SFML/Network/CMakeLists.txt
@@ -14,6 +14,8 @@ set(SRC
${INCROOT}/IpAddress.hpp
${SRCROOT}/Packet.cpp
${INCROOT}/Packet.hpp
+ ${SRCROOT}/Sft... | [
"src/SFML/Network/CMakeLists.txt"
] | [
{
"comment": "these should be scoped to a target",
"path": "src/SFML/Network/CMakeLists.txt",
"hunk": "@@ -78,23 +82,55 @@ else()\n FetchContent_MakeAvailable(MbedTLS)\n endblock()\n \n- set_target_properties(mbedtls mbedcrypto mbedx509 PROPERTIES FOLDER \"Dependencies\" SYSTEM ON)\n+ ... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | How come the formatting was turned off for just this line? | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
new file mode 100644
index 0000000000..95ab95a45e
--- /dev/null
+++ b/src/SFML/Network/Sftp.cpp
@@ -0,0 +1,1347 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-202... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "How come the formatting was turned off for just this line?",
"path": "src/SFML/Network/Sftp.cpp",
"hunk": "@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laur... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | Do we need to take into account sender vs. receiver time zone here? | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
new file mode 100644
index 0000000000..95ab95a45e
--- /dev/null
+++ b/src/SFML/Network/Sftp.cpp
@@ -0,0 +1,1347 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-202... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "Do we need to take into account sender vs. receiver time zone here?",
"path": "src/SFML/Network/Sftp.cpp",
"hunk": "@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gom... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | This error message could be more precise; we know we've got a nullptr. | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
new file mode 100644
index 0000000000..95ab95a45e
--- /dev/null
+++ b/src/SFML/Network/Sftp.cpp
@@ -0,0 +1,1347 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-202... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "This error message could be more precise; we know we've got a nullptr.",
"path": "src/SFML/Network/Sftp.cpp",
"hunk": "@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent ... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | When would you not want to pass the sftp pointer?
Would it be better to use an optional here rather than nullptr; easier to spot that it might not have a value later down the line. | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
new file mode 100644
index 0000000000..95ab95a45e
--- /dev/null
+++ b/src/SFML/Network/Sftp.cpp
@@ -0,0 +1,1347 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-202... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "When would you not want to pass the sftp pointer?\nWould it be better to use an optional here rather than nullptr; easier to spot that it might not have a value later down the line.",
"path": "src/SFML/Network/Sftp.cpp",
"hunk": "@@ -0,0 +1,1377 @@\n+///////////////////////////////////////... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | Given it's deferenced immediately, `implPtr` should be a ref to a pointer instead of a pointer to a pointer. | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
new file mode 100644
index 0000000000..95ab95a45e
--- /dev/null
+++ b/src/SFML/Network/Sftp.cpp
@@ -0,0 +1,1347 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-202... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "Given it's deferenced immediately, `implPtr` should be a ref to a pointer instead of a pointer to a pointer.",
"path": "src/SFML/Network/Sftp.cpp",
"hunk": "@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | Downstream users might want to use mutable lambdas here, so a non-const variant would be needed. | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
new file mode 100644
index 0000000000..95ab95a45e
--- /dev/null
+++ b/src/SFML/Network/Sftp.cpp
@@ -0,0 +1,1347 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-202... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "Downstream users might want to use mutable lambdas here, so a non-const variant would be needed.",
"path": "src/SFML/Network/Sftp.cpp",
"hunk": "@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyri... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | This is deprecated upstream. Do you think it's worth adding support given that, or better to just never add it? | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
new file mode 100644
index 0000000000..95ab95a45e
--- /dev/null
+++ b/src/SFML/Network/Sftp.cpp
@@ -0,0 +1,1347 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-202... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "This is deprecated upstream. Do you think it's worth adding support given that, or better to just never add it?",
"path": "src/SFML/Network/Sftp.cpp",
"hunk": "@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Libr... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | There's a name mismatch between DSS and DSA here. | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
new file mode 100644
index 0000000000..95ab95a45e
--- /dev/null
+++ b/src/SFML/Network/Sftp.cpp
@@ -0,0 +1,1347 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-202... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "There's a name mismatch between DSS and DSA here.",
"path": "src/SFML/Network/Sftp.cpp",
"hunk": "@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | It might be preferable to only support SHA256 is both are available? It reduces the attack surface for a bad actor. SHA1 was known hash collision attacks and probably more by now. | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
new file mode 100644
index 0000000000..95ab95a45e
--- /dev/null
+++ b/src/SFML/Network/Sftp.cpp
@@ -0,0 +1,1347 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-202... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "It might be preferable to only support SHA256 is both are available? It reduces the attack surface for a bad actor. SHA1 was known hash collision attacks and probably more by now.",
"path": "src/SFML/Network/Sftp.cpp",
"hunk": "@@ -0,0 +1,1377 @@\n+/////////////////////////////////////////... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | [nit] this extra nesting can be removed by just checking for this and early returning, rather than an if-else. | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
new file mode 100644
index 0000000000..95ab95a45e
--- /dev/null
+++ b/src/SFML/Network/Sftp.cpp
@@ -0,0 +1,1347 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-202... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "[nit] this extra nesting can be removed by just checking for this and early returning, rather than an if-else.",
"path": "src/SFML/Network/Sftp.cpp",
"hunk": "@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Libra... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | Do these have to be set; an empty but valid string may confuse people. Possible alternative: std::optional | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
new file mode 100644
index 0000000000..95ab95a45e
--- /dev/null
+++ b/src/SFML/Network/Sftp.cpp
@@ -0,0 +1,1347 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-202... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "Do these have to be set; an empty but valid string may confuse people. Possible alternative: std::optional",
"path": "src/SFML/Network/Sftp.cpp",
"hunk": "@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | unsigned int may be smaller than the size_t password. In extreme cases, this will lead to the uncorrect length being passed and a possible buffer overflow exploit being available.
This edge case should be checked for; it's a security issue. | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
new file mode 100644
index 0000000000..95ab95a45e
--- /dev/null
+++ b/src/SFML/Network/Sftp.cpp
@@ -0,0 +1,1347 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-202... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "unsigned int may be smaller than the size_t password. In extreme cases, this will lead to the uncorrect length being passed and a possible buffer overflow exploit being available.\n\nThis edge case should be checked for; it's a security issue.",
"path": "src/SFML/Network/Sftp.cpp",
"hunk":... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | any info on thread safety here requirements here? | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
new file mode 100644
index 0000000000..95ab95a45e
--- /dev/null
+++ b/src/SFML/Network/Sftp.cpp
@@ -0,0 +1,1347 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-202... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "any info on thread safety here requirements here?",
"path": "src/SFML/Network/Sftp.cpp",
"hunk": "@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | need to make sure it can fit into an unsigned int, bad actor may craft a very long file path in an attack. The buffer size will limit the ways in which they can exploit that, but they may be able to find other uses. | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
new file mode 100644
index 0000000000..95ab95a45e
--- /dev/null
+++ b/src/SFML/Network/Sftp.cpp
@@ -0,0 +1,1347 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-202... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "need to make sure it can fit into an unsigned int, bad actor may craft a very long file path in an attack. The buffer size will limit the ways in which they can exploit that, but they may be able to find other uses.",
"path": "src/SFML/Network/Sftp.cpp",
"hunk": "@@ -0,0 +1,1377 @@\n+/////... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | Can we avoid a network call here; is it safe to presume the cwd won't change between ops? | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
new file mode 100644
index 0000000000..95ab95a45e
--- /dev/null
+++ b/src/SFML/Network/Sftp.cpp
@@ -0,0 +1,1347 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-202... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "Can we avoid a network call here; is it safe to presume the cwd won't change between ops?",
"path": "src/SFML/Network/Sftp.cpp",
"hunk": "@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C)... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | why not just use a std::array here? You can get the ptr out via .data() | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
new file mode 100644
index 0000000000..95ab95a45e
--- /dev/null
+++ b/src/SFML/Network/Sftp.cpp
@@ -0,0 +1,1347 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-202... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "why not just use a std::array here? You can get the ptr out via .data()",
"path": "src/SFML/Network/Sftp.cpp",
"hunk": "@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | do you think there's value in asserting the length is >= read here? | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/src/SFML/Network/Sftp.cpp b/src/SFML/Network/Sftp.cpp
new file mode 100644
index 0000000000..95ab95a45e
--- /dev/null
+++ b/src/SFML/Network/Sftp.cpp
@@ -0,0 +1,1347 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-202... | [
"src/SFML/Network/Sftp.cpp"
] | [
{
"comment": "do you think there's value in asserting the length is >= read here?",
"path": "src/SFML/Network/Sftp.cpp",
"hunk": "@@ -0,0 +1,1377 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gom... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | ```suggestion
/// \brief Connect to the specified SFTP server
``` | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/include/SFML/Network/Sftp.hpp b/include/SFML/Network/Sftp.hpp
new file mode 100644
index 0000000000..9be101d562
--- /dev/null
+++ b/include/SFML/Network/Sftp.hpp
@@ -0,0 +1,987 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (... | [
"include/SFML/Network/Sftp.hpp"
] | [
{
"comment": "```suggestion\n /// \\brief Connect to the specified SFTP server\n```",
"path": "include/SFML/Network/Sftp.hpp",
"hunk": "@@ -0,0 +1,998 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Lau... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | Is this being fixed upstream or will users of system packages run into problems with this? | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/tools/libssh2/PatchLibssh2.cmake b/tools/libssh2/PatchLibssh2.cmake
new file mode 100644
index 0000000000..9a7f1e8a8d
--- /dev/null
+++ b/tools/libssh2/PatchLibssh2.cmake
@@ -0,0 +1,13 @@
+# Fix returning a pointer to stack memory by forcing libssh to make a copy of it instead
+file(READ "${LIBSSH2_DIR}/sr... | [
"tools/libssh2/PatchLibssh2.cmake"
] | [
{
"comment": "Is this being fixed upstream or will users of system packages run into problems with this?",
"path": "tools/libssh2/PatchLibssh2.cmake",
"hunk": "@@ -0,0 +1,13 @@\n+# Fix returning a pointer to stack memory by forcing libssh to make a copy of it instead\n+file(READ \"${LIBSSH2_DIR}/src/mbe... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | Should we have separate result sets, instead of using prefixes? | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/include/SFML/Network/Sftp.hpp b/include/SFML/Network/Sftp.hpp
new file mode 100644
index 0000000000..9be101d562
--- /dev/null
+++ b/include/SFML/Network/Sftp.hpp
@@ -0,0 +1,987 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (... | [
"include/SFML/Network/Sftp.hpp"
] | [
{
"comment": "Should we have separate result sets, instead of using prefixes?",
"path": "include/SFML/Network/Sftp.hpp",
"hunk": "@@ -0,0 +1,998 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyright (C) 2007-2025 Laurent Gomi... | true | ||
SFML/SFML | 3,675 | comment_to_fix | Added support for SFTP as a replacement for FTP | Should we have default values? What's the use case of constructing an "empty" Result set? | ae01ab9e7137da4dce9feb4b0db52e30910499e9 | c33977a7e4e78d6d368598e1a6063aea606abd66 | diff --git a/include/SFML/Network/Sftp.hpp b/include/SFML/Network/Sftp.hpp
new file mode 100644
index 0000000000..9be101d562
--- /dev/null
+++ b/include/SFML/Network/Sftp.hpp
@@ -0,0 +1,987 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (... | [
"include/SFML/Network/Sftp.hpp"
] | [
{
"comment": "Should we have default values? What's the use case of constructing an \"empty\" Result set?",
"path": "include/SFML/Network/Sftp.hpp",
"hunk": "@@ -0,0 +1,998 @@\n+////////////////////////////////////////////////////////////\n+//\n+// SFML - Simple and Fast Multimedia Library\n+// Copyrigh... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.