Free slave network filesystem software for linux

SSH Filesystem is a filesystem client based on the SSH File Transfer Protocol. Since most SSH servers already support this protocol it is very easy to set up: i.e. on the server side theres nothing to do. On the client side mounting the filesystem is as easy as logging into the server with ssh.
The idea of sshfs was taken from the SSHFS filesystem distributed with LUFS, which I found very useful. There were some limitations of that codebase, so I rewrote it.
Main features:
- Based on FUSE (the best userspace filesystem framework for linux ;-)
- Multithreading: more than one request can be on its way to the server
- Allowing large reads (max 64k)
- Caching directory contents
Installing
First you need to download FUSE 2.2 or later from http://fuse.sourceforge.net/. You also need to install the devel package for glib2.0. After installing FUSE, compile sshfs the usual way:
./configure
make
make install (as root)
How to mount a filesystem
Once sshfs is installed (see next section) running it is very simple:
sshfs hostname: /mountpoint
Note, that its recommended to run it as user, not as root. For this to work the mountpoint must be owned by the user. If the username is different on the host you are connecting to, then use the "username@host:" form. If you need to enter a password sshfs will ask for it (actually it just runs ssh which ask for the password if needed). You can also specify a directory after the ":". The default is the home directory.
Enhancements:
- This release fixes a couple of rarely occurring crashes and some smaller bugs.

FUR is a application that let the user mount a Windows CE based device on your Linux file system: it uses the brilliant FUSE (acronym of File system in UserSpacE of Miklos Szeredi) and the great librapi2 of the Synce Project, a unix implementation of the RAPI protocol (that your device use to communicate with your other operating $ystem ) which you can find here, along with other very nice tools.
You execute it with proper arguments, then (if everything goes fine) the entire file system of your (previously connected) handheld will appear automagically mounted like a regular Linux file system where you will be able to copy, move read and write data with your favorite programs.
FUR filesystem means FUSE use libRAPI.
What dose not?
- Not very stable, particulary if used concurrently by different processes (but should be usable).
- Not well tested.
- The source is horrible(Tm).
- The implementation is more involved than it should.
- Lack documentation.
- Not even remotely optimized.
- Configuration tools deficient.
- Random access I/O is anti-optimized.
- Write is bugged (maybe a problem with concurrent file access).
- The resource locking system (e.g. to prevent different processes to write on the same file) is only roughly implemented (theres a lot to be done).
- Total absence of a caching system of some sort (which i hope to implement, sooner or later).
- Some errors are to obscure (and maybe not well implemented).
- Some attributes (e.g. ctime) are not implemented (the needed function in the librapi2 library is not yet implemented).
- No UID/GID check: this is not a security issue: only the user that invoke the dccm demon can access the filesystem, but other users should be able to see some kind of error message (which i will implement soon).
- Lot of other things i have forgot now.
- The log reporting suck

Skipole Network Monitor project is a simple network monitor with built in web server.

It allows the user to input host IP addresses, it then pings these hosts every five minutes and displays their status via a built-in web server, on port 8000.

So calling http://your_pc_address:8000 will display pages showing green, yellow or red host or group symbols.

Each host is pinged four times every five minutes, and symbols are displayed as:

green : if three or four pings are successfull
yellow : if only one or two are successfull
red : if all four fail

As well as hosts, group symbols are displayed, and can be opened to show hosts, or sub-groups nested within. The operator can create groups, and sub-groups via the gui.

Noname Network provides a powerful file-sharing network.

The Noname network is a gnutella-based network that features a different and more flexible protocol. The client and network currently support filesharing, but the protocol can be extended to support more features.

Java Neural Network Trainer is a neural network trainer with the ability to easily add new training algorithms and training patterns.

Java Neural Network Trainer project includes a parallel training graphical interface where you can view each trainer working in real-time in parallel.

LUA is a small scripting language designed to be embedded inside your application to provide extensibility.
It is also possible to extend the Lua scripting language itself via the use of extensions written in C. This page describes such an extension which provides a small number of basic networking and filesystem primitives.
By installing this extension you will be able to write networking applications in the Lua!
Enhancements:
- Added some filesystem primitives.
- Added API documentation & examples.
- The HTTP server now falls back to a default virtual host if none is specified, or if the attempted one doesnt exist.
- The HTTPD server now supports directory indexing if no index.html file is found in a directory.
- The HTTPD server now writes access.log files to each virtualhost.

Intelligent Filesystem Guard is a tool that monitors information about changes in files and directories.

Intelligent Filesystem Guard can be used either for the detection of changes in important files (as an intrusion detection system guarding data against viruses and Trojan horses) or for guarding user data.

A large emphasis is put on monitoring files. One of the functions of this system is to tell what happened with the file according to a user query. The system is able to warn of any sort of change, such as modification, creation, erasure, or movement.