You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2235 lines
78 KiB
2235 lines
78 KiB
#!/usr/bin/perl -w |
|
############################################################################## |
|
## sendEmail |
|
## Written by: Brandon Zehm <caspian@dotconf.net> |
|
## |
|
## License: |
|
## sendEmail (hereafter referred to as "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. |
|
## When redistributing modified versions of this source code it is recommended |
|
## that that this disclaimer and the above coder's names are included in the |
|
## modified code. |
|
## |
|
## Disclaimer: |
|
## This program is provided with no warranty of any kind, either expressed or |
|
## implied. It is the responsibility of the user (you) to fully research and |
|
## comprehend the usage of this program. As with any tool, it can be misused, |
|
## either intentionally (you're a vandal) or unintentionally (you're a moron). |
|
## THE AUTHOR(S) IS(ARE) NOT RESPONSIBLE FOR ANYTHING YOU DO WITH THIS PROGRAM |
|
## or anything that happens because of your use (or misuse) of this program, |
|
## including but not limited to anything you, your lawyers, or anyone else |
|
## can dream up. And now, a relevant quote directly from the GPL: |
|
## |
|
## NO WARRANTY |
|
## |
|
## 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY |
|
## FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN |
|
## OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES |
|
## PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED |
|
## OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
|
## MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS |
|
## TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE |
|
## PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, |
|
## REPAIR OR CORRECTION. |
|
## |
|
############################################################################## |
|
use strict; |
|
use IO::Socket; |
|
|
|
|
|
######################## |
|
## Global Variables ## |
|
######################## |
|
|
|
my %conf = ( |
|
## General |
|
"programName" => $0, ## The name of this program |
|
"version" => '1.56', ## The version of this program |
|
"authorName" => 'Brandon Zehm', ## Author's Name |
|
"authorEmail" => 'caspian@dotconf.net', ## Author's Email Address |
|
"timezone" => '+0000', ## We always use +0000 for the time zone |
|
"hostname" => 'changeme', ## Used in printmsg() for all output (is updated later in the script). |
|
"debug" => 0, ## Default debug level |
|
"error" => '', ## Error messages will often be stored here |
|
|
|
## Logging |
|
"stdout" => 1, |
|
"logging" => 0, ## If this is true the printmsg function prints to the log file |
|
"logFile" => '', ## If this is specified (form the command line via -l) this file will be used for logging. |
|
|
|
## Network |
|
"server" => 'localhost', ## Default SMTP server |
|
"port" => 25, ## Default port |
|
"bindaddr" => '', ## Default local bind address |
|
"alarm" => '', ## Default timeout for connects and reads, this gets set from $opt{'timeout'} |
|
"tls_client" => 0, ## If TLS is supported by the client (us) |
|
"tls_server" => 0, ## If TLS is supported by the remote SMTP server |
|
|
|
## Email |
|
"delimiter" => "----MIME delimiter for sendEmail-" ## MIME Delimiter |
|
. rand(1000000), ## Add some randomness to the delimiter |
|
"Message-ID" => rand(1000000) . "-sendEmail", ## Message-ID for email header |
|
|
|
); |
|
|
|
|
|
## This hash stores the options passed on the command line via the -o option. |
|
my %opt = ( |
|
## Addressing |
|
"reply-to" => '', ## Reply-To field |
|
|
|
## Message |
|
"message-file" => '', ## File to read message body from |
|
"message-header" => '', ## Additional email header line(s) |
|
"message-format" => 'normal', ## If "raw" is specified the message is sent unmodified |
|
"message-charset" => 'iso-8859-1', ## Message character-set |
|
"message-content-type" => 'auto', ## auto, text, html or an actual string to put into the content-type header. |
|
|
|
## Network |
|
"timeout" => 60, ## Default timeout for connects and reads, this is copied to $conf{'alarm'} later. |
|
"fqdn" => 'changeme', ## FQDN of this machine, used during SMTP communication (is updated later in the script). |
|
|
|
## eSMTP |
|
"username" => '', ## Username used in SMTP Auth |
|
"password" => '', ## Password used in SMTP Auth |
|
"tls" => 'auto', ## Enable or disable TLS support. Options: auto, yes, no |
|
|
|
); |
|
|
|
## More variables used later in the program |
|
my $SERVER; |
|
my $CRLF = "\015\012"; |
|
my $subject = ''; |
|
my $header = ''; |
|
my $message = ''; |
|
my $from = ''; |
|
my @to = (); |
|
my @cc = (); |
|
my @bcc = (); |
|
my @attachments = (); |
|
my @attachments_names = (); |
|
|
|
## For printing colors to the console |
|
my ${colorRed} = "\033[31;1m"; |
|
my ${colorGreen} = "\033[32;1m"; |
|
my ${colorCyan} = "\033[36;1m"; |
|
my ${colorWhite} = "\033[37;1m"; |
|
my ${colorNormal} = "\033[m"; |
|
my ${colorBold} = "\033[1m"; |
|
my ${colorNoBold} = "\033[0m"; |
|
|
|
## Don't use shell escape codes on Windows systems |
|
if ($^O =~ /win/i) { |
|
${colorRed} = ${colorGreen} = ${colorCyan} = ${colorWhite} = ${colorNormal} = ${colorBold} = ${colorNoBold} = ""; |
|
} |
|
|
|
## Load IO::Socket::SSL if it's available |
|
eval { require IO::Socket::SSL; }; |
|
if ($@) { $conf{'tls_client'} = 0; } |
|
else { $conf{'tls_client'} = 1; } |
|
|
|
|
|
|
|
|
|
|
|
|
|
############################# |
|
## ## |
|
## FUNCTIONS ## |
|
## ## |
|
############################# |
|
|
|
|
|
|
|
|
|
|
|
############################################################################################### |
|
## Function: initialize () |
|
## |
|
## Does all the script startup jibberish. |
|
## |
|
############################################################################################### |
|
sub initialize { |
|
|
|
## Set STDOUT to flush immediatly after each print |
|
$| = 1; |
|
|
|
## Intercept signals |
|
$SIG{'QUIT'} = sub { quit("EXITING: Received SIG$_[0]", 1); }; |
|
$SIG{'INT'} = sub { quit("EXITING: Received SIG$_[0]", 1); }; |
|
$SIG{'KILL'} = sub { quit("EXITING: Received SIG$_[0]", 1); }; |
|
$SIG{'TERM'} = sub { quit("EXITING: Received SIG$_[0]", 1); }; |
|
|
|
## ALARM and HUP signals are not supported in Win32 |
|
unless ($^O =~ /win/i) { |
|
$SIG{'HUP'} = sub { quit("EXITING: Received SIG$_[0]", 1); }; |
|
$SIG{'ALRM'} = sub { quit("EXITING: Received SIG$_[0]", 1); }; |
|
} |
|
|
|
## Fixup $conf{'programName'} |
|
$conf{'programName'} =~ s/(.)*[\/,\\]//; |
|
$0 = $conf{'programName'} . " " . join(" ", @ARGV); |
|
|
|
## Fixup $conf{'hostname'} and $opt{'fqdn'} |
|
if ($opt{'fqdn'} eq 'changeme') { $opt{'fqdn'} = get_hostname(1); } |
|
if ($conf{'hostname'} eq 'changeme') { $conf{'hostname'} = $opt{'fqdn'}; $conf{'hostname'} =~ s/\..*//; } |
|
|
|
return(1); |
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
############################################################################################### |
|
## Function: processCommandLine () |
|
## |
|
## Processes command line storing important data in global vars (usually %conf) |
|
## |
|
############################################################################################### |
|
sub processCommandLine { |
|
|
|
|
|
############################ |
|
## Process command line ## |
|
############################ |
|
|
|
my @ARGS = @ARGV; ## This is so later we can re-parse the command line args later if we need to |
|
my $numargv = @ARGS; |
|
help() unless ($numargv); |
|
my $counter = 0; |
|
|
|
for ($counter = 0; $counter < $numargv; $counter++) { |
|
|
|
if ($ARGS[$counter] =~ /^-h$/i) { ## Help ## |
|
help(); |
|
} |
|
|
|
elsif ($ARGS[$counter] eq "") { ## Ignore null arguments |
|
## Do nothing |
|
} |
|
|
|
elsif ($ARGS[$counter] =~ /^--help/) { ## Topical Help ## |
|
$counter++; |
|
if ($ARGS[$counter] && $ARGS[$counter] !~ /^-/) { |
|
helpTopic($ARGS[$counter]); |
|
} |
|
else { |
|
help(); |
|
} |
|
} |
|
|
|
elsif ($ARGS[$counter] =~ /^-o$/i) { ## Options specified with -o ## |
|
$counter++; |
|
## Loop through each option passed after the -o |
|
while ($ARGS[$counter] && $ARGS[$counter] !~ /^-/) { |
|
|
|
if ($ARGS[$counter] !~ /(\S+)=(\S.*)/) { |
|
printmsg("WARNING => Name/Value pair [$ARGS[$counter]] is not properly formatted", 0); |
|
printmsg("WARNING => Arguments proceeding -o should be in the form of \"name=value\"", 0); |
|
} |
|
else { |
|
if (exists($opt{$1})) { |
|
if ($1 eq 'message-header') { |
|
$opt{$1} .= $2 . $CRLF; |
|
} |
|
else { |
|
$opt{$1} = $2; |
|
} |
|
printmsg("DEBUG => Assigned \$opt{} key/value: $1 => $2", 3); |
|
} |
|
else { |
|
printmsg("WARNING => Name/Value pair [$ARGS[$counter]] will be ignored: unknown key [$1]", 0); |
|
printmsg("HINT => Try the --help option to find valid command line arguments", 1); |
|
} |
|
} |
|
$counter++; |
|
} $counter--; |
|
} |
|
|
|
elsif ($ARGS[$counter] =~ /^-f$/) { ## From ## |
|
$counter++; |
|
if ($ARGS[$counter] && $ARGS[$counter] !~ /^-/) { $from = $ARGS[$counter]; } |
|
else { printmsg("WARNING => The argument after -f was not an email address!", 0); $counter--; } |
|
} |
|
|
|
elsif ($ARGS[$counter] =~ /^-t$/) { ## To ## |
|
$counter++; |
|
while ($ARGS[$counter] && ($ARGS[$counter] !~ /^-/)) { |
|
if ($ARGS[$counter] =~ /[;,]/) { |
|
push (@to, split(/[;,]/, $ARGS[$counter])); |
|
} |
|
else { |
|
push (@to,$ARGS[$counter]); |
|
} |
|
$counter++; |
|
} $counter--; |
|
} |
|
|
|
elsif ($ARGS[$counter] =~ /^-cc$/) { ## Cc ## |
|
$counter++; |
|
while ($ARGS[$counter] && ($ARGS[$counter] !~ /^-/)) { |
|
if ($ARGS[$counter] =~ /[;,]/) { |
|
push (@cc, split(/[;,]/, $ARGS[$counter])); |
|
} |
|
else { |
|
push (@cc,$ARGS[$counter]); |
|
} |
|
$counter++; |
|
} $counter--; |
|
} |
|
|
|
elsif ($ARGS[$counter] =~ /^-bcc$/) { ## Bcc ## |
|
$counter++; |
|
while ($ARGS[$counter] && ($ARGS[$counter] !~ /^-/)) { |
|
if ($ARGS[$counter] =~ /[;,]/) { |
|
push (@bcc, split(/[;,]/, $ARGS[$counter])); |
|
} |
|
else { |
|
push (@bcc,$ARGS[$counter]); |
|
} |
|
$counter++; |
|
} $counter--; |
|
} |
|
|
|
elsif ($ARGS[$counter] =~ /^-m$/) { ## Message ## |
|
$counter++; |
|
$message = ""; |
|
while ($ARGS[$counter] && $ARGS[$counter] !~ /^-/) { |
|
if ($message) { $message .= " "; } |
|
$message .= $ARGS[$counter]; |
|
$counter++; |
|
} $counter--; |
|
|
|
## Replace '\n' with $CRLF. |
|
## This allows newlines with messages sent on the command line |
|
$message =~ s/\\n/$CRLF/g; |
|
} |
|
|
|
elsif ($ARGS[$counter] =~ /^-u$/) { ## Subject ## |
|
$counter++; |
|
$subject = ""; |
|
while ($ARGS[$counter] && $ARGS[$counter] !~ /^-/) { |
|
if ($subject) { $subject .= " "; } |
|
$subject .= $ARGS[$counter]; |
|
$counter++; |
|
} $counter--; |
|
} |
|
|
|
elsif ($ARGS[$counter] =~ /^-s$/) { ## Server ## |
|
$counter++; |
|
if ($ARGS[$counter] && $ARGS[$counter] !~ /^-/) { |
|
$conf{'server'} = $ARGS[$counter]; |
|
if ($conf{'server'} =~ /:/) { ## Port ## |
|
($conf{'server'},$conf{'port'}) = split(":",$conf{'server'}); |
|
} |
|
} |
|
else { printmsg("WARNING - The argument after -s was not the server!", 0); $counter--; } |
|
} |
|
|
|
elsif ($ARGS[$counter] =~ /^-b$/) { ## Bind Address ## |
|
$counter++; |
|
if ($ARGS[$counter] && $ARGS[$counter] !~ /^-/) { |
|
$conf{'bindaddr'} = $ARGS[$counter]; |
|
} |
|
else { printmsg("WARNING - The argument after -b was not the bindaddr!", 0); $counter--; } |
|
} |
|
|
|
elsif ($ARGS[$counter] =~ /^-a$/) { ## Attachments ## |
|
$counter++; |
|
while ($ARGS[$counter] && ($ARGS[$counter] !~ /^-/)) { |
|
push (@attachments,$ARGS[$counter]); |
|
$counter++; |
|
} $counter--; |
|
} |
|
|
|
elsif ($ARGS[$counter] =~ /^-xu$/) { ## AuthSMTP Username ## |
|
$counter++; |
|
if ($ARGS[$counter] && $ARGS[$counter] !~ /^-/) { |
|
$opt{'username'} = $ARGS[$counter]; |
|
} |
|
else { |
|
printmsg("WARNING => The argument after -xu was not valid username!", 0); |
|
$counter--; |
|
} |
|
} |
|
|
|
elsif ($ARGS[$counter] =~ /^-xp$/) { ## AuthSMTP Password ## |
|
$counter++; |
|
if ($ARGS[$counter] && $ARGS[$counter] !~ /^-/) { |
|
$opt{'password'} = $ARGS[$counter]; |
|
} |
|
else { |
|
printmsg("WARNING => The argument after -xp was not valid password!", 0); |
|
$counter--; |
|
} |
|
} |
|
|
|
elsif ($ARGS[$counter] =~ /^-l$/) { ## Logging ## |
|
$counter++; |
|
$conf{'logging'} = 1; |
|
if ($ARGS[$counter] && $ARGS[$counter] !~ /^-/) { $conf{'logFile'} = $ARGS[$counter]; } |
|
else { printmsg("WARNING - The argument after -l was not the log file!", 0); $counter--; } |
|
} |
|
|
|
elsif ($ARGS[$counter] =~ s/^-v+//i) { ## Verbosity ## |
|
my $tmp = (length($&) - 1); |
|
$conf{'debug'} += $tmp; |
|
} |
|
|
|
elsif ($ARGS[$counter] =~ /^-q$/) { ## Quiet ## |
|
$conf{'stdout'} = 0; |
|
} |
|
|
|
else { |
|
printmsg("Error: \"$ARGS[$counter]\" is not a recognized option!", 0); |
|
help(); |
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
################################################### |
|
## Verify required variables are set correctly ## |
|
################################################### |
|
|
|
## Make sure we have something in $conf{hostname} and $opt{fqdn} |
|
if ($opt{'fqdn'} =~ /\./) { |
|
$conf{'hostname'} = $opt{'fqdn'}; |
|
$conf{'hostname'} =~ s/\..*//; |
|
} |
|
|
|
if (!$conf{'server'}) { $conf{'server'} = 'localhost'; } |
|
if (!$conf{'port'}) { $conf{'port'} = 25; } |
|
if (!$from) { |
|
quit("ERROR => You must specify a 'from' field! Try --help.", 1); |
|
} |
|
if ( ((scalar(@to)) + (scalar(@cc)) + (scalar(@bcc))) <= 0) { |
|
quit("ERROR => You must specify at least one recipient via -t, -cc, or -bcc", 1); |
|
} |
|
|
|
## Make sure email addresses look OK. |
|
foreach my $addr (@to, @cc, @bcc, $from, $opt{'reply-to'}) { |
|
if ($addr) { |
|
if (!returnAddressParts($addr)) { |
|
printmsg("ERROR => Can't use improperly formatted email address: $addr", 0); |
|
printmsg("HINT => Try viewing the extended help on addressing with \"--help addressing\"", 1); |
|
quit("", 1); |
|
} |
|
} |
|
} |
|
|
|
## Make sure all attachments exist. |
|
foreach my $file (@attachments) { |
|
if ( (! -f $file) or (! -r $file) ) { |
|
printmsg("ERROR => The attachment [$file] doesn't exist!", 0); |
|
printmsg("HINT => Try specifying the full path to the file or reading extended help with \"--help message\"", 1); |
|
quit("", 1); |
|
} |
|
} |
|
|
|
if ($conf{'logging'} and (!$conf{'logFile'})) { |
|
quit("ERROR => You used -l to enable logging but didn't specify a log file!", 1); |
|
} |
|
|
|
if ( $opt{'username'} ) { |
|
if (!$opt{'password'}) { |
|
## Prompt for a password since one wasn't specified with the -xp option. |
|
$SIG{'ALRM'} = sub { quit("ERROR => Timeout waiting for password inpupt", 1); }; |
|
alarm(60) if ($^O !~ /win/i); ## alarm() doesn't work in win32 |
|
print "Password: "; |
|
$opt{'password'} = <STDIN>; chomp $opt{'password'}; |
|
if (!$opt{'password'}) { |
|
quit("ERROR => A username for SMTP authentication was specified, but no password!", 1); |
|
} |
|
} |
|
} |
|
|
|
## Validate the TLS setting |
|
$opt{'tls'} = lc($opt{'tls'}); |
|
if ($opt{'tls'} !~ /^(auto|yes|no)$/) { |
|
quit("ERROR => Invalid TLS setting ($opt{'tls'}). Must be one of auto, yes, or no.", 1); |
|
} |
|
|
|
## If TLS is set to "yes", make sure sendEmail loaded the libraries needed. |
|
if ($opt{'tls'} eq 'yes' and $conf{'tls_client'} == 0) { |
|
quit("ERROR => No TLS support! SendEmail can't load required libraries. (try installing Net::SSLeay and IO::Socket::SSL)", 1); |
|
} |
|
|
|
## Return 0 errors |
|
return(0); |
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
## getline($socketRef) |
|
sub getline { |
|
my ($socketRef) = @_; |
|
local ($/) = "\r\n"; |
|
return $$socketRef->getline; |
|
} |
|
|
|
|
|
|
|
|
|
## Receive a (multiline?) SMTP response from ($socketRef) |
|
sub getResponse { |
|
my ($socketRef) = @_; |
|
my ($tmp, $reply); |
|
local ($/) = "\r\n"; |
|
return undef unless defined($tmp = getline($socketRef)); |
|
return("getResponse() socket is not open") unless ($$socketRef->opened); |
|
## Keep reading lines if it's a multi-line response |
|
while ($tmp =~ /^\d{3}-/o) { |
|
$reply .= $tmp; |
|
return undef unless defined($tmp = getline($socketRef)); |
|
} |
|
$reply .= $tmp; |
|
$reply =~ s/\r?\n$//o; |
|
return $reply; |
|
} |
|
|
|
|
|
|
|
|
|
############################################################################################### |
|
## Function: SMTPchat ( [string $command] ) |
|
## |
|
## Description: Sends $command to the SMTP server (on SERVER) and awaits a successful |
|
## reply form the server. If the server returns an error, or does not reply |
|
## within $conf{'alarm'} seconds an error is generated. |
|
## NOTE: $command is optional, if no command is specified then nothing will |
|
## be sent to the server, but a valid response is still required from the server. |
|
## |
|
## Input: [$command] A (optional) valid SMTP command (ex. "HELO") |
|
## |
|
## |
|
## Output: Returns zero on success, or non-zero on error. |
|
## Error messages will be stored in $conf{'error'} |
|
## A copy of the last SMTP response is stored in the global variable |
|
## $conf{'SMTPchat_response'} |
|
## |
|
## |
|
## Example: SMTPchat ("HELO mail.isp.net"); |
|
############################################################################################### |
|
sub SMTPchat { |
|
my ($command) = @_; |
|
|
|
printmsg("INFO => Sending: \t$command", 1) if ($command); |
|
|
|
## Send our command |
|
print $SERVER "$command$CRLF" if ($command); |
|
|
|
## Read a response from the server |
|
$SIG{'ALRM'} = sub { $conf{'error'} = "alarm"; $SERVER->close(); }; |
|
alarm($conf{'alarm'}) if ($^O !~ /win/i); ## alarm() doesn't work in win32; |
|
my $result = $conf{'SMTPchat_response'} = getResponse(\$SERVER); |
|
alarm(0) if ($^O !~ /win/i); ## alarm() doesn't work in win32; |
|
|
|
## Generate an alert if we timed out |
|
if ($conf{'error'} eq "alarm") { |
|
$conf{'error'} = "ERROR => Timeout while reading from $conf{'server'}:$conf{'port'} There was no response after $conf{'alarm'} seconds."; |
|
return(1); |
|
} |
|
|
|
## Make sure the server actually responded |
|
if (!$result) { |
|
$conf{'error'} = "ERROR => $conf{'server'}:$conf{'port'} returned a zero byte response to our query."; |
|
return(2); |
|
} |
|
|
|
## Validate the response |
|
if (evalSMTPresponse($result)) { |
|
## conf{'error'} will already be set here |
|
return(2); |
|
} |
|
|
|
## Print the success messsage |
|
printmsg($conf{'error'}, 1); |
|
|
|
## Return Success |
|
return(0); |
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
############################################################################################### |
|
## Function: evalSMTPresponse (string $message ) |
|
## |
|
## Description: Searches $message for either an SMTP success or error code, and returns |
|
## 0 on success, and the actual error code on error. |
|
## |
|
## |
|
## Input: $message Data received from a SMTP server (ex. "220 |
|
## |
|
## |
|
## Output: Returns zero on success, or non-zero on error. |
|
## Error messages will be stored in $conf{'error'} |
|
## |
|
## |
|
## Example: SMTPchat ("HELO mail.isp.net"); |
|
############################################################################################### |
|
sub evalSMTPresponse { |
|
my ($message) = @_; |
|
|
|
## Validate input |
|
if (!$message) { |
|
$conf{'error'} = "ERROR => No message was passed to evalSMTPresponse(). What happened?"; |
|
return(1) |
|
} |
|
|
|
printmsg("DEBUG => evalSMTPresponse() - Checking for SMTP success or error status in the message: $message ", 3); |
|
|
|
## Look for a SMTP success code |
|
if ($message =~ /^([23]\d\d)/) { |
|
printmsg("DEBUG => evalSMTPresponse() - Found SMTP success code: $1", 2); |
|
$conf{'error'} = "SUCCESS => Received: \t$message"; |
|
return(0); |
|
} |
|
|
|
## Look for a SMTP error code |
|
if ($message =~ /^([45]\d\d)/) { |
|
printmsg("DEBUG => evalSMTPresponse() - Found SMTP error code: $1", 2); |
|
$conf{'error'} = "ERROR => Received: \t$message"; |
|
return($1); |
|
} |
|
|
|
## If no SMTP codes were found return an error of 1 |
|
$conf{'error'} = "ERROR => Received a message with no success or error code. The message received was: $message"; |
|
return(2); |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
######################################################### |
|
# SUB: &return_month(0,1,etc) |
|
# returns the name of the month that corrosponds |
|
# with the number. returns 0 on error. |
|
######################################################### |
|
sub return_month { |
|
my $x = $_[0]; |
|
if ($x == 0) { return 'Jan'; } |
|
if ($x == 1) { return 'Feb'; } |
|
if ($x == 2) { return 'Mar'; } |
|
if ($x == 3) { return 'Apr'; } |
|
if ($x == 4) { return 'May'; } |
|
if ($x == 5) { return 'Jun'; } |
|
if ($x == 6) { return 'Jul'; } |
|
if ($x == 7) { return 'Aug'; } |
|
if ($x == 8) { return 'Sep'; } |
|
if ($x == 9) { return 'Oct'; } |
|
if ($x == 10) { return 'Nov'; } |
|
if ($x == 11) { return 'Dec'; } |
|
return (0); |
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
######################################################### |
|
# SUB: &return_day(0,1,etc) |
|
# returns the name of the day that corrosponds |
|
# with the number. returns 0 on error. |
|
######################################################### |
|
sub return_day { |
|
my $x = $_[0]; |
|
if ($x == 0) { return 'Sun'; } |
|
if ($x == 1) { return 'Mon'; } |
|
if ($x == 2) { return 'Tue'; } |
|
if ($x == 3) { return 'Wed'; } |
|
if ($x == 4) { return 'Thu'; } |
|
if ($x == 5) { return 'Fri'; } |
|
if ($x == 6) { return 'Sat'; } |
|
return (0); |
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
############################################################################################### |
|
## Function: returnAddressParts(string $address) |
|
## |
|
## Description: Returns a two element array containing the "Name" and "Address" parts of |
|
## an email address. |
|
## |
|
## Example: "Brandon Zehm <caspian@dotconf.net>" |
|
## would return: ("Brandon Zehm", "caspian@dotconf.net"); |
|
## |
|
## "caspian@dotconf.net" |
|
## would return: ("caspian@dotconf.net", "caspian@dotconf.net") |
|
############################################################################################### |
|
sub returnAddressParts { |
|
my $input = $_[0]; |
|
my $name = ""; |
|
my $address = ""; |
|
|
|
## Make sure to fail if it looks totally invalid |
|
if ($input !~ /(\S+\@\S+)/) { |
|
$conf{'error'} = "ERROR => The address [$input] doesn't look like a valid email address, ignoring it"; |
|
return(undef()); |
|
} |
|
|
|
## Check 1, should find addresses like: "Brandon Zehm <caspian@dotconf.net>" |
|
elsif ($input =~ /^\s*(\S(.*\S)?)\s*<(\S+\@\S+)>/o) { |
|
($name, $address) = ($1, $3); |
|
} |
|
|
|
## Otherwise if that failed, just get the address: <caspian@dotconf.net> |
|
elsif ($input =~ /<(\S+\@\S+)>/o) { |
|
$name = $address = $1; |
|
} |
|
|
|
## Or maybe it was formatted this way: caspian@dotconf.net |
|
elsif ($input =~ /(\S+\@\S+)/o) { |
|
$name = $address = $1; |
|
} |
|
|
|
## Something stupid happened, just return an error. |
|
unless ($name and $address) { |
|
printmsg("ERROR => Couldn't parse the address: $input", 0); |
|
printmsg("HINT => If you think this should work, consider reporting this as a bug to $conf{'authorEmail'}", 1); |
|
return(undef()); |
|
} |
|
|
|
## Make sure there aren't invalid characters in the address, and return it. |
|
my $ctrl = '\000-\037'; |
|
my $nonASCII = '\x80-\xff'; |
|
if ($address =~ /[<> ,;:"'\[\]\\$ctrl$nonASCII]/) { |
|
printmsg("WARNING => The address [$address] seems to contain invalid characters: continuing anyway", 0); |
|
} |
|
return($name, $address); |
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
############################################################################################### |
|
## Function: base64_encode(string $data, bool $chunk) |
|
## |
|
## Description: Returns $data as a base64 encoded string. |
|
## If $chunk is true, the encoded data is returned in 76 character long lines |
|
## with the final \CR\LF removed. |
|
## |
|
## Note: This is only used from the smtp auth section of code. |
|
## At some point it would be nice to merge the code that encodes attachments and this. |
|
############################################################################################### |
|
sub base64_encode { |
|
my $data = $_[0]; |
|
my $chunk = $_[1]; |
|
my $tmp = ''; |
|
my $base64 = ''; |
|
my $CRLF = "\r\n"; |
|
|
|
################################### |
|
## Convert binary data to base64 ## |
|
################################### |
|
while ($data =~ s/(.{45})//s) { ## Get 45 bytes from the binary string |
|
$tmp = substr(pack('u', $&), 1); ## Convert the binary to uuencoded text |
|
chop($tmp); |
|
$tmp =~ tr|` -_|AA-Za-z0-9+/|; ## Translate from uuencode to base64 |
|
$base64 .= $tmp; |
|
} |
|
|
|
########################## |
|
## Encode the leftovers ## |
|
########################## |
|
my $padding = ""; |
|
if ( ($data) and (length($data) > 0) ) { |
|
$padding = (3 - length($data) % 3) % 3; ## Set flag if binary data isn't divisible by 3 |
|
$tmp = substr(pack('u', $data), 1); ## Convert the binary to uuencoded text |
|
chop($tmp); |
|
$tmp =~ tr|` -_|AA-Za-z0-9+/|; ## Translate from uuencode to base64 |
|
$base64 .= $tmp; |
|
} |
|
|
|
############################ |
|
## Fix padding at the end ## |
|
############################ |
|
$data = ''; |
|
$base64 =~ s/.{$padding}$/'=' x $padding/e if $padding; ## Fix the end padding if flag (from above) is set |
|
if ($chunk) { |
|
while ($base64 =~ s/(.{1,76})//s) { ## Put $CRLF after each 76 characters |
|
$data .= "$1$CRLF"; |
|
} |
|
} |
|
else { |
|
$data = $base64; |
|
} |
|
|
|
## Remove any trailing CRLF's |
|
$data =~ s/(\r|\n)*$//s; |
|
return($data); |
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
######################################################### |
|
# SUB: send_attachment("/path/filename") |
|
# Sends the mime headers and base64 encoded file |
|
# to the email server. |
|
######################################################### |
|
sub send_attachment { |
|
my ($filename) = @_; ## Get filename passed |
|
my (@fields, $y, $filename_name, $encoding, ## Local variables |
|
@attachlines, $content_type); |
|
my $bin = 1; |
|
|
|
@fields = split(/\/|\\/, $filename); ## Get the actual filename without the path |
|
$filename_name = pop(@fields); |
|
push @attachments_names, $filename_name; ## FIXME: This is only used later for putting in the log file |
|
|
|
########################## |
|
## Autodetect Mime Type ## |
|
########################## |
|
|
|
@fields = split(/\./, $filename_name); |
|
$encoding = $fields[$#fields]; |
|
|
|
if ($encoding =~ /txt|text|log|conf|^c$|cpp|^h$|inc|m3u/i) { $content_type = 'text/plain'; } |
|
elsif ($encoding =~ /html|htm|shtml|shtm|asp|php|cfm/i) { $content_type = 'text/html'; } |
|
elsif ($encoding =~ /sh$/i) { $content_type = 'application/x-sh'; } |
|
elsif ($encoding =~ /tcl/i) { $content_type = 'application/x-tcl'; } |
|
elsif ($encoding =~ /pl$/i) { $content_type = 'application/x-perl'; } |
|
elsif ($encoding =~ /js$/i) { $content_type = 'application/x-javascript'; } |
|
elsif ($encoding =~ /man/i) { $content_type = 'application/x-troff-man'; } |
|
elsif ($encoding =~ /gif/i) { $content_type = 'image/gif'; } |
|
elsif ($encoding =~ /jpg|jpeg|jpe|jfif|pjpeg|pjp/i) { $content_type = 'image/jpeg'; } |
|
elsif ($encoding =~ /tif|tiff/i) { $content_type = 'image/tiff'; } |
|
elsif ($encoding =~ /xpm/i) { $content_type = 'image/x-xpixmap'; } |
|
elsif ($encoding =~ /bmp/i) { $content_type = 'image/x-MS-bmp'; } |
|
elsif ($encoding =~ /pcd/i) { $content_type = 'image/x-photo-cd'; } |
|
elsif ($encoding =~ /png/i) { $content_type = 'image/png'; } |
|
elsif ($encoding =~ /aif|aiff/i) { $content_type = 'audio/x-aiff'; } |
|
elsif ($encoding =~ /wav/i) { $content_type = 'audio/x-wav'; } |
|
elsif ($encoding =~ /mp2|mp3|mpa/i) { $content_type = 'audio/x-mpeg'; } |
|
elsif ($encoding =~ /ra$|ram/i) { $content_type = 'audio/x-pn-realaudio'; } |
|
elsif ($encoding =~ /mpeg|mpg/i) { $content_type = 'video/mpeg'; } |
|
elsif ($encoding =~ /mov|qt$/i) { $content_type = 'video/quicktime'; } |
|
elsif ($encoding =~ /avi/i) { $content_type = 'video/x-msvideo'; } |
|
elsif ($encoding =~ /zip/i) { $content_type = 'application/x-zip-compressed'; } |
|
elsif ($encoding =~ /tar/i) { $content_type = 'application/x-tar'; } |
|
elsif ($encoding =~ /jar/i) { $content_type = 'application/java-archive'; } |
|
elsif ($encoding =~ /exe|bin/i) { $content_type = 'application/octet-stream'; } |
|
elsif ($encoding =~ /ppt|pot|ppa|pps|pwz/i) { $content_type = 'application/vnd.ms-powerpoint'; } |
|
elsif ($encoding =~ /mdb|mda|mde/i) { $content_type = 'application/vnd.ms-access'; } |
|
elsif ($encoding =~ /xls|xlt|xlm|xld|xla|xlc|xlw|xll/i) { $content_type = 'application/vnd.ms-excel'; } |
|
elsif ($encoding =~ /doc|dot/i) { $content_type = 'application/msword'; } |
|
elsif ($encoding =~ /rtf/i) { $content_type = 'application/rtf'; } |
|
elsif ($encoding =~ /pdf/i) { $content_type = 'application/pdf'; } |
|
elsif ($encoding =~ /tex/i) { $content_type = 'application/x-tex'; } |
|
elsif ($encoding =~ /latex/i) { $content_type = 'application/x-latex'; } |
|
elsif ($encoding =~ /vcf/i) { $content_type = 'application/x-vcard'; } |
|
else { $content_type = 'application/octet-stream'; } |
|
|
|
|
|
############################ |
|
## Process the attachment ## |
|
############################ |
|
|
|
##################################### |
|
## Generate and print MIME headers ## |
|
##################################### |
|
|
|
$y = "$CRLF--$conf{'delimiter'}$CRLF"; |
|
$y .= "Content-Type: $content_type;$CRLF"; |
|
$y .= " name=\"$filename_name\"$CRLF"; |
|
$y .= "Content-Transfer-Encoding: base64$CRLF"; |
|
$y .= "Content-Disposition: attachment; filename=\"$filename_name\"$CRLF"; |
|
$y .= "$CRLF"; |
|
print $SERVER $y; |
|
|
|
|
|
########################################################### |
|
## Convert the file to base64 and print it to the server ## |
|
########################################################### |
|
|
|
open (FILETOATTACH, $filename) || do { |
|
printmsg("ERROR => Opening the file [$filename] for attachment failed with the error: $!", 0); |
|
return(1); |
|
}; |
|
binmode(FILETOATTACH); ## Hack to make Win32 work |
|
|
|
my $res = ""; |
|
my $tmp = ""; |
|
my $base64 = ""; |
|
while (<FILETOATTACH>) { ## Read a line from the (binary) file |
|
$res .= $_; |
|
|
|
################################### |
|
## Convert binary data to base64 ## |
|
################################### |
|
while ($res =~ s/(.{45})//s) { ## Get 45 bytes from the binary string |
|
$tmp = substr(pack('u', $&), 1); ## Convert the binary to uuencoded text |
|
chop($tmp); |
|
$tmp =~ tr|` -_|AA-Za-z0-9+/|; ## Translate from uuencode to base64 |
|
$base64 .= $tmp; |
|
} |
|
|
|
################################ |
|
## Print chunks to the server ## |
|
################################ |
|
while ($base64 =~ s/(.{76})//s) { |
|
print $SERVER "$1$CRLF"; |
|
} |
|
|
|
} |
|
|
|
################################### |
|
## Encode and send the leftovers ## |
|
################################### |
|
my $padding = ""; |
|
if ( ($res) and (length($res) >= 1) ) { |
|
$padding = (3 - length($res) % 3) % 3; ## Set flag if binary data isn't divisible by 3 |
|
$res = substr(pack('u', $res), 1); ## Convert the binary to uuencoded text |
|
chop($res); |
|
$res =~ tr|` -_|AA-Za-z0-9+/|; ## Translate from uuencode to base64 |
|
} |
|
|
|
############################ |
|
## Fix padding at the end ## |
|
############################ |
|
$res = $base64 . $res; ## Get left overs from above |
|
$res =~ s/.{$padding}$/'=' x $padding/e if $padding; ## Fix the end padding if flag (from above) is set |
|
if ($res) { |
|
while ($res =~ s/(.{1,76})//s) { ## Send it to the email server. |
|
print $SERVER "$1$CRLF"; |
|
} |
|
} |
|
|
|
close (FILETOATTACH) || do { |
|
printmsg("ERROR - Closing the filehandle for file [$filename] failed with the error: $!", 0); |
|
return(2); |
|
}; |
|
|
|
## Return 0 errors |
|
return(0); |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
############################################################################################### |
|
## Function: $string = get_hostname (boot $fqdn) |
|
## |
|
## Description: Tries really hard to returns the short (or FQDN) hostname of the current |
|
## system. Uses techniques and code from the Sys-Hostname module. |
|
## |
|
## Input: $fqdn A true value (1) will cause this function to return a FQDN hostname |
|
## rather than a short hostname. |
|
## |
|
## Output: Returns a string |
|
############################################################################################### |
|
sub get_hostname { |
|
## Assign incoming parameters to variables |
|
my ( $fqdn ) = @_; |
|
my $hostname = ""; |
|
|
|
## STEP 1: Get short hostname |
|
|
|
## Load Sys::Hostname if it's available |
|
eval { require Sys::Hostname; }; |
|
unless ($@) { |
|
$hostname = Sys::Hostname::hostname(); |
|
} |
|
|
|
## If that didn't get us a hostname, try a few other things |
|
else { |
|
## Windows systems |
|
if ($^O !~ /win/i) { |
|
if ($ENV{'COMPUTERNAME'}) { $hostname = $ENV{'COMPUTERNAME'}; } |
|
if (!$hostname) { $hostname = gethostbyname('localhost'); } |
|
if (!$hostname) { chomp($hostname = `hostname 2> NUL`) }; |
|
} |
|
|
|
## Unix systems |
|
else { |
|
local $ENV{PATH} = '/usr/bin:/bin:/usr/sbin:/sbin'; ## Paranoia |
|
|
|
## Try the environment first (Help! What other variables could/should I be checking here?) |
|
if ($ENV{'HOSTNAME'}) { $hostname = $ENV{'HOSTNAME'}; } |
|
|
|
## Try the hostname command |
|
eval { local $SIG{__DIE__}; local $SIG{CHLD}; $hostname = `hostname 2>/dev/null`; chomp($hostname); } || |
|
|
|
## Try POSIX::uname(), which strictly can't be expected to be correct |
|
eval { local $SIG{__DIE__}; require POSIX; $hostname = (POSIX::uname())[1]; } || |
|
|
|
## Try the uname command |
|
eval { local $SIG{__DIE__}; $hostname = `uname -n 2>/dev/null`; chomp($hostname); }; |
|
|
|
} |
|
|
|
## If we can't find anything else, return "" |
|
if (!$hostname) { |
|
print "WARNING => No hostname could be determined, please specify one with -o fqdn=FQDN option!\n"; |
|
return("unknown"); |
|
} |
|
} |
|
|
|
## Return the short hostname |
|
unless ($fqdn) { |
|
$hostname =~ s/\..*//; |
|
return(lc($hostname)); |
|
} |
|
|
|
## STEP 2: Determine the FQDN |
|
|
|
## First, if we already have one return it. |
|
if ($hostname =~ /\w\.\w/) { return(lc($hostname)); } |
|
|
|
## Next try using |
|
eval { $fqdn = (gethostbyname($hostname))[0]; }; |
|
if ($fqdn) { return(lc($fqdn)); } |
|
return(lc($hostname)); |
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
############################################################################################### |
|
## Function: printmsg (string $message, int $level) |
|
## |
|
## Description: Handles all messages - printing them to the screen only if the messages |
|
## $level is >= the global debug level. If $conf{'logFile'} is defined it |
|
## will also log the message to that file. |
|
## |
|
## Input: $message A message to be printed, logged, etc. |
|
## $level The debug level of the message. If |
|
## not defined 0 will be assumed. 0 is |
|
## considered a normal message, 1 and |
|
## higher is considered a debug message. |
|
## |
|
## Output: Prints to STDOUT |
|
## |
|
## Assumptions: $conf{'hostname'} should be the name of the computer we're running on. |
|
## $conf{'stdout'} should be set to 1 if you want to print to stdout |
|
## $conf{'logFile'} should be a full path to a log file if you want that |
|
## $conf{'debug'} should be an integer between 0 and 10. |
|
## |
|
## Example: printmsg("WARNING: We believe in generic error messages... NOT!", 0); |
|
############################################################################################### |
|
sub printmsg { |
|
## Assign incoming parameters to variables |
|
my ( $message, $level ) = @_; |
|
|
|
## Make sure input is sane |
|
$level = 0 if (!defined($level)); |
|
$message =~ s/\s+$//sgo; |
|
$message =~ s/\r?\n/, /sgo; |
|
|
|
## Continue only if the debug level of the program is >= message debug level. |
|
if ($conf{'debug'} >= $level) { |
|
|
|
## Get the date in the format: Dec 3 11:14:04 |
|
my ($sec, $min, $hour, $mday, $mon) = localtime(); |
|
$mon = ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')[$mon]; |
|
my $date = sprintf("%s %02d %02d:%02d:%02d", $mon, $mday, $hour, $min, $sec); |
|
|
|
## Print to STDOUT always if debugging is enabled, or if conf{stdout} is true. |
|
if ( ($conf{'debug'} >= 1) or ($conf{'stdout'} == 1) ) { |
|
print "$date $conf{'hostname'} $conf{'programName'}\[$$\]: $message\n"; |
|
} |
|
|
|
## Print to the log file if $conf{'logging'} is true |
|
if ($conf{'logFile'}) { |
|
if (openLogFile($conf{'logFile'})) { $conf{'logFile'} = ""; printmsg("ERROR => Opening the file [$conf{'logFile'}] for appending returned the error: $!", 1); } |
|
print LOGFILE "$date $conf{'hostname'} $conf{'programName'}\[$$\]: $message\n"; |
|
} |
|
|
|
} |
|
|
|
## Return 0 errors |
|
return(0); |
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
############################################################################################### |
|
## FUNCTION: |
|
## openLogFile ( $filename ) |
|
## |
|
## |
|
## DESCRIPTION: |
|
## Opens the file $filename and attaches it to the filehandle "LOGFILE". Returns 0 on success |
|
## and non-zero on failure. Error codes are listed below, and the error message gets set in |
|
## global variable $!. |
|
## |
|
## |
|
## Example: |
|
## openFile ("/var/log/sendEmail.log"); |
|
## |
|
############################################################################################### |
|
sub openLogFile { |
|
## Get the incoming filename |
|
my $filename = $_[0]; |
|
|
|
## Make sure our file exists, and if the file doesn't exist then create it |
|
if ( ! -f $filename ) { |
|
print STDERR "NOTICE: The log file [$filename] does not exist. Creating it now with mode [0600].\n" if ($conf{'stdout'}); |
|
open (LOGFILE, ">>$filename"); |
|
close LOGFILE; |
|
chmod (0600, $filename); |
|
} |
|
|
|
## Now open the file and attach it to a filehandle |
|
open (LOGFILE,">>$filename") or return (1); |
|
|
|
## Put the file into non-buffering mode |
|
select LOGFILE; |
|
$| = 1; |
|
select STDOUT; |
|
|
|
## Return success |
|
return(0); |
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
############################################################################################### |
|
## Function: read_file (string $filename) |
|
## |
|
## Description: Reads the contents of a file and returns a two part array: |
|
## ($status, $file-contents) |
|
## $status is 0 on success, non-zero on error. |
|
## |
|
## Example: ($status, $file) = read_file("/etc/passwd"); |
|
############################################################################################### |
|
sub read_file { |
|
my ( $filename ) = @_; |
|
|
|
## If the value specified is a file, load the file's contents |
|
if ( (-e $filename and -r $filename) ) { |
|
my $FILE; |
|
if(!open($FILE, ' ' . $filename)) { |
|
return((1, "")); |
|
} |
|
my $file = ''; |
|
while (<$FILE>) { |
|
$file .= $_; |
|
} |
|
## Strip an ending \r\n |
|
$file =~ s/\r?\n$//os; |
|
} |
|
return((1, "")); |
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
############################################################################################### |
|
## Function: quit (string $message, int $errorLevel) |
|
## |
|
## Description: Exits the program, optionally printing $message. It |
|
## returns an exit error level of $errorLevel to the |
|
## system (0 means no errors, and is assumed if empty.) |
|
## |
|
## Example: quit("Exiting program normally", 0); |
|
############################################################################################### |
|
sub quit { |
|
my ( $message, $errorLevel ) = @_; |
|
$errorLevel = 0 if (!defined($errorLevel)); |
|
|
|
## Print exit message |
|
if ($message) { |
|
printmsg($message, 0); |
|
} |
|
|
|
## Exit |
|
exit($errorLevel); |
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
############################################################################################### |
|
## Function: help () |
|
## |
|
## Description: For all those newbies ;) |
|
## Prints a help message and exits the program. |
|
## |
|
############################################################################################### |
|
sub help { |
|
exit(1) if (!$conf{'stdout'}); |
|
print <<EOM; |
|
|
|
${colorBold}$conf{'programName'}-$conf{'version'} by $conf{'authorName'} <$conf{'authorEmail'}>${colorNoBold} |
|
|
|
Synopsis: $conf{'programName'} -f ADDRESS [options] |
|
|
|
${colorRed}Required:${colorNormal} |
|
-f ADDRESS from (sender) email address |
|
* At least one recipient required via -t, -cc, or -bcc |
|
* Message body required via -m, STDIN, or -o message-file=FILE |
|
|
|
${colorGreen}Common:${colorNormal} |
|
-t ADDRESS [ADDR ...] to email address(es) |
|
-u SUBJECT message subject |
|
-m MESSAGE message body |
|
-s SERVER[:PORT] smtp mail relay, default is $conf{'server'}:$conf{'port'} |
|
|
|
${colorGreen}Optional:${colorNormal} |
|
-a FILE [FILE ...] file attachment(s) |
|
-cc ADDRESS [ADDR ...] cc email address(es) |
|
-bcc ADDRESS [ADDR ...] bcc email address(es) |
|
-xu USERNAME username for SMTP authentication |
|
-xp PASSWORD password for SMTP authentication |
|
|
|
${colorGreen}Paranormal:${colorNormal} |
|
-b BINDADDR[:PORT] local host bind address |
|
-l LOGFILE log to the specified file |
|
-v verbosity, use multiple times for greater effect |
|
-q be quiet (i.e. no STDOUT output) |
|
-o NAME=VALUE advanced options, for details try: --help misc |
|
-o message-content-type=<auto|text|html> |
|
-o message-file=FILE -o message-format=raw |
|
-o message-header=HEADER -o message-charset=CHARSET |
|
-o reply-to=ADDRESS -o timeout=SECONDS |
|
-o username=USERNAME -o password=PASSWORD |
|
-o tls=<auto|yes|no> -o fqdn=FQDN |
|
|
|
|
|
${colorGreen}Help:${colorNormal} |
|
--help the helpful overview you're reading now |
|
--help addressing explain addressing and related options |
|
--help message explain message body input and related options |
|
--help networking explain -s, -b, etc |
|
--help output explain logging and other output options |
|
--help misc explain -o options, TLS, SMTP auth, and more |
|
|
|
EOM |
|
exit(1); |
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
############################################################################################### |
|
## Function: helpTopic ($topic) |
|
## |
|
## Description: For all those newbies ;) |
|
## Prints a help message and exits the program. |
|
## |
|
############################################################################################### |
|
sub helpTopic { |
|
exit(1) if (!$conf{'stdout'}); |
|
my ($topic) = @_; |
|
|
|
CASE: { |
|
|
|
|
|
|
|
|
|
## ADDRESSING |
|
($topic eq 'addressing') && do { |
|
print <<EOM; |
|
|
|
${colorBold}ADDRESSING DOCUMENTATION${colorNormal} |
|
|
|
${colorGreen}Addressing Options${colorNormal} |
|
Options related to addressing: |
|
-f ADDRESS |
|
-t ADDRESS [ADDRESS ...] |
|
-cc ADDRESS [ADDRESS ...] |
|
-bcc ADDRESS [ADDRESS ...] |
|
-o reply-to=ADDRESS |
|
|
|
-f ADDRESS |
|
This required option specifies who the email is from, I.E. the sender's |
|
email address. |
|
|
|
-t ADDRESS [ADDRESS ...] |
|
This option specifies the primary recipient(s). At least one recipient |
|
address must be specified via the -t, -cc. or -bcc options. |
|
|
|
-cc ADDRESS [ADDRESS ...] |
|
This option specifies the "carbon copy" recipient(s). At least one |
|
recipient address must be specified via the -t, -cc. or -bcc options. |
|
|
|
-bcc ADDRESS [ADDRESS ...] |
|
This option specifies the "blind carbon copy" recipient(s). At least |
|
one recipient address must be specified via the -t, -cc. or -bcc options. |
|
|
|
-o reply-to=ADDRESS |
|
This option specifies that an optional "Reply-To" address should be |
|
written in the email's headers. |
|
|
|
|
|
${colorGreen}Email Address Syntax${colorNormal} |
|
Email addresses may be specified in one of two ways: |
|
Full Name: "John Doe <john.doe\@gmail.com>" |
|
Just Address: "john.doe\@gmail.com" |
|
|
|
The "Full Name" method is useful if you want a name, rather than a plain |
|
email address, to be displayed in the recipient's From, To, or Cc fields |
|
when they view the message. |
|
|
|
|
|
${colorGreen}Multiple Recipients${colorNormal} |
|
The -t, -cc, and -bcc options each accept multiple addresses. They may be |
|
specified by separating them by either a white space, comma, or semi-colon |
|
separated list. You may also specify the -t, -cc, and -bcc options multiple |
|
times, each occurance will append the new recipients to the respective list. |
|
|
|
Examples: |
|
(I used "-t" in these examples, but it can be "-cc" or "-bcc" as well) |
|
|
|
* Space separated list: |
|
-t jane.doe\@yahoo.com "John Doe <john.doe\@gmail.com>" |
|
|
|
* Semi-colon separated list: |
|
-t "jane.doe\@yahoo.com; John Doe <john.doe\@gmail.com>" |
|
|
|
* Comma separated list: |
|
-t "jane.doe\@yahoo.com, John Doe <john.doe\@gmail.com>" |
|
|
|
* Multiple -t, -cc, or -bcc options: |
|
-t "jane.doe\@yahoo.com" -t "John Doe <john.doe\@gmail.com>" |
|
|
|
|
|
EOM |
|
last CASE; |
|
}; |
|
|
|
|
|
|
|
|
|
|
|
|
|
## MESSAGE |
|
($topic eq 'message') && do { |
|
print <<EOM; |
|
|
|
${colorBold}MESSAGE DOCUMENTATION${colorNormal} |
|
|
|
${colorGreen}Message Options${colorNormal} |
|
Options related to the email message body: |
|
-u SUBJECT |
|
-m MESSAGE |
|
-o message-file=FILE |
|
-o message-content-type=<auto|text|html> |
|
-o message-header=EMAIL HEADER |
|
-o message-charset=CHARSET |
|
-o message-format=raw |
|
|
|
-u SUBJECT |
|
This option allows you to specify the subject for your email message. |
|
It is not required (anymore) that the subject be quoted, although it |
|
is recommended. The subject will be read until an argument starting |
|
with a hyphen (-) is found. |
|
Examples: |
|
-u "Contact information while on vacation" |
|
-u New Microsoft vulnerability discovered |
|
|
|
-m MESSAGE |
|
This option is one of three methods that allow you to specify the message |
|
body for your email. The message may be specified on the command line |
|
with this -m option, read from a file with the -o message-file=FILE |
|
option, or read from STDIN if neither of these options are present. |
|
|
|
It is not required (anymore) that the message be quoted, although it is |
|
recommended. The message will be read until an argument starting with a |
|
hyphen (-) is found. |
|
Examples: |
|
-m "See you in South Beach, Hawaii. -Todd" |
|
-m Please ensure that you upgrade your systems right away |
|
|
|
Multi-line message bodies may be specified with the -m option by putting |
|
a "\\n" into the message. Example: |
|
-m "This is line 1.\\nAnd this is line 2." |
|
|
|
HTML messages are supported, simply begin your message with "<html>" and |
|
sendEmail will properly label the mime header so MUAs properly render |
|
the message. It is currently not possible without "-o message-format=raw" |
|
to send a message with both text and html parts with sendEmail. |
|
|
|
-o message-file=FILE |
|
This option is one of three methods that allow you to specify the message |
|
body for your email. To use this option simply specify a text file |
|
containing the body of your email message. Examples: |
|
-o message-file=/root/message.txt |
|
-o message-file="C:\\Program Files\\output.txt" |
|
|
|
-o message-content-type=<auto|text|html> |
|
This option allows you to specify the content-type of the email. If your |
|
email message is an html message but is being displayed as a text message |
|
just add "-o message-content-type=html" to the command line to force it |
|
to display as an html message. This actually just changes the Content-Type: |
|
header. Advanced users will be happy to know that if you specify anything |
|
other than the three options listed above it will use that as the vaule |
|
for the Content-Type header. |
|
|
|
-o message-header=EMAIL HEADER |
|
This option allows you to specify additional email headers to be included. |
|
To add more than one message header simply use this option on the command |
|
line more than once. If you specify a message header that sendEmail would |
|
normally generate the one you specified will be used in it's place. |
|
Do not use this unless you know what you are doing! |
|
Example: |
|
To scare a Microsoft Outlook user you may want to try this: |
|
-o message-header="X-Message-Flag: Message contains illegal content" |
|
Example: |
|
To request a read-receipt try this: |
|
-o message-header="Disposition-Notification-To: <user\@domain.com>" |
|
Example: |
|
To set the message priority try this: |
|
-o message-header="X-Priority: 1" |
|
Priority reference: 1=highest, 2=high, 3=normal, 4=low, 5=lowest |
|
|
|
-o message-charset=CHARSET |
|
This option allows you to specify the character-set for the message body. |
|
The default is iso-8859-1. |
|
|
|
-o message-format=raw |
|
This option instructs sendEmail to assume the message (specified with -m, |
|
read from STDIN, or read from the file specified in -o message-file=FILE) |
|
is already a *complete* email message. SendEmail will not generate any |
|
headers and will transmit the message as-is to the remote SMTP server. |
|
Due to the nature of this option the following command line options will |
|
be ignored when this one is used: |
|
-u SUBJECT |
|
-o message-header=EMAIL HEADER |
|
-o message-charset=CHARSET |
|
-a ATTACHMENT |
|
|
|
|
|
${colorGreen}The Message Body${colorNormal} |
|
The email message body may be specified in one of three ways: |
|
1) Via the -m MESSAGE command line option. |
|
Example: |
|
-m "This is the message body" |
|
|
|
2) By putting the message body in a file and using the -o message-file=FILE |
|
command line option. |
|
Example: |
|
-o message-file=/root/message.txt |
|
|
|
3) By piping the message body to sendEmail when nither of the above command |
|
line options were specified. |
|
Example: |
|
grep "ERROR" /var/log/messages | sendEmail -t you\@domain.com ... |
|
|
|
If the message body begins with "<html>" then the message will be treated as |
|
an HTML message and the MIME headers will be written so that a HTML capable |
|
email client will display the message in it's HTML form. |
|
Any of the above methods may be used with the -o message-format=raw option |
|
to deliver an already complete email message. |
|
|
|
|
|
EOM |
|
last CASE; |
|
}; |
|
|
|
|
|
|
|
|
|
|
|
|
|
## MISC |
|
($topic eq 'misc') && do { |
|
print <<EOM; |
|
|
|
${colorBold}MISC DOCUMENTATION${colorNormal} |
|
|
|
${colorGreen}Misc Options${colorNormal} |
|
Options that don't fit anywhere else: |
|
-a ATTACHMENT [ATTACHMENT ...] |
|
-xu USERNAME |
|
-xp PASSWORD |
|
-o username=USERNAME |
|
-o password=PASSWORD |
|
-o tls=<auto|yes|no> |
|
-o timeout=SECONDS |
|
-o fqdn=FQDN |
|
|
|
-a ATTACHMENT [ATTACHMENT ...] |
|
This option allows you to attach any number of files to your email message. |
|
To specify more than one attachment, simply separate each filename with a |
|
space. Example: -a file1.txt file2.txt file3.txt |
|
|
|
-xu USERNAME |
|
Alias for -o username=USERNAME |
|
|
|
-xp PASSWORD |
|
Alias for -o password=PASSWORD |
|
|
|
-o username=USERNAME (synonym for -xu) |
|
These options allow specification of a username to be used with SMTP |
|
servers that require authentication. If a username is specified but a |
|
password is not, you will be prompted to enter one at runtime. |
|
|
|
-o password=PASSWORD (synonym for -xp) |
|
These options allow specification of a password to be used with SMTP |
|
servers that require authentication. If a username is specified but a |
|
password is not, you will be prompted to enter one at runtime. |
|
|
|
-o tls=<auto|yes|no> |
|
This option allows you to specify if TLS (SSL for SMTP) should be enabled |
|
or disabled. The default, auto, will use TLS automatically if your perl |
|
installation has the IO::Socket::SSL and Net::SSLeay modules available, |
|
and if the remote SMTP server supports TLS. To require TLS for message |
|
delivery set this to yes. To disable TLS support set this to no. A debug |
|
level of one or higher will reveal details about the status of TLS. |
|
|
|
-o timeout=SECONDS |
|
This option sets the timeout value in seconds used for all network reads, |
|
writes, and a few other things. |
|
|
|
-o fqdn=FQDN |
|
This option sets the Fully Qualified Domain Name used during the initial |
|
SMTP greeting. Normally this is automatically detected, but in case you |
|
need to manually set it for some reason or get a warning about detection |
|
failing, you can use this to override the default. |
|
|
|
|
|
EOM |
|
last CASE; |
|
}; |
|
|
|
|
|
|
|
|
|
|
|
|
|
## NETWORKING |
|
($topic eq 'networking') && do { |
|
print <<EOM; |
|
|
|
${colorBold}NETWORKING DOCUMENTATION${colorNormal} |
|
|
|
${colorGreen}Networking Options${colorNormal} |
|
Options related to networking: |
|
-s SERVER[:PORT] |
|
-b BINDADDR[:PORT] |
|
-o tls=<auto|yes|no> |
|
-o timeout=SECONDS |
|
|
|
-s SERVER[:PORT] |
|
This option allows you to specify the SMTP server sendEmail should |
|
connect to to deliver your email message to. If this option is not |
|
specified sendEmail will try to connect to localhost:25 to deliver |
|
the message. THIS IS MOST LIKELY NOT WHAT YOU WANT, AND WILL LIKELY |
|
FAIL unless you have a email server (commonly known as an MTA) running |
|
on your computer! |
|
Typically you will need to specify your company or ISP's email server. |
|
For example, if you use CableOne you will need to specify: |
|
-s mail.cableone.net |
|
If you have your own email server running on port 300 you would |
|
probably use an option like this: |
|
-s myserver.mydomain.com:300 |
|
If you're a GMail user try: |
|
-s smtp.gmail.com:587 -xu me\@gmail.com -xp PASSWD |
|
|
|
-b BINDADDR[:PORT] |
|
This option allows you to specify the local IP address (and optional |
|
tcp port number) for sendEmail to bind to when connecting to the remote |
|
SMTP server. This useful for people who need to send an email from a |
|
specific network interface or source address and are running sendEmail on |
|
a firewall or other host with several network interfaces. |
|
|
|
-o tls=<auto|yes|no> |
|
This option allows you to specify if TLS (SSL for SMTP) should be enabled |
|
or disabled. The default, auto, will use TLS automatically if your perl |
|
installation has the IO::Socket::SSL and Net::SSLeay modules available, |
|
and if the remote SMTP server supports TLS. To require TLS for message |
|
delivery set this to yes. To disable TLS support set this to no. A debug |
|
level of one or higher will reveal details about the status of TLS. |
|
|
|
-o timeout=SECONDS |
|
This option sets the timeout value in seconds used for all network reads, |
|
writes, and a few other things. |
|
|
|
|
|
EOM |
|
last CASE; |
|
}; |
|
|
|
|
|
|
|
|
|
|
|
|
|
## OUTPUT |
|
($topic eq 'output') && do { |
|
print <<EOM; |
|
|
|
${colorBold}OUTPUT DOCUMENTATION${colorNormal} |
|
|
|
${colorGreen}Output Options${colorNormal} |
|
Options related to output: |
|
-l LOGFILE |
|
-v |
|
-q |
|
|
|
-l LOGFILE |
|
This option allows you to specify a log file to append to. Every message |
|
that is displayed to STDOUT is also written to the log file. This may be |
|
used in conjunction with -q and -v. |
|
|
|
-q |
|
This option tells sendEmail to disable printing to STDOUT. In other |
|
words nothing will be printed to the console. This does not affect the |
|
behavior of the -l or -v options. |
|
|
|
-v |
|
This option allows you to increase the debug level of sendEmail. You may |
|
either use this option more than once, or specify more than one v at a |
|
time to obtain a debug level higher than one. Examples: |
|
Specifies a debug level of 1: -v |
|
Specifies a debug level of 2: -vv |
|
Specifies a debug level of 2: -v -v |
|
A debug level of one is recommended when doing any sort of debugging. |
|
At that level you will see the entire SMTP transaction (except the |
|
body of the email message), and hints will be displayed for most |
|
warnings and errors. The highest debug level is three. |
|
|
|
|
|
EOM |
|
last CASE; |
|
}; |
|
|
|
## Unknown option selected! |
|
quit("ERROR => The help topic specified is not valid!", 1); |
|
}; |
|
|
|
exit(1); |
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
############################# |
|
## ## |
|
## MAIN PROGRAM ## |
|
## ## |
|
############################# |
|
|
|
|
|
## Initialize |
|
initialize(); |
|
|
|
## Process Command Line |
|
processCommandLine(); |
|
$conf{'alarm'} = $opt{'timeout'}; |
|
|
|
## Abort program after $conf{'alarm'} seconds to avoid infinite hangs |
|
alarm($conf{'alarm'}) if ($^O !~ /win/i); ## alarm() doesn't work in win32 |
|
|
|
|
|
|
|
|
|
################################################### |
|
## Read $message from STDIN if -m was not used ## |
|
################################################### |
|
|
|
if (!($message)) { |
|
## Read message body from a file specified with -o message-file= |
|
if ($opt{'message-file'}) { |
|
if (! -e $opt{'message-file'}) { |
|
printmsg("ERROR => Message body file specified [$opt{'message-file'}] does not exist!", 0); |
|
printmsg("HINT => 1) check spelling of your file; 2) fully qualify the path; 3) doubble quote it", 1); |
|
quit("", 1); |
|
} |
|
if (! -r $opt{'message-file'}) { |
|
printmsg("ERROR => Message body file specified can not be read due to restricted permissions!", 0); |
|
printmsg("HINT => Check permissions on file specified to ensure it can be read", 1); |
|
quit("", 1); |
|
} |
|
if (!open(MFILE, "< " . $opt{'message-file'})) { |
|
printmsg("ERROR => Error opening message body file [$opt{'message-file'}]: $!", 0); |
|
quit("", 1); |
|
} |
|
while (<MFILE>) { |
|
$message .= $_; |
|
} |
|
close(MFILE); |
|
} |
|
|
|
## Read message body from STDIN |
|
else { |
|
alarm($conf{'alarm'}) if ($^O !~ /win/i); ## alarm() doesn't work in win32 |
|
if ($conf{'stdout'}) { |
|
print "Reading message body from STDIN because the '-m' option was not used.\n"; |
|
print "If you are manually typing in a message:\n"; |
|
print " - First line must be received within $conf{'alarm'} seconds.\n" if ($^O !~ /win/i); |
|
print " - End manual input with a CTRL-D on its own line.\n\n" if ($^O !~ /win/i); |
|
print " - End manual input with a CTRL-Z on its own line.\n\n" if ($^O =~ /win/i); |
|
} |
|
while (<STDIN>) { ## Read STDIN into $message |
|
$message .= $_; |
|
alarm(0) if ($^O !~ /win/i); ## Disable the alarm since at least one line was received |
|
} |
|
printmsg("Message input complete.", 0); |
|
} |
|
} |
|
|
|
## Replace bare LF's with CRLF's (\012 should always have \015 with it) |
|
$message =~ s/(\015)?(\012|$)/\015\012/g; |
|
|
|
## Replace bare CR's with CRLF's (\015 should always have \012 with it) |
|
$message =~ s/(\015)(\012|$)?/\015\012/g; |
|
|
|
## Check message for bare periods and encode them |
|
$message =~ s/(^|$CRLF)(\.{1})($CRLF|$)/$1.$2$3/g; |
|
|
|
## Get the current date for the email header |
|
my ($sec,$min,$hour,$mday,$mon,$year,$day) = gmtime(); |
|
$year += 1900; $mon = return_month($mon); $day = return_day($day); |
|
my $date = sprintf("%s, %s %s %d %.2d:%.2d:%.2d %s",$day, $mday, $mon, $year, $hour, $min, $sec, $conf{'timezone'}); |
|
|
|
|
|
|
|
|
|
################################## |
|
## Connect to the SMTP server ## |
|
################################## |
|
printmsg("DEBUG => Connecting to $conf{'server'}:$conf{'port'}", 1); |
|
$SIG{'ALRM'} = sub { |
|
printmsg("ERROR => Timeout while connecting to $conf{'server'}:$conf{'port'} There was no response after $conf{'alarm'} seconds.", 0); |
|
printmsg("HINT => Try specifying a different mail relay with the -s option.", 1); |
|
quit("", 1); |
|
}; |
|
alarm($conf{'alarm'}) if ($^O !~ /win/i); ## alarm() doesn't work in win32; |
|
$SERVER = IO::Socket::INET->new( PeerAddr => $conf{'server'}, |
|
PeerPort => $conf{'port'}, |
|
LocalAddr => $conf{'bindaddr'}, |
|
Proto => 'tcp', |
|
Autoflush => 1, |
|
timeout => $conf{'alarm'}, |
|
); |
|
alarm(0) if ($^O !~ /win/i); ## alarm() doesn't work in win32; |
|
|
|
## Make sure we got connected |
|
if ( (!$SERVER) or (!$SERVER->opened()) ) { |
|
printmsg("ERROR => Connection attempt to $conf{'server'}:$conf{'port'} failed: $@", 0); |
|
printmsg("HINT => Try specifying a different mail relay with the -s option.", 1); |
|
quit("", 1); |
|
} |
|
|
|
## Save our IP address for later |
|
$conf{'ip'} = $SERVER->sockhost(); |
|
printmsg("DEBUG => My IP address is: $conf{'ip'}", 1); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
######################### |
|
## Do the SMTP Dance ## |
|
######################### |
|
|
|
## Read initial greeting to make sure we're talking to a live SMTP server |
|
if (SMTPchat()) { quit($conf{'error'}, 1); } |
|
|
|
## We're about to use $opt{'fqdn'}, make sure it isn't empty |
|
if (!$opt{'fqdn'}) { |
|
## Ok, that means we couldn't get a hostname, how about using the IP address for the HELO instead |
|
$opt{'fqdn'} = "[" . $conf{'ip'} . "]"; |
|
} |
|
|
|
## EHLO |
|
if (SMTPchat('EHLO ' . $opt{'fqdn'})) { |
|
printmsg($conf{'error'}, 0); |
|
printmsg("NOTICE => EHLO command failed, attempting HELO instead"); |
|
if (SMTPchat('HELO ' . $opt{'fqdn'})) { quit($conf{'error'}, 1); } |
|
if ( $opt{'username'} and $opt{'password'} ) { |
|
printmsg("WARNING => The mail server does not support SMTP authentication!", 0); |
|
} |
|
} |
|
else { |
|
|
|
## Determin if the server supports TLS |
|
if ($conf{'SMTPchat_response'} =~ /STARTTLS/) { |
|
$conf{'tls_server'} = 1; |
|
printmsg("DEBUG => The remote SMTP server supports TLS :)", 2); |
|
} |
|
else { |
|
$conf{'tls_server'} = 0; |
|
printmsg("DEBUG => The remote SMTP server does NOT support TLS :(", 2); |
|
} |
|
|
|
## Start TLS if possible |
|
if ($conf{'tls_server'} == 1 and $conf{'tls_client'} == 1 and $opt{'tls'} =~ /^(yes|auto)$/) { |
|
printmsg("DEBUG => Starting TLS", 2); |
|
if (SMTPchat('STARTTLS')) { quit($conf{'error'}, 1); } |
|
if (! IO::Socket::SSL->start_SSL($SERVER, SSL_version => 'SSLv3 TLSv1')) { |
|
quit("ERROR => TLS setup failed: " . IO::Socket::SSL::errstr(), 1); |
|
} |
|
printmsg("DEBUG => TLS: Using cipher: ". $SERVER->get_cipher(), 3); |
|
printmsg("DEBUG => TLS session initialized :)", 1); |
|
|
|
## Restart our SMTP session |
|
if (SMTPchat('EHLO ' . $opt{'fqdn'})) { quit($conf{'error'}, 1); } |
|
} |
|
elsif ($opt{'tls'} eq 'yes' and $conf{'tls_server'} == 0) { |
|
quit("ERROR => TLS not possible! Remote SMTP server, $conf{'server'}, does not support it.", 1); |
|
} |
|
|
|
|
|
## Do SMTP Auth if required |
|
if ( $opt{'username'} and $opt{'password'} ) { |
|
if ($conf{'SMTPchat_response'} !~ /AUTH\s/) { |
|
printmsg("NOTICE => Authentication not supported by the remote SMTP server!", 0); |
|
} |
|
else { |
|
my $auth_succeeded = 0; |
|
my $mutual_method = 0; |
|
|
|
# ## SASL CRAM-MD5 authentication method |
|
# if ($conf{'SMTPchat_response'} =~ /\bCRAM-MD5\b/i) { |
|
# printmsg("DEBUG => SMTP-AUTH: Using CRAM-MD5 authentication method", 1); |
|
# if (SMTPchat('AUTH CRAM-MD5')) { quit($conf{'error'}, 1); } |
|
# |
|
# ## FIXME!! |
|
# |
|
# printmsg("DEBUG => User authentication was successful", 1); |
|
# } |
|
|
|
## SASL LOGIN authentication method |
|
if ($auth_succeeded == 0 and $conf{'SMTPchat_response'} =~ /\bLOGIN\b/i) { |
|
$mutual_method = 1; |
|
printmsg("DEBUG => SMTP-AUTH: Using LOGIN authentication method", 1); |
|
if (!SMTPchat('AUTH LOGIN')) { |
|
if (!SMTPchat(base64_encode($opt{'username'}))) { |
|
if (!SMTPchat(base64_encode($opt{'password'}))) { |
|
$auth_succeeded = 1; |
|
printmsg("DEBUG => User authentication was successful (Method: LOGIN)", 1); |
|
} |
|
} |
|
} |
|
if ($auth_succeeded == 0) { |
|
printmsg("DEBUG => SMTP-AUTH: LOGIN authenticaion failed.", 1); |
|
} |
|
} |
|
|
|
## SASL PLAIN authentication method |
|
if ($auth_succeeded == 0 and $conf{'SMTPchat_response'} =~ /\bPLAIN\b/i) { |
|
$mutual_method = 1; |
|
printmsg("DEBUG => SMTP-AUTH: Using PLAIN authentication method", 1); |
|
if (SMTPchat('AUTH PLAIN ' . base64_encode("$opt{'username'}\0$opt{'username'}\0$opt{'password'}"))) { |
|
printmsg("DEBUG => SMTP-AUTH: PLAIN authenticaion failed.", 1); |
|
} |
|
else { |
|
$auth_succeeded = 1; |
|
printmsg("DEBUG => User authentication was successful (Method: PLAIN)", 1); |
|
} |
|
} |
|
|
|
## If none of the authentication methods supported by sendEmail were supported by the server, let the user know |
|
if ($mutual_method == 0) { |
|
printmsg("WARNING => SMTP-AUTH: No mutually supported authentication methods available", 0); |
|
} |
|
|
|
## If we didn't get authenticated, log an error message and exit |
|
if ($auth_succeeded == 0) { |
|
quit("ERROR => ERROR => SMTP-AUTH: Authentication to $conf{'server'}:$conf{'port'} failed.", 1); |
|
} |
|
} |
|
} |
|
} |
|
|
|
## MAIL FROM |
|
if (SMTPchat('MAIL FROM:<' .(returnAddressParts($from))[1]. '>')) { quit($conf{'error'}, 1); } |
|
|
|
## RCPT TO |
|
my $oneRcptAccepted = 0; |
|
foreach my $rcpt (@to, @cc, @bcc) { |
|
my ($name, $address) = returnAddressParts($rcpt); |
|
if (SMTPchat('RCPT TO:<' . $address . '>')) { |
|
printmsg("WARNING => The recipient <$address> was rejected by the mail server, error follows:", 0); |
|
$conf{'error'} =~ s/^ERROR/WARNING/o; |
|
printmsg($conf{'error'}, 0); |
|
} |
|
elsif ($oneRcptAccepted == 0) { |
|
$oneRcptAccepted = 1; |
|
} |
|
} |
|
## If no recipients were accepted we need to exit with an error. |
|
if ($oneRcptAccepted == 0) { |
|
quit("ERROR => Exiting. No recipients were accepted for delivery by the mail server.", 1); |
|
} |
|
|
|
## DATA |
|
if (SMTPchat('DATA')) { quit($conf{'error'}, 1); } |
|
|
|
|
|
############################### |
|
## Build and send the body ## |
|
############################### |
|
printmsg("INFO => Sending message body",1); |
|
|
|
## If the message-format is raw just send the message as-is. |
|
if ($opt{'message-format'} =~ /^raw$/i) { |
|
print $SERVER $message; |
|
} |
|
|
|
## If the message-format isn't raw, then build and send the message, |
|
else { |
|
|
|
## Message-ID: <MessageID> |
|
if ($opt{'message-header'} !~ /^Message-ID:/iom) { |
|
$header .= 'Message-ID: <' . $conf{'Message-ID'} . '@' . $conf{'hostname'} . '>' . $CRLF; |
|
} |
|
|
|
## From: "Name" <address@domain.com> (the pointless test below is just to keep scoping correct) |
|
if ($from and $opt{'message-header'} !~ /^From:/iom) { |
|
my ($name, $address) = returnAddressParts($from); |
|
$header .= 'From: "' . $name . '" <' . $address . '>' . $CRLF; |
|
} |
|
|
|
## Reply-To: |
|
if ($opt{'reply-to'} and $opt{'message-header'} !~ /^Reply-To:/iom) { |
|
my ($name, $address) = returnAddressParts($opt{'reply-to'}); |
|
$header .= 'Reply-To: "' . $name . '" <' . $address . '>' . $CRLF; |
|
} |
|
|
|
## To: "Name" <address@domain.com> |
|
if ($opt{'message-header'} =~ /^To:/iom) { |
|
## The user put the To: header in via -o message-header - dont do anything |
|
} |
|
elsif (scalar(@to) > 0) { |
|
$header .= "To:"; |
|
for (my $a = 0; $a < scalar(@to); $a++) { |
|
my $msg = ""; |
|
|
|
my ($name, $address) = returnAddressParts($to[$a]); |
|
$msg = " \"$name\" <$address>"; |
|
|
|
## If we're not on the last address add a comma to the end of the line. |
|
if (($a + 1) != scalar(@to)) { |
|
$msg .= ","; |
|
} |
|
|
|
$header .= $msg . $CRLF; |
|
} |
|
} |
|
## We always want a To: line so if the only recipients were bcc'd they don't see who it was sent to |
|
else { |
|
$header .= "To: \"Undisclosed Recipients\" <>$CRLF"; |
|
} |
|
|
|
if (scalar(@cc) > 0 and $opt{'message-header'} !~ /^Cc:/iom) { |
|
$header .= "Cc:"; |
|
for (my $a = 0; $a < scalar(@cc); $a++) { |
|
my $msg = ""; |
|
|
|
my ($name, $address) = returnAddressParts($cc[$a]); |
|
$msg = " \"$name\" <$address>"; |
|
|
|
## If we're not on the last address add a comma to the end of the line. |
|
if (($a + 1) != scalar(@cc)) { |
|
$msg .= ","; |
|
} |
|
|
|
$header .= $msg . $CRLF; |
|
} |
|
} |
|
|
|
if ($opt{'message-header'} !~ /^Subject:/iom) { |
|
$header .= 'Subject: ' . $subject . $CRLF; ## Subject |
|
} |
|
if ($opt{'message-header'} !~ /^Date:/iom) { |
|
$header .= 'Date: ' . $date . $CRLF; ## Date |
|
} |
|
if ($opt{'message-header'} !~ /^X-Mailer:/iom) { |
|
$header .= 'X-Mailer: sendEmail-'.$conf{'version'}.$CRLF; ## X-Mailer |
|
} |
|
## I wonder if I should put this in by default? |
|
# if ($opt{'message-header'} !~ /^X-Originating-IP:/iom) { |
|
# $header .= 'X-Originating-IP: ['.$conf{'ip'}.']'.$CRLF; ## X-Originating-IP |
|
# } |
|
|
|
## Encode all messages with MIME. |
|
if ($opt{'message-header'} !~ /^MIME-Version:/iom) { |
|
$header .= "MIME-Version: 1.0$CRLF"; |
|
} |
|
if ($opt{'message-header'} !~ /^Content-Type:/iom) { |
|
my $content_type = 'multipart/mixed'; |
|
if (scalar(@attachments) == 0) { $content_type = 'multipart/related'; } |
|
$header .= "Content-Type: $content_type; boundary=\"$conf{'delimiter'}\"$CRLF"; |
|
} |
|
|
|
## Send additional message header line(s) if specified |
|
if ($opt{'message-header'}) { |
|
$header .= $opt{'message-header'}; |
|
} |
|
|
|
## Send the message header to the server |
|
print $SERVER $header . $CRLF; |
|
|
|
## Start sending the message body to the server |
|
print $SERVER "This is a multi-part message in MIME format. To properly display this message you need a MIME-Version 1.0 compliant Email program.$CRLF"; |
|
print $SERVER "$CRLF"; |
|
|
|
|
|
## Send message body |
|
print $SERVER "--$conf{'delimiter'}$CRLF"; |
|
## Send a message content-type header: |
|
## If the message contains HTML... |
|
if ($opt{'message-content-type'} eq 'html' or ($opt{'message-content-type'} eq 'auto' and $message =~ /^\s*(<HTML|<!DOCTYPE)/i) ) { |
|
printmsg("Setting content-type: text/html", 1); |
|
print $SERVER "Content-Type: text/html;$CRLF"; |
|
} |
|
## Otherwise assume it's plain text... |
|
elsif ($opt{'message-content-type'} eq 'text' or $opt{'message-content-type'} eq 'auto') { |
|
printmsg("Setting content-type: text/plain", 1); |
|
print $SERVER "Content-Type: text/plain;$CRLF"; |
|
} |
|
## If they've specified their own content-type string... |
|
else { |
|
printmsg("Setting custom content-type: ".$opt{'message-content-type'}, 1); |
|
print $SERVER "Content-Type: ".$opt{'message-content-type'}.";$CRLF"; |
|
} |
|
print $SERVER " charset=\"" . $opt{'message-charset'} . "\"$CRLF"; |
|
print $SERVER "Content-Transfer-Encoding: 7bit$CRLF"; |
|
print $SERVER $CRLF . $message; |
|
|
|
|
|
|
|
## Send Attachemnts |
|
if (scalar(@attachments) > 0) { |
|
## Disable the alarm so people on modems can send big attachments |
|
alarm(0) if ($^O !~ /win/i); ## alarm() doesn't work in win32 |
|
|
|
## Send the attachments |
|
foreach my $filename (@attachments) { |
|
## This is check 2, we already checked this above, but just in case... |
|
if ( ! -f $filename ) { |
|
printmsg("ERROR => The file [$filename] doesn't exist! Email will be sent, but without that attachment.", 0); |
|
} |
|
elsif ( ! -r $filename ) { |
|
printmsg("ERROR => Couldn't open the file [$filename] for reading: $! Email will be sent, but without that attachment.", 0); |
|
} |
|
else { |
|
printmsg("DEBUG => Sending the attachment [$filename]", 1); |
|
send_attachment($filename); |
|
} |
|
} |
|
} |
|
|
|
|
|
## End the mime encoded message |
|
print $SERVER "$CRLF--$conf{'delimiter'}--$CRLF"; |
|
} |
|
|
|
|
|
## Tell the server we are done sending the email |
|
print $SERVER "$CRLF.$CRLF"; |
|
if (SMTPchat()) { quit($conf{'error'}, 1); } |
|
|
|
|
|
|
|
#################### |
|
# We are done!!! # |
|
#################### |
|
|
|
## Disconnect from the server (don't SMTPchat(), it breaks when using TLS) |
|
print $SERVER "QUIT$CRLF"; |
|
close $SERVER; |
|
|
|
|
|
|
|
|
|
|
|
|
|
####################################### |
|
## Generate exit message/log entry ## |
|
####################################### |
|
|
|
if ($conf{'debug'} or $conf{'logging'}) { |
|
printmsg("Generating a detailed exit message", 3); |
|
|
|
## Put the message together |
|
my $output = "Email was sent successfully! From: <" . (returnAddressParts($from))[1] . "> "; |
|
|
|
if (scalar(@to) > 0) { |
|
$output .= "To: "; |
|
for ($a = 0; $a < scalar(@to); $a++) { |
|
$output .= "<" . (returnAddressParts($to[$a]))[1] . "> "; |
|
} |
|
} |
|
if (scalar(@cc) > 0) { |
|
$output .= "Cc: "; |
|
for ($a = 0; $a < scalar(@cc); $a++) { |
|
$output .= "<" . (returnAddressParts($cc[$a]))[1] . "> "; |
|
} |
|
} |
|
if (scalar(@bcc) > 0) { |
|
$output .= "Bcc: "; |
|
for ($a = 0; $a < scalar(@bcc); $a++) { |
|
$output .= "<" . (returnAddressParts($bcc[$a]))[1] . "> "; |
|
} |
|
} |
|
$output .= "Subject: [$subject] " if ($subject); |
|
if (scalar(@attachments_names) > 0) { |
|
$output .= "Attachment(s): "; |
|
foreach(@attachments_names) { |
|
$output .= "[$_] "; |
|
} |
|
} |
|
$output .= "Server: [$conf{'server'}:$conf{'port'}]"; |
|
|
|
|
|
###################### |
|
# Exit the program # |
|
###################### |
|
|
|
## Print / Log the detailed message |
|
quit($output, 0); |
|
} |
|
else { |
|
## Or the standard message |
|
quit("Email was sent successfully!", 0); |
|
} |
|
|
|
|