Mail-Toaster
view release on metacpan or search on metacpan
contrib/swaks view on Meta::CPAN
# Don't show transaction hints
{ opts => ['nih', 'no-info-hints'], suffix => '',
okey => 'no_hints_info', type => 'scalar', },
# Don't show reception lines
{ opts => ['hr', 'hide-receive'], suffix => '',
okey => 'hide_receive', type => 'scalar', },
# Don't show sending lines
{ opts => ['hs', 'hide-send'], suffix => '',
okey => 'hide_send', type => 'scalar', },
# Don't echo input on potentially sensitive prompts
{ opts => ['pp', 'protect-prompt'], suffix => '',
okey => 'protect_prompt', type => 'scalar', },
# Don't show any swaks-generated, non-error informational lines
{ opts => ['hi', 'hide-informational'], suffix => '',
okey => 'hide_informational', type => 'scalar', },
# Don't send any output to the terminal
{ opts => ['ha', 'hide-all'], suffix => '',
okey => 'hide_all', type => 'scalar', },
# print lapse for send/recv
{ opts => ['stl', 'show-time-lapse'], suffix => ':s',
okey => 'show_time_lapse', type => 'scalar', },
# don't touch the data
{ opts => ['ndf', 'no-data-fixup'], suffix => '',
okey => 'no_data_fixup', type => 'scalar', },
# show dumps of the raw read/written text
{ opts => ['raw', 'show-raw-text'], suffix => '',
okey => 'show_raw_text', type => 'scalar', },
# specify file to write to
{ opts => ['output-file'], suffix => '=s',
okey => 'output_file', type => 'scalar', },
# specify file to write to
{ opts => ['output-file-stdout'], suffix => '=s',
okey => 'output_file_stdout', type => 'scalar', },
# specify file to write to
{ opts => ['output-file-stderr'], suffix => '=s',
okey => 'output_file_stderr', type => 'scalar', },
# command to communicate with
{ opts => ['pipe'], suffix => ':s',
okey => 'pipe_cmd', type => 'scalar', },
# unix domain socket to talk to
{ opts => ['socket'], suffix => ':s',
okey => 'socket', type => 'scalar', },
# the content of the body of the DATA
{ opts => ['body'], suffix => ':s',
okey => 'body_822', type => 'scalar', },
# A file to attach
{ opts => ['attach-name','attach-type','attach'], suffix => ':s',
okey => 'attach_822', type => 'list', },
# replacement for %NEW_HEADERS% DATA token
{ opts => ['ah', 'add-header'], suffix => ':s',
okey => 'add_header', type => 'list', },
# replace header if exist, else add
{ opts => ['header'], suffix => ':s',
okey => 'header', type => 'list', },
# build options and dump
{ opts => ['dump'], suffix => '',
okey => 'dump_args', type => 'scalar', },
# attempt PIPELINING
{ opts => ['pipeline'], suffix => '',
okey => 'pipeline', type => 'scalar', },
# use getpwuid building -f
{ opts => ['force-getpwuid'], suffix => '',
okey => 'force_getpwuid', type => 'scalar', },
# argument is a raw XCLIENT string
{ opts => ['xclient'], suffix => ':s',
okey => 'xclient_raw', type => 'scalar', },
# if set, XCLIENT will proceed even if XCLIENT not advertised
{ opts => ['xclient-optional'], suffix => '',
okey => 'xclient_optional', type => 'scalar', },
# proceed if xclient not offered, but fail if offered and not accepted
{ opts => ['xclient-optional-strict'], suffix => '',
okey => 'xclient_optional_strict', type => 'scalar', },
## xclient send by default after first helo, but can be sent almost anywhere (cf quit-after)
#{ opts => ['xclient-after'], suffix => ':s',
# okey => 'xclient_after', type => 'scalar', },
# XCLIENT NAME
{ opts => ['xclient-name'], suffix => ':s',
okey => 'xclient_name', type => 'scalar', },
# XCLIENT ADDR
{ opts => ['xclient-addr'], suffix => ':s',
okey => 'xclient_addr', type => 'scalar', },
# XCLIENT PORT
{ opts => ['xclient-port'], suffix => ':s',
okey => 'xclient_port', type => 'scalar', },
# XCLIENT PROTO
{ opts => ['xclient-proto'], suffix => ':s',
okey => 'xclient_proto', type => 'scalar', },
# XCLIENT HELO
{ opts => ['xclient-helo'], suffix => ':s',
okey => 'xclient_helo', type => 'scalar', },
# XCLIENT LOGIN
{ opts => ['xclient-login'], suffix => ':s',
okey => 'xclient_login', type => 'scalar', },
# XCLIENT REVERSE_NAME
{ opts => ['xclient-reverse-name'], suffix => ':s',
okey => 'xclient_reverse_name', type => 'scalar', },
);
return(\@G::raw_option_data);
}
# returns %O, the large raw option hash
sub load_args {
# this sub is a jumping point. What we will do is repeatedly massage
# @ARGV and call GetOptions multiple times. We are essentially "layering"
# options. First we load from a config file (if exists/specified), then
# from any environment variables, then the actual command line.
# First, save a copy of the real @ARGV, because that's actually what
# gets processed last
my @real_ARGV = @ARGV;
my %ARGS = ();
@ARGV = ();
# we load our options processing hash here. We abstract it back from the
# native getopt-format because we need to be able to intercept "no-" options
my $option_list = get_option_struct();
# we want to process config files first. There's a default config file in
# ~/.swaksrc, but it is possible for the user to override this with the
# --config options. So, find the one and only file we will use here.
# If we encounter --config in later processing it is a noop.
# first find the default file
contrib/swaks view on Meta::CPAN
exit(1);
}
if ($protos{$G::protocol}{auth} && !$o->{auth_user} &&
!$o->{auth_pass} && !$o->{auth_optional} &&
!$o->{auth_optional_strict} && !$o->{auth})
{
$o->{auth} = ''; # cause auth to be processed below
}
if ($protos{$G::protocol}{tls} && !$o->{tls} && !$o->{tls_optional} &&
!$o->{tls_optional_strict} && !$o->{tls_on_connect})
{
# 'touch' the variable so we process it below
if ($protos{$G::protocol}{tls} eq 's') {
$o->{tls} = '';
} elsif ($protos{$G::protocol}{tls} eq 'c') {
$o->{tls_on_connect} = '';
}
}
$G::protocol = $protos{$G::protocol}{proto};
# set global option of -q option
if ($o->{quit_after}) {
$G::quit_after = lc($o->{quit_after});
if ($G::quit_after =~ /^[el]hlo$/) { $G::quit_after = 'helo'; }
elsif ($G::quit_after =~ /first-[el]hlo/) { $G::quit_after = 'first-helo'; }
elsif ($G::quit_after eq 'starttls') { $G::quit_after = 'tls'; }
elsif ($G::quit_after eq 'banner') { $G::quit_after = 'connect'; }
elsif ($G::quit_after eq 'from') { $G::quit_after = 'mail'; }
elsif ($G::quit_after eq 'to') { $G::quit_after = 'rcpt'; }
elsif ($G::quit_after ne 'connect' && $G::quit_after ne 'first-helo' &&
$G::quit_after ne 'tls' && $G::quit_after ne 'helo' &&
$G::quit_after ne 'auth' && $G::quit_after ne 'mail' &&
$G::quit_after ne 'rcpt' && $G::quit_after ne 'xclient')
{
ptrans(12, "Unknown quit value $G::quit_after, exiting");
exit(1);
}
# only rcpt _requires_ a to address
$G::server_only = 1 if ($G::quit_after ne 'rcpt');
} else {
$G::quit_after = '';
}
# set global flag for -stl flag
$G::show_time_lapse = time() if (defined($o->{show_time_lapse}));
$G::show_time_hires = 1 if ($G::show_time_lapse && avail("hires_timing") &&
$o->{show_time_lapse} !~ /^i/i);
# pipe command, if one is specified
$G::link{process} = $o->{pipe_cmd} || interact("Pipe: ", '^.+$')
if (defined($o->{pipe_cmd}));
if ($G::link{process}) { $G::link{type} = 'pipe'; }
else { delete($G::link{process}); }
# socket file, if one is specified
$G::link{sockfile} = $o->{socket} || interact("Socket File: ", '^.+$')
if (defined($o->{socket}));
if ($G::link{sockfile}) { $G::link{type} = 'socket-unix'; }
else { delete($G::link{sockfile}); }
my $user = get_username($o->{force_getpwuid});
my $hostname = get_hostname();
# SMTP mail from
$n{from} = $o->{mail_from} || interact("From: ", '^.*$')
if (defined($o->{mail_from}));
$n{from} ||= ($hostname || ($G::server_only && $G::quit_after ne 'mail')
? "$user\@$hostname"
: interact("From: ", '^.*$'));
$n{from} = '' if ($n{from} eq '<>');
# local interface to connect from
$G::link{lint} = $o->{lint} || interact("Interface: ", '^.*$')
if (defined($o->{lint}));
if ($G::link{lint}) {
($G::link{lint},$o->{lport}) = parse_server($G::link{lint}, $o->{lport});
}
# SMTP helo/ehlo
$n{helo} = $o->{mail_helo} || interact("Helo: ", '^.*$')
if (defined($o->{mail_helo}));
$n{helo} ||= ($hostname || ($G::quit_after eq 'connect')
? $hostname
: interact("Helo: ", '^.*$'));
# SMTP server and rcpt to are interdependant, so they are handled together
$G::link{server} = $o->{mail_server} || interact("Server: ", '^.*$')
if (defined($o->{mail_server}));
($G::link{server},$o->{mail_port}) = parse_server($G::link{server}, $o->{mail_port});
$n{to} = $o->{mail_to} || interact("To: ", '^.*$')
if (defined($o->{mail_to}));
$n{to} = interact("To: ", '^.*$')
if (!$n{to} && !($G::server_only &&
($G::link{server} || $G::link{type} eq 'socket-unix' || $G::link{type} eq 'pipe')));
$G::link{type} ||= 'socket-inet';
#if (!$G::link{type}) {
# $G::link{server} = get_server($o->{copy_routing} ? $o->{copy_routing} : $n{to}) if (!$G::link{server});
# $G::link{type} = "socket-inet";
#}
# try to catch obvious -s/-li/-4/-6 errors as soon as possible. We don't actually do any DNS
# lookups ourselves, so errors like -s being a domain with only A RRs and -li being a domain
# with only AAAA RRs, or -s being an ipv6 and -li being a domain with only A RRs, will
# get passed into the IO::Socket module to deal with and will just registed as a connection
# failure.
if ($G::link{type} eq 'socket-inet') {
if ($o->{force_ipv4} && $o->{force_ipv6}) {
ptrans(12, "Options -4 and -6 are mutually exclusive, cannot proceed");
exit 1;
} elsif ($o->{force_ipv6}) {
$G::link{force_ipv6} = 1;
} elsif ($o->{force_ipv4}) {
$G::link{force_ipv4} = 1;
}
$G::link{server} ||= get_server($o->{copy_routing} ? $o->{copy_routing} : $n{to});
if ($o->{force_ipv4} && $G::link{server} =~ m|:|) {
ptrans(12, "Option -4 is set but server appears to be ipv6, cannot proceed");
exit 1;
} elsif ($o->{force_ipv4} && $G::link{lint} =~ m|:|) {
contrib/swaks view on Meta::CPAN
. " server_only = " . ($G::server_only ? "TRUE" : "FALSE") . "\n"
. " timeout = $G::link{timeout}\n"
. " pipeline = " . ($G::pipeline ? "TRUE" : "FALSE") . "\n"
. "\n";
$s .= "XCLIENT Info:\n"
. " xclient = ";
if ($G::xclient{try}) {
if ($G::xclient{optional} == 2) { $s .= "optional-strict\n"; }
elsif ($G::xclient{optional} == 1) { $s .= "optional\n"; }
else { $s .= "yes\n"; }
$s .= " raw string = " . ($G::xclient{raw} || 'no') . "\n";
$s .= " attributes = " . join("\n".' 'x16,
map { uc($_)."=".$G::xclient{attr}{$_} } (keys %{$G::xclient{attr}})) . "\n";
} else {
$s .= "no\n";
}
$s .= "\n";
$s .= "TLS / Encryption Info:\n"
. " tls = ";
if ($G::tls || $G::tls_optional) {
if ($G::tls) {
$s .= 'starttls (';
if ($G::tls_optional == 2) { $s .= "optional-strict)\n"; }
elsif ($G::tls_optional == 1) { $s .= "optional)\n"; }
else { $s .= "required)\n"; }
}
elsif ($G::tls_on_connect) { $s .= "on connect (required)\n"; }
$s .= " peer cert = $G::tls_get_peer_cert\n"
. " local cert = $G::tls_cert\n"
. " local key = $G::tls_key\n"
. " local cipher list = $G::tls_cipher\n"
. " ca path = $G::tls_ca_path\n"
. " verify server cert = " . ($G::tls_verify ? "TRUE" : "FALSE") . "\n"
. " available protocols = " . join(', ', @G::tls_supported_protocols) . "\n"
. " requested protocols = " . join(', ', @G::tls_protocols) . "\n";
}
else { $s .= "no\n"; }
$s .= "\n";
$s .= "Authentication Info:\n"
. " auth = ";
if ($opts->{a_type}) {
if ($G::auth_optional == 2) { $s .= 'optional-strict'; }
elsif ($G::auth_optional == 1) { $s .= 'optional'; }
else { $s .= 'yes'; }
$s .= " type='" . join(',', @{$opts->{a_type}}) . "' user='$opts->{a_user}' pass='PROVIDED_BUT_REMOVED'\n";
$s .= " auth_extras = " . join(',', map { "$_=$G::auth_extras{$_}" } keys (%G::auth_extras)) . "\n";
$s .= " auth_showpt = " . ($G::auth_showpt ? "TRUE" : "FALSE") . "\n";
$s .= " auth map = " . join("\n".' 'x16,
map { "$_ = ". join(', ', @{$G::auth_map_t{$_}}) } (keys %G::auth_map_t)) . "\n";
}
else { $s .= "no\n"; }
return $G::running_state = $s;
}
sub get_username {
my $force_getpwuid = shift;
if ($^O eq 'MSWin32') {
require Win32;
return Win32::LoginName();
}
if ($force_getpwuid) {
return (getpwuid($<))[0];
}
return $ENV{LOGNAME} || (getpwuid($<))[0];
}
sub get_date_string {
return($G::date_string) if (length($G::date_string) > 0);
my $et = time();
my @l = localtime($et);
my $o = 0;
if (!avail("date_manip")) {
ptrans(12, avail_str("date_manip").". Date strings will be in GMT");
@l = gmtime($et);
} else {
my @g = gmtime($et);
$o = (timelocal(@l) - timelocal(@g)) / 60;
# Adjust to hours and minutes and not hours and hour-hundreths
# See debian bug 646084
$o = int($o / 60)*100 + ($o%60)*($o > 0 ? 1 : -1);
}
$G::date_string = sprintf("%s, %02d %s %d %02d:%02d:%02d %+05d",
(qw(Sun Mon Tue Wed Thu Fri Sat))[$l[6]],
$l[3],
(qw(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec))[$l[4]],
$l[5]+1900, $l[2], $l[1], $l[0],
$o);
}
# partially Cribbed from "Programming Perl" and MIME::Base64 v2.12
sub db64 {
my $s = shift;
if (load("MIME::Base64")) {
return(decode_base64($s));
} else {
$s =~ tr#A-Za-z0-9+/##cd;
$s =~ s|=+$||;
$s =~ tr#A-Za-z0-9+/# -_#;
my $r = '';
while ($s =~ s/(.{1,60})//s) {
$r .= unpack("u", chr(32 + int(length($1)*3/4)) . $1);
}
return($r);
}
}
# partially Cribbed from MIME::Base64 v2.12
sub eb64 {
my $s = shift;
my $e = shift || ''; # line ending to use "empty by default"
if (load("MIME::Base64")) {
return(encode_base64($s, $e));
} else {
my $l = length($s);
chomp($s = pack("u", $s));
$s =~ s|\n.||gms;
$s =~ s|\A.||gms;
$s =~ tr#` -_#AA-Za-z0-9+/#;
my $p = (3 - $l%3) % 3;
$s =~ s/.{$p}$/'=' x $p/e if ($p);
$s =~ s/(.{1,76})/$1$e/g if (length($e));
return($s);
contrib/swaks view on Meta::CPAN
=item -li, --local-interface [IP or hostname[:port]]
Use argument as the local interface for the outgoing SMTP connection, or prompt user if no argument given. Argument can be an IP address or a hostname. Default action is to let the operating system choose local interface. See --server for addition...
=item -lp, --local-port [port]
Specify the outgoing port to originate the transaction from. If this option is not specified the system will pick an ephemeral port. Note that regular users cannot specify some ports.
=item --copy-routing [domain]
The argument is interpreted as the domain part of an email address and it is used to find the target server using the same logic that would be used to look up the target server for an recipient email address. See --to option for more details on how...
=item -4, -6
Force IPv4 or IPv6.
=back
=item UNIX SOCKETS
This transport method attempts to deliver messages via a unix-domain socket file. This is useful for testing MTA/MDAs that listen on socket files (for instance, testing LMTP delivery to Cyrus). This transport requires the IO::Socket module which is...
=over 4
=item --socket [/path/to/socket/file]
This option takes as its argument a unix-domain socket file. If swaks is unable to open this socket it will display an error and exit.
=back
=item PIPES
This transport attempts to spawn a process and communicate with it via pipes. The spawned program must be prepared to behave as a mail server over STDIN/STDOUT. Any MTA designed to operate from inet/xinet should support this. In addition some MTAs...
This transport requires the IPC::Open2 module which is part of the standard perl distribution. If this module is not loadable, attempting to use this transport will result in an error and program termination.
=over 4
=item --pipe [/path/to/command and arguments]
Provide a process name and arguments to the process. swaks will attempt to spawn the process and communicate with it via pipes. If the argument is not an executable swaks will display an error and exit.
=back
=back
=head1 PROTOCOL OPTIONS
These options are related to the protocol layer.
=over 4
=item -t, --to [email-address[,email-address,...]]
Tells swaks to use argument(s) as the envelope-recipient for the email, or prompt for recipient if no argument provided. If multiple recipients are provided and the recipient domain is needed to determine routing the domain of the last recipient pro...
There is no default value for this option. If no recipients are provided via any means, user will be prompted to provide one interactively. The only exception to this is if a --quit-after value is provided which will cause the smtp transaction to b...
=item -f, --from [email-address]
Use argument as envelope-sender for email, or prompt user if no argument specified. The string <> can be supplied to mean the null sender. If user does not specify a sender address a default value is used. The domain-part of the default sender is ...
=item --ehlo, --lhlo, -h, --helo [helo-string]
String to use as argument to HELO/EHLO/LHLO command, or prompt use if no argument is specified. If this option is not used a best guess at the fully-qualified domain name of the local host is used. If the Sys::Hostname module, which is part of the ...
=item -q, --quit-after [stop-point]
Point at which the transaction should be stopped. When the requested stopping point is reached in the transaction, and provided that swaks has not errored out prior to reaching it, swaks will send "QUIT" and attempt to close the connection cleanly....
=over 4
=item CONNECT, BANNER
Terminate the session after receiving the greeting banner from the target.
=item FIRST-HELO, FIRST-EHLO, FIRST-LHLO
In a STARTTLS (but not tls-on-connect) session, terminate the transaction after the first of two HELOs. In a non-STARTTLS transaction, behaves the same as HELO (see below).
=item XCLIENT
Quit after XCLIENT is sent
=item TLS
Quit the transaction immediately following TLS negotiation. Note that this happens in different places depending on whether STARTTLS or tls-on-connect are used. This always quits after the point where TLS would have been negotiated, regardless of w...
=item HELO, EHLO, LHLO
In a STARTTLS or XCLIENT session, quit after the second HELO. Otherwise quit after the first and only HELO.
=item AUTH
Quit after authentication. This always quits after the point where authentication would have been negotiated, regardless of whether it was attempted.
=item MAIL, FROM
Quit after MAIL FROM: is sent.
=item RCPT, TO
Quit after RCPT TO: is sent.
=back
=item --timeout [time]
Use argument as the SMTP transaction timeout, or prompt user if no argument given. Argument can either be a pure digit, which will be interpretted as seconds, or can have a specifier s or m (5s = 5 seconds, 3m = 180 seconds). As a special case, 0 m...
=item --protocol [protocol]
Specify which protocol to use in the transaction. Valid options are shown in the table below. Currently the 'core' protocols are SMTP, ESMTP, and LMTP. By using variations of these protocol types one can tersely specify default ports, whether auth...
=over 4
=item SMTP
HELO, "-p 25"
=item SSMTP
EHLO->HELO, "-tlsc -p 465"
=item SSMTPA
EHLO->HELO, "-a -tlsc -p 465"
=item SMTPS
HELO, "-tlsc -p 465"
=item ESMTP
EHLO->HELO, "-p 25"
=item ESMTPA
EHLO->HELO, "-a -p 25"
=item ESMTPS
EHLO->HELO, "-tls -p 25"
=item ESMTPSA
EHLO->HELO, "-a -tls -p 25"
=item LMTP
LHLO, "-p 24"
=item LMTPA
LHLO, "-a -p 24"
=item LMTPS
LHLO, "-tls -p 24"
=item LMTPSA
LHLO, "-a -tls -p 24"
=back
=item --pipeline
If the remote server supports it, attempt SMTP PIPELINING (RFC 2920). This is a younger option, if you experience problems with it please notify the author. Potential problem areas include servers accepting DATA even though there were no valid reci...
=item --force-getpwuid
Tell swaks to use the getpwuid method of finding the default sender local-part instead of trying $LOGNAME first.
=back
=head1 TLS / ENCRYPTION
These are options related to encrypting the transaction. These have been tested and confirmed to work with all three transport methods. The Net::SSLeay module is used to perform encryption when it is requested. If this module is not loadable swaks...
A local certificate is not required for a TLS connection to be negotiated. However, some servers use client certificate checking to verify that the client is allowed to connect. swaks can be told to use a specific local certificate through the use ...
=over 4
=item -tls
Require connection to use STARTTLS. Exit if TLS not available for any reason (not advertised, negotiations failed, etc).
=item -tlso, --tls-optional
Attempt to use STARTTLS if available, continue with normal transaction if TLS was unable to be negotiated for any reason. Note that this is a semi-useless option as currently implemented because after a negotiation failure the state of the connectio...
=item -tlsos, --tls-optional-strict
Attempt to use STARTTLS if available. Proceed with transaction if TLS is negotiated successfully or STARTTLS not advertised. If STARTTLS is advertised but TLS negotiations fail, treat as an error and abort transaction. Due to the caveat noted abov...
=item --tlsc, --tls-on-connect
Initiate a TLS connection immediately on connection. Following common convention, if this option is specified the default port changes from 25 to 465, though this can still be overridden with the --port option.
=item -tlsp, --tls-protocol SPECIFICATION
Specify which protocols to use (or not use) when negotiating TLS. At the time of this writing, the available protocols are sslv2, sslv3, tlsv1, tlsv1_1, and tlsv1_2. The availability of these protocols is dependent on your underlying OpenSSL librar...
The specification string is a comma-delimited list of protocols that can be used or not used. For instance 'tlsv1,tlsv1_1' will only succeed if one of those two protocols is available on both the client and the server. Conversely, 'no_sslv2,no_sslv...
=item -tls-cipher CIPHER_STRING
Th argument to this option is passed to the underlying OpenSSL library to set the list of acceptable ciphers to the be used for the connection. The format of this string is opaque to swaks and is defined in http://www.openssl.org/docs/apps/ciphers.h...
=item --tls-verify
By default swaks does not do any certificate verification. Setting --tls-verify will cause swaks to attempt to verify the server's certificate. If this option is set and the server's certificate is not verifiable (either using the system-default CA...
=item --tls-ca-path [ /path/to/CAfile | /path/to/CAdir/ ]
By default swaks will use the underlying OpenSSL library's default CA information for verifying server certificates. --tls-ca-path allows you to specify an alternate location. See http://www.openssl.org/docs/ssl/SSL_CTX_load_verify_locations.html f...
=item --tls-cert /path/to/file
Provide a path to a file containing the local certificate swaks should use if TLS is negotiated. The file path argument is required. As currently implemented the certificate in the file must be in PEM format. Contact the author if there's a compel...
=item --tls-key /path/to/file
Provide a path to a file containing the local private key swaks should use if TLS is negotiated. The file path argument is required. As currently implemented the certificate in the file must be in PEM format. Contact the author if there's a compel...
=item --tls-get-peer-cert [/path/to/file]
Get a copy of the TLS peer's certificate. If no argument is given, it will be displayed to STDOUT. If an argument is given it is assumed to be a filesystem path specifying where the certificate should be written. The saved certificate can then be ...
=back
=head1 AUTHENTICATION
( run in 2.425 seconds using v1.01-cache-2.11-cpan-d8267643d1d )