eventmachine 0.8.1 → 0.9.0

data/lib/eventmachine_version.rb

@@ -1,4 +1,4 @@
-# $Id: eventmachine_version.rb 482 2007-07-28 19:11:03Z blackhedd $
+# $Id: eventmachine_version.rb 536 2007-09-16 23:55:03Z blackhedd $
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -25,7 +25,7 @@
 
 module EventMachine
 
-  VERSION = "0.8.1"
+  VERSION = "0.9.0"
 
 end
 

data/lib/protocols/httpclient.rb

@@ -1,4 +1,4 @@
-# $Id: httpclient.rb 398 2007-07-11 02:46:22Z blackhedd $
+# $Id: httpclient.rb 518 2007-08-30 10:17:02Z blackhedd $
 #
 # Author:: Francis Cianfrocca (gmail: blackhedd)
 # Homepage::  http://rubyeventmachine.com
@@ -132,6 +132,12 @@ class HttpClient < Connection
       req << "Content-length: #{postcontent.length}"
     end
 
+    # TODO, this cookie handler assumes it's getting a single, semicolon-delimited string.
+    # Eventually we will want to deal intelligently with arrays and hashes.
+    if args[:cookie]
+      req << "Cookie: #{args[:cookie]}"
+    end
+
     req << ""
     reqstring = req.map {|l| "#{l}\r\n"}.join
     send_data reqstring

data/lib/protocols/smtpclient.rb

@@ -0,0 +1,276 @@
+# $Id: smtpclient.rb 535 2007-09-16 19:35:05Z blackhedd $
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 16 July 2006
+# 
+# See EventMachine and EventMachine::Connection for documentation and
+# usage examples.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+# Gmail: blackhedd
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) 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; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+# 
+
+
+require 'base64'
+
+module EventMachine
+module Protocols
+
+
+	class SmtpClient < Connection
+		include EventMachine::Deferrable
+		include EventMachine::Protocols::LineText2
+
+		# This is the external entry point.
+		#
+		# The argument is a hash containing these values:
+		# :host => a string containing the IP address or host name of the SMTP server to connect to.
+		# :port => optional, defaults to 25.
+		# :domain => required String. This is passed as the argument to the EHLO command.
+		# :starttls => optional. If it evaluates true, then the client will initiate STARTTLS with
+		#   the server, and abort the connection if the negotiation doesn't succeed.
+		#   TODO, need to be able to pass certificate parameters with this option.
+		# :auth => optional hash of auth parameters. If not given, then no auth will be attempted.
+		#   (In that case, the connection will be aborted if the server requires auth.)
+		#   Specify the hash value :type to determine the auth type, along with additional parameters
+		#   depending on the type.
+		#   Currently only :type => :plain is supported. Pass additional parameters :username (String),
+		#   and :password (either a String or a Proc that will be called at auth-time).
+		#   Example: :auth => {:type=>:plain, :username=>"mickey@disney.com", :password=>"mouse"}
+		# :from => required String. Specifies the sender of the message. Will be passed as the argument
+		#   to the MAIL FROM. Do NOT enclose the argument in angle-bracket (<>) characters.
+		#   The connection will abort if the server rejects the value.
+		# :to => required String or Array of Strings. The recipient(s) of the message. Do NOT enclose
+		#   any of the values in angle-brackets (<>) characters. It's NOT a fatal error if one or more
+		#   recipients are rejected by the server. (Of course, if ALL of them are, the server will most
+		#   likely trigger an error when we try to send data.) An array of codes containing the status
+		#   of each requested recipient is available after the call completes. TODO, we should define
+		#   an overridable stub that will be called on rejection of a recipient or a sender, giving
+		#   user code the chance to try again or abort the connection.
+		# :header => Required hash of values to be transmitted in the header of the message. The hash
+		#   keys are the names of the headers (do NOT append a trailing colon), and the values are strings
+		#   containing the header values. TODO, support Arrays of header values, which would cause us to
+		#   send that specific header line more than once.
+		#   Example: :header => {"Subject" => "Bogus", "CC" => "myboss@example.com"}
+		# :body => Optional string, defaults blank. This will be passed as the body of the email message.
+		#   TODO, this needs to be significantly beefed up. As currently written, this requires the caller
+		#   to properly format the input into CRLF-delimited lines of 7-bit characters in the standard
+		#   SMTP transmission format. We need to be able to automatically convert binary data, and add
+		#   correct line-breaks to text data. I think the :body parameter should remain as it is, and we
+		#   should add a :content parameter that contains autoconversions and/or conversion parameters.
+		#   Then we can check if either :body or :content is present and do the right thing.
+		# :verbose => Optional. If true, will cause a lot of information (including the server-side of the
+		#   conversation) to be dumped to $>.
+		#
+		def self.send args={}
+			args[:port] ||= 25
+			args[:body] ||= ""
+			begin
+				EventMachine.connect( args[:host], args[:port], self) {|c|
+					# According to the EM docs, we will get here AFTER post_init is called.
+					c.args = args
+					c.set_comm_inactivity_timeout 60
+				}
+			rescue
+				# We'll get here on a connect error. This code mimics the effect
+				# of a call to invoke_internal_error. Would be great to DRY this up.
+				# (Actually, it may be that we never get here, if EM#connect catches
+				# its errors internally.)
+				d = EM::DefaultDeferrable.new
+				d.set_deferred_status(:failed, {:error=>[:connect, 500, "unable to connect to server"]})
+				d
+			end
+		end
+
+		attr_writer :args
+
+		def post_init
+			@return_values = {}
+			@return_values[:start_time] = Time.now
+		end
+
+		def connection_completed
+			@responder = :receive_signon
+			@msg = []
+		end
+
+		# We can get here in a variety of ways, all of them being failures unless
+		# the @succeeded flag is set. If a protocol success was recorded, then don't
+		# set a deferred success because the caller will already have done it
+		# (no need to wait until the connection closes to invoke the callbacks).
+		#
+		def unbind
+			unless @succeeded
+				@return_values[:elapsed_time] = Time.now - @return_values[:start_time]
+				@return_values[:error] = [@responder, @code, @msg]
+				set_deferred_status(:failed, @return_values)
+			end
+		end
+
+		def receive_line ln
+			$>.puts ln if @args[:verbose]
+			@range = ln[0...1].to_i
+			@code = ln[0...3].to_i
+			@msg << ln[4..-1]
+			unless ln[3...4] == '-'
+				$>.puts @responder if @args[:verbose]
+				send @responder
+				@msg.clear
+			end
+		end
+
+		# We encountered an error from the server and will close the connection.
+		# Use the error and message the server returned.
+		#
+		def invoke_error
+			set_deferred_status :failed, @responder, @code, @msg
+			send_data "QUIT\r\n"
+			close_connection_after_writing
+		end
+
+		# We encountered an error on our side of the protocol and will close the connection.
+		# Use an extra-protocol error code (900) and use the message from the caller.
+		#
+		def invoke_internal_error msg = "???"
+			set_deferred_status :failed, @responder, 900, msg
+			send_data "QUIT\r\n"
+			close_connection_after_writing
+		end
+
+		def receive_signon
+			return invoke_error unless @range == 2
+			send_data "EHLO #{@args[:domain]}\r\n"
+			@responder = :receive_ehlo_response
+		end
+
+		def receive_ehlo_response
+			return invoke_error unless @range == 2
+			@server_caps = @msg
+			invoke_starttls
+		end
+
+		def invoke_starttls
+			if @args[:starttls]
+				# It would be more sociable to first ask if @server_caps contains
+				# the string "STARTTLS" before we invoke it, but hey, life's too short.
+				send_data "STARTTLS\r\n"
+				@responder = :receive_starttls_response
+			else
+				invoke_auth
+			end
+		end
+		def receive_starttls_response
+			return invoke_error unless @range == 2
+			start_tls
+			invoke_auth
+		end
+
+
+
+		# Perform an authentication. If the caller didn't request one, then fall through
+		# to the mail-from state.
+		def invoke_auth
+			if @args[:auth]
+				if @args[:auth][:type] == :plain
+					psw = @args[:auth][:password]
+					if psw.respond_to?(:call)
+						psw = psw.call
+					end
+					str = Base64::encode64("\0#{@args[:auth][:username]}\0#{psw}").chomp
+					send_data "AUTH PLAIN #{str}\r\n"
+					@responder = :receive_auth_response
+				else
+					return invoke_internal_error("unsupported auth type")
+				end
+			else
+				invoke_mail_from
+			end
+		end
+		def receive_auth_response
+			return invoke_error unless @range == 2
+			invoke_mail_from
+		end
+
+		def invoke_mail_from
+			send_data "MAIL FROM: <#{@args[:from]}>\r\n"
+			@responder = :receive_mail_from_response
+		end
+		def receive_mail_from_response
+			return invoke_error unless @range == 2
+			invoke_rcpt_to
+		end
+
+		def invoke_rcpt_to
+			@rcpt_responses ||= []
+			l = @rcpt_responses.length
+			to = @args[:to].is_a?(Array) ? @args[:to] : [@args[:to].to_s]
+			if l < to.length
+				send_data "RCPT TO: <#{to[l]}>\r\n"
+				@responder = :receive_rcpt_to_response
+			else
+				invoke_data
+			end
+		end
+		def receive_rcpt_to_response
+			@rcpt_responses << [@code, @msg]
+			invoke_rcpt_to
+		end
+
+		def invoke_data
+			send_data "DATA\r\n"
+			@responder = :receive_data_response
+		end
+		def receive_data_response
+			return invoke_error unless @range == 3
+
+			# The data to send can be given either in @args[:content] (an array or string of raw data
+			# which MUST be in correct SMTP body format, including a trailing dot line), or a header and
+			# body given in @args[:header] and @args[:body].
+			#
+			if @args[:content]
+				send_data @args[:content].to_s
+			else
+				# The header can be a hash or an array.
+				if @args[:header].is_a?(Hash)
+					(@args[:header] || {}).each {|k,v| send_data "#{k}: #{v}\r\n" }
+				else
+					send_data @args[:header].to_s
+				end
+				send_data "\r\n"
+
+				if @args[:body].is_a?(Array)
+					@args[:body].each {|e| send_data e}
+				else
+					send_data @args[:body].to_s
+				end
+
+				send_data "\r\n.\r\n"
+			end
+
+			@responder = :receive_message_response
+		end
+		def receive_message_response
+			return invoke_error unless @range == 2
+			send_data "QUIT\r\n"
+			close_connection_after_writing
+			@succeeded = true
+			@return_values[:elapsed_time] = Time.now - @return_values[:start_time]
+			set_deferred_status :succeeded, @return_values
+		end
+	end
+end
+end
+

data/lib/protocols/smtpserver.rb

@@ -0,0 +1,514 @@
+# $Id: smtpserver.rb 532 2007-09-13 21:44:23Z blackhedd $
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 16 July 2006
+# 
+# See EventMachine and EventMachine::Connection for documentation and
+# usage examples.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+# Gmail: blackhedd
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) 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; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+# 
+
+
+require 'base64'
+
+module EventMachine
+module Protocols
+
+
+=begin
+	This is a protocol handler for the server side of SMTP.
+	It's NOT a complete SMTP server obeying all the semantics of servers conforming to
+	RFC2821. Rather, it uses overridable method stubs to communicate protocol states
+	and data to user code. User code is responsible for doing the right things with the
+	data in order to get complete and correct SMTP server behavior.
+
+	Useful paragraphs in RFC-2821:
+	4.3.2: Concise list of command-reply sequences, in essence a text representation
+	of the command state-machine.
+
+	STARTTLS is defined in RFC2487.
+	Observe that there are important rules governing whether a publicly-referenced server
+	(meaning one whose Internet address appears in public MX records) may require the
+	non-optional use of TLS.
+	Non-optional TLS does not apply to EHLO, NOOP, QUIT or STARTTLS.
+
+=end
+
+	class SmtpServer < EventMachine::Connection
+		include Protocols::LineText2
+
+		HeloRegex = /\AHELO\s*/i
+		EhloRegex = /\AEHLO\s*/i
+		QuitRegex = /\AQUIT/i
+		MailFromRegex = /\AMAIL FROM:\s*/i
+		RcptToRegex = /\ARCPT TO:\s*/i
+		DataRegex = /\ADATA/i
+		NoopRegex = /\ANOOP/i
+		RsetRegex = /\ARSET/i
+		VrfyRegex = /\AVRFY\s+/i
+		ExpnRegex = /\AEXPN\s+/i
+		HelpRegex = /\AHELP/i
+		StarttlsRegex = /\ASTARTTLS/i
+		AuthRegex = /\AAUTH\s+/i
+
+
+		# Class variable containing default parameters that can be overridden
+		# in application code.
+		# Individual objects of this class will make an instance-local copy of
+		# the class variable, so that they can be reconfigured on a per-instance
+		# basis.
+		#
+		# Chunksize is the number of data lines we'll buffer before
+		# sending them to the application. TODO, make this user-configurable.
+		#
+		@@parms = {
+			:chunksize => 4000,
+			:verbose => false
+		}
+		def self.parms= parms={}
+			@@parms.merge!(parms)
+		end
+
+
+
+		def initialize *args
+			super
+			@parms = @@parms
+			init_protocol_state
+		end
+
+		def parms= parms={}
+			@parms.merge!(parms)
+		end
+
+		# In SMTP, the server talks first. But by a (perhaps flawed) axiom in EM,
+		# #post_init will execute BEFORE the block passed to #start_server, for any
+		# given accepted connection. Since in this class we'll probably be getting
+		# a lot of initialization parameters, we want the guts of post_init to
+		# run AFTER the application has initialized the connection object. So we
+		# use a spawn to schedule the post_init to run later.
+		# It's a little weird, I admit. A reasonable alternative would be to set
+		# parameters as a class variable and to do that before accepting any connections.
+		#
+		# OBSOLETE, now we have @@parms. But the spawn is nice to keep as an illustration.
+		#
+		def post_init
+			#send_data "220 #{get_server_greeting}\r\n" (ORIGINAL)
+			#(EM.spawn {|x| x.send_data "220 #{x.get_server_greeting}\r\n"}).notify(self)
+			(EM.spawn {|x| x.send_server_greeting}).notify(self)
+		end
+
+		def send_server_greeting
+			send_data "220 #{get_server_greeting}\r\n"
+		end
+
+		def receive_line ln
+			@@parms[:verbose] and $>.puts ">>> #{ln}"
+			if @state.include?(:data)
+				process_data_line ln
+			elsif ln =~ EhloRegex
+				process_ehlo $'.dup
+			elsif ln =~ HeloRegex
+				process_helo $'.dup
+			elsif ln =~ MailFromRegex
+				process_mail_from $'.dup
+			elsif ln =~ RcptToRegex
+				process_rcpt_to $'.dup
+			elsif ln =~ DataRegex
+				process_data
+			elsif ln =~ RsetRegex
+				process_rset
+			elsif ln =~ VrfyRegex
+				process_vrfy
+			elsif ln =~ ExpnRegex
+				process_expn
+			elsif ln =~ HelpRegex
+				process_help
+			elsif ln =~ NoopRegex
+				process_noop
+			elsif ln =~ QuitRegex
+				process_quit
+			elsif ln =~ StarttlsRegex
+				process_starttls
+			elsif ln =~ AuthRegex
+				process_auth $'.dup
+			else
+				process_unknown
+			end
+		end
+
+
+
+		#--
+		# This is called at several points to restore the protocol state
+		# to a pre-transaction state. In essence, we "forget" having seen
+		# any valid command except EHLO and STARTTLS.
+		# We also have to callback user code, in case they're keeping track
+		# of senders, recipients, and whatnot.
+		#
+		# We try to follow the convention of avoiding the verb "receive" for
+		# internal method names except receive_line (which we inherit), and
+		# using only receive_xxx for user-overridable stubs.
+		#
+		# init_protocol_state is called when we initialize the connection as
+		# well as during reset_protocol_state. It does NOT call the user
+		# override method. This enables us to promise the users that they
+		# won't see the overridable fire except after EHLO and RSET, and
+		# after a message has been received. Although the latter may be wrong.
+		# The standard may allow multiple DATA segments with the same set of
+		# senders and recipients.
+		#
+		def reset_protocol_state
+			init_protocol_state
+			s,@state = @state,[]
+			@state << :starttls if s.include?(:starttls)
+			@state << :ehlo if s.include?(:ehlo)
+			receive_transaction
+		end
+		def init_protocol_state
+			@state ||= []
+		end
+
+
+		#--
+		# EHLO/HELO is always legal, per the standard. On success
+		# it always clears buffers and initiates a mail "transaction."
+		# Which means that a MAIL FROM must follow.
+		# 
+		# Per the standard, an EHLO/HELO or a RSET "initiates" an email
+		# transaction. Thereafter, MAIL FROM must be received before
+		# RCPT TO, before DATA. Not sure what this specific ordering
+		# achieves semantically, but it does make it easier to 
+		# implement. We also support user-specified requirements for
+		# STARTTLS and AUTH. We make it impossible to proceed to MAIL FROM
+		# without fulfilling tls and/or auth, if the user specified either
+		# or both as required. We need to check the extension standard
+		# for auth to see if a credential is discarded after a RSET along
+		# with all the rest of the state. We'll behave as if it is.
+		# Now clearly, we can't discard tls after its been negotiated
+		# without dropping the connection, so that flag doesn't get cleared.
+		#
+		def process_ehlo domain
+			if receive_ehlo_domain domain
+				send_data "250-#{get_server_domain}\r\n"
+				if @@parms[:starttls]
+					send_data "250-STARTTLS\r\n"
+				end
+				if @@parms[:auth]
+					send_data "250-AUTH PLAIN LOGIN\r\n"
+				end
+				send_data "250-NO-SOLICITING\r\n"
+				# TODO, size needs to be configurable.
+				send_data "250 SIZE 20000000\r\n"
+				reset_protocol_state
+				@state << :ehlo
+			else
+				send_data "550 Requested action not taken\r\n"
+			end
+		end
+
+		def process_helo domain
+			if receive_ehlo_domain domain.dup
+				send_data "250 #{get_server_domain}\r\n"
+				reset_protocol_state
+				@state << :ehlo
+			else
+				send_data "550 Requested action not taken\r\n"
+			end
+		end
+
+		def process_quit
+			send_data "221 Ok\r\n"
+			close_connection_after_writing
+		end
+
+		def process_noop
+			send_data "250 Ok\r\n"
+		end
+
+		def process_unknown
+			send_data "500 Unknown command\r\n"
+		end
+
+		#--
+		# So far, only AUTH PLAIN is supported but we should do at least LOGIN as well.
+		# TODO, support clients that send AUTH PLAIN with no parameter, expecting a 3xx
+		# response and a continuation of the auth conversation.
+		#
+		def process_auth str
+			if @state.include?(:auth)
+				send_data "503 auth already issued\r\n"
+			elsif str =~ /\APLAIN\s+/i
+				plain = Base64::decode64($'.dup)
+				discard,user,psw = plain.split("\000")
+				if receive_plain_auth user,psw
+					send_data "235 authentication ok\r\n"
+					@state << :auth
+				else
+					send_data "535 invalid authentication\r\n"
+				end
+			#elsif str =~ /\ALOGIN\s+/i
+			else
+				send_data "504 auth mechanism not available\r\n"
+			end
+		end
+
+		#--
+		# Unusually, we can deal with a Deferrable returned from the user application.
+		# This was added to deal with a special case in a particular application, but
+		# it would be a nice idea to add it to the other user-code callbacks.
+		#
+		def process_data
+			unless @state.include?(:rcpt)
+				send_data "503 Operation sequence error\r\n"
+			else
+				succeeded = proc {
+					send_data "354 Send it\r\n"
+					@state << :data
+					@databuffer = []
+				}
+				failed = proc {
+					send_data "550 Operation failed\r\n"
+				}
+
+				d = receive_data_command
+
+				if d.respond_to?(:callback)
+					d.callback &succeeded
+					d.errback &failed
+				else
+					(d ? succeeded : failed).call
+				end
+			end
+		end
+
+		def process_rset
+			reset_protocol_state
+			send_data "250 Ok\r\n"
+		end
+
+		def unbind
+			connection_ended
+		end
+
+		#--
+		# STARTTLS may not be issued before EHLO, or unless the user has chosen
+		# to support it.
+		# TODO, must support user-supplied certificates.
+		#
+		def process_starttls
+			if @@parms[:starttls]
+				if @state.include?(:starttls)
+					send_data "503 TLS Already negotiated\r\n"
+				elsif ! @state.include?(:ehlo)
+					send_data "503 EHLO required before STARTTLS\r\n"
+				else
+					send_data "220 Start TLS negotiation\r\n"
+					start_tls
+					@state << :starttls
+				end
+			else
+				process_unknown
+			end
+		end
+
+
+		#--
+		# Requiring TLS is touchy, cf RFC2784.
+		# Requiring AUTH seems to be much more reasonable.
+		# We don't currently support any notion of deriving an authentication from the TLS
+		# negotiation, although that would certainly be reasonable.
+		# We DON'T allow MAIL FROM to be given twice.
+		# We DON'T enforce all the various rules for validating the sender or
+		# the reverse-path (like whether it should be null), and notifying the reverse
+		# path in case of delivery problems. All of that is left to the calling application.
+		#
+		def process_mail_from sender
+			if (@@parms[:starttls]==:required and !@state.include?(:starttls))
+				send_data "550 This server requires STARTTLS before MAIL FROM\r\n"
+			elsif (@@parms[:auth]==:required and !@state.include?(:auth))
+				send_data "550 This server requires authentication before MAIL FROM\r\n"
+			elsif @state.include?(:mail_from)
+				send_data "503 MAIL already given\r\n"
+			else
+				unless receive_sender sender
+					send_data "550 sender is unacceptable\r\n"
+				else
+					send_data "250 Ok\r\n"
+					@state << :mail_from
+				end
+			end
+		end
+
+		#--
+		# Since we require :mail_from to have been seen before we process RCPT TO,
+		# we don't need to repeat the tests for TLS and AUTH.
+		# Note that we don't remember or do anything else with the recipients.
+		# All of that is on the user code.
+		# TODO: we should enforce user-definable limits on the total number of
+		# recipients per transaction.
+		# We might want to make sure that a given recipient is only seen once, but
+		# for now we'll let that be the user's problem.
+		#
+		def process_rcpt_to rcpt
+			unless @state.include?(:mail_from)
+				send_data "503 MAIL is required before RCPT\r\n"
+			else
+				unless receive_recipient rcpt
+					send_data "550 recipient is unacceptable\r\n"
+				else
+					send_data "250 Ok\r\n"
+					@state << :rcpt unless @state.include?(:rcpt)
+				end
+			end
+		end
+
+
+		# Send the incoming data to the application one chunk at a time, rather than
+		# one line at a time. That lets the application be a little more flexible about
+		# storing to disk, etc.
+		# Since we clear the chunk array every time we submit it, the caller needs to be
+		# aware to do things like dup it if he wants to keep it around across calls.
+		#
+		# DON'T reset the transaction upon disposition of the incoming message.
+		# This means another DATA command can be accepted with the same sender and recipients.
+		# If the client wants to reset, he can call RSET.
+		# Not sure whether the standard requires a transaction-reset at this point, but it
+		# appears not to.
+		#
+		# User-written code can return a Deferrable as a response from receive_message.
+		#
+		def process_data_line ln
+			if ln == "."
+				if @databuffer.length > 0
+					receive_data_chunk @databuffer
+					@databuffer.clear
+				end
+
+
+				succeeded = proc {
+					send_data "250 Message accepted\r\n"
+				}
+				failed = proc {
+					send_data "550 Message rejected\r\n"
+				}
+
+				d = receive_message
+
+				if d.respond_to?(:set_deferred_status)
+					d.callback &succeeded
+					d.errback &failed
+				else
+					(d ? succeeded : failed).call
+				end
+
+				@state.delete :data
+			else
+				# slice off leading . if any
+				ln.slice!(0...1) if ln[0] == 46
+				@databuffer << ln
+				if @databuffer.length > @@parms[:chunksize]
+					receive_data_chunk @databuffer
+					@databuffer.clear
+				end
+			end
+		end
+
+
+		#------------------------------------------
+		# Everything from here on can be overridden in user code.
+
+		# The greeting returned in the initial connection message to the client.
+		def get_server_greeting
+			"EventMachine SMTP Server"
+		end
+		# The domain name returned in the first line of the response to a
+		# successful EHLO or HELO command.
+		def get_server_domain
+			"Ok EventMachine SMTP Server"
+		end
+
+		# A false response from this user-overridable method will cause a
+		# 550 error to be returned to the remote client.
+		#
+		def receive_ehlo_domain domain
+			true
+		end
+
+		# Return true or false to indicate that the authentication is acceptable.
+		def receive_plain_auth user, password
+			true
+		end
+
+		# Receives the argument of the MAIL FROM command. Return false to
+		# indicate to the remote client that the sender is not accepted.
+		# This can only be successfully called once per transaction.
+		#
+		def receive_sender sender
+			true
+		end
+
+		# Receives the argument of a RCPT TO command. Can be given multiple
+		# times per transaction. Return false to reject the recipient.
+		#
+		def receive_recipient rcpt
+			true
+		end
+
+		# Sent when the remote peer has ended the connection.
+		#
+		def connection_ended
+		end
+
+		# Called when the remote peer sends the DATA command.
+		# Returning false will cause us to send a 550 error to the peer.
+		# This can be useful for dealing with problems that arise from processing
+		# the whole set of sender and recipients.
+		#
+		def receive_data_command
+			true
+		end
+
+		# Sent when data from the remote peer is available. The size can be controlled
+		# by setting the :chunksize parameter. This call can be made multiple times.
+		# The goal is to strike a balance between sending the data to the application one
+		# line at a time, and holding all of a very large message in memory.
+		#
+		def receive_data_chunk data
+			@smtps_msg_size ||= 0
+			@smtps_msg_size += data.join.length
+			STDERR.write "<#{@smtps_msg_size}>"
+		end
+
+		# Sent after a message has been completely received. User code
+		# must return true or false to indicate whether the message has
+		# been accepted for delivery.
+		def receive_message
+			@@parms[:verbose] and $>.puts "Received complete message"
+			true
+		end
+
+		# This is called when the protocol state is reset. It happens
+		# when the remote client calls EHLO/HELO or RSET.
+		def receive_transaction
+		end
+	end
+end
+end
+
+