Free vfs software for linux

Gnome2::VFS is a Perl interface to the 2.x series of the GNOME VFS library.

SYNOPSIS

use Gnome2::VFS;

sub die_already {
my ($action) = @_;
die("An error occured while $action.n");
}

die_already("initializing GNOME VFS") unless (Gnome2::VFS -> init());

my $source = "http://www.perldoc.com/about.html";
my ($result, $handle, $info);

# Open a connection to Perldoc.
($result, $handle) = Gnome2::VFS -> open($source, "read");
die_already("opening connection to $source")
unless ($result eq "ok");

# Get the file information.
($result, $info) = $handle -> get_file_info("default");
die_already("retrieving information about $source")
unless ($result eq "ok");

# Read the content.
my $bytes = $info -> { size };

my $bytes_read = 0;
my $buffer = "";

do {
my ($tmp_buffer, $tmp_bytes_read);

($result, $tmp_bytes_read, $tmp_buffer) =
$handle -> read($bytes - $bytes_read);

$buffer .= $tmp_buffer;
$bytes_read += $tmp_bytes_read;
} while ($result eq "ok" and $bytes_read < $bytes);

die_already("reading $bytes bytes from $source")
unless ($result eq "ok" && $bytes_read == $bytes);

# Close the connection.
$result = $handle -> close();
die_already("closing connection to $source")
unless ($result eq "ok");

# Create and open the target.
my $target = "/tmp/" . $info -> { name };
my $uri = Gnome2::VFS::URI -> new($target);

($result, $handle) = $uri -> create("write", 1, 0644);
die_already("creating $target") unless ($result eq "ok");

# Write to it.
my $bytes_written;

($result, $bytes_written) = $handle -> write($buffer, $bytes);
die_already("writing $bytes bytes to $target")
unless ($result eq "ok" && $bytes_written == $bytes);

# Close the target.
$result = $handle -> close();
die_already("closing $target") unless ($result eq "ok");

Gnome2::VFS -> shutdown();

gnome-vfs-obexftp contains extra packages for extentions to GnomeVFS. Contains an OBEX module, VFS DBUS daemon, modified file module that notifies file modifications over DBUS.

Note that if youre not using the standard dbus system bus address, you need to set the environment variable DBUS_SYSTEM_BUS_ADDRESS to the path to the system dbus address to use, e.g:

export DBUS_SYSTEM_BUS_ADDRESS=unix:path=/var/run/dbus/system_bus_socket

for example in the login script.

If the variable is not set, the OBEX module will fallback to the standard name in $(localstatedir), e.g. /var/run/dbus/system_bus_socket.

gnome-vfs is a Filesystem Abstraction library. It provides an abstraction layer for the reading, writing and execution of files. It is primarily used by the Nautilus file manager and other GNOME applications.
A cause of confusion is the fact that the file system abstraction used by the Linux kernel is also called the virtual file system (VFS). This is however at a lower level.
Whats New in 2.19.3 Development Release:
- Export modules directory in pkg-config files
- Fix crash in gnome_vfs_xfer
- Add GNOME_VFS_DIRECTORY_VISIT_IGNORE_RECURSE_ERROR flag
- Dont resolve non-mdns hosts when resolving mDNS service names
- Workaround issue with mDNS and link-local ipv6 addresses

Bluefish is a programmers Web development editor written using GTK, designed to save the experienced webmaster some keystrokes.
It features a multiple file editor, multiple toolbars, custom menus, image and thumbnail dialogs, open from the Web, CSS dialogs, PHP, HTML, Java, C, and XML support, external program integration (tidy, weblint, make, javac), and lots of wizards.
Main features:
- A What You See Is What You Need interface
- Multiple document interface, easily opens 500+ documents (tested 3500 documents simultaneously)
- Project support, enables you to work efficiently on multiple projects
- Support for remote files using gnome-vfs (depending on your gnome-vfs setup, youll have FTP, SFTP, HTTP, HTTPS, WebDAV, Samba and more)
- Customizable syntax highlighting based on Perl Compatible regular expressions, with subpattern support and default patterns for
- HTML
- PHP
- C
- Java
- JavaScript
- Java server pages (JSP)
- SQL
- XML
- Python
- Perl
- Cascading stylesheets (CSS)
- ColdFusion
- Pascal
- R
- Octave/Matlab
- Anti aliased text window
- Multiple encodings support, can convert between different character sets, supports multibyte characters, unicode, UTF8 etc.
- Line numbers along the document, bookmarks in documents and an excellent search function
- Nice wizards for startup, tables, frames, and others
- Dialogs for many HTML tags, with all their attributes
- HTML toolbar and tearable menus
- Compliance with the Gnome and KDE user interface guidelines where possible
- User-customizable toolbar for quick access to often used functions
- Open files based on filename patterns and/or content
- Fully featured image insert dialog
- Thumbnail creation and automatically linking of the thumbnail with the original image
- Multi thumbnail generation for easy creation of photo albums or screenshot pages
- A custom menu, specify your own tags or sets of code, and define your own dialogs
- Very powerful search and replace, allowing POSIX and Perl Compatible regular expressions and sub-pattern replacing
- Custom search and replace pattern support for the Custom menu
- Excellent unlimited undo/redo functionality
- Function reference browser, including reference files for PHP, CSS, Python and obviously HTML
- Configurable recent documents and recent directories functionality
- Complete translations in Brasilian Portuguese, Bulgarian, Chinese, Danish, Finnish, French, German, Hungarian, Italian, Norwegian, Polish, Portuguese, Russian, Spanish, Swedish and Tamil. Some other languages are partially supported.
- User customizable integration of many programs, including weblint, tidy, make, javac etc. etc.
- Auto tag closing for HTML and XML documents
- Escape functions for HTML and XML documents

ferrisfuse is a FUSE module for mounting libferris filesystems through the Linux kernel.
About libferris
In non technical terms libferris makes the file system and other hierarchical storage systems easier to use. For the geeks out there, libferris is a virtual file system (VFS) that runs in the user address space. The FAQ contains entries related to installation, configuration and the usage of libferris.
As of July 2005 libferris can mount many interesting things ranging from a filesystem from your local Linux kernel through to LDAP, Evolution, PostgreSQL, dbXML, and RDF. To get an impression of the current capabilities of libferris mounting see the plugins/context directory of the lastest release. New things to mount are always being added.
Other than mounting things as a filesystem, the other core concept of libferris is extraction of interesting metadata from your libferris filesystems. This means that simple things like width and height of an image file become first class metadata citizens along with a files size and modification time. The limits on what metadata is available extend far beyond image metadata to include XMP, EXIF, music ID tags, geospatial tags, rpm metadata, SELinux integration, partially ordered emblem categories and arbitrary personal RDF stores of metadata.
Though some consider the last point of purely academic interest the end result is that you can add metadata to *all* libferris objects even those you only have read access too, for example, you can attach emblems to this website just as you would a normal file. The metadata interface gives all metadata from file size to digital signature status information equal standing. As such you can sort a directory by any metadata just as easily as you would ls -Sh to sort by file size. Sorting on multiple metadata values is also supported in libferris, you can easily sort your files by mimetype, then image width, then modification time with all three pieces of metadata contributing to the final directory ordering.
Late in 2004 extensive support for both fulltext and metadata indexing was added to libferris. This means you can supply queries against the contents or metadata of any libferris accessable object and have the results returned as a virtual filesystem. With the above mentioned metadata available for searching, finding your files can be done in many different ways instead of being forced to generate fixed directory trees using part of a file collections semantics as directory names. The metadata and virtual filesystem play together here allowing you to geospatially tag both your digital pictures, trip plans, and relevent websites and recall these objects in a single virtual directory no matter what their path or URL may be.
There is also a Samba VFS module which allows you to expose a libferris filesystem as a Samba share. Kfsmd uses the inotify kernel interface to allow libferris to watch changes made to your kernel filesystem by non libferris applications and update its indexes appropriately. Ferriscreate provides a command line and GTK+2 application for creating "new files" with libferris. With this you can create a new db4 database, dbXML database or fulltext index just as easily as you can make a regular file.
The ego filemanager is a GTK+2 interface built on top of libferris. It provides GTK treeview , gevas/edje and gecko based interfaces and makes extensive use of libferris clients to provide its functionality.
If you have a project you wish to use libferris with and want extensions made dont hesitate to contact one of the developers to arrange consulting.
For the geeks out there, libferris is a virtual file system (VFS) that runs in the user address space. At the moment libferris is a shared object that each application can dynamically link to in order to see the file system through a nicer abstraction.
New additions to the XML module allow for data to be converted from one format to another by the VFS for you. To copy data to an XML file:
fcreate --create-type=xml --rdn=2.xml root-element=fred /tmp
gfcp -av Makefile.am --dst-is-dir /tmp/2.xml/fred
To copy data to a db4 file
fcreate --create-type=db4 --rdn=2.db /tmp
gfcp -av Makefile.am --dst-is-dir /tmp/2.db
Ferris presents a C++ interface that makes heavy use of the STL and IOStreams. Currently ferris has two main internal abstractions: Context and Attribute. A context is much like a traditional file or directory in a file system, the major differences being that a context can have both byte content (like a file) and subcontexts (like a directory). An attribute is a chunk of metadata about a context. Contexts can have many attributes.
Some attributes may be large, for example a base 64 encoded version of the contexts content (133% context size). On the other hand an attribute can be small, for example the file size is exposed as an attribute.
Access to all contexts and attributes is performed by first requesting either an IStream or IOStream for that context or attribute. In this way the same context/attribute can be open many times at the same time, just like normal kernel based IO.
Ferris uses Loki from "Modern C++ Design" by Alexandrescu. Most objects use automatic garbage collection based on the SmartPtr template class from Loki. Where possible objects in ferris use a FerrisRefCounted policy to provide COM like intrusive reference counting. This style is used for Context, Attribute and special wrappers of IOStreams that are provided. IOStreams are wrapped to provide a more flexible API than could be offered using references to IOStreams.
There are also new stream classes provided, for example NullStream and LimitingStream. Templates are provided to make SmartPtrs to standard IOStreams act just like the underlying stream would, for example, one can have SmartPtr ss; ss >> stringObj; and does not have to dereference the SmartPtr to use standard IOStreams extractors or inserters.
Ferris uses GModule from glib2 to dynamically load both context and attribute classes at run-time. This way resources are conserved until they are needed. The native file system context is statically linked to ferris at present. When loading either contexts or attribute classes ferris uses a double dispatch factory method. Put simply this means that for each plugin there are two libraries, one that tells ferris if the main one really needs to be loaded or not. Using this scheme ferris can load all the meta factory classes at any time and use these very small meta factories to check if the main factory can create objects that are going to be useful.
This scheme is of great use for attribute classes. Attribute classes take a context and can "generate" attributes from the context. An example of this sort of class would be a MD5 or Base64 attribute. Both can be generated from the base context. More interesting attributes are PCM audio and RGBA-32bpp image data. By using the double dispatch factory ferris can handle a great deal of attribute generators and load them on demand.
Ferris currently can decode mp3, read id3 tags, decode many image formats and break some animation formats into frames. This makes ferris a solid starting point for multimedia applications.
Ferris will automatically mount sub file systems for you. Examples of a sub file system include a Berkeley database or XML file. For example it is possible to read a context such as /tmp/myxml.xml/mynode. Using this automatic mounting the differences between storage formats effectively disappear. To a ferris enabled application loading data from a native disk file, a Berkeley database, and XML file, or mbox file appear to be the same. This allows the user of the application to choose the correct storage for the data at hand.
It is planned to move to a microkernel architecture in Version 2.1 of ferris. I choose 2.1 so that ferris does not fall into version 2 syndrome.
Enhancements:
- Many changes were made to better support rsync(1).
- Extended Attribute support was greatly improved.
- write() now also updates mtime.

FerrisSambaModule is a VFS module for Samba 3.x which allows it to provide shares which use libferris as a data source.
Thus, anything libferris can access can be shared as a filesystem via Samba, including LDAP, PostgreSQL, XML files, sleepycat dbXML database, evolution mail client, and queries against libferris various indexes.
Enhancements:
- STLport use was made optional.
- Some fixes were made for mounting eaquery:// as a Samba share.

deimos project consists of some platform independent libraries.

The deimos project provides some platform independent libraries which contain a reference memory allocator (garbage collector planned), virtual filesystem (Unix sockets, HTTP, etc), configfile management, and a clean build system (easy makefiles).

These libs are used by DDS (Digital Disco System - mp3 player), vmOberon (oberon virtual machine), and ODMS (open document management system).

deimos has some simpl programming principles:

- dont make the packages not too big. one package for each job.

- simplicity. clear interfaces. each package has an front- and an back-interface. better think twice before starting to program anything.

- high abstraction. i.e the core libs are the one and only stuff which has to care about system specifics.

currently these packages are available:

- core:

current implementations: linux + glibc (may work on other unices too, but not tested)

provides:
* simple and clear build system (have a look the makefiles)
* Memory Manager (reference counting, type checking, ...)
* Virtual Filesystem (currently supports: local unix, http)
* ConfigFile (manages config files, goes over the VFS)

- template

an very simple template for writing applications with the deimos make system.

- examples

some applications demonstrating how to use the deimos (mostly core).

- oberon

the oberon subsystem. provides an virtual machine an kernel modules