@cetapod/react-native-smb 1.0.0

package/cpp/shared/operators/mutate/DeleteItemOperator.cpp

@@ -0,0 +1,96 @@
+#include "DeleteItemOperator.hpp"
+
+#include <smb2/libsmb2.h>
+#include <smb2/smb2.h>
+
+#include <algorithm>
+#include <stdexcept>
+#include <vector>
+
+#include "../../ReactNativeSmb.hpp"
+#include "../../io/SmbPathUtil.hpp"
+#include "../../io/SmbTreeOps.hpp"
+
+namespace react_native_smb {
+
+void DeleteItemOperator::run() {
+    const CancellationToken token = cancelToken();
+    const std::string norm = path_util::normalized(path_);
+    setSourceDestination(norm, "");
+
+    bool isDirectory = false;
+    {
+        auto handle = requestContext(AcquireMode::Metadata);
+        handle.submitSync([&](smb2_context* ctx) {
+            struct smb2_stat_64 st;
+            if (smb2_stat(ctx, norm.c_str(), &st) < 0) {
+                throw std::runtime_error("Delete Failed: Could not stat '" + path_ + "'. Error: " + smb2_get_error(ctx));
+            }
+            isDirectory = (st.smb2_type & SMB2_TYPE_DIRECTORY) != 0;
+        });
+    }
+
+    if (!isDirectory) {
+        auto handle = requestContext(AcquireMode::Metadata);
+        handle.submitSync([&](smb2_context* ctx) {
+            const int r = smb2_unlink(ctx, norm.c_str());
+            if (r < 0) throw std::runtime_error("Failed to delete file '" + path_ + "': " + smb2_get_error(ctx));
+        });
+        emitStatus(SmbTaskStatus::Success);
+        return;
+    }
+
+    std::vector<SmbFileInfo> allItems;
+    {
+        auto handle = requestContext(AcquireMode::Metadata);
+        handle.submitSync([&](smb2_context* ctx) { tree_ops::collectAllItems(ctx, path_, allItems, token); });
+    }
+    if (isCancelled()) {
+        emitStatus(SmbTaskStatus::Cancelled);
+        return;
+    }
+
+    std::vector<SmbFileInfo> fileItems;
+    std::vector<SmbFileInfo> dirItems;
+    for (auto& item : allItems) {
+        if (item.isDirectory)
+            dirItems.push_back(std::move(item));
+        else
+            fileItems.push_back(std::move(item));
+    }
+
+    if (!fileItems.empty() && !isCancelled()) {
+        auto handle = requestContext(AcquireMode::Metadata);
+        handle.submitSync([&](smb2_context* ctx) {
+            for (const auto& item : fileItems) {
+                if (isCancelled()) return;
+                std::string n = path_util::normalized(item.path);
+                const int r = smb2_unlink(ctx, n.c_str());
+                if (r < 0) throw std::runtime_error("Recursive Delete Failed: Could not delete file '" + item.path + "'. Error: " + smb2_get_error(ctx));
+            }
+        });
+    }
+    if (isCancelled()) {
+        emitStatus(SmbTaskStatus::Cancelled);
+        return;
+    }
+
+    std::sort(dirItems.begin(), dirItems.end(), [](const SmbFileInfo& a, const SmbFileInfo& b) { return a.path.length() > b.path.length(); });
+    {
+        auto handle = requestContext(AcquireMode::Metadata);
+        handle.submitSync([&](smb2_context* ctx) {
+            for (const auto& item : dirItems) {
+                if (isCancelled()) return;
+                std::string n = path_util::normalized(item.path);
+                const int r = smb2_rmdir(ctx, n.c_str());
+                if (r < 0) throw std::runtime_error("Recursive Delete Failed: Could not delete sub-directory '" + item.path + "'. Error: " + smb2_get_error(ctx));
+            }
+            const int rootR = smb2_rmdir(ctx, norm.c_str());
+            if (rootR < 0) throw std::runtime_error("Delete Failed: Could not delete directory '" + path_ + "'. Error: " + smb2_get_error(ctx));
+        });
+    }
+
+    emitStatus(SmbTaskStatus::Success);
+}
+
+}  // namespace react_native_smb

package/cpp/shared/operators/mutate/DeleteItemOperator.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <string>
+
+#include "../OperatorBase.hpp"
+
+namespace react_native_smb {
+
+// Deletes a file or a directory tree. Directory deletion walks the tree and
+// removes deepest-first (strict ordering), so it runs self-contained on Bulk
+// Metadata slots rather than spawning child operators.
+class DeleteItemOperator : public OperatorBase {
+   public:
+    explicit DeleteItemOperator(std::string path) : path_(std::move(path)) {}
+
+    SmbOperatorKind kind() const override { return SmbOperatorKind::DeleteItem; }
+    void run() override;
+
+   private:
+    std::string path_;
+};
+
+}  // namespace react_native_smb

package/cpp/shared/operators/mutate/DuplicateItemOperator.cpp

@@ -0,0 +1,48 @@
+#include "DuplicateItemOperator.hpp"
+
+#include <smb2/libsmb2.h>
+#include <smb2/smb2.h>
+
+#include <string>
+
+#include "../../io/SmbCopyTree.hpp"
+#include "../../io/SmbPathUtil.hpp"
+#include "../../io/SmbTreeOps.hpp"
+
+namespace react_native_smb {
+
+void DuplicateItemOperator::run() {
+    const CancellationToken token = cancelToken();
+
+    const std::string parentPath = path_util::parentOf(path_);
+    const std::string fileName = path_util::extractFileName(path_);
+
+    MetadataContextLease lease = makeMetadataLease();
+
+    std::string destPath;
+    lease.submitSync([&](smb2_context* ctx) {
+        std::string newName = tree_ops::generateUniqueCopyName(ctx, parentPath, fileName, token);
+        destPath = path_util::buildUrl(parentPath, newName);
+    });
+
+    if (isCancelled() || destPath.empty()) {
+        emitStatus(SmbTaskStatus::Cancelled);
+        return;
+    }
+
+    setSourceDestination(path_, destPath);
+
+    copyTreeImpl(pool(), kind(), path_, destPath, /*recursive=*/true, token, [this](double done, double total) { emitProgress(done, total); },
+                 [this](int64_t n) { addExpectedBytes(n); }, owningTaskId(), &lease);
+
+    if (isCancelled()) {
+        emitStatus(SmbTaskStatus::Cancelled);
+        return;
+    }
+
+    result_ = destPath;
+    publishThisResult();
+    emitStatus(SmbTaskStatus::Success);
+}
+
+}  // namespace react_native_smb

package/cpp/shared/operators/mutate/DuplicateItemOperator.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <string>
+
+#include "../Operator.hpp"
+
+namespace react_native_smb {
+
+// Duplicates a file or directory into the same parent with a unique
+// "<name> copy" suffix. Returns the new path. Self-contained (reuses the same
+// tree-copy logic as CopyItemOperator).
+class DuplicateItemOperator : public Operator<std::string> {
+   public:
+    explicit DuplicateItemOperator(std::string path) : path_(std::move(path)) {}
+
+    SmbOperatorKind kind() const override { return SmbOperatorKind::DuplicateItem; }
+    void run() override;
+
+   private:
+    std::string path_;
+};
+
+}  // namespace react_native_smb

package/cpp/shared/operators/mutate/MoveItemOperator.cpp

@@ -0,0 +1,32 @@
+#include "MoveItemOperator.hpp"
+
+#include <smb2/libsmb2.h>
+#include <smb2/smb2.h>
+
+#include <stdexcept>
+
+#include "../../connection/SmbConnectionPool.hpp"
+#include "../../io/SmbPathUtil.hpp"
+
+namespace react_native_smb {
+
+void MoveItemOperator::run() {
+
+    const std::string from = path_util::normalized(fromPath_);
+    const std::string to = path_util::normalized(toPath_);
+
+    setSourceDestination(from, to);
+
+    auto handle = requestContext(AcquireMode::Interactive);
+
+    handle.submitSync([&](smb2_context* ctx) {
+        const int r = smb2_rename(ctx, from.c_str(), to.c_str());
+        if (r < 0) {
+            throw std::runtime_error("Move Failed: Could not move '" + fromPath_ + "' to '" + toPath_ + "'. Error: " + smb2_get_error(ctx));
+        }
+    });
+
+    emitStatus(SmbTaskStatus::Success);
+}
+
+}  // namespace react_native_smb

package/cpp/shared/operators/mutate/MoveItemOperator.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <string>
+
+#include "../OperatorBase.hpp"
+
+namespace react_native_smb {
+
+class MoveItemOperator : public OperatorBase {
+   public:
+    MoveItemOperator(std::string fromPath, std::string toPath) : fromPath_(std::move(fromPath)), toPath_(std::move(toPath)) {}
+
+    SmbOperatorKind kind() const override { return SmbOperatorKind::MoveItem; }
+    void run() override;
+
+   private:
+    std::string fromPath_;
+    std::string toPath_;
+};
+
+}  // namespace react_native_smb

package/cpp/shared/operators/mutate/RenameItemOperator.cpp

@@ -0,0 +1,37 @@
+#include "RenameItemOperator.hpp"
+
+#include <smb2/libsmb2.h>
+#include <smb2/smb2.h>
+
+#include <stdexcept>
+
+#include "../../connection/SmbConnectionPool.hpp"
+#include "../../io/SmbPathUtil.hpp"
+
+namespace react_native_smb {
+
+void RenameItemOperator::run() {
+    if (newName_.empty() || newName_.find('/') != std::string::npos || newName_.find('\\') != std::string::npos) {
+        throw std::runtime_error("Rename Failed: invalid new name '" + newName_ + "'");
+    }
+
+
+    const std::string normCurrent = path_util::normalized(currentPath_);
+    const std::string parentDir = path_util::parentOf(currentPath_);
+    const std::string newPath = path_util::normalized(path_util::buildUrl(parentDir, newName_));
+
+    setSourceDestination(normCurrent, newPath);
+
+    auto handle = requestContext(AcquireMode::Interactive);
+
+    handle.submitSync([&](smb2_context* ctx) {
+        const int r = smb2_rename(ctx, normCurrent.c_str(), newPath.c_str());
+        if (r < 0) {
+            throw std::runtime_error("Rename Failed: Could not rename '" + currentPath_ + "' to '" + newName_ + "'. Error: " + smb2_get_error(ctx));
+        }
+    });
+
+    emitStatus(SmbTaskStatus::Success);
+}
+
+}  // namespace react_native_smb

package/cpp/shared/operators/mutate/RenameItemOperator.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <string>
+
+#include "../OperatorBase.hpp"
+
+namespace react_native_smb {
+
+class RenameItemOperator : public OperatorBase {
+   public:
+    RenameItemOperator(std::string currentPath, std::string newName) : currentPath_(std::move(currentPath)), newName_(std::move(newName)) {}
+
+    SmbOperatorKind kind() const override { return SmbOperatorKind::RenameItem; }
+    void run() override;
+
+   private:
+    std::string currentPath_;
+    std::string newName_;
+};
+
+}  // namespace react_native_smb

package/cpp/shared/operators/transfer/DownloadFileOperator.cpp

@@ -0,0 +1,31 @@
+#include "DownloadFileOperator.hpp"
+
+#include "../../connection/SmbConnectionPool.hpp"
+#include "../../io/SmbFileIO.hpp"
+#include "../../io/SmbPathUtil.hpp"
+
+namespace react_native_smb {
+
+void DownloadFileOperator::run() {
+
+    const std::string remote = path_util::normalized(remotePath_);
+    const std::string local = path_util::convertUriToPath(localPath_);
+
+    setSourceDestination(remote, local);
+
+    auto handle = requestContext(AcquireMode::Metadata);
+
+    const CancellationToken token = cancelToken();
+    handle.submitSync([&](smb2_context* ctx) {
+        smbReadFileAsync(
+            ctx, remote, local, [this](double done, double total) { emitProgress(done, total); }, token);
+    });
+
+    if (isCancelled()) {
+        emitStatus(SmbTaskStatus::Cancelled);
+        return;
+    }
+    emitStatus(SmbTaskStatus::Success);
+}
+
+}  // namespace react_native_smb

package/cpp/shared/operators/transfer/DownloadFileOperator.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <string>
+
+#include "../OperatorBase.hpp"
+
+namespace react_native_smb {
+
+class DownloadFileOperator : public OperatorBase {
+   public:
+    DownloadFileOperator(std::string remotePath, std::string localPath) : remotePath_(std::move(remotePath)), localPath_(std::move(localPath)) {}
+
+    SmbOperatorKind kind() const override { return SmbOperatorKind::DownloadFile; }
+    void run() override;
+
+   private:
+    std::string remotePath_;
+    std::string localPath_;
+};
+
+}  // namespace react_native_smb

package/cpp/shared/operators/transfer/UploadFileOperator.cpp

@@ -0,0 +1,27 @@
+#include "UploadFileOperator.hpp"
+
+#include "../../connection/SmbConnectionPool.hpp"
+#include "../../io/SmbFileIO.hpp"
+#include "../../io/SmbPathUtil.hpp"
+
+namespace react_native_smb {
+
+void UploadFileOperator::run() {
+
+    const std::string remote = path_util::normalized(remotePath_);
+    const std::string local = path_util::convertUriToPath(localPath_);
+
+    setSourceDestination(local, remote);  // local -> remote for upload
+
+    auto handle = requestContext(AcquireMode::Metadata);
+
+    const CancellationToken token = cancelToken();
+    handle.submitSync([&](smb2_context* ctx) {
+        smbWriteFileAsync(
+            ctx, local, remote, [this](double done, double total) { emitProgress(done, total); }, token);
+    });
+
+    emitStatus(SmbTaskStatus::Success);
+}
+
+}  // namespace react_native_smb

package/cpp/shared/operators/transfer/UploadFileOperator.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <string>
+
+#include "../OperatorBase.hpp"
+
+namespace react_native_smb {
+
+class UploadFileOperator : public OperatorBase {
+   public:
+    UploadFileOperator(std::string localPath, std::string remotePath) : localPath_(std::move(localPath)), remotePath_(std::move(remotePath)) {}
+
+    SmbOperatorKind kind() const override { return SmbOperatorKind::UploadFile; }
+    void run() override;
+
+   private:
+    std::string localPath_;
+    std::string remotePath_;
+};
+
+}  // namespace react_native_smb

package/cpp/shared/util/SmbErrorMapper.hpp

@@ -0,0 +1,229 @@
+#pragma once
+
+#include <algorithm>
+#include <cctype>
+#include <cerrno>
+#include <cstdint>
+#include <initializer_list>
+#include <optional>
+#include <string>
+
+namespace react_native_smb {
+
+enum class SmbErrorCode : int {
+    Unknown = 0,
+    Cancelled = 1,
+
+    InvalidArgument = 100,
+    NotFound = 101,
+    AlreadyExists = 102,
+    AccessDenied = 103,
+    NotDirectory = 104,
+    IsDirectory = 105,
+    DirectoryNotEmpty = 106,
+
+    NotConnected = 200,
+    ConnectionRefused = 201,
+    TimedOut = 202,
+
+    Busy = 300,
+    NoSpace = 301,
+    Io = 302,
+};
+
+class SmbErrorMapper {
+   public:
+    static int normalizeErrnoCode(int resultCode) {
+        if (resultCode == 0) {
+            return 0;
+        }
+        return resultCode < 0 ? -resultCode : resultCode;
+    }
+
+    static int fromErrnoResult(int resultCode) { return fromErrno(normalizeErrnoCode(resultCode)); }
+
+    static int fromErrnoOrMessage(int errnoCode, const std::string& errorMessage) {
+        const int mappedFromErrno = fromErrno(errnoCode);
+        if (mappedFromErrno != static_cast<int>(SmbErrorCode::Unknown)) {
+            return mappedFromErrno;
+        }
+
+        return fromMessage(errorMessage);
+    }
+
+    static int fromErrno(int errnoCode) {
+        switch (errnoCode) {
+            case 0:
+                return static_cast<int>(SmbErrorCode::Unknown);
+            case ECANCELED:
+                return static_cast<int>(SmbErrorCode::Cancelled);
+            case EINVAL:
+                return static_cast<int>(SmbErrorCode::InvalidArgument);
+            case ENOENT:
+                return static_cast<int>(SmbErrorCode::NotFound);
+            case EEXIST:
+                return static_cast<int>(SmbErrorCode::AlreadyExists);
+            case EACCES:
+            case EPERM:
+                return static_cast<int>(SmbErrorCode::AccessDenied);
+            case ENOTDIR:
+                return static_cast<int>(SmbErrorCode::NotDirectory);
+            case EISDIR:
+                return static_cast<int>(SmbErrorCode::IsDirectory);
+            case ENOTEMPTY:
+                return static_cast<int>(SmbErrorCode::DirectoryNotEmpty);
+            case ENOTCONN:
+            case EHOSTUNREACH:
+            case EPIPE:
+#ifdef ENETRESET
+            case ENETRESET:
+#endif
+                return static_cast<int>(SmbErrorCode::NotConnected);
+            case ECONNREFUSED:
+                return static_cast<int>(SmbErrorCode::ConnectionRefused);
+            case ETIMEDOUT:
+                return static_cast<int>(SmbErrorCode::TimedOut);
+            case EBUSY:
+                return static_cast<int>(SmbErrorCode::Busy);
+            case ENOSPC:
+                return static_cast<int>(SmbErrorCode::NoSpace);
+            case EIO:
+                return static_cast<int>(SmbErrorCode::Io);
+            default:
+                return static_cast<int>(SmbErrorCode::Unknown);
+        }
+    }
+
+   private:
+    static int fromMessage(const std::string& errorMessage) {
+        if (errorMessage.empty()) {
+            return static_cast<int>(SmbErrorCode::Unknown);
+        }
+
+        std::string upper = errorMessage;
+        std::transform(upper.begin(), upper.end(), upper.begin(), [](unsigned char c) { return static_cast<char>(std::toupper(c)); });
+
+        if (const auto ntStatus = extractNtStatusHex(upper); ntStatus.has_value()) {
+            const int mapped = fromNtStatus(*ntStatus);
+            if (mapped != static_cast<int>(SmbErrorCode::Unknown)) {
+                return mapped;
+            }
+        }
+
+        if (containsAny(upper, {"STATUS_OBJECT_NAME_COLLISION", "FILE_EXISTS", "EEXIST"})) {
+            return static_cast<int>(SmbErrorCode::AlreadyExists);
+        }
+
+        if (containsAny(upper, {"STATUS_OBJECT_NAME_NOT_FOUND", "STATUS_OBJECT_PATH_NOT_FOUND", "STATUS_NO_SUCH_FILE", "NO SUCH FILE"})) {
+            return static_cast<int>(SmbErrorCode::NotFound);
+        }
+
+        if (containsAny(upper, {"STATUS_ACCESS_DENIED", "STATUS_LOGON_FAILURE", "ACCESS_DENIED", "PERMISSION DENIED"})) {
+            return static_cast<int>(SmbErrorCode::AccessDenied);
+        }
+
+        if (contains(upper, "STATUS_NOT_A_DIRECTORY")) {
+            return static_cast<int>(SmbErrorCode::NotDirectory);
+        }
+
+        if (contains(upper, "STATUS_FILE_IS_A_DIRECTORY")) {
+            return static_cast<int>(SmbErrorCode::IsDirectory);
+        }
+
+        if (contains(upper, "STATUS_DIRECTORY_NOT_EMPTY")) {
+            return static_cast<int>(SmbErrorCode::DirectoryNotEmpty);
+        }
+
+        if (containsAny(upper, {"STATUS_CONNECTION_DISCONNECTED", "STATUS_NETWORK_NAME_DELETED", "BROKEN PIPE"})) {
+            return static_cast<int>(SmbErrorCode::NotConnected);
+        }
+
+        if (contains(upper, "STATUS_CONNECTION_REFUSED")) {
+            return static_cast<int>(SmbErrorCode::ConnectionRefused);
+        }
+
+        if (containsAny(upper, {"STATUS_IO_TIMEOUT", "TIMED OUT"})) {
+            return static_cast<int>(SmbErrorCode::TimedOut);
+        }
+
+        if (containsAny(upper, {"STATUS_SHARING_VIOLATION", "RESOURCE BUSY"})) {
+            return static_cast<int>(SmbErrorCode::Busy);
+        }
+
+        if (containsAny(upper, {"STATUS_DISK_FULL", "NO SPACE"})) {
+            return static_cast<int>(SmbErrorCode::NoSpace);
+        }
+
+        if (containsAny(upper, {"STATUS_IO_DEVICE_ERROR", "I/O"})) {
+            return static_cast<int>(SmbErrorCode::Io);
+        }
+
+        return static_cast<int>(SmbErrorCode::Unknown);
+    }
+
+    static int fromNtStatus(uint32_t ntStatus) {
+        switch (ntStatus) {
+            case 0xC0000034:  // STATUS_OBJECT_NAME_NOT_FOUND
+            case 0xC000003A:  // STATUS_OBJECT_PATH_NOT_FOUND
+                return static_cast<int>(SmbErrorCode::NotFound);
+            case 0xC0000035:  // STATUS_OBJECT_NAME_COLLISION
+                return static_cast<int>(SmbErrorCode::AlreadyExists);
+            case 0xC0000022:  // STATUS_ACCESS_DENIED
+            case 0xC000006D:  // STATUS_LOGON_FAILURE
+                return static_cast<int>(SmbErrorCode::AccessDenied);
+            case 0xC0000103:  // STATUS_NOT_A_DIRECTORY
+                return static_cast<int>(SmbErrorCode::NotDirectory);
+            case 0xC00000BA:  // STATUS_FILE_IS_A_DIRECTORY
+                return static_cast<int>(SmbErrorCode::IsDirectory);
+            case 0xC0000101:  // STATUS_DIRECTORY_NOT_EMPTY
+                return static_cast<int>(SmbErrorCode::DirectoryNotEmpty);
+            case 0xC00000B5:  // STATUS_IO_TIMEOUT
+                return static_cast<int>(SmbErrorCode::TimedOut);
+            case 0xC000007F:  // STATUS_DISK_FULL
+                return static_cast<int>(SmbErrorCode::NoSpace);
+            case 0xC00000E9:  // STATUS_UNEXPECTED_IO_ERROR
+            case 0xC0000185:  // STATUS_IO_DEVICE_ERROR / transport I/O
+                return static_cast<int>(SmbErrorCode::Io);
+            default:
+                return static_cast<int>(SmbErrorCode::Unknown);
+        }
+    }
+
+    static std::optional<uint32_t> extractNtStatusHex(const std::string& upperMessage) {
+        size_t pos = 0;
+        while ((pos = upperMessage.find("0X", pos)) != std::string::npos) {
+            size_t hexStart = pos + 2;
+            size_t hexEnd = hexStart;
+
+            while (hexEnd < upperMessage.size() && std::isxdigit(static_cast<unsigned char>(upperMessage[hexEnd]))) {
+                ++hexEnd;
+            }
+
+            const size_t hexLen = hexEnd - hexStart;
+            if (hexLen >= 6 && hexLen <= 8) {
+                try {
+                    const auto parsed = static_cast<uint32_t>(std::stoul(upperMessage.substr(hexStart, hexLen), nullptr, 16));
+                    return parsed;
+                } catch (...) {
+                }
+            }
+
+            pos = hexStart;
+        }
+
+        return std::nullopt;
+    }
+
+    static bool contains(const std::string& haystack, const char* needle) { return haystack.find(needle) != std::string::npos; }
+
+    static bool containsAny(const std::string& haystack, std::initializer_list<const char*> needles) {
+        for (const char* needle : needles) {
+            if (contains(haystack, needle)) {
+                return true;
+            }
+        }
+        return false;
+    }
+};
+
+}  // namespace react_native_smb

package/cpp/shared/util/SmbLog.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+// Diagnostic logging: os_log on Apple, __android_log_print on Android, fprintf(stderr) elsewhere.
+
+#if defined(__APPLE__)
+#include <os/log.h>
+namespace react_native_smb {
+inline os_log_t smb_log_handle() {
+    static os_log_t h = os_log_create("com.cetapod.smb", "smb");
+    return h;
+}
+}  // namespace react_native_smb
+#define SMB_LOG(fmt, ...) os_log(::react_native_smb::smb_log_handle(), "[smb] " fmt, ##__VA_ARGS__)
+#elif defined(__ANDROID__)
+#include <android/log.h>
+#define SMB_LOG(fmt, ...) __android_log_print(ANDROID_LOG_INFO, "smb", fmt, ##__VA_ARGS__)
+#else
+#include <cstdio>
+#define SMB_LOG(fmt, ...) std::fprintf(stderr, "[smb] " fmt "\n", ##__VA_ARGS__)
+#endif