unix.rs

use crate::errors::{ Error, Result };
use crate::file_ext::{ FileExt };

use errno::{ Errno, errno };
use libc::{ EAGAIN, EWOULDBLOCK, LOCK_EX, LOCK_NB, LOCK_SH, LOCK_UN, flock };

use std::fs::{ File };
use std::os::raw::{ c_int };
use std::os::fd::{ AsFd, AsRawFd, BorrowedFd };

impl FileExt for File {
	type LockGuard<'a> = LockGuard<'a>;

	fn lock_shared(&self) -> Result<Self::LockGuard<'_>> {
		lock(self.as_fd(), LOCK_SH)
	}

	fn lock_exclusive(&self) -> Result<Self::LockGuard<'_>> {
		lock(self.as_fd(), LOCK_EX)
	}

	fn try_lock_shared(&self) -> Result<Self::LockGuard<'_>> {
		try_lock(self.as_fd(), LOCK_SH)
	}

	fn try_lock_exclusive(&self) -> Result<Self::LockGuard<'_>> {
		try_lock(self.as_fd(), LOCK_EX)
	}
}

#[derive(Debug)]
#[must_use = "Not retaining the guard object will result in the file being immediately unlocked"]
pub struct LockGuard<'a> {
	fd: BorrowedFd<'a>,
}

impl Drop for LockGuard<'_> {
	fn drop(&mut self) {
		unsafe {
			flock(self.fd.as_raw_fd(), LOCK_UN);
		}
	}
}

fn lock(fd: BorrowedFd, mode: c_int) -> Result<LockGuard> {
	let status = unsafe {
		flock(fd.as_raw_fd(), mode)
	};

	match status {
		0 => Ok(LockGuard { fd }),
		_ => Err(Error::LockFailed(errno())),
	}
}

fn try_lock(fd: BorrowedFd, mode: c_int) -> Result<LockGuard> {
	let status = unsafe {
		flock(fd.as_raw_fd(), mode | LOCK_NB)
	};

	match status {
		0 => Ok(LockGuard { fd }),
		_ => {
			let e = errno();

			if e == Errno(EAGAIN) || e == Errno(EWOULDBLOCK) {
				Err(Error::AlreadyLocked)
			} else {
				Err(Error::LockFailed(e))
			}
		},
	}
}