1106 lines
32 KiB
Perl
Executable File
1106 lines
32 KiB
Perl
Executable File
#!/usr/bin/env perl
|
|
# -------------------------------------------------------------------------
|
|
# Copyright (C) 2000-2017 TJ Saunders <tj@castaglia.org>
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
|
|
# -------------------------------------------------------------------------
|
|
|
|
use strict;
|
|
|
|
use Fcntl qw(:flock);
|
|
use File::Basename qw(basename);
|
|
use Getopt::Long;
|
|
use IO::Seekable;
|
|
|
|
my $program = basename($0);
|
|
my $verbose = 0;
|
|
|
|
# These formats are highly dependent on the quota record definitions in
|
|
# mod_quotatab.h. Should those definitions change, these format strings will
|
|
# need to be adjusted accordingly.
|
|
my $limit_format = "Z81I1C1I1d3L3";
|
|
my $tally_format = "Z81I1d3L3";
|
|
|
|
# These sizes are determined by the sizes of the quota_limit_t and
|
|
# quota_tally_t structs (NOT using C's sizeof(), though -- alignment issues)
|
|
my $limit_reclen = 126;
|
|
my $tally_reclen = 121;
|
|
|
|
# the values for these variables is similarly dependent on the actual
|
|
# values defined in mod_quotatab.h
|
|
my $ALL_QUOTA = 10;
|
|
my $USER_QUOTA = 20;
|
|
my $GROUP_QUOTA = 30;
|
|
my $CLASS_QUOTA = 40;
|
|
|
|
my $HARD_LIMIT = 1;
|
|
my $SOFT_LIMIT = 2;
|
|
|
|
my $LIMIT_TABLE = 100;
|
|
my $TALLY_TABLE = 101;
|
|
|
|
my $LIMIT_MAGIC = hex(7626);
|
|
my $TALLY_MAGIC = hex(7644);
|
|
|
|
my $default_limit_table = "./ftpquota.limittab";
|
|
my $default_tally_table = "./ftpquota.tallytab";
|
|
my $default_name = "";
|
|
my $default_quota_type = $ALL_QUOTA;
|
|
my $default_limit_type = $HARD_LIMIT;
|
|
my $default_per_session = 0;
|
|
my $default_bytes_in = -1.0;
|
|
my $default_bytes_out = -1.0;
|
|
my $default_bytes_xfer = -1.0;
|
|
my $default_files_in = 0;
|
|
my $default_files_out = 0;
|
|
my $default_files_xfer = 0;
|
|
|
|
my $byte_units = "byte";
|
|
|
|
my %opts = ();
|
|
GetOptions(\%opts, 'Bu=n', 'bytes-upload=n', 'Bd=n', 'bytes-download=n',
|
|
'Bt=n', 'bytes-xfer=n', 'Fu=n', 'files-upload=n', 'Fd=n', 'files-download=n',
|
|
'Ft=n', 'files-xfer', 'L|limit-type=s', 'N|name=s', 'P|per-session',
|
|
'Q|quota-type=s', 'help', 'table-path=s', 'units=s', 'verbose', 'type=s',
|
|
'add-record', 'create-table', 'delete-record', 'show-records',
|
|
'update-record');
|
|
|
|
usage() if (defined($opts{'help'}));
|
|
|
|
my ($table, $table_type);
|
|
my %record = ();
|
|
|
|
parse_options();
|
|
|
|
if (defined($opts{'add-record'})) {
|
|
open_table();
|
|
wlock_table();
|
|
add_record();
|
|
unlock_table();
|
|
close_table();
|
|
exit 0;
|
|
}
|
|
|
|
if (defined($opts{'create-table'})) {
|
|
open_table();
|
|
close_table();
|
|
exit 0;
|
|
}
|
|
|
|
if (defined($opts{'delete-record'})) {
|
|
open_table();
|
|
wlock_table();
|
|
delete_record();
|
|
unlock_table();
|
|
close_table();
|
|
exit 0;
|
|
}
|
|
|
|
if (defined($opts{'show-records'})) {
|
|
open_table();
|
|
rlock_table();
|
|
print_table();
|
|
unlock_table();
|
|
close_table();
|
|
exit 0;
|
|
}
|
|
|
|
if (defined($opts{'update-record'})) {
|
|
open_table();
|
|
wlock_table();
|
|
update_record();
|
|
unlock_table();
|
|
close_table();
|
|
exit 0;
|
|
}
|
|
|
|
# if no operations have been specified, note this and exit
|
|
print STDOUT "$program: no operations to perform, exiting\n";
|
|
|
|
exit;
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub add_record {
|
|
print STDOUT "$program: adding record\n" if $verbose;
|
|
|
|
my $add_quota_type;
|
|
|
|
# first, find the matching record. Note that this option requires
|
|
# both --name and --quota-type
|
|
|
|
if (!defined($opts{'Q'})) {
|
|
print STDOUT "$program: --add-record requires --quota-type option\n";
|
|
exit(1);
|
|
|
|
} else {
|
|
$add_quota_type = get_quota_type(quota_type => $opts{'Q'});
|
|
}
|
|
|
|
if ($add_quota_type != $ALL_QUOTA) {
|
|
if (!defined($opts{'N'})) {
|
|
print STDOUT "$program: --add-record requires --name option\n";
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
# now, see if there is a matching record already in the table
|
|
if (find_record(name => $opts{'N'}, quota_type => $add_quota_type)) {
|
|
print STDOUT "$program: unable to add record: matching record already exists\n";
|
|
exit(1);
|
|
}
|
|
|
|
# move to the end of the table, and write the new record
|
|
set_table_position(0, SEEK_END);
|
|
|
|
my $formatted_record;
|
|
|
|
if ($table_type == $LIMIT_TABLE) {
|
|
$formatted_record = pack($limit_format,
|
|
$record{'name'}, $record{'quota_type'},
|
|
$record{'per_session'}, $record{'limit_type'},
|
|
$record{'bytes_in'}, $record{'bytes_out'}, $record{'bytes_xfer'},
|
|
$record{'files_in'}, $record{'files_out'}, $record{'files_xfer'});
|
|
|
|
} elsif ($table_type == $TALLY_TABLE) {
|
|
|
|
$formatted_record = pack($tally_format,
|
|
$record{'name'}, $record{'quota_type'},
|
|
$record{'bytes_in'}, $record{'bytes_out'}, $record{'bytes_xfer'},
|
|
$record{'files_in'}, $record{'files_out'}, $record{'files_xfer'});
|
|
}
|
|
|
|
write_record(record => $formatted_record);
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub check_table {
|
|
my $data;
|
|
|
|
print STDOUT "$program: checking table '$table'\n" if $verbose;
|
|
|
|
sysread TABLE, $data, 4;
|
|
|
|
# unpack what was read in
|
|
my ($magic) = unpack("L", $data);
|
|
|
|
if ($table_type == $LIMIT_TABLE) {
|
|
|
|
if ($magic != $LIMIT_MAGIC) {
|
|
print STDOUT "$program: bad header: $magic != $LIMIT_MAGIC\n" if
|
|
$verbose;
|
|
die "$program: mismatched table header, exiting\n";
|
|
|
|
} else {
|
|
print STDOUT "$program: table has correct header\n" if $verbose;
|
|
}
|
|
|
|
} elsif ($table_type == $TALLY_TABLE) {
|
|
|
|
if ($magic != $TALLY_MAGIC) {
|
|
print STDOUT "$program: bad header magics: $magic != $TALLY_MAGIC\n" if
|
|
$verbose;
|
|
die "$program: mismatched table header, exiting\n";
|
|
|
|
} else {
|
|
print STDOUT "$program: table has correct header\n" if $verbose;
|
|
}
|
|
}
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub close_table {
|
|
print STDOUT "$program: closing table '$table'\n" if $verbose;
|
|
|
|
close(TABLE);
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub delete_record {
|
|
print STDOUT "$program: deleting record\n" if $verbose;
|
|
|
|
my $delete_quota_type;
|
|
|
|
# first, find the matching record. Note that this option requires
|
|
# both --name and --quota-type
|
|
|
|
if (!defined($opts{'Q'})) {
|
|
print STDOUT "$program: --delete-record requires --quota-type option\n";
|
|
exit(1);
|
|
|
|
} else {
|
|
$delete_quota_type = get_quota_type(quota_type => $opts{'Q'});
|
|
}
|
|
|
|
if ($delete_quota_type != $ALL_QUOTA) {
|
|
if (!defined($opts{'N'})) {
|
|
print STDOUT "$program: --delete-record requires --name option\n";
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
# now, find the matching record in the table
|
|
unless (find_record(name => $opts{'N'}, quota_type => $delete_quota_type)) {
|
|
print STDOUT "$program: unable to delete record: no match found\n";
|
|
exit(1);
|
|
}
|
|
rewind_record();
|
|
|
|
print STDOUT "$program: modifying table '$table'\n" if $verbose;
|
|
|
|
# first, record the current file position
|
|
my $position = get_table_position();
|
|
|
|
# next, advance past this record to be deleted, and read in the
|
|
# rest of the file
|
|
|
|
seek_record(1);
|
|
|
|
my ($nrecords, @records) = read_table();
|
|
|
|
# Rewind the previous position, and "delete" that record by simply
|
|
# overwriting it. Note that this approach works for file tables --
|
|
# tables in other formats, such as SQL, will have a much easier time
|
|
# deleting a quota record.
|
|
|
|
set_table_position($position, SEEK_SET);
|
|
|
|
if ($nrecords > 0) {
|
|
for (my $i = 0; $i < $nrecords; $i++) {
|
|
write_record(record => $records[$i]);
|
|
}
|
|
|
|
# Truncate the table
|
|
truncate_table(len => get_table_position() - 4);
|
|
|
|
} else {
|
|
|
|
# Truncate the table
|
|
truncate_table(len => $position - 4);
|
|
}
|
|
|
|
# done
|
|
exit(0);
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub find_record {
|
|
my %args = @_;
|
|
my $nrecords = 0;
|
|
|
|
my $search_name = $args{'name'};
|
|
my $search_quota_type = $args{'quota_type'};
|
|
|
|
while (my $record = read_record()) {
|
|
$nrecords++;
|
|
|
|
my ($name, $quota_type, @junk);
|
|
|
|
# unpack the binary record structure
|
|
if ($table_type == $LIMIT_TABLE) {
|
|
($name, $quota_type, @junk) = unpack($limit_format, $record);
|
|
|
|
} elsif ($table_type == $TALLY_TABLE) {
|
|
($name, $quota_type, @junk) = unpack($tally_format, $record);
|
|
}
|
|
|
|
# remove any NULs from $name
|
|
$name =~ s/(\0*)?//;
|
|
|
|
if ($search_quota_type == $ALL_QUOTA and
|
|
$quota_type == $ALL_QUOTA) {
|
|
return $record;
|
|
|
|
} elsif ($name eq $search_name and
|
|
$quota_type == $search_quota_type) {
|
|
return $record;
|
|
}
|
|
}
|
|
|
|
return undef;
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub get_display_bytes {
|
|
my %args = @_;
|
|
|
|
my $bytes = $args{'bytes'};
|
|
|
|
if ($byte_units eq "byte") {
|
|
# no calculation necessary
|
|
|
|
unless ($bytes eq "unlimited" || $bytes <= 0) {
|
|
return sprintf "bytes:\t%.2f", $bytes;
|
|
} else {
|
|
return sprintf "bytes:\tunlimited";
|
|
}
|
|
|
|
} elsif ($byte_units eq "kilo") {
|
|
# divide by 1024.0
|
|
my $adj_bytes = $bytes / 1024.0;
|
|
|
|
unless ($bytes eq "unlimited" || $bytes <= 0) {
|
|
return sprintf "Kb:\t%.2f", $adj_bytes;
|
|
} else {
|
|
return sprintf "Kb:\tunlimited";
|
|
}
|
|
|
|
} elsif ($byte_units eq "mega") {
|
|
# divide by 1024.0 * 1024.0
|
|
my $adj_bytes = $bytes / (1024.0 * 1024.0);
|
|
|
|
unless ($bytes eq "unlimited" || $bytes <= 0) {
|
|
return sprintf "Mb:\t%.2f", $adj_bytes;
|
|
} else {
|
|
return sprintf "Mb:\tunlimited";
|
|
}
|
|
|
|
} elsif ($byte_units eq "giga") {
|
|
# divide by 1024.0 * 1024.0 * 1024.0
|
|
my $adj_bytes = $bytes / (1024.0 * 1024.0 * 1024.0);
|
|
|
|
unless ($bytes eq "unlimited" || $bytes <= 0) {
|
|
return sprintf "Gb:\t%.2f", $adj_bytes;
|
|
} else {
|
|
return sprintf "Gb:\tunlimited";
|
|
}
|
|
}
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub get_quota_type {
|
|
my %args = @_;
|
|
|
|
my $quota_type = $args{'quota_type'};
|
|
|
|
# given the command-line --quote-type option value, return the
|
|
# corresponding numeric value
|
|
|
|
if ($quota_type eq "all") {
|
|
return $ALL_QUOTA;
|
|
|
|
} elsif ($quota_type eq "user") {
|
|
return $USER_QUOTA;
|
|
|
|
} elsif ($quota_type eq "group") {
|
|
return $GROUP_QUOTA;
|
|
|
|
} elsif ($quota_type eq "class") {
|
|
return $CLASS_QUOTA;
|
|
|
|
} else {
|
|
print STDERR "$program: unknown quota type: $quota_type\n";
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub get_table_position {
|
|
return sysseek(TABLE, 0, 1);
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub open_table {
|
|
|
|
# if the table doesn't exist, create it if requested
|
|
if (defined($opts{'create-table'})) {
|
|
die "$program: cannot create existing table\n" if (-e $table);
|
|
|
|
print STDOUT "$program: creating new table\n" if $verbose;
|
|
|
|
open(TABLE, "> $table") or
|
|
die "$program: unable to create $table: $!\n";
|
|
|
|
print STDOUT "$program: writing header for new table\n" if $verbose;
|
|
|
|
# write out the identifying header for the table type
|
|
if ($table_type == $LIMIT_TABLE) {
|
|
syswrite TABLE, pack("L", $LIMIT_MAGIC);
|
|
|
|
} elsif ($table_type == $TALLY_TABLE) {
|
|
syswrite TABLE, pack("L", $TALLY_MAGIC);
|
|
}
|
|
|
|
} else {
|
|
|
|
print STDOUT "$program: opening table '$table'\n" if $verbose;
|
|
|
|
if (defined($opts{'show-records'})) {
|
|
open(TABLE, "< $table") or
|
|
die "$program: unable to open $table: $!\n";
|
|
|
|
} else {
|
|
open(TABLE, "+< $table") or
|
|
die "$program: unable to open $table: $!\n";
|
|
}
|
|
|
|
check_table();
|
|
}
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub parse_options {
|
|
|
|
$verbose = 1 if (defined($opts{'verbose'}));
|
|
|
|
if (defined($opts{'type'})) {
|
|
|
|
die "$program: unknown table type: $opts{'type'}\n" if
|
|
($opts{'type'} ne 'limit' and $opts{'type'} ne 'tally');
|
|
|
|
if ($opts{'type'} eq 'limit') {
|
|
$table_type = $LIMIT_TABLE;
|
|
$table = $default_limit_table;
|
|
}
|
|
|
|
if ($opts{'type'} eq 'tally') {
|
|
$table_type = $TALLY_TABLE;
|
|
$table = $default_tally_table;
|
|
}
|
|
|
|
} else {
|
|
die "$program: missing required --type parameter\n";
|
|
}
|
|
|
|
$table = $opts{'table-path'} if (defined($opts{'table-path'}));
|
|
|
|
if (defined($opts{'N'})) {
|
|
$record{'name'} = $opts{'N'};
|
|
|
|
# make sure the name is not too long
|
|
die "$program: name is too long, must be less than 80 characters\n"
|
|
if (length($record{'name'}) >= 80);
|
|
|
|
} else {
|
|
$record{'name'} = $default_name;
|
|
}
|
|
|
|
if (defined($opts{'P'})) {
|
|
$record{'per_session'} = 1;
|
|
|
|
} else {
|
|
$record{'per_session'} = $default_per_session;
|
|
}
|
|
|
|
if (defined($opts{'Q'})) {
|
|
if ($opts{'Q'} eq "all") {
|
|
$record{'quota_type'} = $ALL_QUOTA;
|
|
|
|
} elsif ($opts{'Q'} eq "user") {
|
|
$record{'quota_type'} = $USER_QUOTA;
|
|
|
|
# it's an error if there's no -N option present as well
|
|
unless (defined($opts{'N'})) {
|
|
print STDOUT "$program: quota type \"user\" requires --name option\n";
|
|
exit(1);
|
|
}
|
|
|
|
} elsif ($opts{'Q'} eq "group") {
|
|
$record{'quota_type'} = $GROUP_QUOTA;
|
|
|
|
# it's an error if there's no -N option present as well
|
|
unless (defined($opts{'N'})) {
|
|
print STDOUT "$program: quota type \"group\" requires --name option\n";
|
|
exit(1);
|
|
}
|
|
|
|
} elsif ($opts{'Q'} eq "class") {
|
|
$record{'quota_type'} = $CLASS_QUOTA;
|
|
|
|
# it's an error if there's no -N option present as well
|
|
unless (defined($opts{'N'})) {
|
|
print STDOUT "$program: quota type \"class\" requires --name option\n";
|
|
exit(1);
|
|
}
|
|
|
|
} else {
|
|
print STDERR "$program: unknown quota type: $opts{'Q'}\n";
|
|
exit(1);
|
|
}
|
|
|
|
} else {
|
|
$record{'quota_type'} = $ALL_QUOTA;
|
|
}
|
|
|
|
if (defined($opts{'L'})) {
|
|
if ($opts{'L'} eq "hard") {
|
|
$record{'limit_type'} = $HARD_LIMIT;
|
|
|
|
} elsif ($opts{'L'} eq "soft") {
|
|
$record{'limit_type'} = $SOFT_LIMIT;
|
|
|
|
} else {
|
|
print STDERR "$program: unknown limit type: $opts{'L'}\n";
|
|
exit(1);
|
|
}
|
|
|
|
} else {
|
|
$record{'limit_type'} = $HARD_LIMIT;
|
|
}
|
|
|
|
# process the --units option, if present
|
|
if (defined($opts{'units'})) {
|
|
|
|
if ($opts{'units'} eq "B" or $opts{'units'} eq "byte") {
|
|
$byte_units = "byte";
|
|
|
|
} elsif ($opts{'units'} eq "Kb" or $opts{'units'} eq "kilo") {
|
|
$byte_units = "kilo";
|
|
|
|
} elsif ($opts{'units'} eq "Mb" or $opts{'units'} eq "mega") {
|
|
$byte_units = "mega";
|
|
|
|
} elsif ($opts{'units'} eq "Gb" or $opts{'units'} eq "giga") {
|
|
$byte_units = "giga";
|
|
|
|
} else {
|
|
print STDERR "$program: unknown unit type: $opts{'units'}\n";
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
if (defined($opts{'Bu'}) || defined($opts{'bytes-upload'})) {
|
|
if (defined($opts{'Bu'}) && defined($opts{'bytes-upload'})) {
|
|
print STDOUT "$program: do not use both --Bu and --bytes-upload options\n";
|
|
exit(1);
|
|
}
|
|
|
|
$record{'bytes_in'} = $opts{'Bu'} if (defined($opts{'Bu'}));
|
|
$record{'bytes_in'} = $opts{'bytes-upload'} if
|
|
(defined($opts{'bytes-upload'}));
|
|
|
|
if ($record{'bytes_in'} <= 0.0) {
|
|
print STDERR "$program: notice: upload bytes value '", $record{'bytes_in'}, "' means 'unlimited'\n";
|
|
}
|
|
|
|
if ($record{'bytes_in'} != $default_bytes_in) {
|
|
if ($byte_units eq "kilo") {
|
|
$record{'bytes_in'} = $record{'bytes_in'} * 1024.0;
|
|
|
|
} elsif ($byte_units eq "mega") {
|
|
$record{'bytes_in'} = $record{'bytes_in'} * 1024.0 * 1024.0;
|
|
|
|
} elsif ($byte_units eq "giga") {
|
|
$record{'bytes_in'} = $record{'bytes_in'} * 1024.0 * 1024.0 * 1024.0;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
$record{'bytes_in'} = $default_bytes_in if ($table_type == $LIMIT_TABLE);
|
|
$record{'bytes_in'} = 0.0 if ($table_type == $TALLY_TABLE);
|
|
}
|
|
|
|
if (defined($opts{'Bd'}) || defined($opts{'bytes-download'})) {
|
|
if (defined($opts{'Bd'}) && defined($opts{'bytes-download'})) {
|
|
print STDOUT "$program: do not use both --Bd and --bytes-download options\n";
|
|
exit(1);
|
|
}
|
|
|
|
$record{'bytes_out'} = $opts{'Bd'} if (defined($opts{'Bd'}));
|
|
$record{'bytes_out'} = $opts{'bytes-download'} if
|
|
(defined($opts{'bytes-download'}));
|
|
|
|
if ($record{'bytes_out'} <= 0.0) {
|
|
print STDERR "$program: notice: download bytes value '", $record{'bytes_out'}, "' means 'unlimited'\n";
|
|
}
|
|
|
|
if ($record{'bytes_out'} != $default_bytes_out) {
|
|
if ($byte_units eq "kilo") {
|
|
$record{'bytes_out'} = $record{'bytes_out'} * 1024.0;
|
|
|
|
} elsif ($byte_units eq "mega") {
|
|
$record{'bytes_out'} = $record{'bytes_out'} * 1024.0 * 1024.0;
|
|
|
|
} elsif ($byte_units eq "giga") {
|
|
$record{'bytes_out'} = $record{'bytes_out'} * 1024.0 * 1024.0 * 1024.0;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
$record{'bytes_out'} = $default_bytes_out if ($table_type == $LIMIT_TABLE);
|
|
$record{'bytes_out'} = 0.0 if ($table_type == $TALLY_TABLE);
|
|
}
|
|
|
|
if (defined($opts{'Bx'}) || defined($opts{'bytes-xfer'})) {
|
|
if (defined($opts{'Bx'}) && defined($opts{'bytes-xfer'})) {
|
|
print STDOUT "$program: do not use both --Bx and --bytes-xfer options\n";
|
|
exit(1);
|
|
}
|
|
|
|
$record{'bytes_xfer'} = $opts{'Bx'} if (defined($opts{'Bx'}));
|
|
$record{'bytes_xfer'} = $opts{'bytes-xfer'} if
|
|
(defined($opts{'bytes-xfer'}));
|
|
|
|
if ($record{'bytes_xfer'} <= 0.0) {
|
|
print STDERR "$program: notice: transfer bytes value '", $record{'bytes_xfer'}, "' means 'unlimited'\n";
|
|
}
|
|
|
|
if ($record{'bytes_xfer'} != $default_bytes_xfer) {
|
|
if ($byte_units eq "kilo") {
|
|
$record{'bytes_xfer'} = $record{'bytes_xfer'} * 1024.0;
|
|
|
|
} elsif ($byte_units eq "mega") {
|
|
$record{'bytes_xfer'} = $record{'bytes_xfer'} * 1024.0 * 1024.0;
|
|
|
|
} elsif ($byte_units eq "giga") {
|
|
$record{'bytes_xfer'} =
|
|
$record{'bytes_xfer'} * 1024.0 * 1024.0 * 1024.0;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
$record{'bytes_xfer'} = $default_bytes_xfer if
|
|
($table_type == $LIMIT_TABLE);
|
|
$record{'bytes_xfer'} = 0.0 if ($table_type == $TALLY_TABLE);
|
|
}
|
|
|
|
if (defined($opts{'Fu'}) || defined($opts{'files-upload'})) {
|
|
if (defined($opts{'Fu'}) && defined($opts{'files-upload'})) {
|
|
print STDOUT "$program: do not use both --Fu and --files-upload options\n";
|
|
exit(1);
|
|
}
|
|
|
|
$record{'files_in'} = $opts{'Fu'} if (defined($opts{'Fu'}));
|
|
$record{'files_in'} = $opts{'files-upload'} if
|
|
(defined($opts{'files-upload'}));
|
|
|
|
if ($record{'files_in'} <= 0) {
|
|
print STDERR "$program: notice: upload files value '", $record{'files_in'}, "' means 'unlimited'\n";
|
|
}
|
|
|
|
} else {
|
|
|
|
$record{'files_in'} = $default_files_in if ($table_type == $LIMIT_TABLE);
|
|
$record{'files_in'} = 0 if ($table_type == $TALLY_TABLE);
|
|
}
|
|
|
|
if (defined($opts{'Fd'}) || defined($opts{'files-download'})) {
|
|
if (defined($opts{'Fd'}) && defined($opts{'files-download'})) {
|
|
print STDOUT "$program: do not use both --Fd and --files-download options\n";
|
|
exit(1);
|
|
}
|
|
|
|
$record{'files_out'} = $opts{'Fd'} if (defined($opts{'Fd'}));
|
|
$record{'files_out'} = $opts{'files-download'} if
|
|
(defined($opts{'files-download'}));
|
|
|
|
if ($record{'files_out'} <= 0) {
|
|
print STDERR "$program: notice: download files value '", $record{'files_out'}, "' means 'unlimited'\n";
|
|
}
|
|
|
|
} else {
|
|
|
|
$record{'files_out'} = $default_files_out if ($table_type == $LIMIT_TABLE);
|
|
$record{'files_out'} = 0 if ($table_type == $TALLY_TABLE);
|
|
}
|
|
|
|
if (defined($opts{'Fx'}) || defined($opts{'files-xfer'})) {
|
|
if (defined($opts{'Fx'}) && defined($opts{'files-xfer'})) {
|
|
print STDOUT "$program: do not use both --Fx and --files-xfer options\n";
|
|
exit(1);
|
|
}
|
|
|
|
$record{'files_xfer'} = $opts{'Fx'} if (defined($opts{'Fx'}));
|
|
$record{'files_xfer'} = $opts{'files-xfer'} if
|
|
(defined($opts{'files-xfer'}));
|
|
|
|
if ($record{'files_xfer'} <= 0) {
|
|
print STDERR "$program: notice: transfer files value '", $record{'files_xfer'}, "' means 'unlimited'\n";
|
|
}
|
|
|
|
} else {
|
|
|
|
$record{'files_xfer'} = $default_files_xfer if
|
|
($table_type == $LIMIT_TABLE);
|
|
$record{'files_xfer'} = 0 if ($table_type == $TALLY_TABLE);
|
|
}
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub print_record {
|
|
my %args = @_;
|
|
|
|
my $record = $args{'record'};
|
|
|
|
my ($name, $quota_type, $per_session, $limit_type, $bytes_in, $bytes_out,
|
|
$bytes_xfer, $files_in, $files_out, $files_xfer);
|
|
|
|
if ($table_type == $LIMIT_TABLE) {
|
|
($name, $quota_type, $per_session, $limit_type, $bytes_in, $bytes_out,
|
|
$bytes_xfer, $files_in, $files_out, $files_xfer) = unpack($limit_format,
|
|
$record);
|
|
|
|
} elsif ($table_type == $TALLY_TABLE) {
|
|
|
|
($name, $quota_type, $bytes_in, $bytes_out, $bytes_xfer,
|
|
$files_in, $files_out, $files_xfer) = unpack($tally_format, $record);
|
|
}
|
|
|
|
|
|
# make the symbolic values legible
|
|
$quota_type = "All" if ($quota_type == $ALL_QUOTA);
|
|
$quota_type = "User" if ($quota_type == $USER_QUOTA);
|
|
$quota_type = "Group" if ($quota_type == $GROUP_QUOTA);
|
|
$quota_type = "Class" if ($quota_type == $CLASS_QUOTA);
|
|
|
|
if ($table_type == $LIMIT_TABLE) {
|
|
$limit_type = "Hard" if ($limit_type == $HARD_LIMIT);
|
|
$limit_type = "Soft" if ($limit_type == $SOFT_LIMIT);
|
|
|
|
if ($per_session eq 1) {
|
|
$per_session = "True";
|
|
|
|
} else {
|
|
$per_session = "False";
|
|
}
|
|
}
|
|
|
|
# print "unlimited" if quota is unlimited, but only for limit tables
|
|
if ($table_type == $LIMIT_TABLE) {
|
|
$bytes_in = "unlimited" if ($bytes_in <= 0.0);
|
|
$bytes_out = "unlimited" if ($bytes_out <= 0.0);
|
|
$bytes_xfer = "unlimited" if ($bytes_xfer <= 0.0);
|
|
|
|
$files_in = "unlimited" if ($files_in <= 0);
|
|
$files_out = "unlimited" if ($files_out <= 0);
|
|
$files_xfer = "unlimited" if ($files_xfer <= 0);
|
|
}
|
|
|
|
print STDOUT "-------------------------------------------\n";
|
|
print STDOUT " Name: $name\n";
|
|
print STDOUT " Quota Type: $quota_type\n";
|
|
|
|
if ($table_type == $LIMIT_TABLE) {
|
|
print STDOUT " Per Session: $per_session\n";
|
|
print STDOUT " Limit Type: $limit_type\n";
|
|
}
|
|
|
|
print STDOUT " Uploaded ", get_display_bytes('bytes' => $bytes_in), "\n";
|
|
print STDOUT " Downloaded ", get_display_bytes('bytes' => $bytes_out),
|
|
"\n";
|
|
print STDOUT " Transferred ", get_display_bytes('bytes' => $bytes_xfer),
|
|
"\n";
|
|
|
|
print STDOUT " Uploaded files:\t$files_in\n";
|
|
print STDOUT " Downloaded files:\t$files_out\n";
|
|
print STDOUT " Transferred files:\t$files_xfer\n";
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub print_table {
|
|
my $have_records = 0;
|
|
|
|
while (my $record = read_record()) {
|
|
$have_records = 1;
|
|
print_record(record => $record);
|
|
}
|
|
print STDOUT "$program: (empty table)\n" unless ($have_records);
|
|
|
|
# done
|
|
exit(0);
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub read_record {
|
|
my $record;
|
|
my $bread;
|
|
|
|
if ($table_type == $LIMIT_TABLE) {
|
|
$bread = sysread TABLE, $record, $limit_reclen;
|
|
|
|
} elsif ($table_type == $TALLY_TABLE) {
|
|
$bread = sysread TABLE, $record, $tally_reclen;
|
|
}
|
|
|
|
if ($bread) {
|
|
return $record;
|
|
|
|
} else {
|
|
return undef;
|
|
}
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub read_table {
|
|
my @records = ();
|
|
my $nrecords_read = 0;
|
|
|
|
# read from TABLE
|
|
while (my $record = read_record()) {
|
|
$nrecords_read++;
|
|
push(@records, $record);
|
|
}
|
|
|
|
return ($nrecords_read, @records);
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub rewind_record {
|
|
if ($table_type == $LIMIT_TABLE) {
|
|
sysseek TABLE, -$limit_reclen, 1;
|
|
|
|
} elsif ($table_type == $TALLY_TABLE) {
|
|
sysseek TABLE, -$tally_reclen, 1;
|
|
}
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub rlock_table {
|
|
print STDOUT "$program: read-locking table '$table'\n" if $verbose;
|
|
|
|
flock(TABLE, LOCK_SH);
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub seek_record {
|
|
my ($n) = @_;
|
|
|
|
if ($table_type == $LIMIT_TABLE) {
|
|
sysseek TABLE, $limit_reclen, $n;
|
|
|
|
} elsif ($table_type == $TALLY_TABLE) {
|
|
sysseek TABLE, $tally_reclen, $n;
|
|
}
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub set_table_position {
|
|
my ($position, $whence) = @_;
|
|
|
|
my $result = sysseek(TABLE, $position, $whence);
|
|
|
|
print STDOUT "$program: set table position to $result\n" if $verbose;
|
|
|
|
return $result;
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub truncate_table {
|
|
my %args = @_;
|
|
|
|
my $length = $args{'len'};
|
|
|
|
# don't forget about the header (4 bytes)
|
|
truncate TABLE, $length + 4;
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub unlock_table {
|
|
print STDOUT "$program: unlocking table '$table'\n" if $verbose;
|
|
|
|
flock(TABLE, LOCK_UN);
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub update_record {
|
|
my $current_record;
|
|
my $search_quota_type;
|
|
|
|
# first, find the matching record. Note that this option requires
|
|
# both --name and --quota-type
|
|
|
|
if (!defined($opts{'Q'})) {
|
|
print STDOUT "$program: --update-record requires --quota-type option\n";
|
|
exit(1);
|
|
|
|
} else {
|
|
$search_quota_type = get_quota_type(quota_type => $opts{'Q'});
|
|
}
|
|
|
|
if ($search_quota_type != $ALL_QUOTA) {
|
|
if (!defined($opts{'N'})) {
|
|
print STDOUT "$program: --update-record requires --name option\n";
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
# now, find the matching record in the table
|
|
open_table();
|
|
unless ($current_record = find_record(name => $opts{'N'},
|
|
quota_type => $search_quota_type)) {
|
|
print STDOUT "$program: unable to update record: no match found\n";
|
|
exit(1);
|
|
}
|
|
rewind_record();
|
|
|
|
print STDOUT "$program: updating table '$table'\n" if $verbose;
|
|
|
|
# now, adjust the current record with the updated values in the requested
|
|
# record
|
|
|
|
my ($name, $quota_type, $per_session, $limit_type, @junk);
|
|
|
|
if ($table_type == $LIMIT_TABLE) {
|
|
($name, $quota_type, $per_session, $limit_type,
|
|
@junk) = unpack($limit_format, $current_record);
|
|
|
|
} elsif ($table_type == $TALLY_TABLE) {
|
|
|
|
($name, $quota_type, @junk) = unpack($tally_format, $current_record);
|
|
}
|
|
|
|
my $formatted_record;
|
|
|
|
if ($table_type == $LIMIT_TABLE) {
|
|
$formatted_record = pack($limit_format, $name, $quota_type,
|
|
$record{'per_session'}, $record{'limit_type'},
|
|
$record{'bytes_in'}, $record{'bytes_out'}, $record{'bytes_xfer'},
|
|
$record{'files_in'}, $record{'files_out'}, $record{'files_xfer'});
|
|
|
|
} elsif ($table_type == $TALLY_TABLE) {
|
|
|
|
$formatted_record = pack($tally_format, $name, $quota_type,
|
|
$record{'bytes_in'}, $record{'bytes_out'}, $record{'bytes_xfer'},
|
|
$record{'files_in'}, $record{'files_out'}, $record{'files_xfer'});
|
|
}
|
|
|
|
write_record(record => $formatted_record);
|
|
|
|
# done
|
|
exit(0);
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub wlock_table {
|
|
print STDOUT "$program: write-locking table '$table'\n" if $verbose;
|
|
|
|
flock(TABLE, LOCK_EX);
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub write_record {
|
|
my %args = @_;
|
|
my $record = $args{'record'};
|
|
|
|
print STDOUT "$program: writing record\n" if $verbose;
|
|
|
|
die "$program: error writing table: $!\n" unless
|
|
syswrite TABLE, $record;
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
sub usage {
|
|
|
|
print STDOUT <<END_OF_USAGE;
|
|
|
|
usage: $program [options]
|
|
|
|
The following options describe the type of operation to be performed:
|
|
|
|
--add-record Create a new record with the specified limits. Any
|
|
limits left unspecified with have their default
|
|
values. This option requires the --name and
|
|
--quota-type options.
|
|
|
|
--create-table Create the table if not present. Used to initialize
|
|
a table. The default limit table path is
|
|
"$default_limit_table". The default tally table path is
|
|
"$default_tally_table".
|
|
|
|
--delete-record Deletes a quota record from the table. This option
|
|
requires the --name and --quote-type options.
|
|
|
|
--show-records Prints out all of the quota records in the table in
|
|
a legible format.
|
|
|
|
--update-record Updates a quota record with the specified limits. Any
|
|
limits left unspecified will be updated with their
|
|
default value. This option requires the --name and
|
|
--quota-type options.
|
|
|
|
The following option describes the type of table on which to operate:
|
|
|
|
--type Specifies a table type to use. The allowable options
|
|
are: "limit" or "tally". This is required.
|
|
|
|
The following options are used to specify specific quota limits:
|
|
|
|
--Bu Specifies the limit of the number of bytes that may be
|
|
--bytes-upload uploaded. Defaults to -1 (unlimited). Note that any
|
|
value less than or equal to zero is treated as
|
|
"unlimited".
|
|
|
|
--Bd Specifies the limit of the number of bytes that may be
|
|
--bytes-download downloaded. Defaults to -1 (unlimited). Note that any
|
|
value less than or equal to zero is treated as
|
|
"unlimited".
|
|
|
|
--Bx Specifies the limit of the number of bytes that may be
|
|
--bytes-xfer transferred. Note that this total includes uploads,
|
|
downloads, AND directory listings. Defaults to
|
|
-1 (unlimited). Note that any value value less than or
|
|
equal to zero is treated as "unlimited".
|
|
|
|
--Fu Specifies the limit of the number of files that may be
|
|
--files-upload uploaded. Defaults to -1 (unlimited). Note that any
|
|
value less than or equal to zero is treated as
|
|
"unlimited".
|
|
|
|
--Fd Specifies the limit of the number of files that may be
|
|
--files-download downloaded. Defaults to -1 (unlimited). Note that any
|
|
value less than or equal to zero is treated as
|
|
"unlimited".
|
|
|
|
--Fx Specifies the limit of the number of files that may be
|
|
--files-xfer transferred, including uploads and downloads. Defaults
|
|
to -1 (unlimited). Note that any value less than or
|
|
equal to zero is treated as "unlimited".
|
|
|
|
-L Specifies the type of limit, "hard" or "soft", of
|
|
--limit-type the bytes limits. If "hard", any uploaded files that
|
|
push the bytes used counter past the limit will be
|
|
automatically deleted; if "soft", those extra bytes
|
|
will be allowed, but future uploads will be denied.
|
|
This option only makes sense if --type is "limit".
|
|
|
|
-N Specifies a name for the quota record. This name
|
|
--name will be the user/login name, group name, or class
|
|
name, depending on the quota type. This option
|
|
is ignored if the quota type specified is "all".
|
|
|
|
-P
|
|
--per-session Specifies that the quota limit is to be applied only
|
|
to each session, rather than persisting across
|
|
sessions. By default, quotas are persistent.
|
|
|
|
-Q Specifies a "quota type" for this record, where
|
|
--quota-type the type means to which category of FTP users this
|
|
quota will apply. The quota type must be one of:
|
|
"user", "group", "class", or "all".
|
|
|
|
The following options are miscellaneous:
|
|
|
|
--help Displays this message.
|
|
|
|
--table-path Specifies the path to a quota table file to use.
|
|
|
|
--units Specifies whether to treats bytes as is, in kilobytes,
|
|
megabytes, or gigabytes. Allowable options are:
|
|
"B" or "byte", "Kb" or "kilo", "Mb" or "mega",
|
|
and "Gb" or "giga". Defaults to "byte".
|
|
|
|
--verbose Toggles more verbose information about the doings of
|
|
the tool as it works.
|
|
|
|
END_OF_USAGE
|
|
|
|
exit 0;
|
|
}
|
|
|
|
# -------------------------------------------------------------------------
|
|
|