Free pc lock software for linux

Gnome Wireless PC Lock is a Gnome applet that locks your desktop when you walk away from your desk.

A small gnome program that locks your desktop when you walk away from your desk. It is tested with a Sitecom cn-129 Wireless PC Lock.

FCFS RWLock is a Readers/Writers Lock (or RWLock for short) is a mechanism that allows an arbitrary number of readers or alternatively one writer to access a resource at any given time.

FCFS RWLock project is useful in case writing may temporarily harm the integrity of the resource.

Many RWLock implementations arbitrate the various readers and writers in a manner that may cause starvation of either readers or writers. For instance, a readers/writers lock that prefers readers may cause a writer to starve (i.e: wait for a very long time or indefinetly) if there are two and more competing readers.

A First-Come First-Served (FCFS) RWLock solves this problem by making sure that the pending threads are served at the same order as the time of their arrival. Thus, starvation is eliminated assuming that a thread does not obtain the lock indefinetly (which in any case should not happen in a well-designed system).

vp-usb-lock is a Linux kernel driver and PAM module that utilizes the PC wireless USB lock and makes it possible to use it as authentication method for your Linux box.
It is easy to install, but needs access to the sources of the kernel and PAM to build correctly. It has been tested under Fedora Core 2 with a custom made 2.6.7-1.494.2.2 kernel, but it should also work with other kernel versions and distributions.
Enhancements:
- A lock daemon was added.
- A compilation error that was introduced lately by some changes to the Linux kernel was fixed.
- Support for kernel 2.4.x versions was added.

Termlock project blanks a curses compatible character terminal (e.g. xterm, eterm, PuTTY, konsole, dtterm, etc ...) and locks it. To unlock the terminal a password must be entered. The password, or rather the password hash, is stored in ~/.termlock.

Basically its like a password protected screensaver for character terminals. Written in pure Python it should be immediately usable on any machine with Python and curses (or a compatible library such as ncurses) installed.

Usage:

termlock [-p | --password]

The password switch prompts the user for a password (which must be confirmed) and uses this to create the ~/.termlock hash file.

To lock the screen simply call termlock with no options. If no ~/.termlock file can be found then an error prompting the user to create it will be displayed

Install:

Termlock uses the standard Python distribution utilities. So it should just be a case of uncompressing the archive and running:

./setup.py install

Obviously the user running this must have sufficient permissions to create a file in the install directory.

File::lockf is a Perl module interface to the lockf system call.

SYNOPSIS

use File::lockf;

File-Lockf is an interface to the lockf system call. Perl supports the flock system call natively, but that does not acquire network locks. Perl also supports the fcntl system call, but that is somewhat ugly to use. There are other locking modules available for Perl, but none of them provided what I wanted -- a simple, clean interface to the lockf system call, without any bells or whistles getting in the way.

File-Lockf contains four functions which map directly to the four modes of lockf, and an OO wrapper class that encapulates the basic locking functionality along with an additional utility method that iteratively attempts to acquire a lock.

Lock functions

The following functions return 0 (zero) on success, and the system error number from errno on failure. They each take an open file handle as the first argument, and optionally a size parameter. Please see your system lockf man page for more details about lockf functionality on your system.

$status = File::lockf::lock(FH, size = 0)
This function maps to the F_LOCK mode of lockf.

$status = File::lockf::tlock(FH, size = 0)
This function maps to the F_TLOCK mode of lockf.

$status = File::lockf::ulock(FH, size = 0)
This function maps to the F_ULOCK mode of lockf.

$status = File::lockf::test(FH, size = 0)
This function maps to the F_TEST mode of lockf.

OO wrapper

File-Lockf also provides a simple OO wrapper class around the locking functionality, which allows you to create a lock object for a file handle and then perform lock operations with it. All of the methods return 0 (zero) on success, and the system error number from errno on failure.

$lock = new File::lockf(*FH)

This function returns a new lock object bound to the given file handle. Note that you need to pass a reference to the file handle to the constructor, not the file handle itself.

$status = $lock->lock(size = 0)
This method calls File::lockf::lock on the bound file handle.

$status = $lock->tlock(size = 0)
This method calls File::lockf::tlock on the bound file handle.

$status = $lock->ulock(size = 0)
This method calls File::lockf::ulock on the bound file handle.

$status = $lock->test(size = 0)
This method calls File::lockf::test on the bound file handle.

$status = $lock->slock(count = 5, delay = 2, size = 0)
This method will attempt to lock the bound file handle < count > times, sleeping < delay > seconds after each try. It will return 0 if the lock succeeded, or the system error number from errno if all attempts fail.

Car PC Development Kit is a kit for making a Linux distribution for a car PC.
Unlike most distributions which come prepackaged and ready to load, this distribution requires downloading, compiling, and post-setup before you can load it into a system.
The end result will be a modular platform for quickly putting together a small Linux system to copy onto boot media and start using.
The target platform is a mini-computer to be installed in an automobile and used either headless or with a monitor and some input device like a keyboard or remote control.
Enhancements:
- Fixes LIRC support for both CAUI and MPlayer.
- Updates the CAUI version, and updates the LIRC package to configure more buttons by default.

Tie::DB_Lock Perl module can tie hashes to databases using shared and exclusive locks.

SYNOPSIS

use Tie::DB_Lock;
use DB_File;

tie(%hash, Tie::DB_Lock, $filename, rw); # Open for writing
$hash{key} = value;
untie %hash;

tie(%hash2, Tie::DB_Lock, $filename); # Default is read-only
print("Value is $hash2{key}n");
untie %hash;

This is a front-end for the DB_File package.

If you tie a hash in read-only mode, this module puts a shared lock on the database file, copies it to a temporary file, unlocks the original database, and then ties the tempfile using DB_File.

If you tie the hash in read-write mode, we put an exclusive lock on the database and tie it directly using DB_File.

The reason I copy the whole file every time I read from it is that this allows the program to read from the file for as long as it wants to, without interfering with other peoples writes. This works well if you typically have long, sustained reads, and short, bursty writes. See the README file for help in deciding whether you want to use this package.

You dont always need to call untie() explicitly - it will be called for you when %hash goes out of scope. And if all goes as planned, youll never know the temporary file ever existed, since it will evaporate when %hash goes away.