fuse-pod-0.5.1.
FUSEPod is a userspace filesystem which mounts your iPod into a directory
for easy browsing of your songs on your iPod.
Features
========
* Read and Write support
* Viewing/Removing playlists
* Configurable directory layout
* Transparent copying of files onto iPod
* Tracks have tags in extended attributes
* Discovers where your iPod is mounted
* Statistics file
GmailFS is a virtual filesystem developed by Richard Jones which
allows users to mount and use their Gmail email account's storage as a
local disk drive.
This works as far as logging in and responding properly to a df command,
but python interpreter usage seems far too high. Committed in this state
so that others can work on it.
refuse into the Packages Collection.
Python bindings for the FUSE and refuse interfaces.
FUSE allows file sytsem operations to take place at user level, rather
than in the kernel. Refuse is a BSD-licensed re-implementation of
fuse, running on top of the puffs functionality. This package
provides a python language interface to the FUSE interface.
To achieve backwards compatibility with previous versions of the fuse
bindings for python, set the environment variable
FUSE_PYTHON_COMPAT=0.1
supported cameras as filesystems; while some cameras implement the
USB Mass Storage class and already appear as filesystems (making
this program redundant), many use the Picture Transfer Protocol (PTP)
or some other custom protocol. But as long as the camera is supported
by libgphoto2, it can be mounted as a filesystem using this program.
N.B. This requires revision 1.50 or later of lib/librefuse/refuse.c
on NetBSD
* new: read-write mount is supported using the "force" mount option if
the logfile is unclean
* new: libntfs-3g is versioned
* fix: default ownership of files weren't always set to the mounting user
* fix: mount was denied if the NTFS Master File Table copy had non-standard size
* fix: catch and deny all junction/reparse point write operations
* fix: multiply -o options weren't allowed (FreeBSD's mount(8) requires this)
* fix: don't try to run Linux specific code on non-Linux OSes
U9fs is a program that serves Unix files to Plan 9 machines
using the 9P protocol. It is typically invoked on a Unix
machine by inetd with its standard input and output connected
to a network connection, typically TCP on an Ethernet. It
typically runs as user root and multiplexes access to multiple
Plan 9 clients over the single wire. It assumes Plan 9 uids
match Unix login names, and changes to the corresponding Unix
effective uid when processing requests. U9fs serves both 9P1
(the 9P protocol as used by the second and third editions of
Plan 9) and 9P2000.
* fix: fakeraid/softraid detection was incorrect
* change: major performance improvement for writing large
files (new block allocator)
* change: manual update, added access handling, security section
* new: use the 'nonempty' FUSE mount option by default, so the driver
behaves as the in-kernel file systems
* new: --disable-ldconfig configure option
Collection.
FUSE-based union filesystem, with almost limitless number of root
directories.
This utility is implementedd at the user level - to mount a series
of roots, simply use:
fuse-unionfs root1:root2:root3 <mountpoint>
EncFS provides an encrypted filesystem in user-space. It runs without any
special permissions and uses the FUSE library.
As with most encrypted filesystems, Encfs is meant to provide security
against off-line attacks; ie your notebook or backups fall into the wrong
hands, etc.
Homepage: http://arg0.net/encfs
pancake.
With FUSE it is possible to implement a fully functional filesystem in a
userspace program. Features include:
* 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
This package is enabled only for linux and FreeBSD, NetBSD uses
its own compatible library.
Gateway between FUSE and libarchive. Allows mounting of cpio, .tar.gz,
.tar.bz2 archives.
Reading and writing supported.
Supports all formats libarchive supports.
CurlFtpFS is a filesystem for acessing FTP hosts based on FUSE and libcurl.
Features
CurlFtpFS diferentiates itself from other FTP filesystems because it features:
* SSLv3 and TLSv1 support
* connecting through tunneling HTTP proxies
* automatically reconnection if the server times out
* transform absolute symlinks to point back into the ftp file system
LZOlayer Filesystem is a filesystem which allows you to use transparently
compressed files, just as they would be normal files.
Both read and write operations are possible, along with other most common
system calls. It consumes little memory in my opinion, because files are
divided into blocks, which can be decompressed separetly. In other words,
if you (or an application) would like to read byte 4,500,000 in a file
sized 5,000,000 bytes, it only decompresses a block which constain wanted
data. Write operation is based on a packet gathering and after reaching its
limit it 'syncs' the data. It allows it's user to write/modify files pretty
fast, despite the fact it's block divided.
LZOlayer FileSystem was meant to support only LZO compression algorythm,
because it has extremely low compression/decompression time. However,
currently it supports LZO and ZLIB (but only one at the run-time!)
compression algorythms.
CryptoFS is a encrypted filesystem for Filesystem in Userspace (FUSE).
CryptoFS will use a normal directory to store files encrypted. The
mountpoint will contain the decrypted files. Every file stored in
this mountpoint will be written encrypted (data and filename) to the
directory that was mounted. If you unmount the directory the encrypted
data can only be access by mounting the directory with the correct key
again.
