@cetapod/react-native-smb 1.0.0

package/cpp/shared/operators/OperatorBase.hpp

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <any>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#include "../connection/MetadataContextLease.hpp"
+#include "../connection/PoolContextHandle.hpp"
+#include "../connection/PoolTypes.hpp"
+#include "../core/CancellationToken.hpp"
+#include "../core/OperatorContext.hpp"
+#include "../core/SmbEnums.hpp"
+
+namespace react_native_smb {
+
+namespace jsi = facebook::jsi;
+
+class SmbConnectionPool;
+class SmbTask;
+
+class OperatorBase {
+   public:
+    virtual ~OperatorBase() = default;
+
+    virtual void run() = 0;
+    virtual SmbOperatorKind kind() const = 0;
+
+    void setContext(const OperatorContext& ctx) { ctx_ = ctx; }
+    void start(SmbTask* task, SmbConnectionPool* pool, const CancellationToken& cancel, size_t opIndex);
+
+   protected:
+    void emitStatus(SmbTaskStatus s, const std::string& error = "", int code = 0);
+    void emitProgress(double done, double total);
+
+    bool isCancelled() const { return ctx_.cancel.cancelled(); }
+    const CancellationToken& cancelToken() const { return ctx_.cancel; }
+
+    SmbConnectionPool& pool() const { return *ctx_.pool; }
+    PoolContextHandle requestContext(AcquireMode mode);
+    MetadataContextLease makeMetadataLease();
+    std::string owningTaskId() const;
+
+    size_t spawn(std::vector<std::unique_ptr<OperatorBase>> moreOps);
+    void addExpectedBytes(int64_t bytes);
+    void setSourceDestination(const std::string& source, const std::string& destination);
+    void publishResult(std::any value, std::function<jsi::Value(jsi::Runtime&, const std::any&)> converter);
+
+   private:
+    OperatorContext ctx_{};
+};
+
+}  // namespace react_native_smb

package/cpp/shared/operators/connection/ConnectOperator.cpp

@@ -0,0 +1,19 @@
+#include "ConnectOperator.hpp"
+
+#include "../../connection/SmbConnectionPool.hpp"
+
+namespace react_native_smb {
+
+void ConnectOperator::run() {
+    pool().connect(url_, credentials_);
+    result_ = SmbConnectionInfo{
+        pool().getCurrentUrl(),
+        pool().getServerName(),
+        pool().getShareName(),
+        pool().isConnected(),
+    };
+    publishThisResult();
+    emitStatus(SmbTaskStatus::Success);
+}
+
+}  // namespace react_native_smb

package/cpp/shared/operators/connection/ConnectOperator.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <string>
+
+#include "../../ReactNativeSmb.hpp"  // SmbCredentials, SmbConnectionInfo
+#include "../Operator.hpp"
+
+namespace react_native_smb {
+
+class ConnectOperator : public Operator<SmbConnectionInfo> {
+   public:
+    ConnectOperator(std::string url, SmbCredentials credentials) : url_(std::move(url)), credentials_(std::move(credentials)) {}
+
+    SmbOperatorKind kind() const override { return SmbOperatorKind::Connect; }
+    void run() override;
+
+   private:
+    std::string url_;
+    SmbCredentials credentials_;
+};
+
+}  // namespace react_native_smb

package/cpp/shared/operators/connection/ConnectShareOperator.cpp

@@ -0,0 +1,19 @@
+#include "ConnectShareOperator.hpp"
+
+#include "../../connection/SmbConnectionPool.hpp"
+
+namespace react_native_smb {
+
+void ConnectShareOperator::run() {
+    pool().connectShare(share_);
+    result_ = SmbConnectionInfo{
+        pool().getCurrentUrl(),
+        pool().getServerName(),
+        pool().getShareName(),
+        pool().isConnected(),
+    };
+    publishThisResult();
+    emitStatus(SmbTaskStatus::Success);
+}
+
+}  // namespace react_native_smb

package/cpp/shared/operators/connection/ConnectShareOperator.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <string>
+
+#include "../../ReactNativeSmb.hpp"  // SmbConnectionInfo
+#include "../Operator.hpp"
+
+namespace react_native_smb {
+
+class ConnectShareOperator : public Operator<SmbConnectionInfo> {
+   public:
+    explicit ConnectShareOperator(std::string share) : share_(std::move(share)) {}
+
+    SmbOperatorKind kind() const override { return SmbOperatorKind::ConnectShare; }
+    void run() override;
+
+   private:
+    std::string share_;
+};
+
+}  // namespace react_native_smb

package/cpp/shared/operators/connection/DisconnectOperator.cpp

@@ -0,0 +1,12 @@
+#include "DisconnectOperator.hpp"
+
+#include "../../connection/SmbConnectionPool.hpp"
+
+namespace react_native_smb {
+
+void DisconnectOperator::run() {
+    pool().disconnect();
+    emitStatus(SmbTaskStatus::Success);
+}
+
+}  // namespace react_native_smb

package/cpp/shared/operators/connection/DisconnectOperator.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "../OperatorBase.hpp"
+
+namespace react_native_smb {
+
+class DisconnectOperator : public OperatorBase {
+   public:
+    DisconnectOperator() = default;
+
+    SmbOperatorKind kind() const override { return SmbOperatorKind::Disconnect; }
+    void run() override;
+};
+
+}  // namespace react_native_smb

package/cpp/shared/operators/connection/InitializeOperator.cpp

@@ -0,0 +1,12 @@
+#include "InitializeOperator.hpp"
+
+#include "../../connection/SmbConnectionPool.hpp"
+
+namespace react_native_smb {
+
+void InitializeOperator::run() {
+    pool().initialize(url_, credentials_);
+    emitStatus(SmbTaskStatus::Success);
+}
+
+}  // namespace react_native_smb

package/cpp/shared/operators/connection/InitializeOperator.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <string>
+
+#include "../../ReactNativeSmb.hpp"  // SmbCredentials
+#include "../OperatorBase.hpp"
+
+namespace react_native_smb {
+
+class InitializeOperator : public OperatorBase {
+   public:
+    InitializeOperator(std::string url, SmbCredentials credentials) : url_(std::move(url)), credentials_(std::move(credentials)) {}
+
+    SmbOperatorKind kind() const override { return SmbOperatorKind::Initialize; }
+    void run() override;
+
+   private:
+    std::string url_;
+    SmbCredentials credentials_;
+};
+
+}  // namespace react_native_smb

package/cpp/shared/operators/connection/ListSharesOperator.cpp

@@ -0,0 +1,13 @@
+#include "ListSharesOperator.hpp"
+
+#include "../../connection/SmbConnectionPool.hpp"
+
+namespace react_native_smb {
+
+void ListSharesOperator::run() {
+    result_ = pool().listShares(owningTaskId());
+    publishThisResult();
+    emitStatus(SmbTaskStatus::Success);
+}
+
+}  // namespace react_native_smb

package/cpp/shared/operators/connection/ListSharesOperator.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <vector>
+
+#include "../../ReactNativeSmb.hpp"  // SmbShareList
+#include "../Operator.hpp"
+
+namespace react_native_smb {
+
+class ListSharesOperator : public Operator<std::vector<SmbShareList>> {
+   public:
+    ListSharesOperator() = default;
+
+    SmbOperatorKind kind() const override { return SmbOperatorKind::ListShares; }
+    void run() override;
+};
+
+}  // namespace react_native_smb

package/cpp/shared/operators/listing/GetPathInfoOperator.cpp

@@ -0,0 +1,43 @@
+#include "GetPathInfoOperator.hpp"
+
+#include <stdexcept>
+
+#include "../../connection/SmbConnectionPool.hpp"
+#include "../../io/SmbDirScan.hpp"
+#include "../../io/SmbPathUtil.hpp"
+
+namespace react_native_smb {
+
+void GetPathInfoOperator::run() {
+
+    const std::string parentPath = path_util::parentOf(path_);
+    const std::string fileName = path_util::extractFileName(path_);
+
+    auto handle = requestContext(AcquireMode::Interactive);
+
+    const CancellationToken token = cancelToken();
+    bool found = false;
+    SmbFileInfo info;
+    try {
+        std::vector<SmbFileInfo> siblings = handle.submitSync([&](smb2_context* ctx) { return listOnCtx(ctx, parentPath, true, 1, token); });
+        for (const auto& item : siblings) {
+            if (item.name == fileName) {
+                info = item;
+                found = true;
+                break;
+            }
+        }
+    } catch (...) {
+        throw std::runtime_error("Failed to get path info for '" + path_ + "': File not found.");
+    }
+
+    if (!found) {
+        throw std::runtime_error("Failed to get path info for '" + path_ + "': File not found.");
+    }
+
+    result_ = info;
+    publishThisResult();
+    emitStatus(SmbTaskStatus::Success);
+}
+
+}  // namespace react_native_smb

package/cpp/shared/operators/listing/GetPathInfoOperator.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <string>
+
+#include "../../ReactNativeSmb.hpp"  // SmbFileInfo
+#include "../Operator.hpp"
+
+namespace react_native_smb {
+
+class GetPathInfoOperator : public Operator<SmbFileInfo> {
+   public:
+    explicit GetPathInfoOperator(std::string path) : path_(std::move(path)) {}
+
+    SmbOperatorKind kind() const override { return SmbOperatorKind::GetPathInfo; }
+    void run() override;
+
+   private:
+    std::string path_;
+};
+
+}  // namespace react_native_smb

package/cpp/shared/operators/listing/GetSecurityDescriptorOperator.cpp

@@ -0,0 +1,202 @@
+#include "GetSecurityDescriptorOperator.hpp"
+
+#include <poll.h>
+#include <smb2/libsmb2-raw.h>
+#include <smb2/libsmb2.h>
+#include <smb2/smb2.h>
+
+#include <cstring>
+#include <stdexcept>
+#include <string>
+
+#include "../../connection/SmbConnectionPool.hpp"
+#include "../../io/SmbSecurity.hpp"
+
+namespace react_native_smb {
+
+namespace {
+
+// Mutable state shared with the three compound-PDU callbacks.
+struct AclQueryContext {
+    SmbSecurityDescriptor* result;
+    std::string error;
+    bool finished;
+    int createStatus;
+    int queryStatus;
+    int closeStatus;
+    struct smb2_security_descriptor* sd;
+    bool createCompleted;
+    bool queryCompleted;
+    bool closeCompleted;
+};
+
+int sendAclQuery(smb2_context* context, const std::string& filePath, AclQueryContext& queryContext) {
+    auto createCallback = [](struct smb2_context* smb2, int status, void* /*command_data*/, void* private_data) {
+        if (!private_data) return;
+        auto* ctx = static_cast<AclQueryContext*>(private_data);
+        ctx->createCompleted = true;
+        ctx->createStatus = status;
+        if (status != 0) {
+            ctx->error = "CREATE failed (status=" + std::to_string(status) + "): " + (smb2 ? std::string(smb2_get_error(smb2)) : "");
+        }
+    };
+
+    auto queryCallback = [](struct smb2_context* smb2, int status, void* command_data, void* private_data) {
+        if (!private_data) return;
+        auto* ctx = static_cast<AclQueryContext*>(private_data);
+        ctx->queryCompleted = true;
+        ctx->queryStatus = status;
+        if (status != 0) {
+            ctx->error = "QUERY_INFO failed (status=" + std::to_string(status) + "): " + (smb2 ? std::string(smb2_get_error(smb2)) : "");
+            return;
+        }
+        if (!command_data) {
+            ctx->error = "QUERY_INFO: No command data received";
+            return;
+        }
+        auto rep = static_cast<struct smb2_query_info_reply*>(command_data);
+        if (!rep || !rep->output_buffer) {
+            ctx->error = "QUERY_INFO: No security descriptor data received";
+            return;
+        }
+        ctx->sd = static_cast<struct smb2_security_descriptor*>(rep->output_buffer);
+        if (!ctx->sd) ctx->error = "QUERY_INFO: Invalid security descriptor format";
+    };
+
+    auto closeCallback = [](struct smb2_context* smb2, int status, void* /*command_data*/, void* private_data) {
+        if (!private_data) return;
+        auto* ctx = static_cast<AclQueryContext*>(private_data);
+        ctx->closeCompleted = true;
+        ctx->closeStatus = status;
+        ctx->finished = true;  // final callback
+        if (status != 0) {
+            ctx->error = "CLOSE failed (status=" + std::to_string(status) + "): " + (smb2 ? std::string(smb2_get_error(smb2)) : "");
+            return;
+        }
+        if (ctx->createStatus != 0) {
+            ctx->error = "CREATE command failed with status: " + std::to_string(ctx->createStatus);
+            return;
+        }
+        if (ctx->queryStatus != 0) {
+            ctx->error = "QUERY_INFO command failed with status: " + std::to_string(ctx->queryStatus);
+            return;
+        }
+        if (!ctx->sd) {
+            ctx->error = "No security descriptor available for processing";
+            return;
+        }
+        if (!ctx->result) {
+            ctx->error = "Result pointer is null";
+            return;
+        }
+        try {
+            *ctx->result = SmbSecurity::processSecurityDescriptor(ctx->sd);
+        } catch (const std::exception& e) {
+            ctx->error = "Error converting security descriptor: " + std::string(e.what());
+        } catch (...) {
+            ctx->error = "Unknown error converting security descriptor";
+        }
+    };
+
+    struct smb2_create_request cr_req;
+    struct smb2_query_info_request qi_req;
+    struct smb2_close_request cl_req;
+    struct smb2_pdu *pdu, *next_pdu;
+
+    memset(&cr_req, 0, sizeof(cr_req));
+    cr_req.requested_oplock_level = SMB2_OPLOCK_LEVEL_NONE;
+    cr_req.impersonation_level = SMB2_IMPERSONATION_IMPERSONATION;
+    cr_req.desired_access = SMB2_READ_CONTROL;
+    cr_req.file_attributes = 0;
+    cr_req.share_access = SMB2_FILE_SHARE_READ | SMB2_FILE_SHARE_WRITE | SMB2_FILE_SHARE_DELETE;
+    cr_req.create_disposition = SMB2_FILE_OPEN;
+    cr_req.create_options = 0;
+    cr_req.name = filePath.c_str();
+
+    pdu = smb2_cmd_create_async(context, &cr_req, createCallback, &queryContext);
+    if (!pdu) return -1;
+
+    memset(&qi_req, 0, sizeof(qi_req));
+    qi_req.info_type = SMB2_0_INFO_SECURITY;
+    qi_req.output_buffer_length = 65535;
+    qi_req.additional_information = SMB2_OWNER_SECURITY_INFORMATION | SMB2_GROUP_SECURITY_INFORMATION | SMB2_DACL_SECURITY_INFORMATION;
+    memset(qi_req.file_id, 0xFF, SMB2_FD_SIZE);
+
+    next_pdu = smb2_cmd_query_info_async(context, &qi_req, queryCallback, &queryContext);
+    if (!next_pdu) {
+        smb2_free_pdu(context, pdu);
+        return -1;
+    }
+    smb2_add_compound_pdu(context, pdu, next_pdu);
+
+    memset(&cl_req, 0, sizeof(cl_req));
+    cl_req.flags = SMB2_CLOSE_FLAG_POSTQUERY_ATTRIB;
+    memset(cl_req.file_id, 0xFF, SMB2_FD_SIZE);
+
+    next_pdu = smb2_cmd_close_async(context, &cl_req, closeCallback, &queryContext);
+    if (!next_pdu) {
+        smb2_free_pdu(context, pdu);
+        return -1;
+    }
+    smb2_add_compound_pdu(context, pdu, next_pdu);
+
+    smb2_queue_pdu(context, pdu);
+    return 0;
+}
+
+void pollUntilComplete(smb2_context* ctx, AclQueryContext& context) {
+    if (!ctx) throw std::runtime_error("ACL Error: SMB2 context is invalid during polling.");
+
+    struct pollfd pfd;
+    int timeout_count = 0;
+    const int max_timeouts = 10;
+
+    while (!context.finished) {
+        pfd.fd = smb2_get_fd(ctx);
+        if (pfd.fd < 0) throw std::runtime_error("ACL Error: Invalid file descriptor from libsmb2. Connection might be broken.");
+        pfd.events = smb2_which_events(ctx);
+
+        if (poll(&pfd, 1, 1000) < 0) throw std::runtime_error("Poll failed during ACL query");
+
+        if (pfd.revents == 0) {
+            if (++timeout_count >= max_timeouts) throw std::runtime_error("ACL query timed out");
+            continue;
+        }
+        timeout_count = 0;
+
+        if (pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
+            throw std::runtime_error("ACL Error: Socket poll failure (revents=" + std::to_string(pfd.revents) + ").");
+        }
+        if (smb2_service(ctx, pfd.revents) < 0) {
+            throw std::runtime_error("ACL Error: smb2_service failed: " + std::string(smb2_get_error(ctx)));
+        }
+    }
+}
+
+}  // namespace
+
+void GetSecurityDescriptorOperator::run() {
+    emitStatus(SmbTaskStatus::Running);
+
+    auto handle = requestContext(AcquireMode::Interactive);
+
+    SmbSecurityDescriptor sd{0, {}, "", "", SmbAcl{0, 0, {}}};
+
+    handle.submitSync([&](smb2_context* ctx) {
+        if (!ctx) throw std::runtime_error("ACL Operation Failed: SMB2 context is invalid. Please reconnect.");
+
+        AclQueryContext queryContext = {&sd, "", false, 0, 0, 0, nullptr, false, false, false};
+
+        if (sendAclQuery(ctx, path_, queryContext) != 0) {
+            throw std::runtime_error("ACL Operation Failed: Could not send ACL query for '" + path_ + "'. Error: " + std::string(smb2_get_error(ctx)));
+        }
+        pollUntilComplete(ctx, queryContext);
+        if (!queryContext.error.empty()) throw std::runtime_error(queryContext.error);
+    });
+
+    result_ = sd;
+    publishThisResult();
+    emitStatus(SmbTaskStatus::Success);
+}
+
+}  // namespace react_native_smb

package/cpp/shared/operators/listing/GetSecurityDescriptorOperator.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <string>
+
+#include "../../ReactNativeSmb.hpp"  // SmbSecurityDescriptor
+#include "../Operator.hpp"
+
+namespace react_native_smb {
+
+// Queries a path security descriptor via CREATE + QUERY_INFO + CLOSE.
+class GetSecurityDescriptorOperator : public Operator<SmbSecurityDescriptor> {
+   public:
+    explicit GetSecurityDescriptorOperator(std::string path) : path_(std::move(path)) {}
+
+    SmbOperatorKind kind() const override { return SmbOperatorKind::GetSecurityDescriptor; }
+    void run() override;
+
+   private:
+    std::string path_;
+};
+
+}  // namespace react_native_smb

package/cpp/shared/operators/listing/ListDirectoryOperator.cpp

@@ -0,0 +1,20 @@
+#include "ListDirectoryOperator.hpp"
+
+#include "../../connection/SmbConnectionPool.hpp"
+#include "../../io/SmbDirScan.hpp"
+
+namespace react_native_smb {
+
+void ListDirectoryOperator::run() {
+
+    const AcquireMode mode = (!recursive_ || maxDepth_ == 0) ? AcquireMode::Interactive : AcquireMode::Metadata;
+    auto handle = requestContext(mode);
+
+    const CancellationToken token = cancelToken();
+    result_ = handle.submitSync([&](smb2_context* ctx) { return listOnCtx(ctx, path_, recursive_, maxDepth_, token); });
+    publishThisResult();
+
+    emitStatus(SmbTaskStatus::Success);
+}
+
+}  // namespace react_native_smb

package/cpp/shared/operators/listing/ListDirectoryOperator.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "../../ReactNativeSmb.hpp"  // SmbFileInfo
+#include "../Operator.hpp"
+
+namespace react_native_smb {
+
+class ListDirectoryOperator : public Operator<std::vector<SmbFileInfo>> {
+   public:
+    ListDirectoryOperator(std::string path, bool recursive, int maxDepth) : path_(std::move(path)), recursive_(recursive), maxDepth_(maxDepth) {}
+
+    SmbOperatorKind kind() const override { return SmbOperatorKind::ListDirectory; }
+    void run() override;
+
+   private:
+    std::string path_;
+    bool recursive_;
+    int maxDepth_;
+};
+
+}  // namespace react_native_smb

package/cpp/shared/operators/mutate/CopyItemOperator.cpp

@@ -0,0 +1,19 @@
+#include "CopyItemOperator.hpp"
+
+#include "../../io/SmbCopyTree.hpp"
+
+namespace react_native_smb {
+
+void CopyItemOperator::run() {
+    setSourceDestination(fromPath_, toPath_);
+    MetadataContextLease lease = makeMetadataLease();
+    copyTreeImpl(pool(), kind(), fromPath_, toPath_, recursive_, cancelToken(),
+                 [this](double done, double total) { emitProgress(done, total); }, [this](int64_t n) { addExpectedBytes(n); }, owningTaskId(), &lease);
+    if (isCancelled()) {
+        emitStatus(SmbTaskStatus::Cancelled);
+        return;
+    }
+    emitStatus(SmbTaskStatus::Success);
+}
+
+}  // namespace react_native_smb

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

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <string>
+
+#include "../OperatorBase.hpp"
+
+namespace react_native_smb {
+
+// Copies a file or a directory tree (recursive). Self-contained: mirrors the
+// destination skeleton and copies files via the async pipelined copy. Progress
+// is aggregated into a single cumulative byte count.
+class CopyItemOperator : public OperatorBase {
+   public:
+    CopyItemOperator(std::string fromPath, std::string toPath, bool recursive = true) : fromPath_(std::move(fromPath)), toPath_(std::move(toPath)), recursive_(recursive) {}
+
+    SmbOperatorKind kind() const override { return SmbOperatorKind::CopyItem; }
+    void run() override;
+
+   private:
+    std::string fromPath_;
+    std::string toPath_;
+    bool recursive_;
+};
+
+}  // namespace react_native_smb

package/cpp/shared/operators/mutate/CreateDirectoryOperator.cpp

@@ -0,0 +1,28 @@
+#include "CreateDirectoryOperator.hpp"
+
+#include <smb2/libsmb2.h>
+#include <smb2/smb2.h>
+
+#include <stdexcept>
+
+#include "../../connection/SmbConnectionPool.hpp"
+#include "../../io/SmbPathUtil.hpp"
+
+namespace react_native_smb {
+
+void CreateDirectoryOperator::run() {
+
+    const std::string norm = path_util::normalized(path_);
+    auto handle = requestContext(AcquireMode::Interactive);
+
+    handle.submitSync([&](smb2_context* ctx) {
+        const int r = smb2_mkdir(ctx, norm.c_str());
+        if (r < 0) {
+            throw std::runtime_error("Directory Usage Failed: Could not create directory at '" + path_ + "'. Error: " + smb2_get_error(ctx));
+        }
+    });
+
+    emitStatus(SmbTaskStatus::Success);
+}
+
+}  // namespace react_native_smb

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

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <string>
+
+#include "../OperatorBase.hpp"
+
+namespace react_native_smb {
+
+class CreateDirectoryOperator : public OperatorBase {
+   public:
+    explicit CreateDirectoryOperator(std::string path) : path_(std::move(path)) {}
+
+    SmbOperatorKind kind() const override { return SmbOperatorKind::CreateDirectory; }
+    void run() override;
+
+   private:
+    std::string path_;
+};
+
+}  // namespace react_native_smb