Initial revision

1 files changed, 698 insertions, 0 deletions

diff --git a/fml/lib/Netlib/SMTP.pm b/fml/lib/Netlib/SMTP.pm
new file mode 100644
index 00000000..543d9888
--- /dev/null
+++ b/fml/lib/Netlib/SMTP.pm
@@ -0,0 +1,698 @@
+#-*- perl -*-
+#
+#  Copyright (C) 2000-2001 Ken'ichi Fukamachi
+#   All rights reserved. This program is free software; you can
+#   redistribute it and/or modify it under the same terms as Perl itself. 
+#
+# $Id$
+# $FML$
+#
+
+### XXX comment templates ###
+# Descriptions: 
+#    Arguments: $self $args
+# Side Effects: 
+# Return Value: none
+#############################
+
+
+package Netlib::SMTP;
+use strict;
+use vars qw(@ISA @EXPORT @EXPORT_OK);
+use Carp;
+use IO::Socket;
+use Netlib::Utils;
+use Netlib::INET4;
+use Netlib::INET6;
+
+require Exporter;
+@ISA = qw(Exporter);
+
+
+BEGIN {}
+
+
+# Descriptions: Netlib::SMTP constructor
+#    Arguments: $self $args
+# Side Effects: $self ($me) hash has some default values
+# Return Value: object
+sub new
+{
+    my ($self, $args) = @_;
+    my ($type) = ref($self) || $self;
+    my $me     = {}; # malloc new SMTP session struct
+
+    # _recipient_limit: maximum recipients in one smtp session.
+    #  _socket_timeout: basic timeout parameter for smtp session
+    #    _log_function: pointer to the log() function
+    $me->{_recipient_limit} = $args->{recipient_limit} || 1000;
+    $me->{_socket_timeout}  = $args->{socket_timeout}  || 10;
+    $me->{_log_function}    = $args->{log_function};
+
+    _initialize_delivery_session($me, $args);
+
+    # define package global pointer to the log() function
+    $LogFunctionPointer     = $args->{log_function};
+
+    return bless $me, $type;
+}
+
+
+# Descriptions: send a (SMTP/LMTP) command string to BSD socket
+#    Arguments: $self $command_string
+# Side Effects: log file by _smtplog
+#               set _last_command and _error_action in object itself
+# Return Value: none
+sub _send_command
+{
+    my ($self, $command) = @_;
+    my $socket = $self->{'_socket'};
+
+    $self->{_last_command} = $command;
+    $self->{_error_action} = '';
+    $self->_smtplog($command);
+
+    if (defined $socket) {
+	$socket->print($command, "\r\n");
+    }
+    else {
+	Log("Error: _send_command: undefined socket");
+    }
+}
+
+
+# Descriptions: receive a reply for a (SMTP/LMTP) command
+#    Arguments: $self
+# Side Effects: log file by _smtplog
+# Return Value: none
+sub _read_reply
+{
+    my ($self) = @_;
+    my $socket = $self->{'_socket'};
+
+    # unique identifier to clarify the trapped error message
+    my $id = $$;
+
+    # toggle flag whether we should check SMTP attributes or not.
+    # we should check it only in HELO phase.
+    my $check_attributes = 0;
+    if ($self->{_last_command} =~ /^(EHLO|HELO|LHLO)/) {
+	$check_attributes = 1;
+    }
+
+    # XXX Attention! dynamic scope by local() for %SIG is essential.
+    #     See books on Perl for more details on my() and local() difference.
+    eval {
+	local($SIG{ALRM}) = sub { die("$id socket timeout")}; 
+	alarm( $self->{_socket_timeout} );
+	my $buf = '';
+
+      SMTP_REPLY:
+	while (1) {
+	    $buf = $socket->getline;
+	    $self->_smtplog($buf);
+
+	    # check smtp attributes
+	    if ($check_attributes) {
+		if ($buf =~ /^250.PIPELINING/i) {
+		    $self->{'_can_use_pipelining'} = 'yes'; 
+		}
+		if ($buf =~ /^250.ETRN/i) {
+		    $self->{'_can_use_etrn'} = 'yes';
+		}
+		if ($buf =~ /^250.SIZE\s+(\d+)/i) {
+		    $self->{'_size_limit'} = $1;
+		}
+	    }
+
+	    # store the latest status code
+	    if ($buf =~ /^(\d{3})/) { $self->_set_status_code($1);}
+
+	    # check status code
+	    if ($buf =~ /^[45]\d{2}\s/) {
+		Log($buf);
+		die("$id retry");
+	    }
+
+	    # end of reply e.g. "250 ..."
+	    last SMTP_REPLY if $buf =~ /^\d{3}\s/;
+	}
+    };
+
+    if ($@ =~ /$id retry/) {
+	$self->{'_error_action'} = "retry";
+    }
+
+    if ($@ =~ /$id socket timeout/) {
+	my $x = $self->{'_last_command'};
+	Log("Error: smtp reply for \"$x\" is timeout");
+	$self->_error_why("Error: smtp reply for \"$x\" is timeout");
+    }
+}
+
+
+# Descriptions: connect(2)
+#               1. try connect(2) by IPv6 if we can use Socket6.pm
+#               2. try connect(2) by IPv4
+#                  if $host is not IPv6 raw address e.g. [::1]:25
+#    Arguments: $self $args
+# Side Effects: set file handle (BSD socket) in $self->{_socket}
+# Return Value: file handle (created BSD socket) or undef()
+sub _connect
+{
+    my ($self, $args) = @_;
+    my $mta = $args->{'_mta'} || '127.0.0.1:25';
+    my $socket;
+
+    # 1. try to connect(2) $args->{ _mta } by IPv6 if we can use Socket6.
+    if ($self->is_ipv6_ready($args)) {
+	$self->_connect6($args);
+	my $socket = $self->{_socket};
+	return $socket if defined $socket;
+    }
+    else {
+	Log("(debug) IPv6 is not ready");
+    }
+
+    # 2. try to connect(2) $args->{ _mta } by IPv4.
+    #    XXX check the _mta syntax.
+    #    XXX if $args->{ _mta } looks [$ipv6_addr]:$port style,
+    #    XXX we do not try to connect the host by IPv4.
+    if ( $self->is_ipv6_mta_syntax($mta) ) {
+	Log("(debug) not try MTA $args->{_mta}");
+	return undef;
+    }
+    else {
+	$self->_connect4($args);
+    }
+}
+
+
+# Descriptions: close BSD socket
+#    Arguments: $self
+# Side Effects: 
+# Return Value: none
+sub close
+{
+    my ($self) = @_;
+    my $socket = $self->{'_socket'};
+
+    if (defined $socket) {
+	$socket->close;
+    }
+    else {
+	Log("Error: try to close invalid socket");
+    }
+}
+
+
+############################################################
+#####
+##### SMTP delivery main loop
+#####
+
+
+# Descriptions: main delivery loop for each recipient_maps and each mta.
+#               real delivery is done within _deliver() method.
+#               algorithm:
+#                 for each $map {
+#                    for each $mta {
+#                       call _deliver()
+#                       send recipients up to $recipient_limit
+#                    } 
+#                 }
+#                 
+#    Arguments: $self $args
+# Side Effects: See Netlib::Utils for recipient_map utilities 
+#               to track the delivery process status.
+# Return Value: none
+sub deliver
+{
+    my ($self, $args) = @_;
+
+    # recipient limit
+    $self->{_recipient_limit} = $args->{recipient_limit} || 1000;
+
+    # temporary hash to check whether the map/mta is used already.
+    my %used_mta = ();
+    my %used_map = ();
+
+    # prepare loop for each mta and map 
+    my @mta  = split(/\s+/, $args->{ mta } || '127.0.0.1:25');
+    my @maps = ();
+    if ( $args->{ recipient_maps } ) {
+	@maps = split(/\s+/, $args->{ recipient_maps });
+    }
+
+    # alloc virtual recipient map
+    if (ref( $args->{ recipient_array } ) eq 'ARRAY') {
+	my $map = $self->_alloc_recipients_array_on_memory($args);
+	push(@maps, $map);
+    }
+
+  MAP:
+    for my $map ( @maps ) {
+	# uniq $map
+	next if $used_map{ $map }; $used_map{ $map } = 1;
+	
+	$self->_set_target_map($map);
+	$self->_set_map_status($map, 'not done');
+	$self->_set_map_position($map, 0);
+
+	# To avoid infinite loop, we enforce some artificial limit.
+	# The loop evaluation is limited to "4 * $number_of_mta" for each $map.
+	my $loop_count     = 0;
+	my $max_loop_count = ($#mta * 4) || 4;
+
+      MTA_RETRY_LOOP:
+	while (1) {
+	    my $n_mta = 0;
+
+	    # check infinite loop
+	    if ($loop_count++ > $max_loop_count) {
+		Log("Error: infinite loop for map=$map");
+		last MTA_RETRY_LOOP;
+	    }
+
+	  MTA:
+	    for my $mta (@mta) {
+		# uniq $mta
+		next if $used_mta{ $mta }; $used_mta{ $mta } = 1;
+
+		# count the number of effective mta in this inter loop.
+		$n_mta++;
+
+		# o.k. try to deliver mail by using $mta.
+		Log("(debug) use $mta for map=$map");
+		$args->{ _mta } = $mta;
+		$self->_deliver($args);
+
+		# remove error messages for the next _deliver() session.
+		$self->error_reset;
+
+		# we read the whole $map now. 
+		if ($self->_get_map_status($map) eq 'done') {
+		    last MTA;
+		}
+	    } # end of MTA: loop
+
+	    # end of MTA_RETRY_LOOP: loop
+	    if ($self->_get_map_status($map) eq 'done') {
+		last MTA_RETRY_LOOP;
+	    }
+
+	    # NO effective mta in this inter loop. It impiles that
+	    # we used all MTA candidates. We reuse @mta again.
+	    if ($n_mta == 0) { 
+		Log("(debug) we used all MTA candidates. reuse \$mta");
+		undef %used_mta;
+		next MTA_RETRY_LOOP;
+	    }
+	}
+    }
+
+    # clean up recipient_map information after "all delivery"
+    # CAUTION: this mapinfo tracks the delivery status.
+    $self->_reset_mapinfo;
+
+    if ( $self->{ _num_recipients } ) { 
+	Log( "recipients: ". $self->{ _num_recipients } );
+    }
+}
+
+
+# Descriptions: ordinary SMTP sequence (see RFC821 for more details)
+#              >220 I am some MTA ...
+#              <EHLO/HELO myname
+#              >250 ok
+#              <MAIL FROM:<$sender>
+#              >250 ok
+#              <RCPT TO:<$recipient>
+#              >250 oK
+#              <DATA
+#              >354 ...
+#              < message
+#              <.
+#              >250 oK
+#              <QUIT
+#              >221 good bye
+#    Arguments: $self $args
+# Side Effects: remove error messages when we return from here
+#               for the next _deliver() session.
+# Return Value: none
+sub _deliver
+{
+    my ($self, $args) = @_;
+
+    $self->_initialize_delivery_session($args);
+
+    # prepare smtp information
+    my $myhostname = $args->{ myhostname } || 'localhost';
+    
+    # 0. create BSD SOCKET as the communication terminal
+    #    IF_ERROR_FOUND: do nothing and return as soon as possible
+    my $socket = $self->_connect($args);
+    $socket || return;
+
+    # 1. receive the first "220 .." message
+    #    If you faces some error in this stage, you have to do nothing 
+    #    since smtp connection has not established yet.
+    #    IF_ERROR_FOUND: do nothing and return as soon as possible
+    $self->_read_reply;
+    if ($self->error) { return;}
+
+    # 2. EHLO/HELO;
+    #    IF_ERROR_FOUND: do nothing and return as soon as possible
+    $self->_send_command("EHLO $myhostname");
+    $self->_read_reply;
+    if ($self->error) { $self->_reset_smtp_transaction;	return;}
+
+    # 3. MAIL FROM;
+    #    IF_ERROR_FOUND: do nothing and return as soon as possible
+    $self->_send_mail_from($args);
+    if ($self->error) { $self->_reset_smtp_transaction; return;}
+
+    # 4. RCPT TO; ... send list of recipients
+    #    IF_ERROR_FOUND: roll back the process to the state before this 
+    $self->_send_recipient_list($args);
+    if ($self->error) {
+	$self->_rollback_map_position;
+	$self->_reset_smtp_transaction;
+	return;
+    }
+
+    # 5. DATA; send the mail body itself
+    #    IF_ERROR_FOUND: handled in _send_data_to_mta(), so
+    #                    return as soon as possible from here.
+    $self->_send_data_to_mta($args);
+    if ($self->error) { return;}
+
+    # 6. QUIT; SMTP session closing ...
+    #    IF_ERROR_FOUND: do nothing ?
+    $self->_send_command("QUIT");
+    $self->_read_reply;
+    if ($self->error) { $self->_reset_smtp_transaction; return;}
+}
+
+
+# Descriptions: initialize _deliver() process
+#               this routine is called at the first phase in _deliver()
+#    Arguments: $self $args
+# Side Effects: 
+# Return Value: none
+sub _initialize_delivery_session
+{
+    my ($self, $args) = @_;
+    $self->{ _last_command } = '';
+    $self->{ _status_code  } = '';
+}
+
+
+############################################################
+#####
+##### MAIL FROM:
+#####
+
+# Descriptions: send SMTP command "MAIL FROM"
+#    Arguments: $self $args
+# Side Effects: none
+# Return Value: none
+#     See Also: RFC821, RFC1123
+#         TODO: VERP's
+sub _send_mail_from
+{
+    my ($self, $args) = @_;
+    my $sender = $args->{ smtp_sender };
+    $self->_send_command("MAIL FROM:<$sender>");
+    $self->_read_reply;
+}
+
+
+
+############################################################
+#####
+##### RCPT TO:
+#####
+
+# Descriptions: We evaluate recipient_maps parameter here. 
+#               You can use a lot of classes for this directive: e.g.
+#               file, UNIX's /etc/group, YP, SQL, LDAP, ...
+#               Example: recipient_maps = file:members
+#                                         unix.group:admin
+#                                         mysql:toymodel
+#               IO::MapAdapter class is essential to handle abstract 
+#               $recipient_map.
+#    Arguments: $self $args
+# Side Effects: $self->{ _retry_recipient_table } has recipients which 
+#               causes some errors.
+#               _{set,get}_map_position() and _{set,get}_map_status()
+#               tracks the delivery process.
+# Return Value: none
+sub _send_recipient_list_by_recipient_map
+{
+    my ($self, $args) = @_;
+    my $map = $self->_get_target_map;
+
+    # open abstract recipient list objects.
+    # $map syntax is "type:parameter", e.g., 
+    # file:$filename mysql:$schema_name
+    use IO::MapAdapter;
+    my $obj = new IO::MapAdapter $map;
+
+    unless (defined $obj) {
+	Log("Error: cannot get object for $map by IO::MapAdapter");
+    }
+    else { # $obj is good.
+	my $rcpt;
+	my $num_recipients = 0;
+	my $recipient_limit = $self->{_recipient_limit};
+
+	$obj->open;
+
+	# roll back the previous file offset
+	if ($self->_get_map_position($map) > 0) {
+	    $obj->setpos( $self->_get_map_position($map) );
+	}
+
+	# XXX $obj->get_recipient returns a mail address.
+      RCPT_INPUT:
+	while (defined ($rcpt = $obj->get_recipient)) {
+	    $num_recipients++;
+	    $self->_send_command("RCPT TO:<$rcpt>");
+	    $self->_read_reply;
+
+	    # save addresses to retry later.
+	    if ($self->{_error_action} eq 'retry') {
+		$self->{ _retry_recipient_table }->{ $rcpt } = 'retry';
+	    }
+
+	    last RCPT_INPUT if $num_recipients >= $recipient_limit;
+	}
+
+	# save the current position in the file handle
+	$self->_set_map_position($map, $obj->getpos);
+
+	# done.
+	if ($obj->eof) {
+	    $self->_set_map_status($map, 'done');
+	}
+
+	# ends
+	$obj->close;
+
+	# count up the total number of recipients
+	$self->{ _num_recipients } += $num_recipients;
+
+	unless ($num_recipients) {
+	    Log("Error: no recipients for $map");
+	    $self->_send_command("RSET");
+	    $self->_read_reply;
+	}
+    }
+}
+
+
+# Descriptions: send "RCPT TO:<recipient>" to MTA
+#    Arguments: $self $args
+# Side Effects: none
+# Return Value: none
+sub _send_recipient_list
+{
+    my ($self, $args) = @_;
+    
+    # evaluate recipient_maps
+    if ( $self->_get_target_map ) {
+	$self->_send_recipient_list_by_recipient_map($args);
+    }
+}
+
+
+# Descriptions: create CODE REFERECE to handle recipients array on memory 
+#    Arguments: $self $args
+# Side Effects: $me is referenced, so not destroyed. It is a closure (?).
+# Return Value: CODE REFERENCE
+sub _alloc_recipients_array_on_memory
+{
+    my ($self, $args) = @_;
+    return sub {
+	my ($me) = @_;
+	$me->{ _recipients_array_on_memory } = $args->{ recipient_array };
+    };
+}
+
+
+############################################################
+#####
+##### DATA:
+#####
+
+# Descriptions: send the header part of the message to socket
+#    Arguments: $self $socket $ref_to_header
+#               $ref_to_header is the FML::Header class object.
+# Side Effects: none
+# Return Value: none
+sub _send_header_to_mta
+{
+    my ($self, $socket, $header) = @_;
+
+    # get header 
+    my $h = $header->as_string($socket);
+    $h =~ s/\n/\r\n/g;
+    print $socket $h;
+    $self->_smtplog($h);
+}
+
+
+# Descriptions: send the body part of the message to socket
+#               replace "\n" in the end of line with "\r\n" on memory.
+#               We should do it to use as less memory as possible.
+#               So we use substr() to process each line.
+#    Arguments: $self $socket $ref_to_body
+# Side Effects: none
+# Return Value: none
+sub _send_body_to_mta
+{
+    my ($self, $socket, $r_body) = @_;
+    my ($pp, $p, $maxlen, $len, $buf, $pbuf);
+
+    $pp     = 0;
+    $maxlen = length($$r_body);
+
+    # write each line in buffer
+  SMTP_IO:
+    while (1) {
+	$p   = index($$r_body, "\n", $pp);
+	$len = $p  - $pp + 1;
+	$buf = substr($$r_body, $pp, ($p < 0 ? $maxlen-$pp : $len));
+	if ($buf !~ /\r\n$/) { $buf =~ s/\n$/\r\n/;}
+
+	# ^. -> ..
+	$buf =~ s/^\./../;
+
+	$self->_smtplog($buf);
+	print $socket $buf;
+
+	last SMTP_IO if $p < 0;
+	$pp = $p + 1;
+    }
+}
+
+
+# Descriptions: send message itself to file handle (BSD socket here)
+#    Arguments: $self $args
+# Side Effects: 
+# Return Value: none
+#         TODO: MIME/multipart
+sub _send_data_to_mta
+{
+    my ($self, $args) = @_;
+
+
+    # XXX debug;
+    # Log("(debug) not send DATA now"); return ;
+    # 
+
+
+    # prepare smtp information
+    my $body       = $args->{ body };
+    my $header     = $args->{ header };
+    my $socket     = $self->{'_socket'};
+
+    if (defined $body) {
+	$self->_send_command("DATA");
+	$self->_read_reply;
+
+	# XXX if "DATA" transaction cannot start, retry ?
+	if ($self->_get_status_code != '354' || $self->error) { 
+	    Log($self->error); 
+	    return undef;
+	}
+
+	# 1. header; send header
+	$self->_send_header_to_mta($socket, $header);
+
+	# 2. separator between header and body
+	print $socket "\r\n";
+	$self->_smtplog("\r\n");
+
+	# 3. body; send(copy) body on memory to socket each line
+	$self->_send_body_to_mta($socket, $body);
+
+	# end "DATA" transaction
+	$self->_send_command(".");
+	$self->_read_reply;
+    }
+}
+
+
+############################################################
+#####
+##### QUIT / RSET
+#####
+
+# Descriptions: send the SMTP reset "RSET" command
+#    Arguments: $self $args
+# Side Effects: none
+# Return Value: none
+sub _reset_smtp_transaction
+{
+    my ($self, $args) = @_;
+    $self->_send_command("RSET");
+    $self->_read_reply;
+    Log("Info: reset smtp transcation");
+}
+
+
+=head1 NAME
+
+Netlib::SMTP.pm - SMTP functions
+
+=head1 SYNOPSIS
+
+   use Netlib::SMTP;
+   my $service = new Netlib::SMTP $CurProc;
+
+
+=head1 DESCRIPTION
+
+
+
+=head1 AUTHOR
+
+Ken'ichi Fukamachi
+
+
+=head1 COPYRIGHT
+
+Copyright (C) 2001 Ken'ichi Fukamachi
+
+All rights reserved. This program is free software; you can
+redistribute it and/or modify it under the same terms as Perl itself. 
+
+=head1 HISTORY
+
+Netlib::SMTP.pm appeared in fml5.
+
+=cut
+
+1;