mail 2.4.4 → 2.6.3

data/lib/mail/network/delivery_methods/smtp.rb

@@ -1,3 +1,5 @@
+require 'mail/check_delivery_params'
+
 module Mail
   # == Sending Email with SMTP
   # 
@@ -72,6 +74,7 @@ module Mail
   # 
   #   mail.deliver!
   class SMTP
+    include Mail::CheckDeliveryParams
 
     def initialize(values)
       self.settings = { :address              => "localhost",
@@ -86,68 +89,54 @@ module Mail
                         :tls                  => nil
                       }.merge!(values)
     end
-    
+
     attr_accessor :settings
-    
+
     # Send the message via SMTP.
     # The from and to attributes are optional. If not set, they are retrieve from the Message.
     def deliver!(mail)
+      smtp_from, smtp_to, message = check_delivery_params(mail)
 
-      # Set the envelope from to be either the return-path, the sender or the first from address
-      envelope_from = mail.return_path || mail.sender || mail.from_addrs.first
-      if envelope_from.blank?
-        raise ArgumentError.new('A sender (Return-Path, Sender or From) required to send a message') 
-      end
-      
-      destinations ||= mail.destinations if mail.respond_to?(:destinations) && mail.destinations
-      if destinations.blank?
-        raise ArgumentError.new('At least one recipient (To, Cc or Bcc) is required to send a message') 
-      end
-      
-      message ||= mail.encoded if mail.respond_to?(:encoded)
-      if message.blank?
-        raise ArgumentError.new('A encoded content is required to send a message')
-      end
-      
       smtp = Net::SMTP.new(settings[:address], settings[:port])
       if settings[:tls] || settings[:ssl]
         if smtp.respond_to?(:enable_tls)
-          unless settings[:openssl_verify_mode]
-            smtp.enable_tls
-          else
-            openssl_verify_mode = settings[:openssl_verify_mode]
-            if openssl_verify_mode.kind_of?(String)
-              openssl_verify_mode = "OpenSSL::SSL::VERIFY_#{openssl_verify_mode.upcase}".constantize
-            end
-            context = Net::SMTP.default_ssl_context
-            context.verify_mode = openssl_verify_mode
-            smtp.enable_tls(context)
-          end        
+          smtp.enable_tls(ssl_context)
         end
       elsif settings[:enable_starttls_auto]
-        if smtp.respond_to?(:enable_starttls_auto) 
-          unless settings[:openssl_verify_mode]
-            smtp.enable_starttls_auto
-          else
-            openssl_verify_mode = settings[:openssl_verify_mode]
-            if openssl_verify_mode.kind_of?(String)
-              openssl_verify_mode = "OpenSSL::SSL::VERIFY_#{openssl_verify_mode.upcase}".constantize
-            end
-            context = Net::SMTP.default_ssl_context
-            context.verify_mode = openssl_verify_mode
-            smtp.enable_starttls_auto(context)
-          end
+        if smtp.respond_to?(:enable_starttls_auto)
+          smtp.enable_starttls_auto(ssl_context)
         end
       end
-      
+
       response = nil
       smtp.start(settings[:domain], settings[:user_name], settings[:password], settings[:authentication]) do |smtp_obj|
-        response = smtp_obj.sendmail(message, envelope_from, destinations)
+        response = smtp_obj.sendmail(message, smtp_from, smtp_to)
       end
 
-      return settings[:return_response] ? response : self
+      if settings[:return_response]
+        response
+      else
+        self
+      end
     end
     
-    
+
+    private
+
+    # Allow SSL context to be configured via settings, for Ruby >= 1.9
+    # Just returns openssl verify mode for Ruby 1.8.x
+    def ssl_context
+      openssl_verify_mode = settings[:openssl_verify_mode]
+
+      if openssl_verify_mode.kind_of?(String)
+        openssl_verify_mode = "OpenSSL::SSL::VERIFY_#{openssl_verify_mode.upcase}".constantize
+      end
+
+      context = Net::SMTP.default_ssl_context
+      context.verify_mode = openssl_verify_mode
+      context.ca_path = settings[:ca_path] if settings[:ca_path]
+      context.ca_file = settings[:ca_file] if settings[:ca_file]
+      context
+    end
   end
 end

data/lib/mail/network/delivery_methods/smtp_connection.rb

@@ -1,3 +1,5 @@
+require 'mail/check_delivery_params'
+
 module Mail
   # == Sending Email with SMTP
   # 
@@ -35,40 +37,25 @@ module Mail
   # 
   #   mail.deliver!
   class SMTPConnection
+    include Mail::CheckDeliveryParams
 
     def initialize(values)
       raise ArgumentError.new('A Net::SMTP object is required for this delivery method') if values[:connection].nil?
       self.smtp = values[:connection]
       self.settings = values
     end
-    
+
     attr_accessor :smtp
     attr_accessor :settings
-    
+
     # Send the message via SMTP.
     # The from and to attributes are optional. If not set, they are retrieve from the Message.
     def deliver!(mail)
+      smtp_from, smtp_to, message = check_delivery_params(mail)
+      response = smtp.sendmail(message, smtp_from, smtp_to)
 
-      # Set the envelope from to be either the return-path, the sender or the first from address
-      envelope_from = mail.return_path || mail.sender || mail.from_addrs.first
-      if envelope_from.blank?
-        raise ArgumentError.new('A sender (Return-Path, Sender or From) required to send a message') 
-      end
-      
-      destinations ||= mail.destinations if mail.respond_to?(:destinations) && mail.destinations
-      if destinations.blank?
-        raise ArgumentError.new('At least one recipient (To, Cc or Bcc) is required to send a message') 
-      end
-      
-      message ||= mail.encoded if mail.respond_to?(:encoded)
-      if message.blank?
-        raise ArgumentError.new('A encoded content is required to send a message')
-      end
-            
-      response = smtp.sendmail(message, envelope_from, destinations)
-      
-      settings[:return_response] ? response : self 
+      settings[:return_response] ? response : self
     end
-        
+
   end
 end

data/lib/mail/network/delivery_methods/test_mailer.rb

@@ -1,3 +1,5 @@
+require 'mail/check_delivery_params'
+
 module Mail
   # The TestMailer is a bare bones mailer that does nothing.  It is useful
   # when you are testing.
@@ -5,6 +7,7 @@ module Mail
   # It also provides a template of the minimum methods you require to implement
   # if you want to make a custom mailer for Mail
   class TestMailer
+    include Mail::CheckDeliveryParams
 
     # Provides a store of all the emails sent with the TestMailer so you can check them.
     def TestMailer.deliveries
@@ -27,14 +30,15 @@ module Mail
     end
 
     def initialize(values)
-      @settings = {}
+      @settings = values.dup
     end
     
     attr_accessor :settings
 
     def deliver!(mail)
+      check_delivery_params(mail)
       Mail::TestMailer.deliveries << mail
     end
     
   end
-end
+end

data/lib/mail/network/retriever_methods/imap.rb

@@ -18,7 +18,7 @@ module Mail
   #
   #   Mail.all    #=> Returns an array of all emails
   #   Mail.first  #=> Returns the first unread email
-  #   Mail.last   #=> Returns the first unread email
+  #   Mail.last   #=> Returns the last unread email
   #
   # You can also pass options into Mail.find to locate an email in your imap mailbox
   # with the following options:
@@ -28,12 +28,15 @@ module Mail
   #   order:   order of emails returned. Possible values are :asc or :desc. Default value is :asc.
   #   count:   number of emails to retrieve. The default value is 10. A value of 1 returns an
   #            instance of Message, not an array of Message instances.
+  #   keys:    are passed as criteria to the SEARCH command.  They can either be a string holding the entire search string, 
+  #            or a single-dimension array of search keywords and arguments.  Refer to  [IMAP] section 6.4.4 for a full list
+  #            The default is 'ALL'
   #
-  #   Mail.find(:what => :first, :count => 10, :order => :asc)
+  #   Mail.find(:what => :first, :count => 10, :order => :asc, :keys=>'ALL')
   #   #=> Returns the first 10 emails in ascending order
   #
   class IMAP < Retriever
-    require 'net/imap'
+    require 'net/imap' unless defined?(Net::IMAP)
     
     def initialize(values)
       self.settings = { :address              => "localhost",
@@ -54,42 +57,51 @@ module Mail
     #   order:   order of emails returned. Possible values are :asc or :desc. Default value is :asc.
     #   count:   number of emails to retrieve. The default value is 10. A value of 1 returns an
     #            instance of Message, not an array of Message instances.
-    #   ready_only: will ensure that no writes are made to the inbox during the session. 
-    #               This is helpful when you don't want your messages to be set to read automatically. Default is false.
+    #   read_only: will ensure that no writes are made to the inbox during the session.  Specifically, if this is
+    #              set to true, the code will use the EXAMINE command to retrieve the mail.  If set to false, which
+    #              is the default, a SELECT command will be used to retrieve the mail
+    #              This is helpful when you don't want your messages to be set to read automatically. Default is false.
     #   delete_after_find: flag for whether to delete each retreived email after find. Default
     #           is false. Use #find_and_delete if you would like this to default to true.
+    #   keys:   are passed as criteria to the SEARCH command.  They can either be a string holding the entire search string, 
+    #           or a single-dimension array of search keywords and arguments.  Refer to  [IMAP] section 6.4.4 for a full list
+    #           The default is 'ALL'
     #
     def find(options={}, &block)
       options = validate_options(options)
 
       start do |imap|
-        options[:read_only] ? imap.select(options[:mailbox]) : imap.examine(options[:mailbox])
+        options[:read_only] ? imap.examine(options[:mailbox]) : imap.select(options[:mailbox])
 
-        message_ids = imap.uid_search(options[:keys])
-        message_ids.reverse! if options[:what].to_sym == :last
-        message_ids = message_ids.first(options[:count]) if options[:count].is_a?(Integer)
-        message_ids.reverse! if (options[:what].to_sym == :last && options[:order].to_sym == :asc) ||
+        uids = imap.uid_search(options[:keys])
+        uids.reverse! if options[:what].to_sym == :last
+        uids = uids.first(options[:count]) if options[:count].is_a?(Integer)
+        uids.reverse! if (options[:what].to_sym == :last && options[:order].to_sym == :asc) ||
                                 (options[:what].to_sym != :last && options[:order].to_sym == :desc)
 
         if block_given?
-          message_ids.each do |message_id|
-            fetchdata = imap.uid_fetch(message_id, ['RFC822'])[0]
+          uids.each do |uid|
+            uid = options[:uid].to_i unless options[:uid].nil?
+            fetchdata = imap.uid_fetch(uid, ['RFC822'])[0]
             new_message = Mail.new(fetchdata.attr['RFC822'])
             new_message.mark_for_delete = true if options[:delete_after_find]
             if block.arity == 3
-              yield new_message, imap, message_id
+              yield new_message, imap, uid
             else
               yield new_message
             end
-            imap.uid_store(message_id, "+FLAGS", [Net::IMAP::DELETED]) if options[:delete_after_find] && new_message.is_marked_for_delete?
+            imap.uid_store(uid, "+FLAGS", [Net::IMAP::DELETED]) if options[:delete_after_find] && new_message.is_marked_for_delete?
+            break unless options[:uid].nil?
           end
           imap.expunge if options[:delete_after_find]
         else
           emails = []
-          message_ids.each do |message_id|
-            fetchdata = imap.uid_fetch(message_id, ['RFC822'])[0]
+          uids.each do |uid|
+            uid = options[:uid].to_i unless options[:uid].nil?
+            fetchdata = imap.uid_fetch(uid, ['RFC822'])[0]
             emails << Mail.new(fetchdata.attr['RFC822'])
-            imap.uid_store(message_id, "+FLAGS", [Net::IMAP::DELETED]) if options[:delete_after_find]
+            imap.uid_store(uid, "+FLAGS", [Net::IMAP::DELETED]) if options[:delete_after_find]
+            break unless options[:uid].nil?
           end
           imap.expunge if options[:delete_after_find]
           emails.size == 1 && options[:count] == 1 ? emails.first : emails
@@ -103,8 +115,8 @@ module Mail
       mailbox = Net::IMAP.encode_utf7(mailbox)
 
       start do |imap|
-        imap.uid_search(['ALL']).each do |message_id|
-          imap.uid_store(message_id, "+FLAGS", [Net::IMAP::DELETED])
+        imap.uid_search(['ALL']).each do |uid|
+          imap.uid_store(uid, "+FLAGS", [Net::IMAP::DELETED])
         end
         imap.expunge
       end
@@ -129,6 +141,7 @@ module Mail
         options[:order]   ||= :asc
         options[:what]    ||= :first
         options[:keys]    ||= 'ALL'
+        options[:uid]     ||= nil
         options[:delete_after_find] ||= false
         options[:mailbox] = Net::IMAP.encode_utf7(options[:mailbox])
         options[:read_only] ||= false

data/lib/mail/network/retriever_methods/pop3.rb

@@ -18,7 +18,7 @@ module Mail
   # 
   #   Mail.all    #=> Returns an array of all emails
   #   Mail.first  #=> Returns the first unread email
-  #   Mail.last   #=> Returns the first unread email
+  #   Mail.last   #=> Returns the last unread email
   # 
   # You can also pass options into Mail.find to locate an email in your pop mailbox
   # with the following options:
@@ -32,7 +32,7 @@ module Mail
   #   #=> Returns the first 10 emails in ascending order
   # 
   class POP3 < Retriever
-    require 'net/pop'
+    require 'net/pop' unless defined?(Net::POP)
 
     def initialize(values)
       self.settings = { :address              => "localhost",

data/lib/mail/network/retriever_methods/test_retriever.rb

@@ -20,26 +20,22 @@ module Mail
       options[:count] ||= :all
       options[:order] ||= :asc
       options[:what] ||= :first
-      emails = @@emails.dup
-      emails.reverse! if options[:what] == :last
-      emails = case count = options[:count]
-        when :all then emails
-        when 1 then emails.first
-        when Fixnum then emails[0, count]
+      emails_index = (0...@@emails.size).to_a
+      emails_index.reverse! if options[:what] == :last
+      emails_index = case count = options[:count]
+        when :all then emails_index
+        when Fixnum then emails_index[0, count]
         else
           raise 'Invalid count option value: ' + count.inspect
       end
       if options[:what] == :last && options[:order] == :asc || options[:what] == :first && options[:order] == :desc
-        emails.reverse!
-      end
-      emails.each { |email| email.mark_for_delete = true } if options[:delete_after_find]
-      if block_given?
-        emails.each { |email| yield email }
-      else
-        emails
-      end.tap do |results|
-        emails.each { |email| @@emails.delete(email) if email.is_marked_for_delete? } if options[:delete_after_find]
+        emails_index.reverse!
       end
+      emails_index.each { |idx| @@emails[idx].mark_for_delete = true } if options[:delete_after_find]
+      emails = emails_index.map { |idx| @@emails[idx] }
+      emails.each { |email| yield email } if block_given?
+      @@emails.reject!(&:is_marked_for_delete?) if options[:delete_after_find]
+      emails.size == 1 && options[:count] == 1 ? emails.first : emails
     end
 
   end

data/lib/mail/network.rb

@@ -1,14 +1,14 @@
 require 'mail/network/retriever_methods/base'
 
 module Mail
-  autoload :SMTP, 'mail/network/delivery_methods/smtp'
-  autoload :FileDelivery, 'mail/network/delivery_methods/file_delivery'
-  autoload :Sendmail, 'mail/network/delivery_methods/sendmail'
-  autoload :Exim, 'mail/network/delivery_methods/exim'
-  autoload :SMTPConnection, 'mail/network/delivery_methods/smtp_connection'
-  autoload :TestMailer, 'mail/network/delivery_methods/test_mailer'
+  register_autoload :SMTP, 'mail/network/delivery_methods/smtp'
+  register_autoload :FileDelivery, 'mail/network/delivery_methods/file_delivery'
+  register_autoload :Sendmail, 'mail/network/delivery_methods/sendmail'
+  register_autoload :Exim, 'mail/network/delivery_methods/exim'
+  register_autoload :SMTPConnection, 'mail/network/delivery_methods/smtp_connection'
+  register_autoload :TestMailer, 'mail/network/delivery_methods/test_mailer'
 
-  autoload :POP3, 'mail/network/retriever_methods/pop3'
-  autoload :IMAP, 'mail/network/retriever_methods/imap'
-  autoload :TestRetriever, 'mail/network/retriever_methods/test_retriever'
+  register_autoload :POP3, 'mail/network/retriever_methods/pop3'
+  register_autoload :IMAP, 'mail/network/retriever_methods/imap'
+  register_autoload :TestRetriever, 'mail/network/retriever_methods/test_retriever'
 end

data/lib/mail/parsers/address_lists_parser.rb

@@ -0,0 +1,132 @@
+module Mail::Parsers
+  class AddressListsParser
+    include Mail::Utilities
+
+    def parse(s)
+      address_list = AddressListStruct.new([],[])
+
+      if s.blank?
+        return address_list
+      end
+
+      actions, error = Ragel.parse(:address_lists, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::AddressList, s, error)
+      end
+
+
+      phrase_s = phrase_e = qstr_s = qstr = comment_s = nil
+      group_name_s = domain_s = group_name = nil
+      local_dot_atom_s = local_dot_atom_e = nil
+      local_dot_atom_pre_comment_e = nil
+      obs_domain_list_s = nil
+
+      address_s = 0
+      address = AddressStruct.new(nil, nil, [], nil, nil, nil, nil)
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Phrase
+        when :phrase_s then phrase_s = p
+        when :phrase_e then phrase_e = p-1
+
+        # Quoted String.
+        when :qstr_s then qstr_s = p
+        when :qstr_e then qstr = s[qstr_s..(p-1)]
+
+        # Comment
+        when :comment_s
+          comment_s = p unless comment_s
+        when :comment_e
+          if address
+            address.comments << s[comment_s..(p-2)]
+          end
+          comment_s = nil
+
+        # Group Name
+        when :group_name_s then group_name_s = p
+        when :group_name_e
+          if qstr
+            group = qstr
+            qstr = nil
+          else
+            group = s[group_name_s..(p-1)]
+            group_name_s = nil
+          end
+          address_list.group_names << group
+          group_name = group
+
+          # Start next address
+          address = AddressStruct.new(nil, nil, [], nil, nil, nil, nil)
+          address_s = p
+          address.group = group_name
+
+        # Address
+        when :address_s
+          address_s = p
+        when :address_e
+          # Ignore address end events if they don't have
+          # a matching address start event.
+          next if address_s.nil?
+          if address.local.nil? && local_dot_atom_pre_comment_e && local_dot_atom_s && local_dot_atom_e
+            if address.domain
+              address.local = s[local_dot_atom_s..local_dot_atom_e] if address
+            else
+              address.local = s[local_dot_atom_s..local_dot_atom_pre_comment_e] if address
+            end
+          end
+          address.raw = s[address_s..(p-1)]
+          address_list.addresses << address if address
+
+          # Start next address
+          address = AddressStruct.new(nil, nil, [], nil, nil, nil, nil)
+          address.group = group_name
+          address_s = nil
+
+        # Don't set the display name until the
+        # address has actually started. This allows
+        # us to choose quoted_s version if it
+        # exists and always use the 'full' phrase
+        # version.
+        when :angle_addr_s
+          if qstr
+            address.display_name = qstr
+            qstr = nil
+          elsif phrase_e
+            address.display_name = s[phrase_s..phrase_e].strip
+            phrase_e = phrase_s = nil
+          end
+
+        # Domain
+        when :domain_s
+          domain_s = p
+        when :domain_e
+          address.domain = s[domain_s..(p-1)].rstrip if address
+
+        # Local
+        when :local_dot_atom_s then local_dot_atom_s = p
+        when :local_dot_atom_e then local_dot_atom_e = p-1
+        when :local_dot_atom_pre_comment_e
+          local_dot_atom_pre_comment_e = p-1
+        when :local_quoted_string_e
+          address.local = '"' + qstr + '"' if address
+
+        # obs_domain_list
+        when :obs_domain_list_s then obs_domain_list_s = p
+        when :obs_domain_list_e
+          address.obs_domain_list = s[obs_domain_list_s..(p-1)]
+
+        else
+          raise Mail::Field::ParseError.new(Mail::AddressList, s, "Failed to process unknown action: #{action}")
+        end
+      end
+
+      if address_list.addresses.empty? && address_list.group_names.empty?
+        raise Mail::Field::ParseError.new(Mail::AddressList, s, "Didn't find any addresses or groups")
+      end
+
+      address_list
+    end
+  end
+end

data/lib/mail/parsers/content_disposition_parser.rb

@@ -0,0 +1,67 @@
+module Mail::Parsers
+  class ContentDispositionParser
+    include Mail::Utilities
+
+    def parse(s)
+      content_disposition = ContentDispositionStruct.new("", nil)
+      if s.blank?
+        return content_disposition
+      end
+
+      actions, error = Ragel.parse(:content_disposition, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::ContentDispositionElement, s, error)
+      end
+
+      content_disposition.parameters = []
+
+      disp_type_s = param_attr_s = param_attr = qstr_s = qstr = param_val_s = nil
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Disposition Type
+        when :disp_type_s then disp_type_s = p
+        when :disp_type_e
+          content_disposition.disposition_type = s[disp_type_s..(p-1)].downcase
+
+        # Parameter Attribute
+        when :param_attr_s then param_attr_s = p
+        when :param_attr_e then param_attr = s[param_attr_s..(p-1)]
+
+        # Quoted String.
+        when :qstr_s then qstr_s = p
+        when :qstr_e then qstr = s[qstr_s..(p-1)]
+
+        # Parameter Value
+        when :param_val_s then param_val_s = p
+        when :param_val_e
+          if param_attr.nil?
+            raise Mail::Field::ParseError.new(Mail::ContentDispositionElement, s, "no attribute for value")
+          end
+
+          # Use quoted string value if one exists, otherwise use parameter value
+          if qstr
+            value = qstr
+          else
+            value = s[param_val_s..(p-1)]
+          end
+
+          content_disposition.parameters <<  { param_attr => value }
+          param_attr = nil
+          qstr = nil
+
+        else
+          raise Mail::Field::ParseError.new(Mail::ContentDispositionElement, s, "Failed to process unknown action: #{action}")
+        end
+      end
+
+      content_disposition
+    end
+
+    private
+    def cleaned(string)
+      string =~ /(.+);\s*$/ ? $1 : string
+    end
+  end
+end

data/lib/mail/parsers/content_location_parser.rb

@@ -0,0 +1,35 @@
+module Mail::Parsers
+  class ContentLocationParser
+    def parse(s)
+      content_location = ContentLocationStruct.new(nil)
+      if s.blank?
+        return content_location
+      end
+
+      actions, error = Ragel.parse(:content_location, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::ContentLocationElement, s, error)
+      end
+
+      qstr_s = token_string_s = nil
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Quoted String.
+        when :qstr_s then qstr_s = p
+        when :qstr_e then content_location.location = s[qstr_s..(p-1)]
+
+        # Token String
+        when :token_string_s then token_string_s = p
+        when :token_string_e
+          content_location.location = s[token_string_s..(p-1)]
+
+        else
+          raise Mail::Field::ParseError.new(Mail::ContentLocationElement, s, "Failed to process unknown action: #{action}")
+        end
+      end
+      content_location
+    end
+  end
+end

data/lib/mail/parsers/content_transfer_encoding_parser.rb

@@ -0,0 +1,33 @@
+module Mail::Parsers
+  class ContentTransferEncodingParser
+
+    def parse(s)
+      content_transfer_encoding = ContentTransferEncodingStruct.new("")
+      if s.blank?
+        return content_transfer_encoding
+      end
+
+      actions, error = Ragel.parse(:content_transfer_encoding, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::ContentTransferEncodingElement, s, error)
+      end
+
+      encoding_s = nil
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Encoding
+        when :encoding_s then encoding_s = p
+        when :encoding_e
+          content_transfer_encoding.encoding = s[encoding_s..(p-1)].downcase
+
+        else
+          raise Mail::Field::ParseError.new(Mail::ContentTransferEncodingElement, s, "Failed to process unknown action: #{action}")
+        end
+      end
+
+      content_transfer_encoding
+    end
+  end
+end