percolate-mail 1.0.0

data/examples/percolate-chuckmail

@@ -0,0 +1,36 @@
+#!/usr/bin/ruby
+
+require 'optparse'
+require 'percolate-mail'
+
+opts = OptionParser.new do |o|
+	o.on("-p PORT", "--port PORT", Integer, 
+		"Accept connections on port PORT (defaults to 10025)") do |port|
+		$port = port
+	end
+
+	o.on("-i IPADDR", "--ip IPADDRESS", String,
+		"Bind to IP address IPADDR (defaults to 0.0.0.0)") do |ip|
+		$ip = ip
+	end
+
+	 o.on_tail("-h", "--help", "Show this message") do
+         puts "A lovely little Ruby implementation of that famous BOFH"
+         puts "script \"chuckmail\".  This is what percolate-mail does"
+         puts "by default, because I'm too frightened to have it actually"
+         puts "deliver mail by default on account of the horror that could"
+         puts "be unleashed at that."
+         puts ""
+         puts "What chuckmail does is: it simulates an open relay.  But it"
+         puts "just discards all messages delivered to it.  Very handy if"
+         puts "you want to catch a spammer in the act."
+         puts ""
+		 puts opts
+		 exit
+	 end
+end
+
+opts.parse(ARGV)
+
+listener = Percolate::Listener.new	:port => $port || 10025, :ipaddr => $ip || '0.0.0.0'
+listener.go

data/lib/percolate/listener.rb

@@ -0,0 +1,140 @@
+require "percolate/responder"
+require "socket"
+
+module Percolate
+    class Listener
+        CRLF = "\r\n"
+
+        # The constructor for an smtp listener.  This has a number of
+        # options you can give it, a lot of which already have defaults.
+        #
+        # :verbose_debug::   Just turns on lots of debugging output.
+        # :responder::       The responder class you want to use as a
+        #                    responder.  This defaults to, as you might
+        #                    expect, SMTP::Responder, but really I want
+        #                    you to subclass that and write your own 
+        #                    mail handling code.  Its normal default
+        #                    behaviour is to act as a sort of null MTA,
+        #                    accepting and cheerfully discarding
+        #                    messages.
+        # :ipaddress::       The IP address you want this to listen on.
+        #                    Defaults to 0.0.0.0 (all available
+        #                    interfaces)
+        # :port              The port to listen on.  I have it default
+        #                    to 10025 rather than, as you might expect,
+        #                    25, because 25 is a privileged port and so
+        #                    you have to be root to listen on it.
+        #                    Unless you're foolish enough to try
+        #                    building a real MTA on this (just leave
+        #                    that kind of foolishness to me), just stick
+        #                    to leaving this at a high port and letting
+        #                    Postfix or Sendmail or your real MTA of
+        #                    choice filter through it.
+        def initialize(opts = {})
+            @ipaddress = "0.0.0.0"
+            @hostname = "localhost"
+            @port = 10025
+            @responder = Responder
+
+            @verbose_debug = opts[:debug]
+            @ipaddress     = opts[:ipaddr] if opts[:ipaddr]
+            @port          = opts[:port] if opts[:port]
+            @hostname      = opts[:hostname] if opts[:hostname]
+            @responder     = opts[:responder] if opts[:responder]
+
+            @socket = TCPServer.new @ipaddress, @port
+        end
+
+        # My current hostname as return by the HELO and EHLO commands
+        attr_accessor :hostname
+
+        # Once the listener is running, let it start handling mail by
+        # invoking the poorly-named "go" method.
+        def go
+            trap 'CLD' do 
+                debug "Got SIGCHLD"
+                reap_children 
+            end
+            trap 'INT' do 
+                debug "Got SIGINT"
+                cleanup_and_exit 
+            end
+            
+            @pids = []
+            while mailsocket=@socket.accept
+                debug "Got connection from #{mailsocket.peeraddr[3]}"
+                pid = handle_connection mailsocket
+                mailsocket.close
+                @pids << pid
+            end
+        end
+
+        private
+
+        def handle_connection mailsocket
+            fork do # I can't imagine the contortions required
+                          # in Win32 to get "fork" to work, but hey,
+                          # maybe someone did so anyway.
+                responder = @responder.new hostname, 
+                    :originating_ip => mailsocket.peeraddr[3]
+                begin
+                    while true
+                        response = responder.response
+                        handle_response mailsocket, response
+
+                        cmd = mailsocket.readline
+                        cmd.chomp! CRLF
+                        responder.command cmd
+                    end
+                rescue TransactionFinishedException
+                    mailsocket.puts responder.response + CRLF
+                    mailsocket.close
+                    exit!
+                rescue
+                    mailsocket.puts "421 Server confused, shutting down" +
+                        CRLF
+                    mailsocket.close
+                    exit!
+                end
+            end
+        end
+
+        def handle_response mailsocket, response
+            case response 
+            when String then
+                mailsocket.write response + CRLF
+            when Array then
+                response.each do |str|
+                    mailsocket.write str + CRLF
+                end
+            when NilClass then
+                nil # server has nothing to say
+            end
+        end
+
+        # Prevent a BRAAAAAAINS situation
+        def reap_children
+            begin
+                while reaped=Process.waitpid
+                    @pids -= [ reaped ]
+                end
+            rescue Errno::ECHILD
+                nil
+            end
+        end
+
+        def cleanup_and_exit
+            debug "Shutting down"
+            @socket.close
+            exit
+        end
+
+        def debug debug_string
+            @debugging_stream ||= []
+            @debugging_stream << debug_string
+            if @verbose_debug
+                $stderr.puts debug_string
+            end
+        end
+    end
+end

data/lib/percolate/mail_object.rb

@@ -0,0 +1,106 @@
+# Quoth RFC 2821:
+#   SMTP transports a mail object.  A mail object contains an envelope and
+#   content.
+#
+#   It also happens to contain a couple of ancillary other bits of
+#   information these days, like what the source host was calling
+#   itself, what its actual IP address was, and the actual name of that
+#   IP address if the MTA is feeling particularly enthusiastic, as well
+#   as an SMTP ID to aid sysadmins in sludging through logs, assuming
+#   that any sysadmin still does that, and of course your own idea of
+#   what your name is.
+#
+#   All of this ancillary information goes into the Received: header
+#   which--tee hee!--this thing doesn't even bother writing!  Yet.  No
+#   doubt there's an RFC probably written by one of those rabid
+#   antispammers that make you feel happier just lumping it with the
+#   spam (I'm sure you all know the type--"It comes from Asia!  It must
+#   be spam!"  Yes, but I *AM* in Asia) saying that any email message
+#   which doesn't have the required number of Received: headers in it
+#   must, by definition, be spam, and is thus safe to delete on sight.
+#
+#   Which I suppose makes "add Received: header" part of my huge TODO
+#   list, but well, you know?  I have a LIFE.  Maybe.
+#
+# In most pieces of software, this entire rant would be replaced by a
+# complete copy of the GPL, which is I am sure a total improvement over
+# the standard corporate code preamble of 18 copyright messages
+# detailing every single company which has urinated on the code (and
+# what year they did so in).
+
+module Percolate
+
+    # The SMTP::MailObject is mostly a class.  It's what is produced by the
+    # Percolate::Responder class as a result of a complete SMTP transaction.
+    class MailObject
+
+        # The constructor.  It takes a whole bunch of optional
+        # keyword-style parameters.  View source for more details--I
+        # hope they're self- explanatory.  If they're not, I need to
+        # come up with better names for them.
+        def initialize(opts = {})
+            @envelope_from = opts[:envelope_from]
+            @envelope_to   = opts[:envelope_to]
+            @content       = opts[:content]
+            @origin_ip     = opts[:origin_ip]
+            @heloname      = opts[:heloname]
+            @myhostname    = opts[:myhostname]
+            @timestamp     = Time.now
+            @smtp_id       = ([nil]*16).map { rand(16).to_s(16) }.join.upcase
+        end
+
+        # You get to fiddle with these.  The SMTP standard probably has
+        # some mumbling about this data being sacrosanct, but then
+        # again, it also says that "content" can contain anything at all
+        # and you still have to accept it (and presumably, later try to
+        # reconstruct it into an actual email message).  So hey, have
+        # fun!
+        #
+        # Also, at the time of creation, the responder doesn't know
+        # necessarily who a message is meant for.  Heck, it could be
+        # meant for twenty different people!
+        attr_accessor :envelope_from, :envelope_to, :content
+
+        # These four are read-only because I hate you.  They're actually
+        # read-only because PRESUMABLY the guy creating an object of
+        # this type (namely, the responder), knows all this information
+        # at its own creation, let alone when it eventually gets around
+        # to building a MailObject object.
+        attr_reader :smtp_id, :heloname, :origin_ip, :myhostname
+        
+        begin
+            require "gurgitate/mailmessage"
+
+            # Converts a SMTP::MailObject object into a Gurgitate-Mail
+            # MailMessage object.
+            def to_gurgitate_mailmessage
+                received = "Received: from #{@heloname} (#{@origin_ip}) " +
+                           "by #{@myhostname} with SMTP ID #{smtp_id} " +
+                           "for <#{@envelope_to}>; #{@timestamp.to_s}\n"
+                message = @content.gsub "\r",""
+                begin
+                    g = Gurgitate::Mailmessage.new(received + message, 
+                                                   @envelope_to, @envelope_from)
+                rescue Gurgitate::IllegalHeader
+                    # okay, let's MAKE a mail message (the RFC actually
+                    # says that this is okay.  It says that after DATA,
+                    # an SMTP server should accept pretty well any old
+                    # crap.)
+                    message_text = received + "From: #{@envelope_from}\n" +
+                   "To: undisclosed recipients:;\n" +
+                   "X-Gurgitate-Error: #{$!}\n" +
+                   "\n" +
+                   @content
+                   return Gurgitate::Mailmessage.new(message_text, @envelope_to,
+                                                     @envelope_from)
+                end
+            end
+        rescue LoadError => e
+            nil # and don't define to_gurgitate_mailmessage.  I'm a huge
+                # egotist so I'm not including an rmail variant
+                # (besides, I thought that was abandonware!  It's
+                # certainly done a great job of lurching back to life,
+                # encrusted with grave dirt, since Rails became popular.
+        end
+    end
+end

data/lib/percolate/responder.rb

@@ -0,0 +1,347 @@
+require "percolate/mail_object"
+
+module Percolate
+    # A ResponderError exception is raised when something went horribly
+    # wrong for whatever reason.
+    #
+    # If you actually find one of these leaping into your lap in your
+    # own code, and you're not trying anything gratuitously silly, I
+    # want to know about it, because I have gone out of my way that
+    # these errors manifest themselves in an SMTPish way as error codes.
+    #
+    # If you are trying something silly though, I reserve the right to
+    # laugh at you.  And possibly mock you on my blog.  (Are you scared
+    # now?)
+    class ResponderError < Exception; end
+
+    # This is an exception that you *should* expect to receive, if you
+    # deal with the SMTP Responder yourself (you probably won't
+    # though--if you're smart, you'll just use the Listener and let it
+    # park itself on some port for other network services to talk to).
+    # All it means is that the client has just sent a "quit" message,
+    # and all is kosher, indicating that now would be a good time to
+    # clean up shop.
+    #
+    # NOTE VERY WELL THOUGH!:  When you get one of these exceptions,
+    # there is still one response left in the pipe that you have to
+    # deliver to the client ("221 Pleasure doing business with you") so
+    # make sure you deliver that before closing the connection.  It's
+    # only polite, after all.
+    class TransactionFinishedException < Exception; end
+
+    # This is the bit that actually handles the SMTP conversation with
+    # the client.  Basically, you send it commands, and it acts on them.
+    # There is a small amount of Rubyish magic but that's there mainly
+    # because I'm lazy.  And besides, if I weren't lazy, some guys on
+    # IRC would flame me.  Haha!  I kid.  Greetz to RubyPanther by the
+    # wya.  Even though I know you've never contributed anything and
+    # never will, at least you can live with the satisfaction that you
+    # don't have to deal with my evil racist ass any more.
+    class Responder
+
+        # Sets up the new smtp responder, with the parameter "mailhostname"
+        # as the SMTP hostname (as returned in the response to the SMTP
+        # HELO command.)  Note that "mailhostname" can be anything at
+        # all, because I no longer believe that it's possible to
+        # actually figure out your own full hostname without actually
+        # literally being told it.  This is probably excessively-cynical
+        # of me, but I've seen what happens when wide-eyed optimists try
+        # to guess hostnames, and it just isn't pretty.
+        #
+        # Let's just leave it at "mailhostname is a required parameter",
+        # shall we?
+        #
+        # Also, there are some interesting options you can give this.
+        # Well, only a couple.  The first is :debug which you can set to
+        # true or false, which will cause it to print the SMTP
+        # conversation out.  This is, of course, mostly only useful for
+        # debugging.
+        #
+        # The other option, :originating_ip, probably more interesting,
+        # comes from the listener--the IP address of the client that
+        # connected.
+        def initialize(mailhostname, opts={})
+            @verbose_debug = opts[:debug]
+            @originating_ip = opts[:originating_ip]
+
+            @mailhostname = mailhostname
+            @current_state = nil
+            @current_command = nil
+            @response = connect
+            @mail_object=nil
+            @debug_output = []
+            debug "\n\n"
+        end
+
+        # This is one of the methods you have to override in a subclass
+        # in order to use this class properly (unless chuckmail really 
+        # is acceptable for you, in which case excellent!  Also its
+        # default behaviour is to pretend to be an open relay, which
+        # should delight spammers until they figure out that all of
+        # their mail is being silently and cheerfully discarded, but
+        # they're spammers so they won't).
+        #
+        # Parameters:
+        # +message_object+::      A SMTP::MessageObject object, with envelope
+        #                         data and the message itself (which could, as
+        #                         the RFC says, be any old crap at all!  Don't
+        #                         even expect an RFC2822-formatted message)
+        def process_message message_object
+            return "250 accepted, SMTP id is #{@mail_object.smtp_id}"
+        end
+
+        # Override this if you care about who the sender is (you
+        # probably do care who the sender is).
+        #
+        # Incidentally, you probably Do Not Want To Become An Open Spam
+        # Relay--you really should validate both senders and recipients,
+        # and only accept mail if:
+        #
+        # (a) the sender is local, and the recipient is remote, or
+        # (b) the sender is remote, and the recipient is local.
+        #
+        # The definition of "local" and "remote" are, of course, up to
+        # you--if you're using this to handle mail for a hundred
+        # domains, then all those hundred domains are local for you--but
+        # the idea is that you _shoud_ be picky about who your mail is
+        # from and to.
+        #
+        # This method takes one argument:
+        # +address+::       The email address you're validating
+        def validate_sender address
+            return true, "ok"
+        end
+
+        # Override this if you care about the recipient (which you
+        # should).  When you get to this point, the accessor "sender"
+        # will work to return the sender, so that you can deal with both
+        # recipient and sender here.
+        def validate_recipient address
+            return true, "ok"
+        end
+
+        # The current message's sender, if the MAIL FROM: command has
+        # been processed yet.  If it hasn't, then it returns nil, and
+        # probably isn't meaningful anyway.
+        def sender
+            if @mail_object
+                @mail_object.envelope_from
+            end
+        end
+
+        # Returns the response from the server.  When there's no response,
+        # returns nil.  
+        #
+        # I still haven't figured out what to do when there's
+        # more than one response (like in the case of an ESMTP capabilities
+        # list).
+        def response
+            resp = @response
+            @response = nil
+            debug "<<< #{resp}"
+            resp
+        end
+
+        # Send an SMTP command to the responder.  Use this to send a
+        # line of input to the responder (including a single line of
+        # DATA).
+        #
+        # Parameters:
+        # +offered_command+::   The SMTP command (with end-of-line characters
+        #                       removed)
+        def command offered_command
+            debug ">>> #{offered_command}"
+            begin
+                dispatch offered_command
+            rescue ResponderError => error
+                @response = error.message
+            end
+        end
+
+        private
+
+        attr_reader :current_state
+        attr_reader :current_command
+
+        CommandTable = { 
+            /^helo ([a-z0-9.-]+)$/i => :helo,
+            /^ehlo ([a-z0-9.-]+)$/i => :ehlo,
+            /^mail (.+)$/i          => :mail,
+            /^rcpt (.+)$/i          => :rcpt,
+            /^data$/i               => :data,
+            /^\.$/                  => :endmessage,
+            /^rset$/i               => :rset,
+            /^quit$/                => :quit
+        }
+
+        StateTable = {
+            :connect => { :states => [ nil ], 
+                :error => "This should never happen" },
+            :smtp_greeted_helo => { :states => [ :connect,
+                                    :smtp_greeted_helo,
+                                    :smtp_greeted_ehlo,
+                                    :smtp_mail_started,
+                                    :smtp_rcpt_received,
+                                    :message_received ],
+                                    :error => nil },
+            :smtp_greeted_ehlo => { :states => [ :connect ],
+                                    :error => nil },
+            :smtp_mail_started => { :states => [ :smtp_greeted_helo, 
+                                                 :smtp_greeted_ehlo,
+                                                 :message_received ], 
+                                    :error => "Can't say MAIL right now" }, 
+            :smtp_rcpt_received => { :states => [ :smtp_mail_started,
+                                                  :smtp_rcpt_received ],
+                       :error => "need MAIL FROM: first" },
+            :data => { :states => [ :smtp_rcpt_received ],
+                       :error => "Specify sender and recipient first" },
+            :message_received => { :states => [ :data ],
+                       :error => "500 command not recognized" },
+            :quit => { :states => [ :ANY ],
+                       :error => nil },
+        }
+
+        def debug debug_string
+            @debugging_stream ||= []
+            @debugging_stream << debug_string
+            if @verbose_debug
+                $stderr.puts debug_string
+            end
+        end
+
+        def dispatch offered_command
+            if @current_state == :data
+                handle_message_data offered_command
+                return true
+            end
+
+            CommandTable.keys.each do |regex|
+                matchdata = regex.match offered_command
+                if matchdata then
+                    return send(CommandTable[regex],*(matchdata.to_a[1..-1]))
+                end
+            end
+            raise ResponderError, "500 command not recognized"
+        end
+
+        def connect
+            validate_state :connect
+            respond "220 Ok"
+        end
+
+        # Makes sure that the commands are all happening in the right
+        # order (and complains if they're not)
+        def validate_state target_state
+            unless StateTable[target_state][:states].member? current_state or
+                StateTable[target_state][:states] == [ :ANY ]
+                raise ResponderError, "503 #{StateTable[target_state][:error]}"
+            end
+            @target_state = target_state
+        end
+
+        def respond response
+            @current_state = @target_state
+            @response = response
+        end
+
+        # The smtp commands.  This is thus far not a complete set of
+        # every single imagineable SMTP command, but it's certainly
+        # enough to be able to fairly call this an "SMTP server".
+        #
+        # If you want documentation about what each of these does, see
+        # RFC2821, which explains it much better and in far greater
+        # detail than I could.
+
+        def helo remotehost
+            validate_state :smtp_greeted_helo
+            @heloname = remotehost
+            @mail_object = nil
+            @greeting_state = :smtp_greeted_helo # for rset
+            respond "250 #{@mailhostname}"
+        end
+
+        def ehlo remotehost
+            validate_state :smtp_greeted_ehlo
+            @heloname = remotehost
+            @mail_object = nil
+            @greeting_state = :smtp_greeted_ehlo # for rset
+            respond "250 #{@mailhostname}"
+        end
+
+        def mail sender
+            validate_state :smtp_mail_started
+            matchdata=sender.match(/^From:\<(.*)\>$/i);
+            unless matchdata
+                raise ResponderError, "501 bad MAIL FROM: parameter"
+            end
+
+            mail_from = matchdata[1]
+
+            validated, message = validate_sender mail_from
+            unless validated
+                raise ResponderError, "551 #{message}"
+            end
+
+            @mail_object = MailObject.new(:envelope_from => mail_from,
+                                          :heloname => @heloname,
+                                          :origin_ip => @originating_ip,
+                                          :myhostname => @mailhostname)
+            respond "250 #{message}"
+        end
+
+        def rcpt recipient
+            validate_state :smtp_rcpt_received
+            matchdata=recipient.match(/^To:\<(.*)\>$/i);
+            unless matchdata
+                raise ResponderError, "501 bad RCPT TO: parameter"
+            end
+
+            rcpt_to = matchdata[1]
+
+            @mail_object.envelope_to ||= []
+
+            validated, message = validate_recipient rcpt_to
+            unless validated
+                raise ResponderError, "551 #{message}"
+            end
+            @mail_object.envelope_to << rcpt_to
+            respond "250 #{message}"
+        end
+
+        def data
+            validate_state :data
+            @mail_object.content ||= ""
+            respond "354 end data with <cr><lf>.<cr><lf>"
+        end
+
+        def rset
+            if @mail_object
+                @mail_object = nil
+                @target_state = @greeting_state
+            end
+            respond "250 Ok"
+        end
+
+        def quit
+            validate_state :quit
+            if @mail_object
+                @mail_object = nil
+            end
+            respond "221 Pleasure doing business with you"
+            raise TransactionFinishedException
+        end
+
+        # The special-case code for message data, which unlike other
+        # data, is delivered as lots and lots of lines with a sentinel.
+        def handle_message_data message_line
+            if message_line == "."
+                @current_state = :message_received
+                @response = process_message @mail_object
+            elsif message_line == ".."
+                @mail_object.content << "." + "\r\n"
+            else
+                @mail_object.content << message_line + "\r\n"
+            end
+        end
+    end
+end

data/lib/percolate-mail.rb

@@ -0,0 +1 @@
+require "percolate/listener"  # which actually slurps everything else in

data/test/test_percolate_listener.rb

@@ -0,0 +1,220 @@
+# Please note that this is broken right now
+#
+# Yes, fixing it is on my TODO list.
+#
+# --Dave
+require "test/unit"
+
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+
+$DEBUG = ARGV.include? '-d'
+
+require "percolate-mail"
+
+class SMTPConnection
+	def initialize
+		@socket = TCPSocket.new "localhost", 10025
+	end
+
+	def response
+		resp = ""
+		str = @socket.recv(1000)
+		resp << str
+		$stderr.puts "<- #{resp.inspect}" if $DEBUG
+		if resp.chomp("\r\n") == resp
+			raise "whoops, we're not doing EOLs properly"
+		else
+			return resp.chomp("\r\n")
+		end
+	end
+
+	def command str
+		$stderr.puts "-> #{str.inspect}" if $DEBUG
+		@socket.write_nonblock str + "\r\n"
+	end
+
+	def closed?
+		@socket.eof?
+	end
+end
+
+class TestPercolateResponder < Test::Unit::TestCase
+	TestHostName="testhelohost"
+
+	def setup
+		@pid = fork do 
+			listener = Percolate::Listener.new :hostname => TestHostName
+			listener.go
+		end
+
+		sleep 0.2 # to give the listener time to fire up
+
+		@responder ||= SMTPConnection.new
+		# @responder = Percolate::Responder.new TestHostName, :debug => false
+	end
+
+	def teardown
+		begin
+			if @responder
+				@responder.command 'quit'
+				@responder.response
+			end
+		rescue
+		end
+		$stderr.puts "== killing #{@pid}" if $DEBUG
+		Process.kill 'KILL', @pid
+		$stderr.puts "== waiting for #{@pid}" if $DEBUG
+		Process.waitpid @pid
+		sleep 0.1
+	end
+
+	def test_initialize
+		assert_equal "220 Ok", @responder.response
+	end
+
+	def test_helo
+		test_initialize
+		@responder.command "helo testhelohost"
+		assert_equal "250 #{TestHostName}", @responder.response
+	end
+
+	def test_ehlo
+		test_initialize
+		@responder.command "ehlo testhelohost"
+		assert_equal "250 #{TestHostName}", @responder.response
+	end
+
+	def test_randomcrap
+		test_initialize
+		@responder.command "huaglhuaglhuaglhuagl"
+		assert_equal "500 command not recognized", @responder.response
+	end
+
+	def test_mail_from_valid
+		test_ehlo
+		@responder.command "mail from:<validaddress>"
+		assert_equal "250 ok", @responder.response
+	end
+
+	def test_mail_from_nested
+		test_mail_from_valid
+		@responder.command "mail from:<anotheraddress>"
+		assert_equal "503 Can't say MAIL right now", @responder.response
+	end
+
+	def test_mail_from_invalid
+		test_ehlo
+		@responder.command "mail from: invalidsyntax"
+		assert_equal "501 bad MAIL FROM: parameter", @responder.response
+		assert_nil @responder.instance_variable_get("@mail_object")
+	end
+
+	def test_good_after_bad
+		test_mail_from_invalid
+		@responder.command "mail from:<validaddress>"
+		assert_equal "250 ok", @responder.response
+	end
+
+	def test_rset_after_mail_from
+		test_mail_from_valid
+		@responder.command "rset"
+		assert_equal "250 Ok", @responder.response
+		assert_nil @smtpd.instance_variable_get("@mail_object")
+		@responder.command "helo testhelohost"
+		assert_equal "250 #{TestHostName}", @responder.response
+		@responder.command "mail from:<anotheraddress>"
+		assert_equal "250 ok", @responder.response
+	end
+
+	def test_rcpt_to_valid
+		test_mail_from_valid
+		@responder.command "rcpt to:<validrcptaddress>"
+		assert_equal "250 ok", @responder.response
+	end
+
+	def test_crappy_transaction_bad_from_good_to
+		test_mail_from_invalid
+		@responder.command "rcpt to:<validrcptaddress>"
+		assert_equal "503 need MAIL FROM: first", 
+			@responder.response
+		assert_nil @responder.instance_variable_get("@mail_object") 
+	end
+
+	def test_rcpt_to_multiple
+		test_rcpt_to_valid
+		@responder.command "rcpt to:<anothervalidrcptaddress>"
+		assert_equal "250 ok", @responder.response
+	end
+
+	def test_rcpt_to_invalid
+		test_mail_from_valid
+		@responder.command "rcpt to: not actually valid"
+		assert_equal "501 bad RCPT TO: parameter", @responder.response
+	end
+
+	def test_rcpt_to_at_wrong_time
+		test_helo
+		@responder.command "rcpt to:<validrcptaddress>"
+		assert_equal "503 need MAIL FROM: first", @responder.response
+	end
+
+	def test_data
+		test_rcpt_to_valid
+		@responder.command "data"
+		assert_equal "354 end data with <cr><lf>.<cr><lf>", 
+			@responder.response
+		@responder.command "This is a test"
+		@responder.command "Line 2 of the test"
+		@responder.command "."
+		assert_match /250 accepted, SMTP id is [A-Z0-9]+/, @responder.response
+	end
+
+	def test_data_at_wrong_time
+		test_mail_from_valid
+		@responder.command "data"
+		assert_equal "503 Specify sender and recipient first",
+			@responder.response
+	end
+
+	def test_quit
+		@responder.command 'quit'
+		assert_match /221 Pleasure doing business with you/, 
+					 @responder.response
+		assert @responder.closed?
+		@responder = nil
+	end
+
+	def test_quit_after_message
+		test_data
+		test_quit
+	end
+
+	def test_quit_after_helo
+		test_helo
+		test_quit
+	end
+
+	def test_quit_after_mail_from
+		test_mail_from_valid
+		test_quit
+	end
+
+	def test_more_than_one_message
+		test_data
+		@responder.command "mail from:<validaddress>"
+		assert_equal "250 ok", @responder.response
+		@responder.command "rcpt to:<validrcptaddress>"
+		assert_equal "250 ok", @responder.response
+		@responder.command "data"
+		assert_equal "354 end data with <cr><lf>.<cr><lf>", 
+			@responder.response
+		@responder.command "This is a test"
+		@responder.command "Line 2 of the test"
+		@responder.command "."
+		assert_match /250 accepted, SMTP id is [A-Z0-9]+/, @responder.response
+	end
+
+	def test_long_complete_transaction
+		test_more_than_one_message
+	end
+end

data/test/test_percolate_responder.rb

@@ -0,0 +1,358 @@
+require "test/unit"
+
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+
+require "percolate/responder"
+
+class MyResponder < Percolate::Responder
+    attr_writer :sender_validation, :recipient_validation
+
+    Responses = { false => "no", true => "ok" }
+
+    def initialize(hostname,opts={})
+        @sender_validation = true
+        @recipient_validation = true
+        super(hostname, opts)
+    end
+
+    def validate_sender addr
+        return @sender_validation, Responses[@sender_validation]
+    end
+
+    def validate_recipient addr
+        return @recipient_validation, Responses[@recipient_validation]
+    end
+end
+
+class TestPercolateResponder < Test::Unit::TestCase
+    TestHostName="testhost"
+
+    def setup
+        @responder = Percolate::Responder.new TestHostName, :debug => false
+    end
+
+    def test_initialize
+        assert_equal "220 Ok", @responder.response
+    end
+
+    def test_should_never_get_here
+        # deliberately meddle about with the internal state of the thing
+        # because I have no doubt that someone will at some point do just
+        # that.
+        @responder.instance_variable_set "@current_state", :data
+        assert_raises Percolate::ResponderError do
+            @responder.__send__ :connect
+            puts @responder.response
+        end
+    end
+
+    def test_helo
+        test_initialize
+        @responder.command "helo testhelohost"
+        assert_equal "250 #{TestHostName}", @responder.response
+        assert_equal "testhelohost", 
+            @responder.instance_variable_get("@heloname")
+    end
+
+    def test_should_never_get_here
+        test_helo
+        assert_raises Percolate::ResponderError do
+            @responder.__send__ "connect"
+        end
+    end
+
+    def test_ehlo
+        test_initialize
+        @responder.command "ehlo testhelohost"
+        assert_equal "250 #{TestHostName}", @responder.response
+        assert_equal "testhelohost", 
+            @responder.instance_variable_get("@heloname")
+    end
+
+    def test_randomcrap
+        test_initialize
+        @responder.command "huaglhuaglhuaglhuagl"
+        assert_equal "500 command not recognized", @responder.response
+    end
+
+    def test_mail_from_valid
+        test_ehlo
+        @responder.command "mail from:<validaddress>"
+        assert_equal "250 ok", @responder.response
+        assert_not_nil @responder.instance_variable_get("@mail_object")
+    end
+
+    def test_mail_from_nested
+        test_mail_from_valid
+        @responder.command "mail from:<anotheraddress>"
+        assert_equal "503 Can't say MAIL right now", @responder.response
+    end
+
+    def test_mail_from_invalid
+        test_ehlo
+        @responder.command "mail from: invalidsyntax"
+        assert_equal "501 bad MAIL FROM: parameter", @responder.response
+        assert_nil @responder.instance_variable_get("@mail_object")
+    end
+
+    def test_good_after_bad
+        test_mail_from_invalid
+        @responder.command "mail from:<validaddress>"
+        assert_equal "250 ok", @responder.response
+        assert_not_nil @responder.instance_variable_get("@mail_object")
+    end
+
+    def test_rset_after_mail_from
+        test_mail_from_valid
+        @responder.command "rset"
+        assert_equal "250 Ok", @responder.response
+        assert_nil @smtpd.instance_variable_get("@mail_object")
+        @responder.command "helo testhelohost"
+        assert_equal "250 #{TestHostName}", @responder.response
+        assert_equal "testhelohost", 
+            @responder.instance_variable_get("@heloname")
+        @responder.command "mail from:<anotheraddress>"
+        assert_equal "250 ok", @responder.response
+    end
+
+    def test_rcpt_to_valid
+        test_mail_from_valid
+        @responder.command "rcpt to:<validrcptaddress>"
+        assert_equal "250 ok", @responder.response
+        assert_equal [ "validrcptaddress" ], 
+            @responder.instance_variable_get("@mail_object") .
+                envelope_to
+    end
+
+    def test_crappy_transaction_bad_from_good_to
+        test_mail_from_invalid
+        @responder.command "rcpt to:<validrcptaddress>"
+        assert_equal "503 need MAIL FROM: first", 
+            @responder.response
+        assert_nil @responder.instance_variable_get("@mail_object") 
+    end
+
+    def test_rcpt_to_multiple
+        test_rcpt_to_valid
+        @responder.command "rcpt to:<anothervalidrcptaddress>"
+        assert_equal "250 ok", @responder.response
+        assert_equal [ "validrcptaddress", "anothervalidrcptaddress" ], 
+            @responder.instance_variable_get("@mail_object") .
+                envelope_to
+    end
+
+    def test_rcpt_to_invalid
+        test_mail_from_valid
+        @responder.command "rcpt to: not actually valid"
+        assert_equal "501 bad RCPT TO: parameter", @responder.response
+        assert_nil @responder.instance_variable_get("@mail_object") .
+                envelope_to
+    end
+
+    def test_rcpt_to_at_wrong_time
+        test_helo
+        @responder.command "rcpt to:<validrcptaddress>"
+        assert_equal "503 need MAIL FROM: first", @responder.response
+    end
+
+    def test_data
+        test_rcpt_to_valid
+        @responder.command "data"
+        assert_equal "354 end data with <cr><lf>.<cr><lf>", 
+            @responder.response
+        @responder.command "This is a test"
+        assert_equal nil, @responder.response
+        @responder.command "Line 2 of the test"
+        assert_equal nil, @responder.response
+        @responder.command "."
+        assert_match /^250 accepted, SMTP id is [0-9A-F]{16}$/, @responder.response
+        assert_equal "This is a test\r\nLine 2 of the test\r\n", 
+            @responder.instance_variable_get("@mail_object").content
+    end
+
+    def test_data_with_dot_on_line
+        test_rcpt_to_valid
+        @responder.command "data"
+        assert_equal "354 end data with <cr><lf>.<cr><lf>", 
+            @responder.response
+        @responder.command ".."
+        assert_equal nil, @responder.response
+        @responder.command "."
+        assert_match /^250 accepted, SMTP id is [0-9A-F]{16}$/, @responder.response
+        assert_equal ".\r\n", 
+            @responder.instance_variable_get("@mail_object").content
+    end
+
+    def test_data_at_wrong_time
+        test_mail_from_valid
+        @responder.command "data"
+        assert_equal "503 Specify sender and recipient first",
+            @responder.response
+    end
+
+    def quit
+        assert_raises Percolate::TransactionFinishedException, 
+            "This should never happen" do
+            @responder.command "quit"
+        end
+        assert_equal "221 Pleasure doing business with you", 
+                     @responder.response
+    end
+
+    def test_quit_after_message
+        test_data
+        quit
+    end
+
+    def test_quit_after_helo
+        test_helo
+        quit
+    end
+
+    def test_quit_after_mail_from
+        test_mail_from_valid
+        quit
+    end
+
+    def test_more_than_one_message
+        test_data
+        @responder.command "mail from:<validaddress>"
+        assert_equal "250 ok", @responder.response
+        assert_not_nil @responder.instance_variable_get("@mail_object")
+        @responder.command "rcpt to:<validrcptaddress>"
+        assert_equal "250 ok", @responder.response
+        assert_equal [ "validrcptaddress" ], 
+            @responder.instance_variable_get("@mail_object") .
+                envelope_to
+        @responder.command "data"
+        assert_equal "354 end data with <cr><lf>.<cr><lf>", 
+            @responder.response
+        @responder.command "This is a test"
+        assert_equal nil, @responder.response
+        @responder.command "Line 2 of the test"
+        assert_equal nil, @responder.response
+        @responder.command "."
+        assert_match /^250 accepted, SMTP id is [0-9A-F]{16}$/, @responder.response
+    end
+
+    def test_long_complete_transaction
+        test_more_than_one_message
+        quit
+    end
+end
+
+class TestSubclassedSMTPResponder < TestPercolateResponder
+    def setup
+        @responder = MyResponder.new TestHostName, :debug => false
+    end
+
+    def test_invalid_sender
+        @responder.sender_validation = false
+
+        test_ehlo
+        @responder.command "mail from:<invalidaddress>"
+        assert_equal "551 no", @responder.response
+        assert_nil @responder.instance_variable_get("@mail_object")
+        assert_nil @responder.sender
+    end
+
+    def test_valid_sender_after_invalid_sender
+        test_invalid_sender
+
+        @responder.sender_validation = true
+
+        @responder.command "mail from:<validaddress>"
+        assert_equal "250 ok", @responder.response
+        assert_not_nil @responder.instance_variable_get("@mail_object")
+        assert_not_nil @responder.sender
+        assert_equal "validaddress", @responder.sender
+    end
+
+    def test_invalid_recipient
+        @responder.recipient_validation = false
+
+        test_mail_from_valid
+
+        @responder.command "rcpt to:<invalidrcptaddress>"
+        assert_equal "551 no", @responder.response
+        assert_equal [ ], 
+            @responder.instance_variable_get("@mail_object") .
+                envelope_to
+    end
+
+    def test_valid_recipient_after_invalid
+        test_invalid_recipient
+
+        @responder.recipient_validation = true
+
+        @responder.command "rcpt to:<validaddress>"
+        assert_equal "250 ok", @responder.response
+        assert_equal [ "validaddress" ],
+            @responder.instance_variable_get("@mail_object") .
+                envelope_to
+    end
+
+    def test_data_actual_message
+        test_rcpt_to_valid
+        @responder.command "data"
+        assert_equal "354 end data with <cr><lf>.<cr><lf>", 
+            @responder.response
+        @responder.command "From: A Sender <sendera@example.org>"
+        assert_equal nil, @responder.response
+        @responder.command "To: A Receiver <receivera@example.com>"
+        assert_equal nil, @responder.response
+        @responder.command "Subject: You know, stuff"
+        assert_equal nil, @responder.response
+        @responder.command ""
+        assert_equal nil, @responder.response
+        @responder.command "42!"
+        assert_equal nil, @responder.response
+        @responder.command "."
+        assert_match /^250 accepted, SMTP id is [0-9A-F]{16}$/, @responder.response
+    end
+
+    def test_data_bogus_message
+        test_rcpt_to_valid
+        @responder.command "data"
+        assert_equal "354 end data with <cr><lf>.<cr><lf>", 
+            @responder.response
+        @responder.command "Boxcar!"
+        assert_equal nil, @responder.response
+        @responder.command "."
+        assert_match /^250 accepted, SMTP id is [0-9A-F]{16}$/, @responder.response
+    end
+
+    if $LOADED_FEATURES.include? "gurgitate/mailmessage.rb"
+
+      def test_to_gurgitate_mailmessage
+          test_data_actual_message
+          mo = @responder.instance_variable_get("@mail_object")
+          gm = mo.to_gurgitate_mailmessage
+          assert_instance_of Gurgitate::Mailmessage, gm
+          assert gm.headers.match('From', /sendera@example.org/)
+          assert gm.headers.match('To', /receivera@example.com/)
+      end
+
+      def test_to_gurgitate_mailmessage_with_bogus
+          test_data_bogus_message
+          mo = @responder.instance_variable_get("@mail_object")
+          gm = mo.to_gurgitate_mailmessage
+          assert_instance_of Gurgitate::Mailmessage, gm
+          assert gm.headers.match('From', /validaddress/)
+          assert gm.headers.match('To', /undisclosed/)
+          assert_match /Boxcar!/, gm.body
+      end
+   end
+end
+
+class TestDebug < TestPercolateResponder
+    def setup
+        @old_stderr = $stderr
+        $stderr = File.open("/dev/null","w")
+        @responder = Percolate::Responder.new TestHostName, :debug => true
+    end
+    
+    def teardown
+        $stderr = @old_stderr
+    end
+end

data/test/unittest_percolate_listener.rb

@@ -0,0 +1,77 @@
+
+require "test/unit"
+
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+require "percolate-mail"
+
+class Responder
+    def command cmd
+        nil
+    end
+
+    def response
+        "Boxcar!"
+    end
+end
+
+class SMTPConnection
+    def initialize
+        @socket = TCPSocket.new "localhost", 10025
+    end
+
+    def response
+        resp = ""
+        begin
+            str = @socket.recv_nonblock(1000)
+            resp << str
+        rescue Errno::EAGAIN
+            if resp.chomp "\r\n" == resp
+                raise Error, "whoops, we're not doing EOLs properly"
+            else
+                return resp
+            end
+        end
+    end
+
+    def send str
+        @socket.write_nonblock str + "\r\n"
+    end
+end
+
+
+class TestPercolateListener < Test::Unit::TestCase
+    TestHostName="localhost"
+
+    def test_startup_and_shutdown
+        pid = fork do
+            listener = Percolate::Listener.new :hostname => TestHostName,
+                :responder => ::Responder, :port => 10025
+            listener.go
+        end
+
+        sleep 0.1
+
+        sock = nil
+
+        assert_nothing_raised do
+            sock = TCPSocket.new "localhost", 10025
+        end
+
+        assert_nothing_raised do
+            sock.write "\r\n"
+        end
+
+        assert_raises Errno::EAGAIN do
+            assert_equal "Boxcar!\r\n", sock.recv_nonblock(1000)
+        end
+
+        sock.close
+
+        Process.kill 'INT', pid
+        assert_equal pid, Process.wait
+
+        assert_raises Errno::ECONNREFUSED do
+            TCPSocket.new "localhost", 10025
+        end
+    end
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.1
+specification_version: 1
+name: percolate-mail
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2007-02-11 00:00:00 +09:00
+summary: Skeleton smtp daemon for you to subclass
+require_paths: 
+- lib
+email: dagbrown@lart.ca
+homepage: http://percolate-mail.rubyforge.org/
+rubyforge_project: percolate-mail
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.4
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Dave Brown
+files: 
+- lib/percolate
+- lib/percolate-mail.rb
+- lib/percolate/responder.rb
+- lib/percolate/mail_object.rb
+- lib/percolate/listener.rb
+- test/unittest_percolate_listener.rb
+- test/test_percolate_listener.rb
+- test/test_percolate_responder.rb
+- examples/percolate-chuckmail
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+