C++跨平台文件锁定方案问询：阻止跨设备程序访问远程文件

Great question—locking remote files across Linux and Windows is totally doable, but the approach depends entirely on whether you're accessing them via a shared directory (like SMB/NFS) or FTP, since those two protocols handle concurrency very differently. Let's break this down:

1. Shared Directories (SMB/NFS) #

When you mount a remote shared directory locally (e.g., SMB on Windows or CIFS/NFS on Linux), you can leverage native OS file locking mechanisms, just like you would with local files. These locks work across devices as long as the file system protocol supports them.

Cross-Platform Implementation #

You'll need to wrap platform-specific APIs to create a unified locking function. Here's a simplified example:

#include <fstream>
#ifdef _WIN32
#include <windows.h>
#include <io.h> // For _get_osfhandle
#else
#include <fcntl.h>
#include <unistd.h>
#endif

// Lock the entire file exclusively
bool lockFile(std::fstream& file) {
#ifdef _WIN32
    HANDLE hFile = (HANDLE)_get_osfhandle(file.native_handle());
    OVERLAPPED overlapped = {0};
    // Lock entire file with exclusive access
    return LockFileEx(hFile, LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY, 
                      0, 0xFFFFFFFF, 0xFFFFFFFF, &overlapped);
#else
    struct flock fl;
    fl.l_type = F_WRLCK;    // Exclusive write lock
    fl.l_whence = SEEK_SET; // Start from file beginning
    fl.l_start = 0;
    fl.l_len = 0;           // Lock entire file
    // F_SETLK = fail immediately if locked; use F_SETLKW to block
    return fcntl(file.native_handle(), F_SETLK, &fl) == 0;
#endif
}

// Unlock the file
bool unlockFile(std::fstream& file) {
#ifdef _WIN32
    HANDLE hFile = (HANDLE)_get_osfhandle(file.native_handle());
    OVERLAPPED overlapped = {0};
    return UnlockFileEx(hFile, 0, 0xFFFFFFFF, 0xFFFFFFFF, &overlapped);
#else
    struct flock fl;
    fl.l_type = F_UNLCK;
    fl.l_whence = SEEK_SET;
    fl.l_start = 0;
    fl.l_len = 0;
    return fcntl(file.native_handle(), F_SETLK, &fl) == 0;
#endif
}

Key Notes #

• Collaborative Locks: These are advisory locks—all programs accessing the file must use the same locking logic for it to work. A rogue program ignoring locks can still modify/read the file.
• Protocol Support: Ensure your remote server enables file locking (e.g., SMB servers need oplocks enabled; NFS v4 supports better locking than v3).
• Open Modes: When opening the file, set appropriate share modes (e.g., FILE_SHARE_READ on Windows if you want to allow read-only access while locked).

2. FTP Access #

FTP has no built-in file locking standard, so you'll need to implement a simulated locking mechanism using "lock files".

Core Approach #

When you want to process a file (e.g., data.csv), first attempt to create a companion lock file (e.g., data.csv.lock) in the same FTP directory. Only the program that successfully creates the lock file (atomically) can process the original file. Once done, delete the lock file.

Atomic Lock File Creation #

The critical part is ensuring only one program can create the lock file. Here's how to do it with libcurl (a popular cross-platform FTP library):

#include <curl/curl.h>
#include <string>
#include <ctime>

// Atomically create a lock file on FTP
bool createFTPLock(const std::string& ftpFileUrl) {
    CURL* curl = curl_easy_init();
    if (!curl) return false;

    std::string lockUrl = ftpFileUrl + ".lock";
    // Write current timestamp to lock file for timeout checks
    std::string lockContent = std::to_string(time(nullptr));

    curl_easy_setopt(curl, CURLOPT_URL, lockUrl.c_str());
    curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
    // CURLOPT_CREATE_NEW_FILE ensures atomic creation (fails if file exists)
    curl_easy_setopt(curl, CURLOPT_CREATE_NEW_FILE, 1L);
    // Custom read function to send lock file content
    curl_easy_setopt(curl, CURLOPT_READFUNCTION, [](char* ptr, size_t size, size_t nmemb, void* userdata) {
        auto* content = static_cast<std::string*>(userdata);
        size_t copySize = std::min(size * nmemb, content->size());
        memcpy(ptr, content->data(), copySize);
        content->erase(0, copySize);
        return copySize;
    });
    curl_easy_setopt(curl, CURLOPT_READDATA, &lockContent);

    CURLcode res = curl_easy_perform(curl);
    curl_easy_cleanup(curl);

    return res == CURLE_OK;
}

// Delete the FTP lock file
void deleteFTPLock(const std::string& ftpFileUrl) {
    CURL* curl = curl_easy_init();
    if (!curl) return;

    std::string lockUrl = ftpFileUrl + ".lock";
    curl_easy_setopt(curl, CURLOPT_URL, lockUrl.c_str());
    curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELE"); // FTP delete command

    curl_easy_perform(curl);
    curl_easy_cleanup(curl);
}

Key Notes #

• Timeout Handling: If a program crashes mid-processing, the lock file will linger. Add logic to check the timestamp in the lock file—if it's older than a threshold (e.g., 5 minutes), delete it and proceed.
• Collaborative Rule: All programs accessing the FTP files must follow the lock file convention. Without this, duplicates will still happen.
• Permissions: Ensure your FTP user has write/delete permissions in the target directory.

Final Recommendations #

• Use native file locks if you're working with shared directories—they're more reliable and efficient.
• For FTP, stick with the lock file pattern, but test edge cases (like server downtime or crashed processes) thoroughly.
• Always document the locking mechanism for all teams/programs that interact with these files to avoid misconfiguration.

内容的提问来源于stack exchange，提问作者Jose Luis Bernal Castillo