@cetapod/react-native-smb 1.0.0

package/cpp/shared/core/TaskSnapshotCodec.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <string>
+#include <unordered_map>
+
+#include "SmbTypes.hpp"
+
+namespace react_native_smb {
+
+// Single source of truth for the SmbTaskState -> Nitro string-map projection.
+// The TS decoder (src/bridge/decode.ts) mirrors these key names.
+class TaskSnapshotCodec {
+   public:
+    struct Keys {
+        static constexpr const char* exists = "exists";  // "1" / "0" sentinel for getTask
+        static constexpr const char* taskId = "taskId";
+        static constexpr const char* kind = "kind";      // int(SmbOperatorKind)
+        static constexpr const char* operation = "operation";  // debug only; TS ignores
+        static constexpr const char* status = "status";  // int(SmbTaskStatus)
+        static constexpr const char* determinate = "determinate";
+        static constexpr const char* progress = "progress";
+        static constexpr const char* errorCode = "errorCode";
+        static constexpr const char* errorMessage = "errorMessage";
+        static constexpr const char* sourcePath = "sourcePath";
+        static constexpr const char* destinationPath = "destinationPath";
+        static constexpr const char* bytesDone = "bytesDone";
+        static constexpr const char* totalBytes = "totalBytes";
+        static constexpr const char* bytesPerSecond = "bytesPerSecond";
+        static constexpr const char* etaSeconds = "etaSeconds";
+        static constexpr const char* startedAt = "startedAt";
+        static constexpr const char* updatedAt = "updatedAt";
+        static constexpr const char* endedAt = "endedAt";
+    };
+
+    static std::unordered_map<std::string, std::string> encode(const SmbTaskState& s);
+
+    // Sentinel map for "task not found".
+    static std::unordered_map<std::string, std::string> notFound();
+};
+
+}  // namespace react_native_smb

package/cpp/shared/io/SmbCopyTree.hpp

@@ -0,0 +1,114 @@
+#pragma once
+
+#include <smb2/libsmb2.h>
+#include <smb2/smb2.h>
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "../ReactNativeSmb.hpp"
+#include "../connection/MetadataContextLease.hpp"
+#include "../connection/SmbConnectionPool.hpp"
+#include "../core/CancellationToken.hpp"
+#include "../core/SmbEnums.hpp"
+#include "SmbFileIO.hpp"
+#include "SmbDirScan.hpp"
+#include "SmbPathUtil.hpp"
+#include "SmbTreeOps.hpp"
+#include "../util/SmbLog.hpp"
+
+namespace react_native_smb {
+
+inline void copyTreeImpl(SmbConnectionPool& pool, SmbOperatorKind kind, const std::string& fromPath, const std::string& toPath, bool recursive,
+                         const CancellationToken& cancel, const std::function<void(double, double)>& onProgress,
+                         const std::function<void(int64_t)>& onExpectedBytes, const std::string& taskId = "",
+                         MetadataContextLease* sharedLease = nullptr) {
+    const std::string normFrom = path_util::normalized(fromPath);
+
+    std::optional<MetadataContextLease> ownedLease;
+    if (!sharedLease) {
+        ownedLease.emplace(pool, kind, taskId);
+        sharedLease = &*ownedLease;
+    }
+
+    bool isDirectory = false;
+    int64_t totalSize = 0;
+    sharedLease->submitSync([&](smb2_context* ctx) {
+        struct smb2_stat_64 st;
+        if (smb2_stat(ctx, normFrom.c_str(), &st) < 0) {
+            throw std::runtime_error("Copy Failed: Could not stat source '" + fromPath + "'. Error: " + smb2_get_error(ctx));
+        }
+        isDirectory = (st.smb2_type & SMB2_TYPE_DIRECTORY) != 0;
+        totalSize = tree_ops::calculateTotalSize(ctx, fromPath, isDirectory && recursive, cancel);
+    });
+
+    auto totalBytesCopied = std::make_shared<int64_t>(0);
+    if (onExpectedBytes) onExpectedBytes(totalSize);
+    if (onProgress) onProgress(0.0, static_cast<double>(totalSize));
+
+    if (!isDirectory) {
+        sharedLease->submitSync([&](smb2_context* ctx) {
+            SMB_LOG("CopyTree file taskId=%s from=%s to=%s", taskId.c_str(), fromPath.c_str(), toPath.c_str());
+            smbCopyFileAsync(ctx, path_util::normalized(fromPath), path_util::normalized(toPath), totalBytesCopied, totalSize, onProgress, cancel);
+        });
+        if (onProgress) onProgress(static_cast<double>(totalSize), static_cast<double>(totalSize));
+        SMB_LOG("CopyTree finish taskId=%s copiedBytes=%lld totalBytes=%lld cancelled=%d", taskId.c_str(), static_cast<long long>(*totalBytesCopied),
+                static_cast<long long>(totalSize), cancel.cancelled() ? 1 : 0);
+        return;
+    }
+
+    struct CopyJob {
+        std::string src;
+        std::string dst;
+        int64_t size;
+    };
+    std::vector<CopyJob> files;
+    const std::string normToRoot = path_util::normalized(toPath);
+    sharedLease->submitSync([&](smb2_context* ctx) {
+        const int mk = smb2_mkdir(ctx, normToRoot.c_str());
+        if (mk < 0) throw std::runtime_error("Failed to create destination directory: " + std::string(smb2_get_error(ctx)));
+        if (!recursive) return;
+
+        std::function<void(const std::string&, const std::string&)> walk = [&](const std::string& srcDir, const std::string& dstDir) {
+            if (cancel.cancelled()) return;
+            std::vector<SmbFileInfo> contents = listOnCtx(ctx, srcDir, false, 0, cancel);
+            for (const auto& item : contents) {
+                if (cancel.cancelled()) return;
+                std::string destItem = path_util::buildUrl(dstDir, item.name);
+                if (item.isDirectory) {
+                    std::string normDest = path_util::normalized(destItem);
+                    const int r = smb2_mkdir(ctx, normDest.c_str());
+                    if (r < 0) throw std::runtime_error("Failed to create destination directory: " + std::string(smb2_get_error(ctx)));
+                    walk(item.path, destItem);
+                } else {
+                    files.push_back({item.path, destItem, item.size});
+                }
+            }
+        };
+        walk(fromPath, toPath);
+    });
+
+    if (cancel.cancelled() || files.empty()) {
+        SMB_LOG("CopyTree finish taskId=%s reason=%s", taskId.c_str(), cancel.cancelled() ? "cancelled" : "empty");
+        if (onProgress) onProgress(static_cast<double>(totalSize), static_cast<double>(totalSize));
+        return;
+    }
+
+    for (const auto& job : files) {
+        if (cancel.cancelled()) break;
+        sharedLease->submitSync([&](smb2_context* ctx) {
+            SMB_LOG("CopyTree file taskId=%s from=%s to=%s size=%lld", taskId.c_str(), job.src.c_str(), job.dst.c_str(), static_cast<long long>(job.size));
+            smbCopyFileAsync(ctx, path_util::normalized(job.src), path_util::normalized(job.dst), totalBytesCopied, totalSize, onProgress, cancel);
+        });
+    }
+
+    SMB_LOG("CopyTree finish taskId=%s copiedBytes=%lld totalBytes=%lld cancelled=%d", taskId.c_str(), static_cast<long long>(*totalBytesCopied),
+            static_cast<long long>(totalSize), cancel.cancelled() ? 1 : 0);
+    if (onProgress) onProgress(static_cast<double>(totalSize), static_cast<double>(totalSize));
+}
+
+}  // namespace react_native_smb

package/cpp/shared/io/SmbDirScan.hpp

@@ -0,0 +1,80 @@
+#pragma once
+
+#include <smb2/libsmb2.h>
+#include <smb2/smb2.h>
+
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "../ReactNativeSmb.hpp"  // SmbFileInfo
+#include "../core/CancellationToken.hpp"
+#include "SmbPathUtil.hpp"
+
+namespace react_native_smb {
+
+// Directory listing on a single smb2_context. Does not use the connection pool.
+inline std::vector<SmbFileInfo> listOnCtx(smb2_context* ctx, const std::string& path, bool recursive, int maxDepth, const CancellationToken& cancel) {
+    std::vector<SmbFileInfo> files;
+    const std::string norm = path_util::normalized(path);
+
+    smb2dir* dir = smb2_opendir(ctx, norm.c_str());
+    if (!dir) {
+        throw std::runtime_error(std::string("List Directory Failed: Could not open directory '") + path + "'. Error: " + smb2_get_error(ctx));
+    }
+
+    try {
+        struct smb2dirent* ent;
+        while ((ent = smb2_readdir(ctx, dir))) {
+            if (cancel.cancelled()) {
+                smb2_closedir(ctx, dir);
+                return {};
+            }
+            std::string name = ent->name;
+            if (name == "." || name == "..") continue;
+            std::string fullPath = path_util::buildUrl(path, name);
+            files.push_back(path_util::makeFileInfo(ent->st, name, fullPath));
+        }
+    } catch (...) {
+        smb2_closedir(ctx, dir);
+        throw;
+    }
+    smb2_closedir(ctx, dir);
+
+    // Cheap childCount per directory (opendir/readdir count, no per-entry stat).
+    for (auto& item : files) {
+        if (!item.isDirectory) continue;
+        if (cancel.cancelled()) return {};
+        smb2dir* sub = smb2_opendir(ctx, path_util::normalized(item.path).c_str());
+        if (!sub) {
+            item.childCount = -1;
+            continue;
+        }
+        int64_t count = 0;
+        struct smb2dirent* subEnt;
+        while ((subEnt = smb2_readdir(ctx, sub))) {
+            std::string n = subEnt->name;
+            if (n == "." || n == "..") continue;
+            ++count;
+        }
+        smb2_closedir(ctx, sub);
+        item.childCount = count;
+    }
+
+    if (recursive && maxDepth != 0) {
+        for (auto& item : files) {
+            if (cancel.cancelled()) return {};
+            if (item.isDirectory) {
+                try {
+                    int newMaxDepth = (maxDepth > 0) ? maxDepth - 1 : maxDepth;
+                    item.children = listOnCtx(ctx, item.path, true, newMaxDepth, cancel);
+                } catch (const std::exception&) {
+                    item.children.clear();
+                }
+            }
+        }
+    }
+    return files;
+}
+
+}  // namespace react_native_smb