R E D

NAME	SIZE	PERMISSION
ModemManager	2.09 MB	-rwxr-xr-x
a2disconf	15.89 KB	-rwxr-xr-x
a2dismod	15.89 KB	-rwxr-xr-x
a2dissite	15.89 KB	-rwxr-xr-x
a2enconf	15.89 KB	-rwxr-xr-x
a2enmod	15.89 KB	-rwxr-xr-x
a2ensite	15.89 KB	-rwxr-xr-x
a2query	9.64 KB	-rwxr-xr-x
aa-remove-unknown	3 KB	-rwxr-xr-x
aa-status	62.62 KB	-rwxr-xr-x
aa-teardown	137 B	-rwxr-xr-x
accessdb	14.55 KB	-rwxr-xr-x
add-shell	1.03 KB	-rwxr-xr-x
addgnupghome	3 KB	-rwxr-xr-x
addgroup	37.35 KB	-rwxr-xr-x
adduser	37.35 KB	-rwxr-xr-x
agetty	55.56 KB	-rwxr-xr-x
apache2	740.89 KB	-rwxr-xr-x
apache2ctl	7.06 KB	-rwxr-xr-x
apachectl	7.06 KB	-rwxr-xr-x
apparmor_parser	1.48 MB	-rwxr-xr-x
apparmor_status	62.62 KB	-rwxr-xr-x
applygnupgdefaults	2.17 KB	-rwxr-xr-x
arp	61.61 KB	-rwxr-xr-x
arpd	26.33 KB	-rwxr-xr-x
arptables	219.04 KB	-rwxr-xr-x
arptables-nft	219.04 KB	-rwxr-xr-x
arptables-nft-restore	219.04 KB	-rwxr-xr-x
arptables-nft-save	219.04 KB	-rwxr-xr-x
arptables-restore	219.04 KB	-rwxr-xr-x
arptables-save	219.04 KB	-rwxr-xr-x
auth-otp	18.54 KB	-rwxr-xr-x
badblocks	34.32 KB	-rwxr-xr-x
bcache-super-show	14.3 KB	-rwxr-xr-x
biosdecode	23.2 KB	-rwxr-xr-x
blkdeactivate	15.97 KB	-rwxr-xr-x
blkdiscard	22.38 KB	-rwxr-xr-x
blkid	50.41 KB	-rwxr-xr-x
blkzone	34.38 KB	-rwxr-xr-x
blockdev	30.38 KB	-rwxr-xr-x
bridge	92.49 KB	-rwxr-xr-x
cache_check	1.33 MB	-rwxr-xr-x
cache_dump	1.33 MB	-rwxr-xr-x
cache_metadata_size	1.33 MB	-rwxr-xr-x
cache_repair	1.33 MB	-rwxr-xr-x
cache_restore	1.33 MB	-rwxr-xr-x
cache_writeback	1.33 MB	-rwxr-xr-x
capsh	30.3 KB	-rwxr-xr-x
cfdisk	94.73 KB	-rwxr-xr-x
cgdisk	150.48 KB	-rwxr-xr-x
chcpu	30.38 KB	-rwxr-xr-x
check_forensic	952 B	-rwxr-xr-x
chgpasswd	58.13 KB	-rwxr-xr-x
chmem	34.38 KB	-rwxr-xr-x
chpasswd	54.16 KB	-rwxr-xr-x
chroot	38.51 KB	-rwxr-xr-x
convertquota	66.88 KB	-rwxr-xr-x
cpgr	48.29 KB	-rwxr-xr-x
cppw	48.29 KB	-rwxr-xr-x
cron	50.58 KB	-rwxr-xr-x
cryptdisks_start	1.51 KB	-rwxr-xr-x
cryptdisks_stop	844 B	-rwxr-xr-x
cryptsetup	169.55 KB	-rwxr-xr-x
cryptsetup-reencrypt	90.38 KB	-rwxr-xr-x
cryptsetup-ssh	23.53 KB	-rwxr-xr-x
ctrlaltdel	14.38 KB	-rwxr-xr-x
dbconfig-generate-include	12.36 KB	-rwxr-xr-x
dbconfig-load-include	5.57 KB	-rwxr-xr-x
dcb	80.52 KB	-rwxr-xr-x
debugfs	229.8 KB	-rwxr-xr-x
delgroup	16.11 KB	-rwxr-xr-x
deluser	16.11 KB	-rwxr-xr-x
depmod	166.36 KB	-rwxr-xr-x
devlink	142.86 KB	-rwxr-xr-x
dhclient	442.66 KB	-rwxr-xr-x
dhclient-script	15.92 KB	-rwxr-xr-x
dmeventd	50.38 KB	-rwxr-xr-x
dmidecode	122.98 KB	-rwxr-xr-x
dmsetup	171.02 KB	-rwxr-xr-x
dmstats	171.02 KB	-rwxr-xr-x
dosfsck	82.38 KB	-rwxr-xr-x
dosfslabel	38.38 KB	-rwxr-xr-x
dpkg-preconfigure	3.58 KB	-rwxr-xr-x
dpkg-reconfigure	4.38 KB	-rwxr-xr-x
dumpe2fs	30.31 KB	-rwxr-xr-x
e2freefrag	14.3 KB	-rwxr-xr-x
e2fsck	351.84 KB	-rwxr-xr-x
e2image	42.31 KB	-rwxr-xr-x
e2label	102.55 KB	-rwxr-xr-x
e2mmpstatus	30.31 KB	-rwxr-xr-x
e2scrub	7.13 KB	-rwxr-xr-x
e2scrub_all	5.27 KB	-rwxr-xr-x
e2undo	22.3 KB	-rwxr-xr-x
e4crypt	30.38 KB	-rwxr-xr-x
e4defrag	30.3 KB	-rwxr-xr-x
ebtables	219.04 KB	-rwxr-xr-x
ebtables-nft	219.04 KB	-rwxr-xr-x
ebtables-nft-restore	219.04 KB	-rwxr-xr-x
ebtables-nft-save	219.04 KB	-rwxr-xr-x
ebtables-restore	219.04 KB	-rwxr-xr-x
ebtables-save	219.04 KB	-rwxr-xr-x
edquota	83.31 KB	-rwxr-xr-x
era_check	1.33 MB	-rwxr-xr-x
era_dump	1.33 MB	-rwxr-xr-x
era_invalidate	1.33 MB	-rwxr-xr-x
era_restore	1.33 MB	-rwxr-xr-x
ethtool	551.48 KB	-rwxr-xr-x
faillock	14.15 KB	-rwxr-xr-x
fatlabel	38.38 KB	-rwxr-xr-x
fdisk	110.42 KB	-rwxr-xr-x
filefrag	18.32 KB	-rwxr-xr-x
findfs	14.38 KB	-rwxr-xr-x
fixparts	58.48 KB	-rwxr-xr-x
fsadm	23.94 KB	-rwxr-xr-x
fsck	42.42 KB	-rwxr-xr-x
fsck.btrfs	1.16 KB	-rwxr-xr-x
fsck.cramfs	30.44 KB	-rwxr-xr-x
fsck.ext2	351.84 KB	-rwxr-xr-x
fsck.ext3	351.84 KB	-rwxr-xr-x
fsck.ext4	351.84 KB	-rwxr-xr-x
fsck.fat	82.38 KB	-rwxr-xr-x
fsck.minix	54.41 KB	-rwxr-xr-x
fsck.msdos	82.38 KB	-rwxr-xr-x
fsck.vfat	82.38 KB	-rwxr-xr-x
fsck.xfs	1.89 KB	-rwxr-xr-x
fsfreeze	14.38 KB	-rwxr-xr-x
fstab-decode	18.3 KB	-rwxr-xr-x
fstrim	42.38 KB	-rwxr-xr-x
ftpasswd	37.11 KB	-rwxr-xr-x
ftpmail	13.63 KB	-rwxr-xr-x
ftpquota	32.2 KB	-rwxr-xr-x
ftpscrub	23.66 KB	-rwxr-xr-x
ftpshut	14.3 KB	-rwxr-xr-x
ftpstats	12.16 KB	-rwxr-xr-x
gdisk	174.48 KB	-rwxr-xr-x
genl	90.44 KB	-rwxr-xr-x
getcap	14.3 KB	-rwxr-xr-x
getpcaps	14.3 KB	-rwxr-xr-x
getty	55.56 KB	-rwxr-xr-x
groupadd	66.91 KB	-rwxr-xr-x
groupdel	62.73 KB	-rwxr-xr-x
groupmems	54.19 KB	-rwxr-xr-x
groupmod	66.82 KB	-rwxr-xr-x
grpck	58.13 KB	-rwxr-xr-x
grpconv	50.01 KB	-rwxr-xr-x
grpunconv	50.01 KB	-rwxr-xr-x
grub-install	1.15 MB	-rwxr-xr-x
grub-macbless	929.11 KB	-rwxr-xr-x
grub-mkconfig	8.6 KB	-rwxr-xr-x
grub-mkdevicemap	215.7 KB	-rwxr-xr-x
grub-probe	941.36 KB	-rwxr-xr-x
grub-reboot	4.73 KB	-rwxr-xr-x
grub-set-default	3.47 KB	-rwxr-xr-x
halt	1.06 MB	-rwxr-xr-x
hdparm	139.43 KB	-rwxr-xr-x
httxt2dbm	14.3 KB	-rwxr-xr-x
hwclock	50.5 KB	-rwxr-xr-x
iconvconfig	30.4 KB	-rwxr-xr-x
ifconfig	77.17 KB	-rwxr-xr-x
in.proftpd	1.17 MB	-rwxr-xr-x
init	1.76 MB	-rwxr-xr-x
insmod	166.36 KB	-rwxr-xr-x
installkernel	2.6 KB	-rwxr-xr-x
integritysetup	54.07 KB	-rwxr-xr-x
invoke-rc.d	16.12 KB	-rwxr-xr-x
ip	702.05 KB	-rwxr-xr-x
ip6tables	219.04 KB	-rwxr-xr-x
ip6tables-apply	6.89 KB	-rwxr-xr-x
ip6tables-legacy	96.95 KB	-rwxr-xr-x
ip6tables-legacy-restore	96.95 KB	-rwxr-xr-x
ip6tables-legacy-save	96.95 KB	-rwxr-xr-x
ip6tables-nft	219.04 KB	-rwxr-xr-x
ip6tables-nft-restore	219.04 KB	-rwxr-xr-x
ip6tables-nft-save	219.04 KB	-rwxr-xr-x
ip6tables-restore	219.04 KB	-rwxr-xr-x
ip6tables-restore-translate	219.04 KB	-rwxr-xr-x
ip6tables-save	219.04 KB	-rwxr-xr-x
ip6tables-translate	219.04 KB	-rwxr-xr-x
ipmaddr	18.3 KB	-rwxr-xr-x
iptables	219.04 KB	-rwxr-xr-x
iptables-apply	6.89 KB	-rwxr-xr-x
iptables-legacy	96.95 KB	-rwxr-xr-x
iptables-legacy-restore	96.95 KB	-rwxr-xr-x
iptables-legacy-save	96.95 KB	-rwxr-xr-x
iptables-nft	219.04 KB	-rwxr-xr-x
iptables-nft-restore	219.04 KB	-rwxr-xr-x
iptables-nft-save	219.04 KB	-rwxr-xr-x
iptables-restore	219.04 KB	-rwxr-xr-x
iptables-restore-translate	219.04 KB	-rwxr-xr-x
iptables-save	219.04 KB	-rwxr-xr-x
iptables-translate	219.04 KB	-rwxr-xr-x
iptunnel	18.3 KB	-rwxr-xr-x
irqbalance	66.86 KB	-rwxr-xr-x
irqbalance-ui	34.38 KB	-rwxr-xr-x
iscsi-iname	14.3 KB	-rwxr-xr-x
iscsi_discovery	5.17 KB	-rwxr-xr-x
iscsiadm	398.46 KB	-rwxr-xr-x
iscsid	298.55 KB	-rwxr-xr-x
iscsistart	278.56 KB	-rwxr-xr-x
isosize	14.38 KB	-rwxr-xr-x
iucode-tool	58.34 KB	-rwxr-xr-x
iucode_tool	58.34 KB	-rwxr-xr-x
kbdrate	18.16 KB	-rwxr-xr-x
killall5	30.38 KB	-rwxr-xr-x
kpartx	46.16 KB	-rwxr-xr-x
ldattach	26.38 KB	-rwxr-xr-x
ldconfig	387 B	-rwxr-xr-x
ldconfig.real	1.16 MB	-rwxr-xr-x
locale-gen	4.29 KB	-rwxr-xr-x
logrotate	102.24 KB	-rwxr-xr-x
logsave	14.16 KB	-rwxr-xr-x
losetup	70.52 KB	-rwxr-xr-x
lsmod	166.36 KB	-rwxr-xr-x
luksformat	3.32 KB	-rwxr-xr-x
lvchange	2.89 MB	-rwxr-xr-x
lvconvert	2.89 MB	-rwxr-xr-x
lvcreate	2.89 MB	-rwxr-xr-x
lvdisplay	2.89 MB	-rwxr-xr-x
lvextend	2.89 MB	-rwxr-xr-x
lvm	2.89 MB	-rwxr-xr-x
lvmconfig	2.89 MB	-rwxr-xr-x
lvmdiskscan	2.89 MB	-rwxr-xr-x
lvmdump	10.07 KB	-rwxr-xr-x
lvmpolld	236.2 KB	-rwxr-xr-x
lvmsadc	2.89 MB	-rwxr-xr-x
lvmsar	2.89 MB	-rwxr-xr-x
lvreduce	2.89 MB	-rwxr-xr-x
lvremove	2.89 MB	-rwxr-xr-x
lvrename	2.89 MB	-rwxr-xr-x
lvresize	2.89 MB	-rwxr-xr-x
lvs	2.89 MB	-rwxr-xr-x
lvscan	2.89 MB	-rwxr-xr-x
make-bcache	22.38 KB	-rwxr-xr-x
make-ssl-cert	6.65 KB	-rwxr-xr-x
mdadm	601.31 KB	-rwxr-xr-x
mdmon	258.44 KB	-rwxr-xr-x
mii-tool	26.73 KB	-rwxr-xr-x
mkdosfs	50.83 KB	-rwxr-xr-x
mke2fs	130.62 KB	-rwxr-xr-x
mkfs	14.38 KB	-rwxr-xr-x
mkfs.bfs	22.38 KB	-rwxr-xr-x
mkfs.btrfs	471.25 KB	-rwxr-xr-x
mkfs.cramfs	34.32 KB	-rwxr-xr-x
mkfs.ext2	130.62 KB	-rwxr-xr-x
mkfs.ext3	130.62 KB	-rwxr-xr-x
mkfs.ext4	130.62 KB	-rwxr-xr-x
mkfs.fat	50.83 KB	-rwxr-xr-x
mkfs.minix	42.39 KB	-rwxr-xr-x
mkfs.msdos	50.83 KB	-rwxr-xr-x
mkfs.ntfs	70.38 KB	-rwxr-xr-x
mkfs.vfat	50.83 KB	-rwxr-xr-x
mkfs.xfs	382.77 KB	-rwxr-xr-x
mkhomedir_helper	22.17 KB	-rwxr-xr-x
mkinitramfs	12.16 KB	-rwxr-xr-x
mklost+found	14.3 KB	-rwxr-xr-x
mkntfs	70.38 KB	-rwxr-xr-x
mkswap	46.38 KB	-rwxr-xr-x
modinfo	166.36 KB	-rwxr-xr-x
modprobe	166.36 KB	-rwxr-xr-x
mount.fuse	18.3 KB	-rwxr-xr-x
mount.fuse3	18.3 KB	-rwxr-xr-x
mount.lowntfs-3g	114.98 KB	-rwxr-xr-x
mount.ntfs	159.01 KB	-rwxr-xr-x
mount.ntfs-3g	159.01 KB	-rwxr-xr-x
mpathpersist	31.05 KB	-rwxr-xr-x
multipath	34.15 KB	-rwxr-xr-x
multipathd	134.26 KB	-rwxr-xr-x
mysqld	53.02 MB	-rwxr-xr-x
nameif	14.48 KB	-rwxr-xr-x
needrestart	38.73 KB	-rwxr-xr-x
netplan	798 B	-rwxr-xr-x
newusers	74.73 KB	-rwxr-xr-x
nfnl_osf	18.3 KB	-rwxr-xr-x
nft	26.23 KB	-rwxr-xr-x
nologin	14.3 KB	-rwxr-xr-x
ntfsclone	50.38 KB	-rwxr-xr-x
ntfscp	34.38 KB	-rwxr-xr-x
ntfslabel	22.38 KB	-rwxr-xr-x
ntfsresize	62.39 KB	-rwxr-xr-x
ntfsundelete	50.38 KB	-rwxr-xr-x
on_ac_power	3.7 KB	-rwxr-xr-x
overlayroot-chroot	2.45 KB	-rwxr-xr-x
ownership	14.45 KB	-rwxr-xr-x
pam-auth-update	20.5 KB	-rwxr-xr-x
pam_extrausers_chkpwd	22.15 KB	-rwxr-sr-x
pam_extrausers_update	30.15 KB	-rwxr-xr-x
pam_getenv	2.82 KB	-rwxr-xr-x
pam_timestamp_check	14.15 KB	-rwxr-xr-x
parted	86.4 KB	-rwxr-xr-x
partprobe	14.38 KB	-rwxr-xr-x
pdata_tools	1.33 MB	-rwxr-xr-x
phpdismod	7.11 KB	-rwxr-xr-x
phpenmod	7.11 KB	-rwxr-xr-x
phpquery	6.24 KB	-rwxr-xr-x
pivot_root	14.38 KB	-rwxr-xr-x
plipconfig	14.3 KB	-rwxr-xr-x
plymouthd	150.55 KB	-rwxr-xr-x
poweroff	1.06 MB	-rwxr-xr-x
proftpd	1.17 MB	-rwxr-xr-x
proftpd-gencert	1.64 KB	-rwxr-xr-x
pvchange	2.89 MB	-rwxr-xr-x
pvck	2.89 MB	-rwxr-xr-x
pvcreate	2.89 MB	-rwxr-xr-x
pvdisplay	2.89 MB	-rwxr-xr-x
pvmove	2.89 MB	-rwxr-xr-x
pvremove	2.89 MB	-rwxr-xr-x
pvresize	2.89 MB	-rwxr-xr-x
pvs	2.89 MB	-rwxr-xr-x
pvscan	2.89 MB	-rwxr-xr-x
pwck	50.13 KB	-rwxr-xr-x
pwconv	46.01 KB	-rwxr-xr-x
pwunconv	42.01 KB	-rwxr-xr-x
quota_nld	26.41 KB	-rwxr-xr-x
quotacheck	91.34 KB	-rwxr-xr-x
quotaoff	54.78 KB	-rwxr-xr-x
quotaon	54.78 KB	-rwxr-xr-x
quotastats	14.15 KB	-rwxr-xr-x
rarp	32.33 KB	-rwxr-xr-x
readprofile	22.41 KB	-rwxr-xr-x
reboot	1.06 MB	-rwxr-xr-x
remove-shell	1.07 KB	-rwxr-xr-x
repquota	71.41 KB	-rwxr-xr-x
resize2fs	66.3 KB	-rwxr-xr-x
rmmod	166.36 KB	-rwxr-xr-x
rmt	58.57 KB	-rwxr-xr-x
rmt-tar	58.57 KB	-rwxr-xr-x
route	64.27 KB	-rwxr-xr-x
rpc.rquotad	75.18 KB	-rwxr-xr-x
rsyslogd	767.19 KB	-rwxr-xr-x
rtacct	28.31 KB	-rwxr-xr-x
rtcwake	34.38 KB	-rwxr-xr-x
rtmon	90.39 KB	-rwxr-xr-x
runlevel	1.06 MB	-rwxr-xr-x
runuser	54.38 KB	-rwxr-xr-x
service	8.88 KB	-rwxr-xr-x
setcap	14.3 KB	-rwxr-xr-x
setquota	79.38 KB	-rwxr-xr-x
setvesablank	14.23 KB	-rwxr-xr-x
setvtrgb	14.29 KB	-rwxr-xr-x
sfdisk	102.38 KB	-rwxr-xr-x
sgdisk	162.48 KB	-rwxr-xr-x
shadowconfig	885 B	-rwxr-xr-x
shutdown	1.06 MB	-rwxr-xr-x
slattach	36.08 KB	-rwxr-xr-x
split-logfile	2.36 KB	-rwxr-xr-x
sshd	899.7 KB	-rwxr-xr-x
start-stop-daemon	47.35 KB	-rwxr-xr-x
sudo_logsrvd	200.1 KB	-rwxr-xr-x
sudo_sendlog	107.34 KB	-rwxr-xr-x
sulogin	42.38 KB	-rwxr-xr-x
swaplabel	18.38 KB	-rwxr-xr-x
swapoff	22.38 KB	-rwxr-xr-x
swapon	42.38 KB	-rwxr-xr-x
switch_root	22.38 KB	-rwxr-xr-x
sysctl	30.23 KB	-rwxr-xr-x
tarcat	936 B	-rwxr-xr-x
tc	614.08 KB	-rwxr-xr-x
telinit	1.06 MB	-rwxr-xr-x
thermald	554.6 KB	-rwxr-xr-x
thin_check	1.33 MB	-rwxr-xr-x
thin_delta	1.33 MB	-rwxr-xr-x
thin_dump	1.33 MB	-rwxr-xr-x
thin_ls	1.33 MB	-rwxr-xr-x
thin_metadata_size	1.33 MB	-rwxr-xr-x
thin_repair	1.33 MB	-rwxr-xr-x
thin_restore	1.33 MB	-rwxr-xr-x
thin_rmap	1.33 MB	-rwxr-xr-x
thin_trim	1.33 MB	-rwxr-xr-x
tipc	90.44 KB	-rwxr-xr-x
tune2fs	102.55 KB	-rwxr-xr-x
tzconfig	106 B	-rwxr-xr-x
u-d-c-print-pci-ids	517 B	-rwxr-xr-x
ufw	4.82 KB	-rwxr-xr-x
umount.udisks2	14.3 KB	-rwxr-xr-x
unix_chkpwd	26.15 KB	-rwxr-sr-x
unix_update	30.15 KB	-rwxr-xr-x
update-ca-certificates	5.29 KB	-rwxr-xr-x
update-grub	64 B	-rwxr-xr-x
update-grub2	64 B	-rwxr-xr-x
update-info-dir	1.66 KB	-rwxr-xr-x
update-initramfs	6.74 KB	-rwxr-xr-x
update-locale	2.99 KB	-rwxr-xr-x
update-mime	9.39 KB	-rwxr-xr-x
update-passwd	34.56 KB	-rwxr-xr-x
update-pciids	1.71 KB	-rwxr-xr-x
update-rc.d	16.92 KB	-rwxr-xr-x
update-secureboot-policy	7.43 KB	-rwxr-xr-x
update-shells	3.72 KB	-rwxr-xr-x
usb_modeswitch	59.66 KB	-rwxr-xr-x
usb_modeswitch_dispatcher	26.78 KB	-rwxr-xr-x
usbmuxd	86.6 KB	-rwxr-xr-x
useradd	127.66 KB	-rwxr-xr-x
userdel	86.85 KB	-rwxr-xr-x
usermod	123.46 KB	-rwxr-xr-x
uuidd	30.85 KB	-rwxr-xr-x
validlocale	1.73 KB	-rwxr-xr-x
vcstime	14.15 KB	-rwxr-xr-x
vdpa	30.56 KB	-rwxr-xr-x
veritysetup	43.76 KB	-rwxr-xr-x
vgcfgbackup	2.89 MB	-rwxr-xr-x
vgcfgrestore	2.89 MB	-rwxr-xr-x
vgchange	2.89 MB	-rwxr-xr-x
vgck	2.89 MB	-rwxr-xr-x
vgconvert	2.89 MB	-rwxr-xr-x
vgcreate	2.89 MB	-rwxr-xr-x
vgdisplay	2.89 MB	-rwxr-xr-x
vgexport	2.89 MB	-rwxr-xr-x
vgextend	2.89 MB	-rwxr-xr-x
vgimport	2.89 MB	-rwxr-xr-x
vgimportclone	2.89 MB	-rwxr-xr-x
vgmerge	2.89 MB	-rwxr-xr-x
vgmknodes	2.89 MB	-rwxr-xr-x
vgreduce	2.89 MB	-rwxr-xr-x
vgremove	2.89 MB	-rwxr-xr-x
vgrename	2.89 MB	-rwxr-xr-x
vgs	2.89 MB	-rwxr-xr-x
vgscan	2.89 MB	-rwxr-xr-x
vgsplit	2.89 MB	-rwxr-xr-x
vigr	56.53 KB	-rwxr-xr-x
vipw	56.53 KB	-rwxr-xr-x
visudo	219.79 KB	-rwxr-xr-x
vpddecode	14.58 KB	-rwxr-xr-x
warnquota	87.3 KB	-rwxr-xr-x
wipefs	38.38 KB	-rwxr-xr-x
xfs_admin	1.37 KB	-rwxr-xr-x
xfs_bmap	695 B	-rwxr-xr-x
xfs_copy	82.48 KB	-rwxr-xr-x
xfs_db	652.44 KB	-rwxr-xr-x
xfs_estimate	14.16 KB	-rwxr-xr-x
xfs_freeze	800 B	-rwxr-xr-x
xfs_fsr	42.18 KB	-rwxr-xr-x
xfs_growfs	38.28 KB	-rwxr-xr-x
xfs_info	1.26 KB	-rwxr-xr-x
xfs_io	199.55 KB	-rwxr-xr-x
xfs_logprint	78.33 KB	-rwxr-xr-x
xfs_mdrestore	26.17 KB	-rwxr-xr-x
xfs_metadump	782 B	-rwxr-xr-x
xfs_mkfile	1.02 KB	-rwxr-xr-x
xfs_ncheck	685 B	-rwxr-xr-x
xfs_quota	90.16 KB	-rwxr-xr-x
xfs_repair	599.38 KB	-rwxr-xr-x
xfs_rtcp	18.15 KB	-rwxr-xr-x
xfs_scrub	106.27 KB	-rwxr-xr-x
xfs_scrub_all	5.87 KB	-rwxr-xr-x
xfs_spaceman	42.3 KB	-rwxr-xr-x
xqmstats	14.15 KB	-rwxr-xr-x
xtables-legacy-multi	96.95 KB	-rwxr-xr-x
xtables-monitor	219.04 KB	-rwxr-xr-x
xtables-nft-multi	219.04 KB	-rwxr-xr-x
zerofree	14.15 KB	-rwxr-xr-x
zic	62.32 KB	-rwxr-xr-x
zramctl	54.52 KB	-rwxr-xr-x

Code Editor : ftpquota

#!/usr/bin/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;
}

# -------------------------------------------------------------------------

${this.title}

Code Editor : ftpquota