advisory-lock 0.3.0

A cross-platform advisory file lock.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use std::fs::File;
use std::io;
use std::os::windows::io::{AsRawHandle, RawHandle};

use winapi::{
    shared::{
        minwindef::TRUE,
        ntdef::NULL,
        winerror::{ERROR_LOCK_VIOLATION, ERROR_NOT_LOCKED},
    },
    um::{
        errhandlingapi::GetLastError,
        fileapi::{LockFileEx, UnlockFileEx},
        minwinbase::{
            OVERLAPPED_u, OVERLAPPED_u_s, LOCKFILE_EXCLUSIVE_LOCK, LOCKFILE_FAIL_IMMEDIATELY,
            OVERLAPPED,
        },
    },
};

use crate::{AdvisoryFileLock, FileLockError, FileLockMode};

impl AdvisoryFileLock for File {
    fn lock(&self, file_lock_mode: FileLockMode) -> Result<(), FileLockError> {
        lock_file(self.as_raw_handle(), file_lock_mode, false)
    }

    fn try_lock(&self, file_lock_mode: FileLockMode) -> Result<(), FileLockError> {
        lock_file(self.as_raw_handle(), file_lock_mode, true)
    }

    fn unlock(&self) -> Result<(), FileLockError> {
        unlock_file(self.as_raw_handle())
    }
}

impl AdvisoryFileLock for RawHandle {
    fn lock(&self, file_lock_mode: FileLockMode) -> Result<(), FileLockError> {
        lock_file(*self, file_lock_mode, false)
    }

    fn try_lock(&self, file_lock_mode: FileLockMode) -> Result<(), FileLockError> {
        lock_file(*self, file_lock_mode, true)
    }

    fn unlock(&self) -> Result<(), FileLockError> {
        unlock_file(*self)
    }
}

fn create_overlapped() -> OVERLAPPED {
    let overlapped = unsafe {
        let mut overlapped = std::mem::zeroed::<OVERLAPPED_u>();
        *overlapped.s_mut() = OVERLAPPED_u_s {
            Offset: u32::MAX,
            OffsetHigh: u32::MAX,
        };
        overlapped
    };

    OVERLAPPED {
        Internal: usize::MAX,
        InternalHigh: usize::MAX,
        u: overlapped,
        hEvent: NULL,
    }
}

fn lock_file(
    raw_handle: RawHandle,
    file_lock_mode: FileLockMode,
    immediate: bool,
) -> Result<(), FileLockError> {
    let mut overlapped = create_overlapped();

    let mut flags = 0;
    if file_lock_mode == FileLockMode::Exclusive {
        flags |= LOCKFILE_EXCLUSIVE_LOCK;
    }
    if immediate {
        flags |= LOCKFILE_FAIL_IMMEDIATELY;
    }

    let result = unsafe {
        LockFileEx(
            raw_handle as *mut winapi::ctypes::c_void,
            flags,
            0,
            1,
            0,
            &mut overlapped,
        )
    };
    if result != TRUE {
        return match unsafe { GetLastError() } {
            ERROR_LOCK_VIOLATION => Err(FileLockError::AlreadyLocked),
            raw_error => Err(FileLockError::Io(io::Error::from_raw_os_error(
                raw_error as i32,
            ))),
        };
    }

    Ok(())
}

fn unlock_file(raw_handle: RawHandle) -> Result<(), FileLockError> {
    let mut overlapped = create_overlapped();

    let result = unsafe {
        UnlockFileEx(
            raw_handle as *mut winapi::ctypes::c_void,
            0,
            1,
            0,
            &mut overlapped,
        )
    };

    if result == TRUE {
        Ok(())
    } else {
        let raw_error = unsafe { GetLastError() };
        if raw_error == ERROR_NOT_LOCKED {
            Ok(())
        } else {
            Err(FileLockError::Io(io::Error::from_raw_os_error(
                raw_error as i32,
            )))
        }
    }
}