| Current File : //usr/bin/ftpmail |
#!/usr/bin/perl
# ---------------------------------------------------------------------------
# Copyright (C) 2008-2013 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.
#
# $Id: ftpmail,v 1.8 2013-10-13 22:34:14 castaglia Exp $
# ---------------------------------------------------------------------------
use strict;
use File::Basename qw(basename);
use Getopt::Long;
use Mail::Sendmail;
use MIME::Base64 qw(encode_base64);
use Time::HiRes qw(usleep);
my $program = basename($0);
my $opts = {};
GetOptions($opts, 'attach-file', 'fifo=s', 'from=s', 'help', 'ignore-users=s',
'log=s', 'recipient=s@', 'upload-recipient=s@', 'download-recipient=s@',
'sleep=s', 'smtp-server=s', 'subject=s', 'watch-users=s', 'auth=s');
if ($opts->{help}) {
usage();
exit 0;
}
unless ($opts->{fifo}) {
print STDERR "$program: missing required --fifo parameter\n";
exit 1;
}
my $fifo = $opts->{fifo};
unless ($opts->{from}) {
print STDERR "$program: missing required --from parameter\n";
exit 1;
}
my $from = $opts->{from};
unless ($opts->{recipient} ||
$opts->{'upload-recipient'}) {
print STDERR "$program: missing required --recipient (or --upload-recipient) parameter\n";
exit 1;
}
my $upload_recipients = $opts->{recipient};
# The --upload-recipient list takes precedence over the (deprecated)
# --recipient list.
if (defined($opts->{'upload-recipient'})) {
$upload_recipients = $opts->{'upload-recipient'};
}
my $download_recipients = undef;
if (defined($opts->{'download-recipient'})) {
$download_recipients = $opts->{'download-recipient'};
}
unless ($opts->{'smtp-server'}) {
print STDERR "$program: missing required --smtp-server parameter\n";
exit 1;
}
my $smtp_server = $opts->{'smtp-server'};
my $smtp_auth;
if ($opts->{'auth'}) {
eval { $smtp_auth = get_auth_info($opts->{'auth'}) };
if ($@) {
my $ex = $@;
print STDERR "$program: unable to obtain SMTP auth info: $ex\n";
exit 1;
}
}
my $delay = 0.5;
if ($opts->{sleep}) {
$delay = $opts->{sleep};
}
my $fifoh;
if (open($fifoh, "< $fifo")) {
while (1) {
my $line = <$fifoh>;
if ($line) {
chomp($line);
if ($line =~ /^(\S+\s+\S+\s+\d+\s+\d+:\d+:\d+\s+\d+)\s+(\d+)\s+(.*?)\s+(\d+)\s+(.*?)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(.*?)\s+.*?(\S+)$/o) {
my $curr_time = $1;
my $xfer_nsecs = $2;
my $client = $3;
my $nbytes = $4;
# Note that any spaces or control characters will be replaced in this
# path with underscores. This can make finding the actual file, as for
# attachments, rather difficult; we have to test to find the difference
# between a real underscore in the name, and a substituted underscore.
my $path = $5;
unless (-e $path) {
# Perform a quick-and-dirty check, on the assumption that all of the
# underscores in the given path are actually spaces. If a
# combination of underscores and spaces appears in the real file,
# we won't detect that here.
my $alt_path = $path;
$alt_path =~ s/_/ /g;
if (-e $alt_path) {
$path = $alt_path;
}
}
my $xfer_type = $6;
my $action_flag = $7;
my $xfer_direction = $8;
my $access_mode = $9;
my $user_name = $10;
my $completion_status = $11;
my $send_email = 0;
if ($xfer_direction eq 'i') {
$send_email = 1;
}
if (defined($download_recipients)) {
# If we have a list of download email recipients, it means we should
# send emails for downloads, too.
if ($xfer_direction eq 'o') {
$send_email = 1;
}
}
if ($send_email) {
# First, check for any specific --watch-users filter. If configured,
# and if the user name does NOT match the --watch-users filter, then
# don't send email. Otherwise, check for an --ignore-users filter,
# and see if the user matches that ignore filter.
if ($opts->{'watch-users'}) {
if ($user_name !~ /$opts->{'watch-users'}/) {
$send_email = 0;
}
} elsif ($opts->{'ignore-users'}) {
if ($user_name =~ /$opts->{'ignore-users'}/) {
$send_email = 0;
}
}
}
if ($send_email) {
send_email({
timestamp => $curr_time,
duration => $xfer_nsecs,
client => $client,
size => $nbytes,
file => $path,
transfer_type => $xfer_type,
auth_mode => $access_mode,
user => $user_name,
status => $completion_status,
direction => $xfer_direction,
});
}
}
if ($opts->{log}) {
# Note: since this opens, writes, then closes the log file for every
# write, it will interact with log rotation scripts MUCH better than
# proftpd by itself. Just one of the small benefits.
my $log_file = $opts->{log};
my $logfh;
if (open($logfh, ">> $log_file")) {
print $logfh "$line\n";
unless (close($logfh)) {
print STDERR "$program: error writing to log file '$log_file': $!\n";
}
} else {
print STDERR "$program: error opening log file '$log_file': $!\n";
}
}
} else {
# No input at this time. Sleep for half a second (or less) and check
# again.
usleep($delay * 1000000);
}
}
close($fifoh);
} else {
die "$program: unable to read FIFO '$fifo': $!\n";
}
sub get_auth_info {
my $path = shift;
my $info = {};
if (open(my $fh, "< $path")) {
while (my $line = <$fh>) {
chomp($line);
# Skip comments and blank lines
if ($line =~ /^(\s+)?#/) {
next;
}
if ($line =~ /^\s+$/) {
next;
}
if ($line =~ /^(\s+)?(\S+)(\s+)?=(\s+)?(.*)$/) {
my $key = $2;
my $val = $5;
# Trim off comments after the value, if any
$val =~ s/(\s*#.*)?$//;
# Ignore any keys other than 'user' and 'password'.
if (lc($key) eq 'user') {
$info->{'user'} = $val;
} elsif (lc($key) eq 'password' ||
lc($key) eq 'pass') {
$info->{'password'} = $val;
}
}
}
close($fh);
} else {
die("Can't read '$path': $!\n");
}
# Make sure that we have the required values
my $reqs = [qw(user password)];
foreach my $req (@$reqs) {
unless (exists($info->{$req})) {
die("Missing required '$req' value\n");
}
}
return $info;
}
sub send_email {
my $transfer_info = shift;
my $file = $transfer_info->{file};
my $file_str = basename($file);
my $transferred = 'uploaded';
if ($transfer_info->{direction} eq 'o') {
$transferred = 'downloaded';
}
my $subject = "User '$transfer_info->{user}' $transferred file '$file_str' via FTP";
if ($opts->{subject}) {
$subject = $opts->{subject};
}
my $bytes_str = "bytes";
if ($transfer_info->{size} == 1) {
$bytes_str = "byte";
}
my $status = "Completed";
if ($transfer_info->{status} eq 'i') {
$status = "Incomplete";
}
my $secs_str = "secs";
if ($transfer_info->{duration} == 1) {
$secs_str = "sec";
}
my $type_str = "Binary";
if ($transfer_info->{transfer_type} eq 'a') {
$type_str = "ASCII";
}
my $attached = "";
if ($opts->{'attach-file'} &&
-e $file) {
$attached = "(attached)";
}
my $text = <<EOT;
File just uploaded via FTP:
User: $transfer_info->{user}
Client: $transfer_info->{client}
File: $file $attached
Size: $transfer_info->{size} $bytes_str
At: $transfer_info->{timestamp}
Duration: $transfer_info->{duration} $secs_str
Status: $status
Transfer type: $type_str
Cheers,
--$program
EOT
my $email_info = {
smtp => $smtp_server,
From => $from,
Subject => $subject,
};
if ($transfer_info->{direction} eq 'i') {
$email_info->{To} = join(', ', @$upload_recipients);
} elsif ($transfer_info->{direction} eq 'o') {
$email_info->{To} = join(', ', @$download_recipients);
}
if ($opts->{'auth'}) {
$email_info->{'auth'} = $smtp_auth;
}
if ($opts->{'attach-file'}) {
if (-e $file) {
$email_info->{'MIME-Version'} = '1.0';
my $boundary = '====' . time() . '====';
$email_info->{'Content-Type'} = "multipart/mixed; boundary=\"$boundary\"";
$boundary = '--' . $boundary;
$email_info->{Body} .= "$boundary\n";
$email_info->{Body} .= "Content-Type: text/plain; charset=\"iso-8859-1\"\n";
$email_info->{Body} .= "Content-Transfer-Encoding: quoted-printable\n\n";
$email_info->{Body} .= "$text\n";
if (open(my $fh, "< $file")) {
binmode($fh);
# Note: this reads the entire file into memory, and can fail if
# the file is too big.
local $/;
my $attach;
while (my $data = <$fh>) {
$attach .= $data;
}
close($fh);
$email_info->{Body} .= "$boundary\n";
$email_info->{Body} .= "Content-Disposition: attachment; filename=\"$file\"\n";
if ($transfer_info->{transfer_type} eq 'a') {
$email_info->{Body} .= "Content-Type: text/plain; charset=\"iso-8859-1\"\n\n";
$email_info->{Body} .= $attach;
} else {
$email_info->{Body} .= "Content-Type: application/octet-stream\n";
$email_info->{Body} .= "Content-Transfer-Encoding: base64\n\n";
$email_info->{Body} .= encode_base64($attach);
}
$email_info->{Body} .= "\n";
} else {
my $timestamp = scalar(localtime());
print STDERR "$program: $timestamp: error reading file '$file' for attaching: $!\n";
}
} else {
# Couldn't find/access the uploaded file on the filesystem. This usually
# indicates either a permissions problem, or a munged filename.
#
# XXX Need to handle this better.
}
} else {
$email_info->{Body} = $text;
}
my $res = Mail::Sendmail::sendmail(%$email_info);
unless ($res) {
my $timestamp = scalar(localtime());
print STDERR "$program: $timestamp: error sending email: $Mail::Sendmail::error\n";
}
}
sub usage {
print <<EOH;
usage: $program [--help] [--fifo \$path] [--from \$addr] [--log \$path]
[--recipient \$addrs] [--upload-recipient \$addrs]
[--download-recipient \$addrs] [--subject \$string] [--smtp-server \$addr]
[--attach-file] [--ignore-users \$regex | --watch-users \$regex]
The purpose of this script is to monitor the TransferLog written by proftpd
for uploaded files. Whenever a file is uploaded by a user, an email will be
sent to the specified recipients. In the email there will be the timestamp,
the name of the user who uploaded the file, the path to the uploaded file, the
size of the uploaded file, and the time it took to upload.
Command-line options:
--attach-file If used, this will cause a copy of the uploaded file
to be included, as an attachment, in the generated
email.
--auth \$path Configures the path to a file containing SMTP
authentication information.
The configured file should look like this:
user = \$user
password = \$password
--fifo \$path Indicates the path to the FIFO to which proftpd is
writing its TransferLog. That is, this is the path
that you used for the TransferLog directive in your
proftpd.conf. This parameter is REQUIRED.
--from \$addr Specifies the email address to use in the From header.
This parameter is REQUIRED.
--help Displays this message.
--ignore-users \$regex
Specifies a Perl regular expression. If the uploading
user name matches this regular expression, then NO
email notification is sent; otherwise, an email is
sent.
--log \$path Since this script reads the TransferLog using FIFOs,
the actual TransferLog file is not written by default.
Use this option to write the normal TransferLog file,
in addition to watching for uploads.
--recipient \$addr Specifies an email address to which to send an email
notification of the upload. This option can be
used multiple times to specify multiple recipients.
AT LEAST ONE recipient is REQUIRED.
--upload-recipient Same as --recipient.
--download-recipient \$addr
Specifies an email address to which to send an email
notification of the B<download>. This option can be
used multiple times to specify multiple recipients.
If this option is specified, then C<ftpmail> will
watch for FTP downloads as well as uploads.
--smtp-server \$addr Specifies the SMTP server to which to send the email.
This parameter is REQUIRED.
--subject \$string Specify a custom Subject header for the email sent.
The default Subject is:
User '\$user' uploaded file '\$file' via FTP
--watch-users \$regex Specifies a Perl regular expression. If the uploading
user name matches this regular expression, then an
email notification is sent; otherwise, no email is
sent.
EOH
}