Free quota software for linux

vzquota is the tool that allows a system administrator to control disk quotas for OpenVZ Virtual Private Servers (VPS).
OpenVZ is an Operating System-level server virtualization solution, built on Linux. OpenVZ creates isolated, secure virtual private servers (VPSs) or virtual environments on a single physical server enabling better server utilization and ensuring that applications do not conflict.
Each VPS performs and executes exactly like a stand-alone server; VPSs can be rebooted independently and have root access, users, IP addresses, memory, processes, files, applications, system libraries and configuration files.
Enhancements:
- Relative quota file support was added.
- Minor code and documentation fixes were made.
- The vzquota.spec file was fixed according to Fedora packaging guidelines.

ProFTPD Quota LDAP module provides a ProFTPD module that imposes quotas based on LDAP user accounts.
This module is designed to impose quotas, on FTP accounts, based on user accounts. It is based on the ideas contained in Eric Estabrooks mod_quota and TJ Saunders mod_quotatab; however, this module has been written from scratch to implement quotas in a very different manner.
Installation
To install mod_quota_ldap, follow these instructions. After unpacking the tarball, copy the mod_quota_ldap.c file into:
{proftpd-dir}/contrib/
after unpacking the latest proftpd-1.2 source code. Follow the usual steps for using third-party modules in proftpd:
$ ./configure --with-modules=mod_quota_ldap make make install
Enhancements:
- Release works with proFTPd-1.2.8 or higher
- Bug#679338 & Bug#679343 - quota_ldap_getconf() bug solved

mod_dav_fs_diskquota module is a derived work of mod_dav_fs in Apache 2.0.

When it stores files or directories, it changes their owner to the OS user account that has same name as the Web-authorized user, so OS disk quota can continue to work for WebDAV contents.

mod_dav_fs_diskquota makes new files/directories:

owner: OS user account (= same name of Web authorized account)
group: Apache group account
mode: user=readable/writable, group=readable/writable

The owner of them is an user account, so amount of them is limited by OS disk quota. Apache can treat them with group permission. To change files/directories owner, we need to:

1.Give CAP_NET_BIND_SERVICE and CAP_CHOWN capability to Apache.

2.Run Apache as non-root account from beginning. (otherwise, Apache process changes its UID as apache user and it drops above capabilities.)

ext3 adds journaling filesystem capabilities to ext2fs.
What is journaling?
It means you dont have to fsck after a crash. Basically.
What works?
Journaling to a journal file on the journaled filesystem
Automatic recover when the filesystem is remounted
All VFS operations (including quota) should be journaled
Add data updates are also journaled
What is left to be done?
Quota support for non-data-journaled filesystems.
Journaling to an off-filesystem device, eg. NVRam
Decent documentation!
A few internal cleanups: migrating the extra buffer_head fields to a separate jfs_buffer_info field in particular.
Enhancements:
- The major change in this release is a missing byte-endian conversion in the recovery code. This problem affects both the ext3 kernel recovery and the recovery code in e2fsck. Please upgrade to e2fsprogs-1.21-WIP-0601.tar.gz or later.
- The other significant change is a fix when running shared mmaped files on ext3 with more than one ext3 filesystem active: it was possible for ext3 to get confused about which filesystem was active if the VM tried to swap out a page on one filesystem while processing a filesystem update on the other filesystem.
- Pin the buffer heads backing an inode to a transaction when the transaction starts, to prevent the inode being flushed to disk before transaction commit.
- Add a debugging check to trap any attempts to run a nested transaction inside a transaction on a different filesystem.
- Fix an assertion failure that could occur after allocating an indirect block but failing to allocate a block beneath it due to disk full.
- Fix a bug which meant that writes larger than 4k were never being coalesced into a single transaction.
- Rename the confusingly-named "tid_ge" transaction-greater-than function to "tid_gt"
- Update the README to describe the new ext3 features of current e2fsprogs.

vHost is a one-step solution for all virtual hosting needs. It enables a Linux/BSD server with single or multiple IP addresses to function as unlimited virtual hosts with HTTP, FTP, SMTP, POP3, IMAP, and other virtual services extendible via modules.
vHost comes with both a command-line interface and a web-based GUI ("control panel"), offering maximum control to a domains owner while relieving the system administrator of most routine administration tasks. Other major features include four levels of login, comprehensive quota control, and built-in clustering capability.
Main features:
- Supports all major Linux distros, and FreeBSD, NetBSD.
- Integrated install/upgrade module provides effortless one-step install and upgrade from any old version.
- Retains all previous system configurations while upgrading in order to ensure zero downtime.
- Clean virtual host file system follows *nix conventions.
- Virtual user home/web space.
- Integrated web-based FTP client for virtual users as well as host owners.
- All operations available in both command-line and web-based GUI ("control panel").
- Modularized architecture allows for arbitrary features and virtual services extended by modules.
- Four levels of login and security: root, vroot ("reseller"), host owner, and virtual user.
- Comprehensive quota control: disk space limit, inbox size limit, per-owner host limit, per-host user limit.
- Built-in clustering capability supports DNS round-robin clustering and distributed host/DNS.
- Automatic local and remote DNS setup.
- Automatic IP address aliasing and management for multiple-IP systems.
- Supports host alias and user alias.
- Built-in log rotation, easy exclusion of logs from rotation.
- Optional email "catch-all".
- Built-in "POP before SMTP" relay support.
- True virtual webmail per virtual host.
- Virtual host webstats.
- Command logging.
- Optional per-host and per-owner profiles for fine-grained system configuration.
- Easy system migration with command --cphost.
- No database backend required.
Enhancements:
- This is a major release with a minor version number increment (version 4.0 is planned for a new Web GUI).
- Changes include an integrated Web-based FTP client, a virtualization module for OpenWebmail, the new commands --addmydb/--delmydb, virtual user ".forward" support, improved SELinux support, improvements for clustering/distributed systems, numerous other fixes and enhancements, and documentation.

Frottle (Freenet throttle) is a project to control traffic on wireless networks. Such control eliminates the common hidden-node effect even on large scale wireless networks. Frottle is currently only available for Linux wireless gateways using iptables firewalls, with plans to develop a windows client in the future.
Frottle is made to schedule the traffic of each client, using a master node to co-ordinate actions. This eliminates collisions, and prevents clients with stronger signals from receiving bandwidth bias.
Frottle has been developed and tested on the large community wireless network of WaFreeNet. We have found running frottle has given us a significant improvment in the network usability. Testing results will be documented here as time permits.
Frottle currently operates as a userspace application, receiveing outbound packets via the iptables QUEUE functionality. Access to the network is controlled by the frottle master, sending each client a control packet (token) which contains information about how much data can be sent at this time.
Each client receives its token and sends any required data, one at a time. This eliminates collisions, and with a reasonable signal packetloss is virtually zero. Also, since each client gets a limited slice of the bandwidth, everyone can get fair access regardless of their signal strength. Whilst this mechanism does result in increased latency, overall network performance and utilisation can significantly increase.
Main features:
- Traffic queues built in to frottle assign different, dynamic priorities to different traffic. Most traffic has a default priority. Traffic to/from specified ports (and ICMP packets) are made high priority. Traffic for connections that have done more than 2 MB of data and have a rate of more than 5 KB/s are made low priority. When a client is polled, high priority traffic is sent first, then default, then low until the poll quota is used.
-
- Realtime info on each clients performance is available from the master in a html file and optionally at each client in a similar html file. (The names and locations of these files is set in /etc/frottle.conf.)

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

SYNOPSIS

use Filesys::DfPortable;

my $ref = dfportable("C:"); # Default block size is 1, which outputs bytes
if(defined($ref)) {
print"Total bytes: $ref->{blocks}n";
print"Total bytes free: $ref->{bfree}n";
print"Total bytes avail to me: $ref->{bavail}n";
print"Total bytes used: $ref->{bused}n";
print"Percent full: $ref->{per}n"
}


my $ref = dfportable("/tmp", 1024); # Display output in 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->{bused}n";
print"Percent full: $ref->{per}n"
}

This module provides a portable way to obtain filesystem disk space information.

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

This module differs from Filesys::Df in that it has added support for Windows, but does not support open filehandles as a argument.

dfportable() requires a directory argument that represents the filesystem you want to query. There is also an optional block size argument so that you can tailor the size of the values returned. The default block size is 1, this will cause the function to return the values in bytes. If you never use the block size argument, then you can think of any instance of "blocks" in this document to really mean "bytes".

dfportable() 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.
{bused} = 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 to make sure the information is available. Some filesystems may not return inode information, for example Windows, and 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.

If the dfportable() 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. dfportable() will croak() if you pass it a undefined value.