remailer 0.2.1 → 0.3.0

data/lib/remailer/connection/smtp_interpreter.rb

@@ -0,0 +1,270 @@
+class Remailer::Connection::SmtpInterpreter < Remailer::Interpreter
+  # == Constants ============================================================
+
+  LINE_REGEXP = /^.*?\r?\n/.freeze
+
+  # == Properties ===========================================================
+
+  # == Class Methods ========================================================
+  
+  # Expands a standard SMTP reply into three parts: Numerical code, message
+  # and a boolean indicating if this reply is continued on a subsequent line.
+  def self.split_reply(reply)
+    reply.match(/(\d+)([ \-])(.*)/) and [ $1.to_i, $3, $2 == '-' ? :continued : nil ].compact
+  end
+
+  # Encodes the given user authentication paramters as a Base64-encoded
+  # string as defined by RFC4954
+  def self.encode_authentication(username, password)
+    base64("\0#{username}\0#{password}")
+  end
+  
+  # Encodes the given data for an RFC5321-compliant stream where lines with
+  # leading period chracters are escaped.
+  def self.encode_data(data)
+    data.gsub(/((?:\r\n|\n)\.)/m, '\\1.')
+  end
+
+  # Encodes a string in Base64 as a single line
+  def self.base64(string)
+    [ string.to_s ].pack('m').chomp
+  end
+  
+  # == State Mapping ========================================================
+  
+  parse(LINE_REGEXP) do |data|
+    split_reply(data.chomp)
+  end
+  
+  state :initialized do
+    interpret(220) do |message|
+      message_parts = message.split(/\s+/)
+      delegate.remote = message_parts.first
+      
+      if (message_parts.include?('ESMTP'))
+        delegate.protocol = :esmtp
+        enter_state(:ehlo)
+      else
+        delegate.protocol = :smtp
+        enter_state(:helo)
+      end
+    end
+  end
+  
+  state :helo do
+    enter do
+      delegate.send_line("HELO #{delegate.hostname}")
+    end
+
+    interpret(250) do
+      enter_state(:established)
+    end
+  end
+  
+  state :ehlo do
+    enter do
+      delegate.send_line("EHLO #{delegate.hostname}")
+    end
+
+    interpret(250) do |message, continues|
+      message_parts = message.split(/\s+/)
+
+      case (message_parts[0].to_s.upcase)
+      when 'SIZE'
+        delegate.max_size = message_parts[1].to_i
+      when 'PIPELINING'
+        delegate.pipelining = true
+      when 'STARTTLS'
+        delegate.tls_support = true
+      when 'AUTH'
+        delegate.auth_support = message_parts[1, message_parts.length].inject({ }) do |h, v|
+          h[v] = true
+          h
+        end
+      end
+
+      unless (continues)
+        if (delegate.use_tls? and delegate.tls_support?)
+          enter_state(:starttls)
+        elsif (delegate.requires_authentication?)
+          enter_state(:auth)
+        else
+          enter_state(:established)
+        end
+      end
+    end
+  end
+  
+  state :starttls do
+    enter do
+      delegate.send_line("STARTTLS")
+    end
+    
+    interpret(220) do
+      delegate.start_tls
+      
+      if (delegate.requires_authentication?)
+        enter_state(:auth)
+      else
+        enter_state(:established)
+      end
+    end
+  end
+
+  state :auth do
+    enter do
+      delegate.send_line("AUTH PLAIN #{self.class.encode_authentication(delegate.options[:username], delegate.options[:password])}")
+    end
+    
+    interpret(235) do
+      enter_state(:established)
+    end
+    
+    interpret(535) do |message, continues|
+      if (@error)
+        @error << ' '
+        
+        if (message.match(/^(\S+)/).to_s == @error.match(/^(\S+)/).to_s)
+          @error << message.sub(/^\S+/, '')
+        else
+          @error << message
+        end
+      else
+        @error = message
+      end
+
+      unless (continues)
+        enter_state(:quit)
+      end
+    end
+  end
+  
+  state :established do
+    enter do
+      delegate.connect_notification(true)
+      
+      enter_state(:ready)
+    end
+  end
+  
+  state :ready do
+    enter do
+      delegate.after_ready
+    end
+  end
+  
+  state :send do
+    enter do
+      enter_state(:mail_from)
+    end
+  end
+  
+  state :mail_from do
+    enter do
+      delegate.send_line("MAIL FROM:#{delegate.active_message[:from]}")
+    end
+
+    interpret(250) do
+      enter_state(:rcpt_to)
+    end
+  end
+  
+  state :rcpt_to do
+    enter do
+      delegate.send_line("RCPT TO:#{delegate.active_message[:to]}")
+    end
+    
+    interpret(250) do
+      enter_state(:data)
+    end
+  end
+  
+  state :data do
+    enter do
+      delegate.send_line("DATA")
+    end
+    
+    interpret(354) do
+      enter_state(:sending)
+    end
+  end
+  
+  state :sending do
+    enter do
+      data = delegate.active_message[:data]
+
+      delegate.debug_notification(:send, data.inspect)
+
+      delegate.send_data(self.class.encode_data(data))
+
+      # Ensure that a blank line is sent after the last bit of email content
+      # to ensure that the dot is on its own line.
+      delegate.send_line
+      delegate.send_line(".")
+    end
+    
+    default do |reply_code, reply_message|
+      delegate_call(:after_message_sent, reply_code, reply_message)
+
+      enter_state(:sent)
+    end
+  end
+  
+  state :sent do
+    enter do
+      enter_state(:ready)
+    end
+  end
+  
+  state :quit do
+    enter do
+      delegate.send_line("QUIT")
+    end
+    
+    interpret(221) do
+      enter_state(:terminated)
+    end
+  end
+  
+  state :terminated do
+    enter do
+      delegate.close_connection
+    end
+  end
+  
+  state :reset do
+    enter do
+      delegate.send_line("RESET")
+    end
+    
+    interpret(250) do
+      enter_state(:ready)
+    end
+  end
+  
+  state :noop do
+    enter do
+      delegate.send_line("NOOP")
+    end
+    
+    interpret(250) do
+      enter_state(:ready)
+    end
+  end
+  
+  on_error do |reply_code, reply_message|
+    delegate.send_callback(reply_code, reply_message)
+    delegate.debug_notification(:error, "[#{@state}] #{reply_code} #{reply_message}")
+    delegate.error_notification(reply_code, reply_message)
+    
+    delegate.active_message = nil
+    
+    enter_state(delegate.protocol ? :reset : :terminated)
+  end
+
+  # == Instance Methods =====================================================
+
+  def label
+    'SMTP'
+  end
+end

data/lib/remailer/connection/socks5_interpreter.rb

@@ -0,0 +1,186 @@
+class Remailer::Connection::Socks5Interpreter < Remailer::Interpreter
+  # == Constants ============================================================
+
+  SOCKS5_VERSION = 5
+
+  SOCKS5_METHOD = {
+    :no_auth => 0,
+    :gssapi => 1,
+    :username_password => 2
+  }.freeze
+  
+  SOCKS5_COMMAND = {
+    :connect => 1,
+    :bind => 2
+  }.freeze
+  
+  SOCKS5_REPLY = {
+    0 => 'Succeeded',
+    1 => 'General SOCKS server failure',
+    2 => 'Connection not allowed',
+    3 => 'Network unreachable',
+    4 => 'Host unreachable',
+    5 => 'Connection refused',
+    6 => 'TTL expired',
+    7 => 'Command not supported',
+    8 => 'Address type not supported'
+  }.freeze
+  
+  SOCKS5_ADDRESS_TYPE = {
+    :ipv4 => 1,
+    :domainname => 3,
+    :ipv6 => 4
+  }.freeze
+  
+  # == State Mapping ========================================================
+
+  state :initialized do
+    enter do
+      enter_state(:connect_to_proxy)
+    end
+  end
+  
+  state :connect_to_proxy do
+    enter do
+      proxy_options = delegate.options[:proxy]
+
+      delegate.debug_notification(:proxy, "Initiating proxy connection through #{proxy_options[:host]}")
+
+      socks_methods = [ ]
+      
+      if (proxy_options[:username])
+        socks_methods << SOCKS5_METHOD[:username_password]
+      end
+
+      delegate.send_data(
+        [
+          SOCKS5_VERSION,
+          socks_methods.length,
+          socks_methods
+        ].flatten.pack('CCC*')
+      )
+    end
+    
+    parse do |s|
+      return unless (s.length >= 2)
+      
+      version, method = s.slice!(0,2).unpack('CC')
+      
+      method
+    end
+    
+    interpret(SOCKS5_METHOD[:username_password]) do
+      enter_state(:authentication)
+    end
+    
+    default do
+      enter_state(:resolving_destination)
+    end
+  end
+  
+  state :resolving_destination do
+    enter do
+      # FIX: Use an async resolver here
+      @destination_address = delegate.resolve_hostname(delegate.options[:host])
+      enter_state(:connect_through_proxy)
+    end
+  end
+  
+  state :connect_through_proxy do
+    enter do
+      delegate.debug_notification(:proxy, "Sending proxy connection request to #{delegate.options[:host]}:#{delegate.options[:port]}")
+    
+      if (@destination_address)
+        delegate.send_data(
+          [
+            SOCKS5_VERSION,
+            SOCKS5_COMMAND[:connect],
+            0,
+            SOCKS5_ADDRESS_TYPE[:ipv4],
+            @destination_address,
+            delegate.options[:port]
+          ].pack('CCCCA4n')
+        )
+      else
+        delegate.send_callback(:error_connecting, "Could not resolve hostname #{delegate.options[:host]}")
+        enter_state(:failed)
+      end
+    end
+    
+    parse do |s|
+      return unless (s.length >= 10)
+    
+      version, reply, reserved, address_type, address, port = s.slice!(0,10).unpack('CCCCNn')
+      
+      [
+        reply,
+        {
+          :address => address,
+          :port => port,
+          :address_type => address_type
+        }
+      ]
+    end
+  
+    interpret(0) do
+      enter_state(:connected)
+    end
+    
+    default do |reply|
+      @reply = reply
+      enter_state(:failed)
+    end
+  end
+  
+  state :authentication do
+    enter do
+      delegate.debug_notification(:proxy, "Sending proxy authentication")
+
+      proxy_options = delegate.options[:proxy]
+      username = proxy_options[:username]
+      password = proxy_options[:password]
+
+      send_data(
+        [
+          SOCKS5_VERSION,
+          username.length,
+          username,
+          password.length,
+          password
+        ].pack('CCA*CA*')
+      )
+    end
+    
+    parse do |s|
+    end
+    
+    interpret(0) do
+      enter_state(:connected)
+    end
+  end
+  
+  state :connected do
+    enter do
+      delegate_call(:after_proxy_connected)
+    end
+  end
+  
+  state :failed do
+    enter do
+      message = "Proxy server returned error code #{@reply}: #{SOCKS5_REPLY[@reply]}"
+      delegate.debug(:error, message)
+      delegate.connect_notification(false, message)
+      delegate.close_connection
+    end
+    
+    terminate
+  end
+
+  # == Class Methods ========================================================
+
+  # == Instance Methods =====================================================
+  
+  def label
+    'SOCKS5'
+  end
+end