@cetapod/react-native-smb 1.0.0

package/cpp/shared/connection/PoolSlot.cpp

@@ -0,0 +1,73 @@
+#include "PoolSlot.hpp"
+
+namespace react_native_smb {
+
+PoolSlot::PoolSlot(size_t index) : index_(index), conn_(std::make_unique<SmbConnectionManager>()) {}
+
+bool PoolSlot::accepts(AcquireMode mode) const {
+    if (index_ == 0) return mode == AcquireMode::Interactive;
+    return true;
+}
+
+PoolSlotInfo PoolSlot::snapshot(size_t poolSize) const {
+    PoolSlotInfo info;
+    info.poolSize = poolSize;
+    info.index = index_;
+    info.interactiveOnly = isInteractiveOnly();
+    info.state = state();
+    info.isConnected = conn_ && conn_->isConnected();
+    info.shareName = conn_ ? conn_->getShareName() : std::string();
+    info.taskId = activeTaskId_;
+    info.kind = isIdle() ? SmbOperatorKind::Initialize : activeKind_;
+    return info;
+}
+
+void PoolSlot::assign(uint64_t requestId, const std::string& taskId, SmbOperatorKind kind) {
+    assignedRequestId_ = requestId;
+    activeTaskId_ = taskId;
+    activeKind_ = kind;
+    state_ = SlotState::Assigned;
+}
+
+void PoolSlot::release() {
+    assignedRequestId_ = 0;
+    activeTaskId_.clear();
+    activeKind_ = SmbOperatorKind::Initialize;
+    state_ = SlotState::Idle;
+}
+
+void PoolSlot::markActivating() { state_ = SlotState::Activating; }
+
+void PoolSlot::activate(const PoolConnectParams& params, const std::string& taskId) {
+    state_ = SlotState::Activating;
+    if (!params.serverUrl.empty() && params.credentials) {
+        conn_->initialize(params.serverUrl, *params.credentials, taskId);
+    }
+    if (!params.shareName.empty()) {
+        conn_->connectShare(params.shareName, taskId);
+    }
+}
+
+void PoolSlot::ensureShare(const std::string& share, const std::string& taskId) {
+    if (share.empty()) {
+        return;
+    }
+    if (conn_->getShareName() != share) {
+        conn_->connectShare(share, taskId);
+    } else if (!conn_->isConnected()) {
+        conn_->checkAndConnect(taskId);
+    }
+}
+
+void PoolSlot::resetBroken() {
+    release();
+    if (conn_) {
+        try {
+            conn_->disconnect();
+        } catch (...) {
+        }
+    }
+    conn_ = std::make_unique<SmbConnectionManager>();
+}
+
+}  // namespace react_native_smb

package/cpp/shared/connection/PoolSlot.hpp

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+
+#include "PoolTypes.hpp"
+#include "SmbConnection.hpp"
+
+namespace react_native_smb {
+
+class PoolSlot {
+   public:
+    explicit PoolSlot(size_t index);
+
+    size_t index() const { return index_; }
+    SlotState state() const { return state_; }
+
+    bool isInteractiveOnly() const { return index_ == 0; }
+    bool isIdle() const { return state() == SlotState::Idle; }
+    bool accepts(AcquireMode mode) const;
+
+    SmbConnectionManager* manager() { return conn_.get(); }
+    const SmbConnectionManager* manager() const { return conn_.get(); }
+    smb2_context* rawCtx() const { return conn_ ? conn_->rawCtx() : nullptr; }
+
+    PoolSlotInfo snapshot(size_t poolSize) const;
+
+    void assign(uint64_t requestId, const std::string& taskId, SmbOperatorKind kind);
+    void release();
+    void markActivating();
+    void activate(const PoolConnectParams& params, const std::string& taskId);
+    void ensureShare(const std::string& share, const std::string& taskId);
+    void resetBroken();
+
+   private:
+    size_t index_{0};
+    SlotState state_{SlotState::Idle};
+    std::unique_ptr<SmbConnectionManager> conn_;
+    std::string activeTaskId_;
+    SmbOperatorKind activeKind_{SmbOperatorKind::Initialize};
+    uint64_t assignedRequestId_{0};
+};
+
+}  // namespace react_native_smb

package/cpp/shared/connection/PoolTypes.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <cstddef>
+#include <memory>
+#include <string>
+
+#include "../core/SmbEnums.hpp"
+
+namespace react_native_smb {
+
+struct SmbCredentials;
+
+enum class AcquireMode {
+    Interactive,
+    Metadata,
+};
+
+enum class SlotState {
+    Idle,
+    Assigned,
+    Activating,
+};
+
+struct PoolConnectParams {
+    std::string serverUrl;
+    std::string shareName;
+    std::shared_ptr<SmbCredentials> credentials;
+};
+
+struct PoolSlotInfo {
+    size_t poolSize{0};
+    size_t index{0};
+    bool interactiveOnly{false};
+    SlotState state{SlotState::Idle};
+    bool isConnected{false};
+    std::string shareName;
+    std::string taskId;
+    SmbOperatorKind kind{SmbOperatorKind::Initialize};
+};
+
+}  // namespace react_native_smb

package/cpp/shared/connection/SmbConnection.cpp

@@ -0,0 +1,385 @@
+#include "SmbConnection.hpp"  // sibling
+
+#include <poll.h>
+#include <smb2/libsmb2-dcerpc-srvsvc.h>
+#include <smb2/libsmb2-raw.h>
+
+#include <cerrno>
+#include <stdexcept>
+
+namespace react_native_smb {
+
+namespace {
+constexpr int kShareEnumPollTimeoutMs = 5000;
+constexpr int kShareEnumMaxIdlePolls = 12;
+
+[[noreturn]] void throwError(const std::string& /*taskId*/, const std::string& message, int /*code*/) {
+    throw std::runtime_error(message);
+}
+}  // namespace
+
+ScopedContextLock::ScopedContextLock(SmbConnectionManager& manager, const std::string& taskId) : lock_(manager.connectionMutex_), context_(nullptr) {
+    manager.checkAndConnect(taskId);
+    context_ = manager.context_.get();
+}
+
+SmbConnectionManager::SmbConnectionManager() {
+    context_ = nullptr;
+    currentUrl_ = "";
+    serverName_ = "";
+    isInitialized_ = false;
+    isConnected_ = false;
+}
+
+SmbConnectionManager::~SmbConnectionManager() {
+    std::lock_guard<std::recursive_timed_mutex> lock(connectionMutex_);
+    if (isConnected_ && context_) {
+        smb2_disconnect_share(context_.get());
+        isConnected_ = false;
+        currentShareName_.clear();
+    }
+    context_.reset();
+}
+
+void SmbConnectionManager::initialize(const std::string& url, const SmbCredentials& credentials, const std::string& taskId) {
+    try {
+        std::lock_guard<std::recursive_timed_mutex> lock(connectionMutex_);
+
+        initializeContext();
+
+        credentials_ = std::make_shared<SmbCredentials>(credentials);
+
+        smb2_set_user(context_.get(), credentials.username.c_str());
+        smb2_set_password(context_.get(), credentials.password.c_str());
+
+        if (url.substr(0, 6) == "smb://") {
+            std::string remaining = url.substr(6);
+            size_t slashPos = remaining.find('/');
+            if (slashPos != std::string::npos) {
+                serverName_ = remaining.substr(0, slashPos);
+            } else {
+                serverName_ = remaining;
+            }
+        } else {
+            std::string msg = "Invalid SMB URL format. Expected: smb://server";
+            throwError(taskId, msg, static_cast<int>(SmbErrorCode::InvalidArgument));
+        }
+
+        currentUrl_ = "smb://" + serverName_;
+        isInitialized_ = true;
+    } catch (const std::exception& e) {
+        throwError(taskId, e.what(), static_cast<int>(SmbErrorCode::Unknown));
+    }
+}
+
+void SmbConnectionManager::connect(const std::string& url, const SmbCredentials& credentials, const std::string& taskId) {
+    try {
+        std::lock_guard<std::recursive_timed_mutex> lock(connectionMutex_);
+
+        if (isConnected_) {
+            smb2_disconnect_share(context_.get());
+            isConnected_ = false;
+        }
+
+        initializeContext();
+
+        credentials_ = std::make_shared<SmbCredentials>(credentials);
+
+        smb2_set_user(context_.get(), credentials.username.c_str());
+        smb2_set_password(context_.get(), credentials.password.c_str());
+
+        std::string serverName;
+        std::string shareName;
+
+        if (url.substr(0, 6) == "smb://") {
+            std::string remaining = url.substr(6);
+            size_t slashPos = remaining.find('/');
+            if (slashPos != std::string::npos) {
+                serverName = remaining.substr(0, slashPos);
+                shareName = remaining.substr(slashPos + 1);
+            } else {
+                std::string msg = "Invalid URL: format must be smb://server/share. Received: " + url;
+                throwError(taskId, msg, static_cast<int>(SmbErrorCode::InvalidArgument));
+            }
+        } else {
+            std::string msg = "Invalid URL: format must be smb://server/share. Received: " + url;
+            throwError(taskId, msg, static_cast<int>(SmbErrorCode::InvalidArgument));
+        }
+
+        const int connectResult = smb2_connect_share(context_.get(), serverName.c_str(), shareName.c_str(), credentials.username.c_str());
+        if (connectResult < 0) {
+            std::string libError = smb2_get_error(context_.get());
+            std::string msg = "SMB Connection Failed: Could not connect to share '" + shareName + "'. Error: " + libError;
+            throwError(taskId, msg, SmbErrorMapper::fromErrnoResult(connectResult));
+        }
+
+        isConnected_ = true;
+        isInitialized_ = true;
+        serverName_ = serverName;
+        currentShareName_ = shareName;
+        currentUrl_ = url;
+    } catch (const std::exception& e) {
+        throwError(taskId, e.what(), static_cast<int>(SmbErrorCode::Unknown));
+    }
+}
+
+void SmbConnectionManager::connectShare(const std::string& share, const std::string& taskId) {
+    try {
+        std::lock_guard<std::recursive_timed_mutex> lock(connectionMutex_);
+
+        if (!isInitialized_) {
+            std::string msg = "Connection not initialized. Call initialize() first.";
+            throwError(taskId, msg, static_cast<int>(SmbErrorCode::NotConnected));
+        }
+
+        if (isConnected_ && currentShareName_ == share) {
+            return;
+        }
+
+        if (isConnected_) {
+            smb2_disconnect_share(context_.get());
+            isConnected_ = false;
+            currentShareName_.clear();
+        }
+
+        const int connectResult = smb2_connect_share(context_.get(), serverName_.c_str(), share.c_str(), credentials_->username.c_str());
+        if (connectResult < 0) {
+            std::string msg = "Failed to connect to SMB share '" + share + "': " + std::string(smb2_get_error(context_.get()));
+            throwError(taskId, msg, SmbErrorMapper::fromErrnoResult(connectResult));
+        }
+
+        isConnected_ = true;
+        currentShareName_ = share;
+
+        currentUrl_ = "smb://" + serverName_ + "/" + share;
+    } catch (const std::exception& e) {
+        throwError(taskId, e.what(), static_cast<int>(SmbErrorCode::Unknown));
+    }
+}
+
+void SmbConnectionManager::disconnect(const std::string& taskId) {
+    try {
+        std::lock_guard<std::recursive_timed_mutex> lock(connectionMutex_);
+        if (isConnected_ && context_) {
+            smb2_disconnect_share(context_.get());
+            isConnected_ = false;
+        }
+        context_.reset();
+        isInitialized_ = false;
+        credentials_.reset();
+        serverName_.clear();
+        currentShareName_.clear();
+        currentUrl_.clear();
+    } catch (const std::exception& e) {
+        throwError(taskId, e.what(), static_cast<int>(SmbErrorCode::Unknown));
+    }
+}
+
+std::vector<SmbShareList> SmbConnectionManager::listShares(const std::string& taskId) {
+    std::lock_guard<std::recursive_timed_mutex> lock(connectionMutex_);
+
+    if (!isInitialized_) {
+        throwError(taskId, "Share List Failed: SMB context not initialized. Please call initialize() first.", static_cast<int>(SmbErrorCode::NotConnected));
+    }
+
+    if (serverName_.empty()) {
+        throwError(taskId, "Share List Failed: No server name found. You must connect to a server before listing shares.", static_cast<int>(SmbErrorCode::NotConnected));
+    }
+
+    std::vector<SmbShareList> shares;
+
+    auto ipcContext = std::shared_ptr<smb2_context>(smb2_init_context(), [](smb2_context* ctx) {
+        if (ctx) {
+            smb2_destroy_context(ctx);
+        }
+    });
+
+    if (!ipcContext) {
+        throwError(taskId, "Share List Failed: Could not create temporary SMB context. System might be low on memory.", static_cast<int>(SmbErrorCode::Io));
+    }
+
+    if (credentials_) {
+        smb2_set_user(ipcContext.get(), credentials_->username.c_str());
+        smb2_set_password(ipcContext.get(), credentials_->password.c_str());
+    } else {
+        throwError(taskId, "No credentials available for share enumeration", static_cast<int>(SmbErrorCode::NotConnected));
+    }
+
+    const int ipcConnectResult = smb2_connect_share(ipcContext.get(), serverName_.c_str(), "IPC$", nullptr);
+    if (ipcConnectResult < 0) {
+        throwError(taskId, "Failed to connect to IPC$ share: " + std::string(smb2_get_error(ipcContext.get())), SmbErrorMapper::fromErrnoResult(ipcConnectResult));
+    }
+
+    struct ShareEnumContext {
+        std::vector<SmbShareList>* shares;
+        std::string error;
+        int errorCode;
+        bool finished;
+    } enumContext = {&shares, "", static_cast<int>(SmbErrorCode::Unknown), false};
+
+    auto shareEnumCallback = [](struct smb2_context* smb2, int status, void* command_data, void* private_data) {
+        ShareEnumContext* ctx = static_cast<ShareEnumContext*>(private_data);
+        ctx->finished = true;
+
+        if (status != 0) {
+            ctx->error = "Failed to enumerate shares: " + std::string(smb2_get_error(smb2));
+            ctx->errorCode = SmbErrorMapper::fromErrnoResult(status);
+            return;
+        }
+
+        auto rep = static_cast<struct srvsvc_NetrShareEnum_rep*>(command_data);
+        if (!rep) {
+            ctx->error = "No share enumeration data received";
+            return;
+        }
+
+        for (uint32_t i = 0; i < rep->ses.ShareInfo.Level1.EntriesRead; i++) {
+            auto& shareInfo = rep->ses.ShareInfo.Level1.Buffer->share_info_1[i];
+
+            SmbShareList share;
+            share.name = shareInfo.netname.utf8 ? shareInfo.netname.utf8 : "";
+            share.comment = shareInfo.remark.utf8 ? shareInfo.remark.utf8 : "";
+
+            bool isHidden = (shareInfo.type & SHARE_TYPE_HIDDEN) != 0;
+            bool isSystem = (shareInfo.type & 3) == SHARE_TYPE_IPC;
+
+            if (!isHidden && !isSystem && !share.name.empty()) {
+                ctx->shares->push_back(share);
+            }
+        }
+
+        smb2_free_data(smb2, rep);
+    };
+
+    const int enumStartResult = smb2_share_enum_async(ipcContext.get(), SHARE_INFO_1, shareEnumCallback, &enumContext);
+    if (enumStartResult != 0) {
+        throwError(taskId, "Failed to start share enumeration: " + std::string(smb2_get_error(ipcContext.get())), SmbErrorMapper::fromErrnoResult(enumStartResult));
+    }
+
+    struct pollfd pfd;
+    int idlePolls = 0;
+    while (!enumContext.finished) {
+        pfd.fd = smb2_get_fd(ipcContext.get());
+        pfd.events = smb2_which_events(ipcContext.get());
+
+        if (poll(&pfd, 1, kShareEnumPollTimeoutMs) < 0) {
+            throwError(taskId, "Poll failed during share enumeration", SmbErrorMapper::fromErrno(errno));
+        }
+
+        if (pfd.revents == 0) {
+            if (++idlePolls >= kShareEnumMaxIdlePolls) {
+                throwError(taskId, "Share enumeration timed out", static_cast<int>(SmbErrorCode::TimedOut));
+            }
+            continue;
+        }
+        idlePolls = 0;
+
+        const int serviceResult = smb2_service(ipcContext.get(), pfd.revents);
+        if (serviceResult < 0) {
+            throwError(taskId, "SMB2 service failed: " + std::string(smb2_get_error(ipcContext.get())), SmbErrorMapper::fromErrnoResult(serviceResult));
+        }
+    }
+
+    if (!enumContext.error.empty()) {
+        throwError(taskId, enumContext.error, enumContext.errorCode);
+    }
+
+    smb2_disconnect_share(ipcContext.get());
+
+    return shares;
+}
+
+void SmbConnectionManager::checkAndInitialize(const std::string& taskId) {
+    try {
+        std::lock_guard<std::recursive_timed_mutex> lock(connectionMutex_);
+
+        if (isInitialized_ && context_) {
+            return;
+        }
+
+        if (!credentials_) {
+            std::string msg = "SMB Reconnect Error: Missing saved credentials. Please call initialize() or connect() first.";
+            throwError(taskId, msg, static_cast<int>(SmbErrorCode::NotConnected));
+        }
+
+        if (serverName_.empty()) {
+            if (!currentUrl_.empty() && currentUrl_.rfind("smb://", 0) == 0) {
+                std::string remaining = currentUrl_.substr(6);
+                size_t slashPos = remaining.find('/');
+                serverName_ = (slashPos == std::string::npos) ? remaining : remaining.substr(0, slashPos);
+            }
+        }
+
+        if (serverName_.empty()) {
+            std::string msg = "SMB Reconnect Error: Missing saved server name. Please call initialize() or connect() first.";
+            throwError(taskId, msg, static_cast<int>(SmbErrorCode::NotConnected));
+        }
+
+        initializeContext();
+
+        smb2_set_user(context_.get(), credentials_->username.c_str());
+        smb2_set_password(context_.get(), credentials_->password.c_str());
+
+        if (currentUrl_.empty()) {
+            currentUrl_ = "smb://" + serverName_;
+        }
+
+        isInitialized_ = true;
+    } catch (const std::exception& e) {
+        throwError(taskId, e.what(), static_cast<int>(SmbErrorCode::Unknown));
+    }
+}
+
+void SmbConnectionManager::checkAndConnect(const std::string& taskId) {
+    try {
+        std::lock_guard<std::recursive_timed_mutex> lock(connectionMutex_);
+
+        if (isConnected_ && context_) {
+            return;
+        }
+
+        checkAndInitialize(taskId);
+
+        if (currentShareName_.empty() && currentUrl_.rfind("smb://", 0) == 0) {
+            std::string remaining = currentUrl_.substr(6);
+            size_t slashPos = remaining.find('/');
+            if (slashPos != std::string::npos && slashPos + 1 < remaining.size()) {
+                currentShareName_ = remaining.substr(slashPos + 1);
+            }
+        }
+
+        if (currentShareName_.empty()) {
+            std::string msg = "SMB Reconnect Error: Missing saved share name. Please call connect() or connectShare() first.";
+            throwError(taskId, msg, static_cast<int>(SmbErrorCode::NotConnected));
+        }
+
+        const int connectResult = smb2_connect_share(context_.get(), serverName_.c_str(), currentShareName_.c_str(), credentials_->username.c_str());
+        if (connectResult < 0) {
+            std::string msg = "SMB Reconnect Failed: Could not connect to share '" + currentShareName_ + "'. Error: " + std::string(smb2_get_error(context_.get()));
+            throwError(taskId, msg, SmbErrorMapper::fromErrnoResult(connectResult));
+        }
+        isConnected_ = true;
+        currentUrl_ = "smb://" + serverName_ + "/" + currentShareName_;
+
+    } catch (const std::exception& e) {
+        throwError(taskId, e.what(), static_cast<int>(SmbErrorCode::Unknown));
+    }
+}
+
+void SmbConnectionManager::initializeContext() {
+    if (context_) {
+        context_.reset();
+    }
+
+    auto* raw_context = smb2_init_context();
+    if (!raw_context) {
+        throw std::runtime_error("Fatal Error: Failed to initialize libsmb2 context. System may be out of memory.");
+    }
+
+    context_ = std::shared_ptr<smb2_context>(raw_context, [](smb2_context* ctx) {
+        if (ctx) {
+            smb2_destroy_context(ctx);
+        }
+    });
+}
+}  // namespace react_native_smb

package/cpp/shared/connection/SmbConnection.hpp

@@ -0,0 +1,93 @@
+#pragma once
+
+#include "../ReactNativeSmb.hpp"
+#include "../util/SmbErrorMapper.hpp"
+
+#include <cstdint>
+#include <cstddef>
+#include <ctime>
+#include <smb2/smb2.h>
+#include <smb2/libsmb2.h>
+
+#include <future>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+namespace react_native_smb {
+class SmbConnectionManager;
+
+// RAII lock over connectionMutex_; auto-reconnects on construction.
+class ScopedContextLock {
+   private:
+    std::unique_lock<std::recursive_timed_mutex> lock_;
+    smb2_context* context_;
+
+   public:
+    ScopedContextLock(SmbConnectionManager& manager, const std::string& taskId = "");
+
+    smb2_context* get() const { return context_; }
+
+    ScopedContextLock(const ScopedContextLock&) = delete;
+    ScopedContextLock& operator=(const ScopedContextLock&) = delete;
+};
+
+// Per-manager recursive_timed_mutex serialises all smb2_* calls on one context.
+// submitSync() acquires the mutex and runs the callable on the calling thread.
+// No background poll thread — a second poller on the same fd corrupts libsmb2.
+class SmbConnectionManager {
+    friend class ScopedContextLock;
+
+   private:
+    std::shared_ptr<smb2_context> context_;
+    std::shared_ptr<SmbCredentials> credentials_;
+    std::recursive_timed_mutex connectionMutex_;
+    std::string currentUrl_;
+    std::string serverName_;
+    std::string currentShareName_;
+    bool isInitialized_ = false;
+    bool isConnected_ = false;
+
+   public:
+    SmbConnectionManager();
+    ~SmbConnectionManager();
+
+    void initialize(const std::string& url, const SmbCredentials& credentials, const std::string& taskId = "");
+    void connect(const std::string& url, const SmbCredentials& credentials, const std::string& taskId = "");
+    void connectShare(const std::string& share, const std::string& taskId = "");
+    void disconnect(const std::string& taskId = "");
+
+    std::vector<SmbShareList> listShares(const std::string& taskId = "");
+
+    void checkAndInitialize(const std::string& taskId = "");
+    void checkAndConnect(const std::string& taskId = "");
+
+    bool isConnected() const { return isConnected_; }
+    bool isInitialized() const { return isInitialized_; }
+    const std::string& getCurrentUrl() const { return currentUrl_; }
+    const std::string& getServerName() const { return serverName_; }
+    const std::string& getShareName() const { return currentShareName_; }
+
+    std::shared_ptr<smb2_context> getContext() { return context_; }
+    const std::shared_ptr<SmbCredentials>& getCredentials() const { return credentials_; }
+
+    std::recursive_timed_mutex& getConnectionMutex() { return connectionMutex_; }
+
+    smb2_context* rawCtx() const { return context_.get(); }
+
+    template <typename Fn, typename R = std::invoke_result_t<Fn, smb2_context*>>
+    R submitSync(Fn&& fn) {
+        std::lock_guard<std::recursive_timed_mutex> lock(connectionMutex_);
+        if constexpr (std::is_void_v<R>) {
+            fn(context_.get());
+        } else {
+            return fn(context_.get());
+        }
+    }
+
+   private:
+    void initializeContext();
+};
+}  // namespace react_native_smb