/*
 * Copyright 2007, Vasilis Kaoutsis, kaoutsis@sch.gr.
 * Distributed under the terms of the MIT License.
 */

#include <errno.h>
#include <fcntl.h>
#include <unistd.h>

#include <errno_private.h>


int
lockf(int fileDescriptor, int function, off_t size)
{
	struct flock fileLock;
	fileLock.l_start = 0;
	fileLock.l_len = size;
	fileLock.l_whence = SEEK_CUR;

	if (function == F_ULOCK) {
		// unlock locked sections
		fileLock.l_type = F_UNLCK;
		return fcntl(fileDescriptor, F_SETLK, &fileLock);
	} else if (function == F_LOCK) {
		// lock a section for exclusive use
		fileLock.l_type = F_WRLCK;
		return fcntl(fileDescriptor, F_SETLKW, &fileLock);
	} else if (function == F_TLOCK) {
		// test and lock a section for exclusive use
		fileLock.l_type = F_WRLCK;
		return fcntl(fileDescriptor, F_SETLK, &fileLock);
	} else if (function == F_TEST) {
		// test a section for locks by other processes
		fileLock.l_type = F_WRLCK;
		if (fcntl(fileDescriptor, F_GETLK, &fileLock) == -1)
			return -1;
		if (fileLock.l_type == F_UNLCK)
			return 0;

		__set_errno(EAGAIN);
		return -1;
	} else {
		__set_errno(EINVAL);
		return -1;
	}

	// Notes regarding standard compliance (cf. Open Group Base Specs):
	// * "The interaction between fcntl() and lockf() locks is unspecified."
	// * fcntl() locking works on a per-process level. The lockf() description
	//   is a little fuzzy on whether it works the same way. The first quote
	//   seem to describe per-thread locks (though it might actually mean
	//   "threads of other processes"), but the others quotes are strongly
	//   indicating per-process locks:
	//   - "Calls to lockf() from other threads which attempt to lock the locked
	//     file section shall either return an error value or block until the
	//     section becomes unlocked."
	//   - "All the locks for a process are removed when the process
	//     terminates."
	//   - "F_TEST shall detect if a lock by another process is present on the
	//     specified section."
	//   - "The sections locked with F_LOCK or F_TLOCK may, in whole or in part,
	//     contain or be contained by a previously locked section for the same
	//     process. When this occurs, or if adjacent locked sections would
	//     occur, the sections shall be combined into a single locked section."
	// * fcntl() and lockf() handle a 0 size argument differently. The former
	//   use the file size at the time of the call:
	//    "If the command is F_SETLKW and the process must wait for another
	//     process to release a lock, then the range of bytes to be locked shall
	//     be determined before the fcntl() function blocks. If the file size
	//     or file descriptor seek offset change while fcntl() is blocked, this
	//     shall not affect the range of bytes locked."
	//   lockf(), on the other hand, is supposed to create a lock whose size
	//   dynamically adjusts to the file size:
	//    "If size is 0, the section from the current offset through the largest
	//     possible file offset shall be locked (that is, from the current
	//     offset through the present or any future end-of-file)."
	// * The lock release handling when closing descriptors sounds a little
	//   different, though might actually mean the same.
	//   For fcntl():
	//    "All locks associated with a file for a given process shall be removed
	//     when a file descriptor for that file is closed by that process or the
	//     process holding that file descriptor terminates."
	//   For lockf():
	//    "File locks shall be released on first close by the locking process of
	//     any file descriptor for the file."
}