Free filesystems in unix 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.

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.

Gaim is a multi-protocol instant messaging client for Linux, BSD, MacOS X, and Windows. It is compatible with AIM (Oscar and TOC protocols), ICQ, MSN Messenger, Yahoo, IRC, Jabber, Gadu-Gadu, and Zephyr networks.
Gaim users can log in to multiple accounts on multiple IM networks simultaneously. This means that you can be chatting with friends on AOL Instant Messenger, talking to a friend on Yahoo Messenger, and sitting in an IRC channel all at the same time.
Gaim supports many features of the various networks, such as file transfer (coming soon), away messages, typing notification, and MSN window closing notification.
It also goes beyond that and provides many unique features.
A few popular features are Buddy Pounces, which give the ability to notify you, send a message, play a sound, or run a program when a specific buddy goes away, signs online, or returns from idle; and plugins, consisting of text replacement, a buddy ticker, extended message notification, iconify on away, and more.
Enhancements:
- Fix system log start times for some protocols
- SILC compiles with newer SILC toolkit versions (Pekka Riikonen)
- Fixed a bug where buddy icon cache files were left in the icon cache directory after they were no longer in use.
- Attempt to detect the file type of a buddy icon when saving.
- Additional Yahoo! boot protection (Peter Lawler)
- A few Yahoo! memory leaks plugged (Peter Lawler)
- Fixed handling of the new Yahoo! profile page. (Joshua Honeycutt, Peter Lawler)
- Fixed localized Yahoo! room lists. Please refer to the Yahoo! section of the Gaim FAQ for details. (Peter Lawler)
- Enabled sending files to ICQ users using ICQ 5.02 and newer (Jonathan Clark)

TreeSize for Unix is a disk consumption analyzing tool, which sorts folders according to their physical occupied sizes.

The perfect tool to help you obtaining more disk free space, on your hard drive, usb pen drive or even on network folders (provided that they are mounted and you have access to them, of course )

Just like du, it counts hard links just once and the space utilized by different filesystems are not added together.

Wireless Access Point Utilites for Unix is a set of utilites to configure and monitor Wireless Access Points under Unix using SNMP protocol.
Utilites knownly compiles by GCC and IBM C compiler and run under Linux, FreeBSD, NetBSD, MacOS-X, AIX, QNX, OpenBSD.
Utilites writen by Roman Festchook and released under the terms GNU General Public License version 2.0. A copy of the file is included with this distribution package.
Main features:
- ap-config - to config and get stats from Atmel-MIB based APs and devices that support IEEE 802.11 MIB and NWN DOT11EXT MIB;
- ap-mrtg - to get stat from AP and return it in MRTG parsable format;
- ap-trapd - to receive, parse and log trap messages from AP.
Enhancements:
- Dutch and Swedish translations have been added.

Speak Freely is an application for Unix and Unix-like systems (Linux, FreeBSD, IRIX, etc.) with audio hardware, which allows you to talk (actually send voice, not typed characters) over a network. Speak Freely for Unix uses the workstation audio hardware and network to allow conversations of users over the network.

The phone company never gives you a break! You pay a fortune for a leased line connection to the Internet, and you *still* have to pay every time you want to chat with somebody, even though youre both sitting in front of workstations with digital audio capability, linked by a fast network. Speak Freely for Unix can intercommunicate with

Workstations on local area networks can generally communicate with excellent audio quality and response. A software implementation (developed by Jutta Degener and Carsten Bormann, Technische
Universitaet Berlin) of the compression algorithm used in GSM digital cellular telephones allows operation over Internet links of modest bandwidth. By using GSM compression in conjunction with sample interpolation, the data rate can be reduced to about 9600 baud. Users with CPUs too slow or two heavily loaded to perform GSM compression and decompression in real time may select less compact but quicker to
execute ADPCM coding, using an implementation developed by Jack Jansen of the Centre for Mathematics and Computer Science, Amsterdam, The Netherlands.