Free filesystem software for linux

Sys::Filesystem project is intended to be a portable interface to list and query filesystem names and their properties.

It hopes to provide a consistent API to list all, mounted, unmounted, and special filesystems on a system, and query as many properties as possible with common aliases wherever possible.

FileSystemStorage is a project that provides FileSystem storage for Archetypes.

FileSystemStorage is an Archetype storage for storing data on FileSystem This storage is used to avoid ZODB to grow quickly when using a lot of large files.

FUSE can implement a fully functional filesystem in a userspace program.
Main features:
- Simple library API
- Simple installation (no need to patch or recompile the kernel)
- Secure implementation
- Userspace - kernel interface is very efficient
- Usable by non privileged users
- Runs on Linux kernels 2.4.X and 2.6.X
- Has proven very stable over time
Installation
Some projects include the whole FUSE package (for simpler installation). In other cases or just to try out the examples FUSE must be installed first. The installation is simple, after unpacking enter:
./configure
make
make install
If this produces an error, please read on.
The configure script will try to guess the location of the kernel source. In case this fails, it may be specified using the --with-kernel parameter. Building the kernel module needs a configured kernel source tree matching the running kernel. If you build your own kernel this is no problem. On the other hand if a precompiled kernel is used, the kernel headers used by the FUSE build process must first be prepared. There are two possibilities:
1. A package containing the kernel headers for the kernel binary is available in the distribution (e.g. on Debian its the kernel-headers-X.Y.Z package for kernel-image-X.Y.Z)
2. The kernel source must be prepared:
- Extract the kernel source to some directory
- Copy the running kernels config (usually found in /boot/config-X.Y.Z) to .config at the top of the source tree
- Run make menuconfig, then make dep at the top of the source tree (only needed on 2.4 kernels)
If using the 2.6 kernel, then write access is needed to some files in the kernel source tree. Usually it is enough if you make .tmp_versions and .__modpost.cmd writable.
Enhancements:
- Stacking support for the high level API
- Add filename charset conversion module
- Improved mounting

ASFS is a filesystem driver for the Linux kernel that adds support for the Amiga SmartFileSystem. ASFS filesystem driver supports both read and write, however, write support is in an early beta stage.
ASFS - Amiga Smart File System - Linux implementation
Version 1.0beta8 in "read-only mode" should be considered as the lasted stable version of ASFS driver.
It is available for Linux kernel version 2.6.x.
From version 1.0 there is also full write support. Use it with care. It is in EXPERIMETAL stage and COULD be DANGEROUS.
Remember! YOU USE THIS DRIVER AT YOUR OWN RISK. Read included docs for
more details.
Enhancements:
- The code was updated to match changes in the VFS of Linux kernel 2.6.19.

Adeos (named after the obscure Roman goddess of modesty) is an automated filesystem security scanner. It recursively walks all mounted filesystems on the local system and attempts to identify common security concerns such as SUID and world-writeable files.

The output is available as text or html, with either output type formatted in either report or list style. Text is written to stdout and is redirected to a file, while HTML is written to a file named results.html in the local directory.


Adeos should compile and run on almost any UNIX-type system. It has been tested on Sun Solaris and Linux 2.x.

Adeos must be run from a non-priveleged user account on the system. Since a priveleged account, such as root has much greater priveleges than a standard user, the results would be meaningless.

Adeos supports three scan modes: normal, verbose, and paranoid. A brief description of what each looks for is below.

normal: Set-User-ID (SUID) files, Set-Group-ID (SGID) files, world-writeable files, and world-writeable directories. (Default mode)
verbose: Everything that a Normal scan looks for, "Sticky" files, unreadable directories, and inaccessible files.
paranoid: Everything Normal and Verbose scans look for, world-readable files, world-executable files, world-readable directories, and world-executable directories.

Adeos supports the following command-line options. Note that if you want to use multiple options you must specify each one individually.

-d Include dynamic directories (/dev /devices /proc /tmp) in the scan.
-h Place output in an HTML file named results.html
-r Format output as a collated report.
--help Display usage and help information.

A default Adeos run performs a Normal mode scan with list-formatted text output.

Filesys::Df is a Perl extension for filesystem disk space information.

SYNOPSIS

use Filesys::Df;

#### Get information by passing a scalar directory/filename value
my $ref = df("/tmp"); # Default output is 1K blocks
if(defined($ref)) {
print "Total 1k blocks: $ref->{blocks}n";
print "Total 1k blocks free: $ref->{bfree}n";
print "Total 1k blocks avail to me: $ref->{bavail}n";
print "Total 1k blocks used: $ref->{used}n";
print "Percent full: $ref->{per}n";

if(exists($ref->{files})) {
print "Total inodes: $ref->{files}n";
print "Total inodes free: $ref->{ffree}n";
print "Inode percent full: $ref->{fper}n";
}
}

#### Get information by passing a filehandle
open(FILE, "some_file"); # Get information for filesystem at "some_file"
my $ref = df(*FILE);
#### or
my $ref = df(*FILE);
#### or
my $fhref = *FILE;
my $ref = df($fhref);

#### Get information in other than 1k blocks
my $ref = df("/tmp", 8192); # output is 8K blocks
my $ref = df("/tmp", 1); # output is bytes

This module provides a way to obtain filesystem disk space information. This is a Unix only distribution. If you want to gather this information for Unix and Windows, use Filesys::DfPortable. The only major benefit of using Filesys::Df over Filesys::DfPortable, is that Filesys::Df supports the use of open filehandles as arguments.

The module should work with all flavors of Unix that implement the statvfs() and fstatvfs() calls, or the statfs() and fstatfs() calls. This would include Linux, *BSD, HP-UX, AIX, Solaris, Mac OS X, Irix, Cygwin, etc ...

df() requires a argument that represents the filesystem you want to query. The argument can be either a scalar directory/file name or a open filehandle. There is also an optional block size argument so you can tailor the size of the values returned. The default block size is 1024. This will cause the function to return the values in 1k blocks. If you want bytes, set the block size to 1.

df() returns a reference to a hash. The keys available in the hash are as follows:
{blocks} = Total blocks on the filesystem.
{bfree} = Total blocks free on the filesystem.
{bavail} = Total blocks available to the user executing the Perl application. This can be different than {bfree} if you have per-user quotas on the filesystem, or if the super user has a reserved amount. {bavail} can also be a negative value because of this. For instance if there is more space being used then you have available to you.
{used} = Total blocks used on the filesystem.
{per} = Percent of disk space used. This is based on the disk space available to the user executing the application. In other words, if the filesystem has 10% of its space reserved for the superuser, then the percent used can go up to 110%.
You can obtain inode information through the module as well, but you must call exists() on the {files} key first, to make sure the information is available. Some filesystems may not return inode information, for example some NFS filesystems.
Here are the available inode keys:
{files} = Total inodes on the filesystem.
{ffree} = Total inodes free on the filesystem.
{favail} = Total inodes available to the user executing the application. See the rules for the {bavail} key.
{fused} = Total inodes used on the filesystem.
{fper} = Percent of inodes used on the filesystem. See rules for the {per} key.

There are some undocumented keys that are defined to maintain backwards compatibilty: {su_blocks}, {user_blocks}, etc ...

If the df() call fails for any reason, it will return undef. This will probably happen if you do anything crazy like try to get information for /proc, or if you pass an invalid filesystem name, or if there is an internal error. df() will croak() if you pass it a undefined value.

ISO Master is an open-source, graphical CD image editor that runs on Linux; and bkisofs, the underlying library used for reading, modifying and writing ISO images.
The hard part of this project is the library for working with ISOs (bkisofs). My hope is that people will like this library enough to make their own GUIs using it. So my choice of widget set (GTK, that is) will not necessarily annoy too many people.
Main features:
- Display file/directory contents of the image and and the regular filesystem in two panels and be able to navigate them.
- Display file sizes for files on image/filesystem.
- Sort by name or by size
- Select any number of items in the file browsers.
- Extract selected from image to the filesystem
- Delete selected from image.
- Add selected from filesystem to image.
- Save modified image.
- Create image from scratch.
Enhancements:
- Usability and performance improvements.
- 10 new translations.
- A bug that sometimes caused corrupt ISOs to be written has been fixed.