Implementing a File Locking Mechanism

1#include <fcntl.h>
2#include <unistd.h>
3#include <sys/file.h>
4#include <iostream>
5
6namespace File{
7  bool LockFile(int fd) {
8    if (flock(fd, LOCK_EX | LOCK_NB) == -1) {
9      
10      std::cout << "Error locking file" <<
11        std::endl;
12      return false;
13    }
14    return true;
15  }
16
17  bool UnlockFile(int fd) {
18    if (flock(fd, LOCK_UN) == -1) {
19      
20      std::cout << "Error unlocking file" <<
21        std::endl;
22      return false;
23    }
24    return true;
25  }
26
27  void WriteWithLock(const std::string& Path,
28                     const char* Content) {
29    int fd = open(Path.c_str(),
30                  O_WRONLY | O_CREAT, 0644);
31    if (fd == -1) {
32      std::cout << "Error opening file" <<
33        std::endl;
34      return;
35    }
36
37    if (LockFile(fd)) {
38      write(fd, Content, strlen(Content));
39      UnlockFile(fd);
40    }
41
42    close(fd);
43  }
44}

1#include <windows.h>
2
3#include <iostream>
4
5namespace File{
6  bool LockFile(HANDLE hFile) {
7    OVERLAPPED ov = {0};
8    return LockFileEx(hFile,
9                      LOCKFILE_EXCLUSIVE_LOCK,
10                      0, MAXDWORD, MAXDWORD,
11                      &ov);
12  }
13
14  bool UnlockFile(HANDLE hFile) {
15    OVERLAPPED ov = {0};
16    return UnlockFileEx(hFile, 0, MAXDWORD,
17                        MAXDWORD, &ov);
18  }
19
20  void WriteWithLock(const std::string& Path,
21                     const char* Content) {
22    HANDLE hFile = CreateFile(
23      Path.c_str(), GENERIC_WRITE, 0, NULL,
24      OPEN_ALWAYS,
25      FILE_ATTRIBUTE_NORMAL, NULL);
26    if (hFile == INVALID_HANDLE_VALUE) {
27      std::cout << "Error opening file" <<
28        std::endl;
29      return;
30    }
31
32    if (LockFile(hFile)) {
33      DWORD BytesWritten;
34      WriteFile(hFile, Content, strlen(Content),
35                &BytesWritten, NULL);
36      UnlockFile(hFile);
37    }
38
39    CloseHandle(hFile);
40  }
41}