remailer 0.4.21 → 0.5.0

data/lib/remailer/constants.rb

@@ -0,0 +1,10 @@
+module Remailer::Constants
+  # == Constants ============================================================
+  
+  LINE_REGEXP = /^.*?\r?\n/.freeze
+  CRLF = "\r\n".freeze
+  
+  SMTP_PORT = 25
+  IMAPS_PORT = 993
+  SOCKS5_PORT = 1080
+end

data/lib/remailer/email_address.rb

@@ -0,0 +1,41 @@
+# encoding: BINARY
+#
+# RFC822 Email Address Regex
+# --------------------------
+# 
+# Originally written by Cal Henderson
+# c.f. http://iamcal.com/publish/articles/php/parsing_email/
+#
+# Translated to Ruby by Tim Fletcher, with changes suggested by Dan Kubb.
+#
+# Licensed under a Creative Commons Attribution-ShareAlike 2.5 License
+# http://creativecommons.org/licenses/by-sa/2.5/
+# 
+
+class Remailer::EmailAddress
+  # == Class Methods ========================================================
+
+  PATTERN =
+    begin
+      qtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]'
+      dtext = '[^\\x0d\\x5b-\\x5d\\x80-\\xff]'
+      atom = '[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-' +
+        '\\x3c\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+'
+      quoted_pair = '\\x5c[\\x00-\\x7f]'
+      domain_literal = "\\x5b(?:#{dtext}|#{quoted_pair})*\\x5d"
+      quoted_string = "\\x22(?:#{qtext}|#{quoted_pair})*\\x22"
+      domain_ref = atom
+      sub_domain = "(?:#{domain_ref}|#{domain_literal})"
+      word = "(?:#{atom}|#{quoted_string})"
+      domain = "#{sub_domain}(?:\\x2e#{sub_domain})*"
+      local_part = "#{word}(?:\\x2e#{word})*"
+      addr_spec = "#{local_part}\\x40#{domain}"
+      pattern = /\A#{addr_spec}\z/
+    end
+
+  # == Class Methods ========================================================
+
+  def self.valid?(address)
+    PATTERN.match(address)
+  end
+end

data/lib/remailer/imap.rb

@@ -0,0 +1,6 @@
+module Remailer::IMAP
+  # == Submodules ===========================================================
+  
+  autoload(:Client, 'remailer/imap/client')
+  autoload(:Server, 'remailer/imap/server')
+end

data/lib/remailer/imap/client.rb

@@ -0,0 +1,228 @@
+class Remailer::IMAP::Client < Remailer::AbstractConnection
+  # == Exceptions ===========================================================
+  
+  # == Extensions ===========================================================
+  
+  include Remailer::Support
+  
+  # == Submodules ===========================================================
+  
+  autoload(:Interpreter, 'remailer/imap/client/interpreter')
+
+  # == Constants ============================================================
+  
+  DEFAUT_TIMEOUT = 60
+  
+  # == Properties ===========================================================
+
+  # == Class Methods ========================================================
+  
+  def self.default_timeout
+    DEFAULT_TIMEOUT
+  end
+
+  def self.default_port
+    IMAPS_PORT
+  end
+
+  # Opens a connection to a specific IMAP server. Options can be specified:
+  # * port => Numerical port number (default is 993)
+  # * require_tls => If true will fail connections to non-TLS capable
+  #   servers (default is false)
+  # * username => Username to authenticate with the IMAP server
+  # * password => Password to authenticate with the IMAP server
+  # * use_tls => Will use TLS if availble (default is true)
+  # * debug => Where to send debugging output (IO or Proc)
+  # * connect => Where to send a connection notification (IO or Proc)
+  # * error => Where to send errors (IO or Proc)
+  # * on_connect => Called upon successful connection (Proc)
+  # * on_error => Called upon connection error (Proc)
+  # * on_disconnect => Called when connection is closed (Proc)
+  # A block can be supplied in which case it will stand in as the :connect
+  # option. The block will recieve a first argument that is the status of
+  # the connection, and an optional second that is a diagnostic message.
+  def self.open(imap_server, options = nil, &block)
+    super(imap_server, options, &block)
+  end
+  
+  # == Instance Methods =====================================================
+  
+  def after_initialize
+    if (using_proxy?)
+      @connecting_to_proxy = true
+      use_socks5_interpreter!
+    else
+      if (@options[:use_tls])
+        self.start_tls
+      end
+      
+      use_imap_interpreter!
+    end
+    
+    @command_tags = { }
+    @issued_command = { }
+  end
+
+  # Callback receiver for when the proxy connection has been completed.
+  def after_proxy_connected
+    if (@options[:use_tls])
+      self.start_tls
+    end
+    
+    use_imap_interpreter!
+  end
+  
+  def after_unbind
+    debug_notification(:disconnect, "Disconnected by remote.")
+    
+    @command_tags.each do |tag, callback|
+      callback[1].call(nil)
+    end
+  end
+
+  def receive_response(tag, status, message, additional = nil)
+    if (set = @command_tags.delete(tag))
+      @issued_command.delete(set[0])
+      set[1].call(status, message, additional)
+    end
+  end
+  
+  # -- Commands -------------------------------------------------------------
+  
+  def capability
+    self.issue_command('CAPABILITY') do |status, message, additional|
+      yield(additional)
+    end
+  end
+  
+  def login(username, password)
+    self.issue_command('LOGIN', quoted(username), quoted(password)) do |status, message, additional|
+      yield(status, message, additional)
+    end
+  end
+  
+  def list(reference_name = '/', mailbox_name = '*')
+    self.issue_command('LIST', quoted(reference_name), quoted(mailbox_name)) do |status, message, additional|
+      yield(status, message, additional)
+    end
+  end
+
+  def select(mailbox_name = 'INBOX')
+    self.issue_command('SELECT', quoted(mailbox_name)) do |status, message, additional|
+      yield(status, message, additional)
+    end
+  end
+
+  def examine(mailbox_name = 'INBOX')
+    self.issue_command('EXAMINE', quoted(mailbox_name)) do |status, message, additional|
+      yield(status, message, additional)
+    end
+  end
+
+  def status(mailbox_name = 'INBOX', *flags)
+    flags.flatten!
+    flags = [ :uidnext, :messages ] if (flags.empty?)
+    
+    # Valid flags are: MESSAGES RECENT UIDNEXT UIDVALIDITY UNSEEN
+    
+    self.issue_command('STATUS', quoted(mailbox_name), "(#{flags.collect { |f| f.to_s.upcase }.join(' ')})") do |status, message, additional|
+      yield(status, message, additional)
+    end
+  end
+  
+  def noop
+    self.issue_command('NOOP') do |status, message, additional|
+      yield(status, message, additional)
+    end
+  end
+  
+  def fetch(range, *options)
+    fetch_options = { }
+    
+    options.each do |option|
+      case (option)
+      when Hash
+        fetch_options.merge(option)
+      else
+        fetch_options[option] = true
+      end
+    end
+    
+    if (fetch_options.empty?)
+      fetch_options[:all] = true
+    end
+    
+    sequence_set =
+      case (range)
+      when Range
+        "#{range.min}:#{range.max}"
+      else
+        range.to_s
+      end
+      
+    items =
+      if (fetch_options[:all])
+        'ALL'
+      elsif (fetch_options[:fast])
+        'FAST'
+      elsif (fetch_options[:full])
+        'FULL'
+      elsif (body_options = fetch_options[:body])
+        case (body_options)
+        when Hash
+          # ...
+        else
+          'BODY'
+        end
+      end
+    
+    self.issue_command('FETCH', sequence_set, items) do |status, message, additional|
+      yield(status, message, additional)
+    end
+  end
+  
+  def idle
+    self.issue_command('IDLE') do |status, message, additional|
+      yield(status, message, additional)
+    end
+    
+    lambda { self.send_line('DONE') }
+  end
+
+protected
+  # Switches to use the IMAP interpreter for all subsequent communication
+  def use_imap_interpreter!
+    @interpreter = Interpreter.new(:delegate => self)
+  end
+
+  def next_tag
+    @next_tag ||= (rand(1 << 32) << 32) | (1 << 64)
+  
+    @next_tag += 1
+  
+    @next_tag.to_s(16)
+  end
+
+  def issue_command(*args, &block)
+    tag = self.next_tag
+  
+    self.send_line(([ tag ] + args.flatten).join(' '))
+  
+    @command_tags[tag] = [ args.first, block ]
+    @issued_command[args.first] = [ tag, block ]
+  
+    tag
+  end
+
+  def pending_command_with_tag(tag)
+    set = @command_tags[tag]
+  
+    set and set[0] or false
+  end
+
+  def pending_command_of_type(type)
+    set = @issued_command[tag]
+  
+    set and set[0] or false
+  end
+end

data/lib/remailer/imap/client/interpreter.rb

@@ -0,0 +1,101 @@
+class Remailer::IMAP::Client::Interpreter < Remailer::Interpreter
+  # == Constants ============================================================
+  
+  LINE_REGEXP = /^(.*?)\r?\n/.freeze
+  RESPONSE_REGEXP = /^(\S+)(?:\s+(?:(OK|NO|BAD)\s+)?([^\r\n]*))?\r?\n/.freeze
+  
+  # == Class Methods ========================================================
+
+  def self.split_reply(reply)
+    if (m = reply.match(RESPONSE_REGEXP))
+      parts = m.to_a
+      parts.shift
+      
+      parts
+    else
+      nil
+    end
+  end
+  
+  def self.split_list_definition(string)
+    m = string.match(/^\(([^\)]+)\)\s+\"((?:\\\"|\\x[0-9a-fA-F][0-9a-fA-F]|\\[abtnvfr]|.)+)\"\s+\"((?:\\\"|\\x[0-9a-fA-F][0-9a-fA-F]|\\[abtnvfr]|.)+)\"/)
+    
+    return unless (m)
+    
+    split = m.to_a
+    split.shift
+    split[0] = split[0].split(/\s+/)
+    
+    split
+  end
+
+  # == State Definitions ====================================================
+  
+  # Based on the RFC3501 specification with extensions
+  
+  parse(LINE_REGEXP) do |data|
+    split_reply(data)
+  end
+
+  state :initialized do
+    interpret('*') do |tag, status, message|
+      delegate.connect_notification(status, message)
+
+      enter_state(:connected)
+    end
+  end
+
+  state :connected do
+    interpret('*') do |tag, status, message|
+      message_parts = message.split(/\s+/)
+      message_key = message_parts.shift
+      
+      case (message_key)
+      when 'CAPABILITY'
+        @additional ||= [ ]
+        @additional += message_parts
+      when 'LIST'
+        message = message.sub(/^LIST\s+/, '')
+
+        if (split = self.class.split_list_definition(message))
+          @additional ||= [ ]
+          @additional << split.reverse
+        end
+      end
+    end
+
+    default do |tag, status, message|
+      delegate.receive_response(tag, status, message, @additional)
+      
+      @additional = nil
+    end
+  end
+  
+  state :fetch do
+    parse(LINE_REGEXP)
+
+    enter do
+      @additional = ''
+    end
+    
+    interpret(/^\*\s+(\d+)\s+FETCH\s+(.*)/) do |uid, line|
+      @additional << line
+    end
+
+    interpret(/^(\w+)\s+(OK|NO|BAD)\s+(FETCH\s+.*)/) do |tag, status, message|
+      delegate.receive_response(tag, [ status, message ], @additional)
+      
+      @additional = nil
+    end
+    
+    default do |line|
+      @additional << line
+    end
+  end
+  
+  # == Instance Methods =====================================================
+  
+  def label
+    'IMAP'
+  end
+end

data/lib/remailer/imap/server.rb

@@ -0,0 +1,15 @@
+require 'socket'
+require 'eventmachine'
+
+class Remailer::IMAP::Server < EventMachine::Protocols::LineAndTextProtocol
+  # == Submodules ===========================================================
+  
+  autoload(:Interpreter, 'remailer/imap/server/imap_interpreter')
+
+  # == Constants ============================================================
+
+  # == Class Methods ========================================================
+
+  # == Instance Methods =====================================================
+  
+end

data/lib/remailer/imap/server/interpreter.rb

@@ -0,0 +1,2 @@
+class Remailer::IMAP::Server::Interpreter < Remailer::Interpreter
+end

data/lib/remailer/interpreter.rb

@@ -67,9 +67,9 @@ class Remailer::Interpreter
   
   # This is a method to convert a spec and a block into a proper parser
   # method. If spec is specified, it should be a Fixnum, or a Regexp. A 
-  # Fixnum defines a  minimum size to process, useful for packed binary
-  # streams, and a Regexp defines a pattern that must match before the parser
-  # is engaged.
+  # Fixnum defines a minimum size to process, useful for packed binary
+  # streams, while a Regexp defines a pattern that must match before the
+  # parser is engaged.
   def self.create_parser_for_spec(spec, &block)
     case (spec)
     when nil
@@ -202,17 +202,18 @@ class Remailer::Interpreter
   end
 
   # Processes a given input string into interpretable tokens, processes these
-  # tokens, and removes them from the input string. If no interpretable
-  # tokens could be found, returns immediately. An optional block can be
+  # tokens, and removes them from the input string. An optional block can be
   # given that will be called as each interpretable token is discovered with
   # the token provided as the argument.
   def process(s)
     _parser = parser
 
-    while (parsed = s.empty? ? false : instance_exec(s, &_parser))
+    while (parsed = instance_exec(s, &_parser))
       yield(parsed) if (block_given?)
 
       interpret(*parsed)
+      
+      break if (s.empty?)
     end
   end