#!/usr/bin/perl -w

require 5;
use strict;
use Getopt::Std;
use File::Find;
use vars qw(%opts @mailboxen $file $access $mod $user $unread $i $j @passwd $name @oldusers $mailbytes $mailsize $homebytes $homesize @sorted @units @multipliers $limit $outputstring $length);

getopts('ho:al:', \%opts);

sub usage(){
    print <<EOF;
Usage: $0 [options]
Example: $0 -om -l m=10m
Synopsis: Checks the age and size of all mailboxen on the system, to help you isolate dead accounts, or disk hogs.

-h : Displays this help screen.
-o : Order of results[1].
-a : List all users, not just those with unread mail.
-l : Limit. Format is 'F=LLU', comma seperated, where 'F' is the field[2], 'L' the limit, and 'U' the unit[3].
     Example: $0 -l u=1w,m=5m
(This lists all users with unread mail who haven't checked there mailbox in over a week, and which is over 5 megabytes in size)

[1]: Can be ordered by 'a' (alphabetic), 'u' (time mailbox unread), 'm' (mailbox size), 'h' (home dir size) or 't' (total disk usage).
[2]: Field can be any listed above, except 'a'.
[3]: Unit is the first letter of whichever unit you wish to use.
     i.e. for times: 's' (second), 'm' (minute), 'h' (hour), 'd' (day), 'w' (week) or 'y' (year).
     or for memory: 'b' (bytes), 'k' (Kb), 'm' (Mb) or 'g' (Gb).

EOF
    exit;
}
<READMORE>
if ($opts{'h'}){
    usage();
}

sub subdivide ($$\@\@$) {

    my ($ordinal, $unit, $result);
    my $time = shift;
    my $depth = shift;
    my $mult_ref = shift;
    my @multipliers = @$mult_ref;
    my $unit_ref = shift;
    my @Units = @$unit_ref;
    my $pluralise = shift;

    my $k;
    my $l = 1;
    for ($k=0; $k<@units; $k++) {

        if ($k == @multipliers || $time < $l * $multipliers[$k]) {
            $ordinal = int ( $time / $l );
            $unit = $units[$k];
            $time -= $ordinal * $l;
            last;
        }

        $l *= $multipliers[$k];
    }

    if ($pluralise && ($ordinal > 1)) {
        $unit .= 's';
    }

    $result = "$ordinal $unit";

    if ($depth && $time) {
        $result .= ", " . subdivide($time, --$depth, \@multipliers, \@units, $pluralise);
    }

    return $result;
}

sub multiplyup ($\@\@) {

    my $time = shift;
    my $result = substr ($time, 0, -1);
    my $unit = substr ($time, -1, 1);
    my $mult_ref = shift;
    my @multipliers = @$mult_ref;
    my $unit_ref = shift;
    my @Units = @$unit_ref;

    my $k;
    for ($k=0; $k<@units; $k++) {

        if ($unit eq $units[$k]) {
            last;
        }

        $result *= $multipliers[$k];
    }

    return $result;
}

open PASSWD, "/etc/passwd" or die "Could now open /etc/passwd, wtf?";
@passwd = <PASSWD>;

opendir MAIL, "/var/spool/mail" or die "Could not open /var/spool/mail, wtf?";
@mailboxen = grep { ! /^\..*$/  } readdir MAIL;
closedir MAIL;

my $longestname = 0;

for ($i=0; $i<@mailboxen; $i++) {

    $user = $mailboxen[$i];
    $file = "/var/spool/mail/$user";

    $access = (-A $file);
    $mod = (-M $file);

    if ($access > $mod || $opts{'a'}) {

        @multipliers = (60, 60, 24, 7, 365/7);
        @units = ('second', 'minute', 'hour', 'day', 'week', 'year');
        $unread = $access > $mod ? subdivide(int($access * 86400), 1, @multipliers, @units, 1) : "no time";

        for ($j=0; $j<@passwd; $j++) {
            if ($passwd[$j] =~ /^$user:[^:]+:[^:]+:[^:]+:([^,:]+).+$/) {
                $name = $1;
                $name =~ s/\\//;
                $name =~ s/(\b)(\w+)/$1\u\L$2/g;
                last;
            }
        }

        if (length($name) > $longestname) { $longestname = length($name) }

        @multipliers = (1024, 1024, 1024);
        @units = ('bytes', 'Kb', 'Mb', 'Gb');
        $mailbytes = -s $file;
        $mailsize = subdivide($mailbytes, 0, @multipliers, @units, 0);

        $homebytes = 0;
        find sub { $homebytes += -s }, "/home/$user";
        $homesize = subdivide($homebytes, 0, @multipliers, @units, 0);

        push @oldusers, { user      => "$user",
                          unread    => "$unread",
                          name      => "$name",
                          access    => $access > $mod ? "$access" : 0,
                          mailbytes => "$mailbytes",
                          mailsize  => "$mailsize",
                          homebytes => "$homebytes",
                          homesize  => "$homesize" };

    }
}

if ( $opts{'l'} ) {
    my %limits = split /[,=]/, $opts{'l'};

    if ( $limits{'u'} ) {
        @multipliers = (60, 60, 24, 7, 365/7);
        @units = ('s', 'm', 'h', 'd', 'w', 'y');
        $limit = multiplyup($limits{'u'}, @multipliers, @units) / 86400;
        @oldusers = grep { $_->{access} > $limit } @oldusers;
    }

    if ( $limits{'m'} ) {
        @multipliers = (1024, 1024, 1024);
        @units = ('b', 'k', 'm', 'g');
        $limit = multiplyup($limits{'m'}, @multipliers, @units);
        @oldusers = grep { $_->{mailbytes} > $limit } @oldusers;
    }

    if ( $limits{'h'} ) {
        @multipliers = (1024, 1024, 1024);
        @units = ('b', 'k', 'm', 'g');
        $limit = multiplyup($limits{'h'}, @multipliers, @units);
        @oldusers = grep { $_->{homebytes} > $limit } @oldusers;
    }

    if ( $limits{'t'} ) {
        @multipliers = (1024, 1024, 1024);
        @units = ('b', 'k', 'm', 'g');
        $limit = multiplyup($limits{'t'}, @multipliers, @units);
        @oldusers = grep { $_->{mailbytes} + $_->{homebytes} > $limit } @oldusers;
    }

}


if ( !defined( $opts{'o'} ) || $opts{'o'} eq 'u') {
    @sorted = sort { $b->{access} <=> $a->{access} } @oldusers;
}
elsif ($opts{'o'} eq 'm') {
    @sorted = sort { $b->{mailbytes} <=> $a->{mailbytes} } @oldusers;
}
elsif ($opts{'o'} eq 'h') {
    @sorted = sort { $b->{homebytes} <=> $a->{homebytes} } @oldusers;
}
elsif ($opts{'o'} eq 't') {
    @sorted = sort { $b->{mailbytes} + $b->{homebytes} <=> $a->{mailbytes} + $a->{homebytes} } @oldusers;
}
elsif ($opts{'o'} eq 'a') {
    @sorted = sort { $a->{name} cmp $b->{name} } @oldusers;
}
else {
    warn "Bad ordering option, returning results unordered.";
}

print "Name" . ' ' x ($longestname+1) ."Unread For              Mailbox Size   Home Dir Size\n";

for ($i=0; $i<@sorted; $i++) {
    $outputstring = "$sorted[$i]{name} " . '-' x $longestname;
    $outputstring = substr($outputstring, 0, $longestname + 4);

    $outputstring .= " $sorted[$i]{unread} ----------------------";
    $outputstring = substr($outputstring, 0, $longestname + 40 - length($sorted[$i]{mailsize}));

    $outputstring .= " $sorted[$i]{mailsize} ------------";
    $outputstring = substr($outputstring, 0, $longestname + 56 - length($sorted[$i]{homesize}));

    $outputstring .= " $sorted[$i]{homesize}\n";

    print $outputstring;
}

exit;