Free nfs planet software for linux

RSS-Planet is a custom marker file generator for xplanet which uses RSS feeds from news websites to plot the current headlines on a world map.

By default, Yahoo! News and CNN.com are supported, but other feeds that point to articles with easily-discoverable place names (such as the Washington Post) should work as well.

Planets is a simple interactive program for playing with simulations of planetary systems, released under the GPL. The project runs on Linux and Windows, and could doubtless be ported to your favorite flavor of Unix.
Planets was originally designed for kids, in particular, for my then 4-year old nephew who is fascinated by astronomy. The user interface is aimed at being simple enough that a fairly young kid can get some joy out of it. But the adults who have used it have found it to be pretty fun as well.
The code is not bug-free, and Planets is missing some significant features. But its pretty stable and is a fun toy to play with. If you do download it, please drop me an email and tell me about your experience with it.
Main features:
- Saving and loading of universes
- Infinite undo (erase last action) and goback (return to point in time just after last action). This allows for undoing mistakes and replaying interesting configurations.
- Traces of planet trajectories
- Two ways of dealing with planet collisions:
- merges, where the colliding planets are merged into one planet, and
- bounces, where the colliding planets are bounced off each other elastically. This itself comes in two varieties:
- force bouncing, where the force between planets is made repulsive at close quarters.
- true bouncing, where simple pool-table physics calculations are made to determine when planets collide, and compute the appropriate bounce from said collision.
- kidmode, a mode where the focus is (mostly) locked on the application, and interesting changes are initiated by merely banging on the keyboard. This mode is aimed at 1-5 year olds.
- Center-of-mass following: it is possible to follow the center of mass of a subset of the planets. Thus, if you have a sun-moon-planet system, you can have the view automatically track the moon-planet pair.
- Can display kinetic, potential and total energy of the system.
- Both the gravitational constant and the gravitational exponent can be changed.
- There is a simple control panel that makes it possible to see and change the simulation options.
- Zooming, panning, and centering on the center of mass.

xplanets shows a simulation of a spacecraft flying through the solar system. With the controls next to the simulation screen you can control the simulation and steer the spacecrafts flight.
The following planets are visible:
- the Sun (yellow)
- mercury (gray38)
- venus (burlywood2)
- earth (blue2)
- mars (LightSalmon3)
Note that the sizes of the sun and planets are not to scale, though their distances are. Showing the planets to scale would mean that they wouldnt be visible. The solar system is rather big, after all.
The planet nearest to the spaceship is indicated with a red circle around it. Its relative speed and distance are shown in the data display.
The xplanets program uses the GTK+ toolkit. It has been built with version 2.2.1, so it should work with any version >2.0.0. It does not work with GTK+ 1.x anymore.

NFS Backup System is a Perl script that backup system for NFS. The basic function nfsbu is an automated perl-script backup system between an NFS server and an NFS client.
Either by crontab or manual execution, directories listed in the configuration file can be backed up to a directory mounted on the NFS server. In turn, the NFS server uses the client-side script of nsbu (nfsbuc.pl) to move the data from the temporary NFS mount directory to their final places (also specified in the configuration file).
I created this script having been learning Perl for maybe 2 weeks and progressing not much further than page 12 of Programming Perl by Larry Wall and Randal L. Shwartz. Hence you may consider the code badly written, but a quote from the book Id like to include is "a Perl script is correct if its halfway readable and gets the job done before your boss fires you". So I take no blame for the code, Ive commented my code and it worked for me and I make no promises it will work for you.
With regards to licencing, I guess its not really worthy of the full 9 yards, but lets have the happy code hacker ethic of open source development. I.e. something of somewhat basic GPL licence terms and conditions. You may feel inclined to modify the code, in such case if you do, please e-mail me the changes and include the modified code. If youd like to redistribute it with your modifications, please include my name and the original code.
Main features:
- multiple directory backup, with alternative destination directories
- directories are simply listed in a file with their respective destinations
- thorough error checking, if any errors occur e-mail will be sent to the administrator
- checks the status of the NFS server and mountd to prevent any hang-ups from a dead NFS server which is common

FreeNAS is a free implementation of a minimal FreeBSD distribution(for run it on a Compact Flash, CD-ROM or USB key) that provide NAS (Network-Attached Storage) services, supporting: CIFS, FTP, NFS protocols, with a Full WEB configuration interface.

The minimal FreeBSD distribution, Web interface,PHP scripts and documentations are based on M0n0wall.

LockFile::Simple is a simple file locking scheme.

SYNOPSIS

use LockFile::Simple qw(lock trylock unlock);

# Simple locking using default settings
lock("/some/file") || die "cant lock /some/filen";
warn "already lockedn" unless trylock("/some/file");
unlock("/some/file");

# Build customized locking manager object
$lockmgr = LockFile::Simple->make(-format => %f.lck,
-max => 20, -delay => 1, -nfs => 1);

$lockmgr->lock("/some/file") || die "cant lock /some/filen";
$lockmgr->trylock("/some/file");
$lockmgr->unlock("/some/file");

$lockmgr->configure(-nfs => 0);

# Using lock handles
my $lock = $lockmgr->lock("/some/file");
$lock->release;

This simple locking scheme is not based on any file locking system calls such as flock() or lockf() but rather relies on basic file system primitives and properties, such as the atomicity of the write() system call. It is not meant to be exempt from all race conditions, especially over NFS. The algorithm used is described below in the ALGORITHM section.

It is possible to customize the locking operations to attempt locking once every 5 seconds for 30 times, or delete stale locks (files that are deemed too ancient) before attempting the locking.

TCFS project is a cryptographic network file system featuring group sharing of encrypted files. TCFS will encrypt your files before sending them to the file server and will decrypt them before they are read by the requesting application.

Because the encryption/decryption process takes place on the client host, no clean data will travel the network. This is particularly valid for the encryption key.

Recent advances in hardware and communication technologies have made possible and cost effective to share a file system among several machines over a local (but possibly also a wide) area network.

One of the most successful and widely used such applications is Suns Network File System (NFS).

NFS is very simple in structure but assumes a very strong trust model: the user trusts the remote file system server (which might be running on a machine in different country) and a network with his/her data. It is easy to see that neither assumption is a very realistic one.

The server (or anybody with superuser privileges) might very well read the data on its local filesytem and it is well known that the Internet or any local area network (e.g, Ethernet) is very easy to tap (see for example, Berkeleys tcpdump application program).
Impersonification of users is also another security drawback of NFS.

In fact, most of the permission checking over NFS are performed in the kernel of the client. In such a context a pirate can temporarely assign to his own workstation the Internet address of victim. Without secure RPC no further authentication procedure is requested. From here on, the pirate can issue NFS requests presenting himself with any (false) uid and therefore accessing for reading and writing any private data on the server, even protected data.

Given the above, a user seeking a certain level of security should take some measures. We propose a new cryptographic file system, which we call TCFS, as a suitable solution to the problem of privacy for distributed file system.

Dynamic Encryption Modules in TCFS:

The dynamic encryption module feature of TCFS allows a user to specify the encryption engine of his/her choiche to be used by TCFS. So you are not forced anymore to use what us (the developer) consider the best (i.e., more secure and efficient) encryption algorithm. The encryption engine must be given in the form of a Linux module and must conform to (the very simple) TCFS API for encryption module. Essentially, it must specify four functions:

1. An initialization function that is called by TCFS when the user pushes her key into TCFS.

Typically the initialization function takes as input the key and returns a pointer to a struct containing a the result of a preprocessing of the key to be used for the encryption and the decryption.

For the specific case of DES the initialization function computes the 16 48-bit subkeys, one for each round of DES.

2. An encryption function which takes a block of data, the length of the block in bytes and the result of the initialization function and encrypts the data.

3. A decryption function which takes a block of data, the length of the block in bytes and the result of the initialization function and decrypts the data.

The encryption and the decryption functions are called each time TCFS needs to read/write a block of data.

4. A cleanup function which performs whatever operation is needed before the key removed by TCFS.

Our work improves on Matt Blazes CFS by providing deeper integration between the encryption service and the file system which results in a complete transparency of use to the user applications.

Release 2.2 of TCFS includes the possibility of threshold sharing files among users. Threshold sharing consists in specifying a minimum number of members (the threshold) that need to be ``active for the files owned by the group to become available.

TCFS enforces the threshold sharing by generating an encryption key for each group and giving each member of the group a share using a Threshold Secret Sharing Scheme. The group encryption key can be reconstructed by any set of at least threshold keys.

A member of the group that intends to become active does so by pushing her/his share of the group key into the kernel. The TCFS module checks if the number of shares available is above the threshold and, if it is so, it attempts to reconstruct the group encryption key. By the properties of the Threshold Secret Sharing Scheme, it is guaranteed that, if enough shares are available, the group encryption key is correctly reconstructed.

Once the group encryption key has been reconstructed, the files owned by the group become accessible. Each time a member decides to become inactive, her share of the group encryption key is removed. The TCFS module checks if the number of shares available has gone under the threshold. In this case, the group encryption key is removed from the TCFS module and files owned by the group become unaccessible.

The current TCFS implementation of the group sharing facility requires each memeber to trust the kernel of the machine that reconstructs the key to actually remove the key once the number of active users goes below the threshold. Future implementations will remove this requirement by performing the reconstruction of the key in a distributed manner.

File::NFSLock is a Perl module to do NFS (or not) locking.
SYNOPSIS
use File::NFSLock qw(uncache);
use Fcntl qw(LOCK_EX LOCK_NB);
my $file = "somefile";
### set up a lock - lasts until object looses scope
if (my $lock = new File::NFSLock {
file => $file,
lock_type => LOCK_EX|LOCK_NB,
blocking_timeout => 10, # 10 sec
stale_lock_timeout => 30 * 60, # 30 min
}) {
### OR
### my $lock = File::NFSLock->new($file,LOCK_EX|LOCK_NB,10,30*60);
### do write protected stuff on $file
### at this point $file is uncached from NFS (most recent)
open(FILE, "+<<less