eventmachine 1.0.3-x86-mingw32 → 1.2.0.dev.2-x86-mingw32

data/lib/em/protocols/line_and_text.rb

@@ -32,20 +32,20 @@ module EventMachine
     # for a version which is optimized for correctness with regard to binary text blocks
     # that can switch back to line mode.
     class LineAndTextProtocol < Connection
-      MaxLineLength = 16*1024
       MaxBinaryLength = 32*1024*1024
 
       def initialize *args
         super
         lbp_init_line_state
       end
+
       def receive_data data
         if @lbp_mode == :lines
           begin
-            @lpb_buffer.extract(data).each do |line| 
+            @lpb_buffer.extract(data).each do |line|
               receive_line(line.chomp) if respond_to?(:receive_line)
             end
-          rescue Exception
+          rescue
             receive_error('overlength line') if respond_to?(:receive_error)
             close_connection
             return
@@ -116,7 +116,7 @@ module EventMachine
       #--
       # For internal use, establish protocol baseline for handling lines.
       def lbp_init_line_state
-        @lpb_buffer = BufferedTokenizer.new("\n", MaxLineLength)
+        @lpb_buffer = BufferedTokenizer.new("\n")
         @lbp_mode = :lines
       end
       private :lbp_init_line_state

data/lib/em/protocols/linetext2.rb

@@ -37,11 +37,10 @@ module EventMachine
       # When we get around to that, call #receive_error if the user defined it, otherwise
       # throw exceptions.
 
-      MaxLineLength = 16*1024
       MaxBinaryLength = 32*1024*1024
 
       #--
-      # Will be called recursively until there's no data to read.
+      # Will loop internally until there's no data left to read.
       # That way the user-defined handlers we call can modify the
       # handling characteristics on a per-token basis.
       #
@@ -53,45 +52,51 @@ module EventMachine
         @lt2_delimiter ||= "\n"
         @lt2_linebuffer ||= []
 
-        if @lt2_mode == :lines
-          if ix = data.index( @lt2_delimiter )
-            @lt2_linebuffer << data[0...ix]
-            ln = @lt2_linebuffer.join
-            @lt2_linebuffer.clear
-            if @lt2_delimiter == "\n"
-              ln.chomp!
+        remaining_data = data
+
+        while remaining_data.length > 0
+          if @lt2_mode == :lines
+            if ix = remaining_data.index( @lt2_delimiter )
+              @lt2_linebuffer << remaining_data[0...ix]
+              ln = @lt2_linebuffer.join
+              @lt2_linebuffer.clear
+              if @lt2_delimiter == "\n"
+                ln.chomp!
+              end
+              receive_line ln
+              remaining_data = remaining_data[(ix+@lt2_delimiter.length)..-1]
+            else
+              @lt2_linebuffer << remaining_data
+              remaining_data = ""
             end
-            receive_line ln
-            receive_data data[(ix+@lt2_delimiter.length)..-1]
-          else
-            @lt2_linebuffer << data
-          end
-        elsif @lt2_mode == :text
-          if @lt2_textsize
-            needed = @lt2_textsize - @lt2_textpos
-            will_take = if data.length > needed
-                          needed
-                        else
-                          data.length
-                        end
-
-            @lt2_textbuffer << data[0...will_take]
-            tail = data[will_take..-1]
-
-            @lt2_textpos += will_take
-            if @lt2_textpos >= @lt2_textsize
-              # Reset line mode (the default behavior) BEFORE calling the
-              # receive_binary_data. This makes it possible for user code
-              # to call set_text_mode, enabling chains of text blocks
-              # (which can possibly be of different sizes).
-              set_line_mode
-              receive_binary_data @lt2_textbuffer.join
-              receive_end_of_binary_data
+          elsif @lt2_mode == :text
+            if @lt2_textsize
+              needed = @lt2_textsize - @lt2_textpos
+              will_take = if remaining_data.length > needed
+                            needed
+                          else
+                            remaining_data.length
+                          end
+
+              @lt2_textbuffer << remaining_data[0...will_take]
+              tail = remaining_data[will_take..-1]
+
+              @lt2_textpos += will_take
+              if @lt2_textpos >= @lt2_textsize
+                # Reset line mode (the default behavior) BEFORE calling the
+                # receive_binary_data. This makes it possible for user code
+                # to call set_text_mode, enabling chains of text blocks
+                # (which can possibly be of different sizes).
+                set_line_mode
+                receive_binary_data @lt2_textbuffer.join
+                receive_end_of_binary_data
+              end
+
+              remaining_data = tail
+            else
+              receive_binary_data remaining_data
+              remaining_data = ""
             end
-
-            receive_data tail
-          else
-            receive_binary_data data
           end
         end
       end

data/lib/em/protocols/smtpclient.rb

@@ -48,20 +48,20 @@ module EventMachine
     #     puts 'Email failed!'
     #   }
     #
-    # Sending generated emails (using mailfactory)
+    # Sending generated emails (using Mail)
     #
-    #   mail = MailFactory.new
-    #   mail.to = 'someone@site.co'
-    #   mail.from = 'me@site.com'
-    #   mail.subject = 'hi!'
-    #   mail.text = 'hello world'
-    #   mail.html = '<h1>hello world</h1>'
+    #   mail = Mail.new do
+    #     from    'alice@example.com'
+    #     to      'bob@example.com'
+    #     subject 'This is a test email'
+    #     body    'Hello, world!'
+    #   end
     #
     #   email = EM::P::SmtpClient.send(
-    #     :domain=>'site.com',
-    #     :from=>mail.from,
+    #     :domain=>'example.com',
+    #     :from=>mail.from.first,
     #     :to=>mail.to,
-    #     :content=>"#{mail.to_s}\r\n.\r\n"
+    #     :message=>mail.to_s
     #   )
     #
     class SmtpClient < Connection
@@ -108,25 +108,29 @@ module EventMachine
       #   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.
+      #
+      # One of either :message, :content, or :header and :body is required:
+      #
+      # :message => String
+      #   A valid RFC2822 Internet Message.
+      # :content => String
+      #   Raw data which MUST be in correct SMTP body format, with escaped leading dots and a trailing
+      #   dot line.
+      # :header => String or 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.
+      # :body => Optional String or Array of Strings, 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.
-      # :content => Optional array or string
-      #   Alternative to providing header and body, an array or string of raw data which MUST be in
-      #   correct SMTP body format, including a trailing dot line
+      #   correct line-breaks to text data.
+      #
       # :verbose => Optional.
       #   If true, will cause a lot of information (including the server-side of the
       #   conversation) to be dumped to $>.
@@ -233,12 +237,15 @@ module EventMachine
         close_connection_after_writing
       end
 
+      def send_ehlo
+        send_data "EHLO #{@args[:domain]}\r\n"
+      end
+
       def receive_signon
         return invoke_error unless @range == 2
-        send_data "EHLO #{@args[:domain]}\r\n"
+        send_ehlo
         @responder = :receive_ehlo_response
       end
-
       def receive_ehlo_response
         return invoke_error unless @range == 2
         @server_caps = @msg
@@ -258,6 +265,15 @@ module EventMachine
       def receive_starttls_response
         return invoke_error unless @range == 2
         start_tls
+        invoke_ehlo_over_tls
+      end
+
+      def invoke_ehlo_over_tls
+        send_ehlo
+        @responder = :receive_ehlo_over_tls_response
+      end
+      def receive_ehlo_over_tls_response
+        return invoke_error unless @range == 2
         invoke_auth
       end
 
@@ -316,6 +332,10 @@ module EventMachine
         invoke_rcpt_to
       end
 
+      def escape_leading_dots(s)
+        s.gsub(/^\./, '..')
+      end
+
       def invoke_data
         send_data "DATA\r\n"
         @responder = :receive_data_response
@@ -323,25 +343,34 @@ module EventMachine
       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].
+        # The data to send can be given in either @args[:message], @args[:content], or the
+        # combination of @args[:header] and @args[:body].
+        #
+        #   - @args[:message] (String) MUST be a valid RFC2822 Internet Message
         #
-        if @args[:content]
+        #   - @args[:content] (String) MUST be in correct SMTP body format, with escaped
+        #     leading dots and a trailing dot line
+        #
+        #   - @args[:header]  (Hash or String)
+        #   - @args[:body]    (Array or String)
+        if @args[:message]
+          send_data escape_leading_dots(@args[:message].to_s)
+          send_data "\r\n.\r\n"
+        elsif @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" }
+            (@args[:header] || {}).each {|k,v| send_data escape_leading_dots("#{k}: #{v}\r\n") }
           else
-            send_data @args[:header].to_s
+            send_data escape_leading_dots(@args[:header].to_s)
           end
           send_data "\r\n"
 
           if @args[:body].is_a?(Array)
-            @args[:body].each {|e| send_data e}
+            @args[:body].each {|e| send_data escape_leading_dots(e)}
           else
-            send_data @args[:body].to_s
+            send_data escape_leading_dots(@args[:body].to_s)
           end
 
           send_data "\r\n.\r\n"

data/lib/em/protocols/smtpserver.rb

@@ -227,18 +227,26 @@ module EventMachine
           process_unknown
         end
       end
-
+      
       # TODO - implement this properly, the implementation is a stub!
-      def process_vrfy
+      def process_help
         send_data "250 Ok, but unimplemented\r\n"
       end
+      
+      # RFC2821, 3.5.3 Meaning of VRFY or EXPN Success Response:
+      #   A server MUST NOT return a 250 code in response to a VRFY or EXPN
+      #   command unless it has actually verified the address.  In particular,
+      #   a server MUST NOT return 250 if all it has done is to verify that the
+      #   syntax given is valid.  In that case, 502 (Command not implemented)
+      #   or 500 (Syntax error, command unrecognized) SHOULD be returned.
+      #
       # TODO - implement this properly, the implementation is a stub!
-      def process_help
-        send_data "250 Ok, but unimplemented\r\n"
+      def process_vrfy
+        send_data "502 Command not implemented\r\n"
       end
       # TODO - implement this properly, the implementation is a stub!
       def process_expn
-        send_data "250 Ok, but unimplemented\r\n"
+        send_data "502 Command not implemented\r\n"
       end
 
       #--
@@ -358,12 +366,23 @@ module EventMachine
       def process_auth_line(line)
         plain = line.unpack("m").first
         _,user,psw = plain.split("\000")
-        if receive_plain_auth user,psw
+        
+        succeeded = proc {
           send_data "235 authentication ok\r\n"
           @state << :auth
-        else
+        }
+        failed = proc {
           send_data "535 invalid authentication\r\n"
+        }
+        auth = receive_plain_auth user,psw
+        
+        if auth.respond_to?(:callback)
+          auth.callback(&succeeded)
+          auth.errback(&failed)
+        else
+          (auth ? succeeded : failed).call
         end
+        
         @state.delete :auth_incomplete
       end
 
@@ -409,8 +428,12 @@ module EventMachine
       #--
       # STARTTLS may not be issued before EHLO, or unless the user has chosen
       # to support it.
-      # TODO, must support user-supplied certificates.
       #
+      # If :starttls_options is present and :starttls is set in the parms
+      # pass the options in :starttls_options to start_tls. Do this if you want to use
+      # your own certificate
+      # e.g. {:cert_chain_file => "/etc/ssl/cert.pem", :private_key_file => "/etc/ssl/private/cert.key"}
+
       def process_starttls
         if @@parms[:starttls]
           if @state.include?(:starttls)
@@ -419,7 +442,7 @@ module EventMachine
             send_data "503 EHLO required before STARTTLS\r\n"
           else
             send_data "220 Start TLS negotiation\r\n"
-            start_tls
+            start_tls(@@parms[:starttls_options] || {})
             @state << :starttls
           end
         else

data/lib/em/pure_ruby.rb

@@ -66,6 +66,11 @@ module EventMachine
     def release_machine
     end
 
+
+    def stopping?
+      return Reactor.instance.stop_scheduled
+    end
+
     # @private
     def stop
       Reactor.instance.stop
@@ -273,7 +278,7 @@ module EventMachine
 
     HeartbeatInterval = 2
 
-    attr_reader :current_loop_time
+    attr_reader :current_loop_time, :stop_scheduled
 
     def initialize
       initialize_for_run
@@ -393,7 +398,7 @@ module EventMachine
       100.times {
         @loopbreak_port = rand(10000) + 40000
         begin
-          @loopbreak_reader.bind "localhost", @loopbreak_port
+          @loopbreak_reader.bind "127.0.0.1", @loopbreak_port
           bound = true
           break
         rescue
@@ -410,7 +415,7 @@ module EventMachine
 
     def signal_loopbreak
       #@loopbreak_writer.write '+' if @loopbreak_writer
-      @loopbreak_writer.send('+',0,"localhost",@loopbreak_port) if @loopbreak_writer
+      @loopbreak_writer.send('+',0,"127.0.0.1",@loopbreak_port) if @loopbreak_writer
     end
 
     def set_timer_quantum interval_in_seconds

data/lib/em/queue.rb

@@ -17,7 +17,8 @@ module EventMachine
   #
   class Queue
     def initialize
-      @items = []
+      @sink  = []
+      @drain = []
       @popq  = []
     end
 
@@ -29,10 +30,14 @@ module EventMachine
     def pop(*a, &b)
       cb = EM::Callback(*a, &b)
       EM.schedule do
-        if @items.empty?
+        if @drain.empty?
+          @drain = @sink
+          @sink = []
+        end
+        if @drain.empty?
           @popq << cb
         else
-          cb.call @items.shift
+          cb.call @drain.shift
         end
       end
       nil # Always returns nil
@@ -43,8 +48,12 @@ module EventMachine
     # next reactor tick.
     def push(*items)
       EM.schedule do
-        @items.push(*items)
-        @popq.shift.call @items.shift until @items.empty? || @popq.empty?
+        @sink.push(*items)
+        unless @popq.empty?
+          @drain = @sink
+          @sink = []
+          @popq.shift.call @drain.shift until @drain.empty? || @popq.empty?
+        end
       end
     end
     alias :<< :push
@@ -52,13 +61,13 @@ module EventMachine
     # @return [Boolean]
     # @note This is a peek, it's not thread safe, and may only tend toward accuracy.
     def empty?
-      @items.empty?
+      @drain.empty? && @sink.empty?
     end
 
     # @return [Integer] Queue size
     # @note This is a peek, it's not thread safe, and may only tend toward accuracy.
     def size
-      @items.size
+      @drain.size + @sink.size
     end
 
     # @return [Integer] Waiting size