sisimai 4.25.5-java → 4.25.11-java

data/lib/sisimai/mail/memory.rb

@@ -3,39 +3,41 @@ module Sisimai
     # Sisimai::Mail::Memory is a class for reading an email string
     class Memory
       # Imported from p5-Sisimail/lib/Sisimai/Mail/Memory.pm
-      # :size   [Integer] data size of the email text
-      # :data   [Array]   Entire bounce mail message
-      # :offset [Integer] Index of ":data"
-      attr_reader :size
-      attr_accessor :data, :offset
+      # :path    [String]  Fixed string "<MEMORY>"
+      # :size    [Integer] data size of the email text
+      # :payload [Array]   Entire bounce mail message
+      # :offset  [Integer] Index of ":payload"
+      attr_reader :path, :size
+      attr_accessor :payload, :offset
 
       # Constructor of Sisimai::Mail::Memory
-      # @param    [String] argv1              Entire email string
-      # @return   [Sisimai::Mail::Memory,Nil] Object or nil if the argument is
-      #                                       not specified or does not exist
+      # @param    [String] argv1          Entire email string
+      # @return   [Sisimai::Mail::Memory] Object
+      #           [Nil]                   is not specified or does not exist
       def initialize(argv1)
         raise 'is not a String' unless argv1.is_a? ::String
         raise 'is empty'        if argv1.empty?
 
-        @size   = argv1.size
-        @data   = []
-        @offset = 0
+        @path    = '<MEMORY>'
+        @size    = argv1.size
+        @payload = []
+        @offset  = 0
 
         if argv1.start_with?('From ')
           # UNIX mbox
-          @data = argv1.split(/^From /).map! { |e| e = 'From ' + e }
-          @data.shift
+          @payload = argv1.split(/^From /).map! { |e| e = 'From ' + e }
+          @payload.shift
         else
-          @data = [argv1]
+          @payload = [argv1]
         end
       end
 
       # Memory reader, works as an iterator.
       # @return   [String] Contents of a bounce mail
       def read
-        return nil if self.data.empty?
+        return nil if self.payload.empty?
         self.offset += 1
-        return self.data.shift
+        return self.payload.shift
       end
     end
   end

data/lib/sisimai/mail/stdin.rb

@@ -4,10 +4,9 @@ module Sisimai
     # STDIN
     class STDIN
       # Imported from p5-Sisimail/lib/Sisimai/Mail/STDIN.pm
-      # :path   [String]  Path to mbox
-      # :name   [String]  File name of the mbox
-      # :size   [Integer] File size of the mbox
-      # :offset [Integer]  Offset position for seeking
+      # :path   [String]  Fixed string "<STDIN>"
+      # :size   [Integer] Data size which has been read
+      # :offset [Integer]  The number of emails which have neen read
       # :handle [IO::File] File handle
       attr_reader :path, :name, :size
       attr_accessor :offset, :handle
@@ -19,7 +18,6 @@ module Sisimai
         raise 'is not an IO object' unless stdin.is_a?(IO)
 
         @path   = '<STDIN>'
-        @name   = '<STDIN>'
         @size   = nil
         @offset = 0
         @handle = stdin
@@ -45,6 +43,8 @@ module Sisimai
           readhandle.close
         end
 
+        self.size   += readbuffer.size
+        self.offset += 1
         return readbuffer
       end
     end

data/lib/sisimai/mda.rb

@@ -7,7 +7,7 @@ module Sisimai
         # dovecot/src/deliver/deliver.c
         # 11: #define DEFAULT_MAIL_REJECTION_HUMAN_REASON \
         # 12: "Your message to <%t> was automatically rejected:%n%r"
-        'dovecot'    => %r/\AYour message to .+ was automatically rejected:\z/,
+        'dovecot'    => %r/\AYour message to [^ ]+ was automatically rejected:\z/,
         'mail.local' => %r/\Amail[.]local: /,
         'procmail'   => %r/\Aprocmail: /,
         'maildrop'   => %r/\Amaildrop: /,
@@ -16,7 +16,7 @@ module Sisimai
       }.freeze
       MarkingsOf = {
         message: %r{\A(?>
-           Your[ ]message[ ]to[ ].+[ ]was[ ]automatically[ ]rejected:\z
+           Your[ ]message[ ]to[ ][^ ]+[ ]was[ ]automatically[ ]rejected:\z
           |(?:mail[.]local|procmail|maildrop|vdelivermail|vdeliver):[ ]
           )
         }x
@@ -75,16 +75,10 @@ module Sisimai
       }.freeze
 
       # Parse message body and return reason and text
-      # @param         [Hash] mhead       Message header of a bounce email
-      # @options mhead [String] from      From header
-      # @options mhead [String] date      Date header
-      # @options mhead [String] subject   Subject header
-      # @options mhead [Array]  received  Received headers
-      # @options mhead [String] others    Other required headers
-      # @param         [String] mbody     Message body of a bounce email
-      # @return        [Hash, Nil]        Bounce data list and message/rfc822 part
-      #                                   or nil if it failed to parse or the
-      #                                   arguments are missing
+      # @param  [Hash] mhead    Message headers of a bounce email
+      # @param  [String] mbody  Message body of a bounce email
+      # @return [Hash]          Bounce data list and message/rfc822 part
+      # @return [Nil]           it failed to parse or the arguments are missing
       def make(mhead, mbody)
         return nil unless mhead['from'].downcase.start_with?('mail delivery subsystem','mailer-daemon', 'postmaster')
 

data/lib/sisimai/message.rb

@@ -12,137 +12,91 @@ module Sisimai
     # :catch  [Any]    The results returned by hook method
     attr_accessor :from, :header, :ds, :rfc822, :catch
 
-    require 'sisimai/arf'
     require 'sisimai/mime'
     require 'sisimai/order'
+    require 'sisimai/lhost'
     require 'sisimai/string'
     require 'sisimai/address'
     require 'sisimai/rfc5322'
-    require 'sisimai/rfc3834'
-    require 'sisimai/smtp/error'
-
     DefaultSet = Sisimai::Order.another
-    ExtHeaders = Sisimai::Order.headers
-    SubjectTab = Sisimai::Order.by('subject')
-    RFC822Head = Sisimai::RFC5322.HEADERFIELDS
-    RFC3834Set = Sisimai::RFC3834.headerlist
-    HeaderList = %w[from to date subject content-type reply-to message-id
-                    received content-transfer-encoding return-path x-mailer]
-    IsMultiple = { 'received' => true }
-    EndOfEmail = Sisimai::String.EOM
-    BorderLine = '__MIME_ENCODED_BOUNDARY__'
+    LhostTable = Sisimai::Lhost.path
 
     # Constructor of Sisimai::Message
     # @param         [String] data      Email text data
     # @param         [Hash] argvs       Module to be loaded
     # @options argvs [String] :data     Entire email message
     # @options argvs [Array]  :load     User defined MTA module list
-    # @options argvs [Array]  :field    Email header names to be captured
     # @options argvs [Array]  :order    The order of MTA modules
     # @options argvs [Code]   :hook     Reference to callback method
     # @return        [Sisimai::Message] Structured email data or nil if each
     #                                   value of the arguments are missing
     def initialize(data: '', **argvs)
       return nil if data.empty?
-
+      param = {}
       email = data.scrub('?').gsub("\r\n", "\n")
-      field = argvs[:field] || []
-
-      unless field.is_a? Array
-        # Unsupported value in "field"
-        warn ' ***warning: "field" accepts an array reference only'
-        return nil
-      end
+      thing = { 'from' => '','header' => {}, 'rfc822' => '', ds => [], 'catch' => nil }
 
-      methodargv = { 'data' => email, 'hook' => argvs[:hook] || nil, 'field' => field }
+      #methodargv = { 'data' => email, 'hook' => argvs[:hook] || nil }
+      # 1. Load specified MTA modules
       [:load, :order].each do |e|
         # Order of MTA modules
         next unless argvs[e]
         next unless argvs[e].is_a? Array
         next if argvs[e].empty?
-        methodargv[e.to_s] = argvs[e]
+        param[e.to_s] = argvs[e]
       end
+      tobeloaded = Sisimai::Message.load(param)
 
-      datasource = Sisimai::Message.make(methodargv)
-      return nil unless datasource
-      return nil unless datasource['ds']
-
-      @from   = datasource['from']
-      @header = datasource['header']
-      @ds     = datasource['ds']
-      @rfc822 = datasource['rfc822']
-      @catch  = datasource['catch'] || nil
-    end
-
-    # Check whether the object has valid content or not
-    # @return        [True,False]   returns true if the object is void
-    def void
-      return true unless @ds
-      return false
-    end
-
-    # Make data structure from the email message(a body part and headers)
-    # @param         [Hash] argvs   Email data
-    # @options argvs [String] data  Entire email message
-    # @options argvs [Array]  load  User defined MTA module list
-    # @options argvs [Array]  field Email header names to be captured
-    # @options argvs [Array]  order The order of MTA modules
-    # @options argvs [Code]   hook  Reference to callback method
-    # @return        [Hash]         Resolved data structure
-    def self.make(argvs)
-      email = argvs['data']
-
-      hookmethod = argvs['hook'] || nil
-      processing = {
-        'from'   => '',  # From_ line
-        'header' => {},  # Email header
-        'rfc822' => '',  # Original message part
-        'ds'     => [],  # Parsed data, Delivery Status
-        'catch'  => nil, # Data parsed by callback method
-      }
-      methodargv = {
-        'load'  => argvs['load'] || [],
-        'order' => argvs['order'] || []
-      }
-      tobeloaded = Sisimai::Message.load(methodargv)
-
-      # 1. Split email data to headers and a body part.
+      # 2. Split email data to headers and a body part.
       return nil unless aftersplit = Sisimai::Message.divideup(email)
 
-      # 2. Convert email headers from text to hash reference
-      headerargv = {
-        'extheaders' => ExtHeaders,
-        'tryonfirst' => [],
-        'extrafield' => argvs['field'] || [],
-      }
-      processing['from']   = aftersplit['from']
-      processing['header'] = Sisimai::Message.headers(aftersplit['header'], headerargv)
+      # 3. Convert email headers from text to hash reference
+      thing['from']   = aftersplit[0]
+      thing['header'] = Sisimai::Message.makemap(aftersplit[1])
 
-      # 3. Check headers for detecting MTA modules
-      if headerargv['tryonfirst'].empty?
-        headerargv['tryonfirst'] += Sisimai::Message.makeorder(processing['header'])
+      # 4. Decode and rewrite the "Subject:" header
+      unless thing['header']['subject'].empty?
+        # Decode MIME-Encoded "Subject:" header
+        s = thing['header']['subject']
+        q = Sisimai::MIME.is_mimeencoded(s) ? Sisimai::MIME.mimedecode(s.split(/[ ]/)) : s
+
+        # Remove "Fwd:" string from the Subject: header
+        if cv = q.downcase.match(/\A[ \t]*fwd?:[ ]*(.*)\z/)
+          # Delete quoted strings, quote symbols(>)
+          q = cv[1]
+          aftersplit[2] = aftersplit[2].gsub(/^[>]+[ ]/, '').gsub(/^[>]$/, '')
+        end
+        thing['header']['subject'] = q
       end
 
-      # 4. Rewrite message body for detecting the bounce reason
-      methodargv = {
-        'hook' => hookmethod,
-        'mail' => processing,
-        'body' => aftersplit['body'],
-        'tryonfirst' => headerargv['tryonfirst'],
+      # 5. Rewrite message body for detecting the bounce reason
+      param = {
+        'hook' => argvs[:hook] || nil,
+        'mail' => thing,
+        'body' => aftersplit[2],
         'tobeloaded' => tobeloaded,
+        'tryonfirst' => Sisimai::Order.make(thing['header']['subject'])
       }
-      return nil unless bouncedata = Sisimai::Message.parse(methodargv)
+      return nil unless bouncedata = Sisimai::Message.parse(param)
       return nil if bouncedata.empty?
-      %w|ds catch rfc822|.each { |e| processing[e] = bouncedata[e] }
 
-      # 5. Rewrite headers of the original message in the body part
+      # 6. Rewrite headers of the original message in the body part
+      %w|ds catch rfc822|.each { |e| thing[e] = bouncedata[e] }
       p = bouncedata['rfc822']
-      p = aftersplit['body'] if p.empty?
-      processing['rfc822'] = p.is_a?(::String) ? Sisimai::Message.takeapart(p) : p
-
-      return processing
+      p = aftersplit[2] if p.empty?
+      thing['rfc822'] = p.is_a?(::String) ? Sisimai::Message.makemap(p, true) : p
+
+      @from   = thing['from']
+      @header = thing['header']
+      @ds     = thing['ds']
+      @rfc822 = thing['rfc822']
+      @catch  = thing['catch'] || nil
     end
 
+    # Check whether the object has valid content or not
+    # @return        [True,False]   returns true if the object is void
+    def void; return @ds ? false : true; end
+
     # Load MTA modules which specified at 'order' and 'load' in the argument
     # @param         [Hash] argvs       Module information to be loaded
     # @options argvs [Array]  load      User defined MTA module list
@@ -171,12 +125,6 @@ module Sisimai
             warn ' ***warning: Failed to load ' << v
             next
           end
-
-          Module.const_get(v).headerlist.each do |w|
-            # Get header name which required user defined MTA module
-            ExtHeaders[w]  ||= {}
-            ExtHeaders[w][v] = 1
-          end
           tobeloaded << v
         end
       end
@@ -190,191 +138,81 @@ module Sisimai
       return tobeloaded
     end
 
-    # Check headers for detecting MTA module and returns the order of modules
-    # @param         [Hash] heads   Email header data
-    # @return        [Array]        Order of MTA modules
-    def self.makeorder(heads)
-      return [] unless heads
-      return [] unless heads['subject']
-      return [] if heads['subject'].empty?
-      order = []
-
-      # Try to match the value of "Subject" with patterns generated by
-      # Sisimai::Order->by('subject') method
-      title = heads['subject'].downcase
-      SubjectTab.each_key do |e|
-        # Get MTA list from the subject header
-        next unless title.include?(e)
-        order += SubjectTab[e]  # Matched and push MTA list
-        break
-      end
-      return order
-    end
-
-    # Convert email headers from text to hash reference
-    # @param         [String] heads  Email header data
-    # @param         [Hash]   argvs
-    # @param options extheaders [Array] External header table
-    # @return        [Hash]          Structured email header data
-    def self.headers(heads, argvs = {})
-      return nil unless heads
-
-      currheader = ''
-      allheaders = {}
-      structured = {}
-      extheaders = argvs['extheaders'] || []
-      extrafield = argvs['extrafield'] || []
-      headslices = heads.split("\n")
-
-      HeaderList.each { |e| structured[e] = nil  }
-      HeaderList.each { |e| allheaders[e] = true }
-      RFC3834Set.each { |e| allheaders[e] = true }
-      IsMultiple.each_key { |e| structured[e] = [] }
-      extheaders.each_key { |e| allheaders[e] = true }
-      unless extrafield.empty?
-        extrafield.each { |e| allheaders[e] = true }
-      end
-
-      while e = headslices.shift do
-        # Convert email headers to hash
-        if cv = e.match(/\A[ \t]+(.+)\z/)
-          # Continued (foled) header value from the previous line
-          next unless allheaders[currheader]
-
-          # Header line continued from the previous line
-          if structured[currheader].is_a? Array
-            # Concatenate a header which have multi-lines such as 'Received'
-            structured[currheader][-1] << ' ' << cv[1]
-          else
-            structured[currheader] ||= ''
-            structured[currheader] << ' ' << cv[1]
-          end
-        else
-          # split the line into a header name and a header content
-          (lhs, rhs) = e.split(/:[ ]*/, 2)
-          currheader = lhs ? lhs.downcase : ''
-          next unless allheaders[currheader]
-
-          if IsMultiple[currheader]
-            # Such as 'Received' header, there are multiple headers in a single
-            # email message.
-            rhs = rhs.tr("\t", ' ')
-            structured[currheader] << rhs
-          else
-            # Other headers except "Received" and so on
-            if extheaders[currheader]
-              # MTA specific header
-              extheaders[currheader].each do |r|
-                next if argvs['tryonfirst'].index(r)
-                argvs['tryonfirst'] << r
-              end
-            end
-            structured[currheader] = rhs
-          end
-        end
-      end
-      return structured
-    end
-
     # Divide email data up headers and a body part.
     # @param         [String] email  Email data
-    # @return        [Hash]          Email data after split
+    # @return        [Array]         Email data after split
     def self.divideup(email)
       return nil if email.empty?
 
-      block = { 'from' => '', 'header' => '', 'body' => '' }
-      email.scrub!('?')
+      block = ['', '', '']  # 0:From, 1:Header, 2:Body
       email.gsub!(/\r\n/, "\n")  if email.include?("\r\n")
       email.gsub!(/[ \t]+$/, '') if email =~ /[ \t]+$/
 
-      (block['header'], block['body']) = email.split(/\n\n/, 2)
-      return nil unless block['header']
-      return nil unless block['body']
+      (block[1], block[2]) = email.split(/\n\n/, 2)
+      return nil unless block[1]
+      return nil unless block[2]
 
-      if block['header'].start_with?('From ')
+      if block[1].start_with?('From ')
         # From MAILER-DAEMON Tue Feb 11 00:00:00 2014
-        block['from'] = block['header'].split(/\n/, 2)[0].delete("\r")
+        block[0] = block[1].split(/\n/, 2)[0].delete("\r")
       else
         # Set pseudo UNIX From line
-        block['from'] = 'MAILER-DAEMON Tue Feb 11 00:00:00 2014'
+        block[0] = 'MAILER-DAEMON Tue Feb 11 00:00:00 2014'
       end
 
-      block['body'] << "\n"
+      block[1] << "\n" unless block[1].end_with?("\n")
+      block[2] << "\n"
       return block
     end
 
-    # Take each email header in the original message apart
-    # @param         [String] heads The original message header
-    # @return        [Hash]         Structured message headers
-    def self.takeapart(heads)
-      return {} unless heads
-
-      # 1. Scrub to avoid "invalid byte sequence in UTF-8" exception (#82)
-      # 2. Convert from string to hash reference
-      heads = heads.scrub('?').gsub(/^[>]+[ ]/m, '').gsub(/=[ ]+=/, "=\n =")
-
-      previousfn = '' # Previous field name
-      asciiarmor = {} # Header names which has MIME encoded value
-      headerpart = {} # Required headers in the original message part
-      headslices = heads.split("\n")
-
-      while e = headslices.shift do
-        # Header name as a key, The value of header as a value
-        if e.start_with?(' ', "\t")
-          # Continued (foled) header value from the previous line
-          next if previousfn.empty?
-
-          # Concatenate the line if it is the value of required header
-          if Sisimai::MIME.is_mimeencoded(e)
-            # The line is MIME-Encoded test
-            headerpart[previousfn] << if previousfn == 'subject'
-                                        # Subject: header
-                                        BorderLine + e
-                                      else
-                                        # Is not Subject header
-                                        e
-                                      end
-            asciiarmor[previousfn] = true
-          else
-            # ASCII Characters only: Not MIME-Encoded
-            headerpart[previousfn] << e.lstrip
-            asciiarmor[previousfn] ||= false
-          end
-        else
-          # Header name as a key, The value of header as a value
-          (lhs, rhs) = e.split(/:[ ]*/, 2)
-          next unless lhs
-          lhs.downcase!
-          previousfn = ''
-
-          next unless RFC822Head[lhs]
-          previousfn = lhs
-          headerpart[previousfn] = rhs unless headerpart[previousfn]
-        end
+    # Convert a text including email headers to a hash reference
+    # @param    [String] argv0  Email header data
+    # @param    [Bool]   argv1  Decode "Subject:" header
+    # @return   [Hash]          Structured email header data
+    # @since    v4.25.6
+    def self.makemap(argv0 = '', argv1 = nil)
+      return {} if argv0.empty?
+      argv0.gsub!(/^[>]+[ ]/m, '') # Remove '>' indent symbol of forwarded message
+
+      # Select and convert all the headers in $argv0. The following regular expression
+      # is based on https://gist.github.com/xtetsuji/b080e1f5551d17242f6415aba8a00239
+      headermaps = { 'subject' => '' }
+      recvheader = []
+      argv0.scan(/^([\w-]+):[ ]*(.*?)\n(?![\s\t])/m) { |e| headermaps[e[0].downcase] = e[1] }
+      headermaps.delete('received')
+      headermaps.each_key { |e| headermaps[e].gsub!(/\n[\s\t]+/, ' ') }
+
+      if argv0.include?('Received:')
+        # Capture values of each Received: header
+        recvheader = argv0.scan(/^Received:[ ]*(.*?)\n(?![\s\t])/m).flatten
+        recvheader.each { |e| e.gsub!(/\n[\s\t]+/, ' ') }
       end
-      return headerpart unless headerpart['subject']
+      headermaps['received'] = recvheader
+
+      return headermaps unless argv1
+      return headermaps if headermaps['subject'].empty?
 
       # Convert MIME-Encoded subject
-      if Sisimai::String.is_8bit(headerpart['subject'])
+      if Sisimai::String.is_8bit(headermaps['subject'])
         # The value of ``Subject'' header is including multibyte character,
         # is not MIME-Encoded text.
-        headerpart['subject'].scrub!('?')
+        headermaps['subject'].scrub!('?')
       else
         # MIME-Encoded subject field or ASCII characters only
         r = []
-        if asciiarmor['subject']
+        if Sisimai::MIME.is_mimeencoded(headermaps['subject'])
           # split the value of Subject by borderline
-          headerpart['subject'].split(BorderLine).each do |v|
+          headermaps['subject'].split(/ /).each do |v|
             # Insert value to the array if the string is MIME encoded text
             r << v if Sisimai::MIME.is_mimeencoded(v)
           end
         else
           # Subject line is not MIME encoded
-          r << headerpart['subject']
+          r << headermaps['subject']
         end
-        headerpart['subject'] = Sisimai::MIME.mimedecode(r)
+        headermaps['subject'] = Sisimai::MIME.mimedecode(r)
       end
-      return headerpart
+      return headermaps
     end
 
     # @abstract Parse bounce mail with each MTA module
@@ -396,7 +234,6 @@ module Sisimai
       bodystring = argvs['body']
       hookmethod = argvs['hook'] || nil
       havecaught = nil
-
       return nil unless mailheader
 
       # PRECHECK_EACH_HEADER:
@@ -408,7 +245,6 @@ module Sisimai
       # Decode BASE64 Encoded message body, rewrite.
       mesgformat = (mailheader['content-type'] || '').downcase
       ctencoding = (mailheader['content-transfer-encoding'] || '').downcase
-
       if mesgformat.start_with?('text/plain', 'text/html')
         # Content-Type: text/plain; charset=UTF-8
         if ctencoding == 'base64'
@@ -432,89 +268,83 @@ module Sisimai
           bodystring = p unless p.empty?
         end
       end
-
-      # EXPAND_FORWARDED_MESSAGE:
-      # Check whether or not the message is a bounce mail.
-      # Pre-Process email body if it is a forwarded bounce message.
-      # Get the original text when the subject begins from 'fwd:' or 'fw:'
-      if mailheader['subject'].downcase =~ /\A[ \t]*fwd?:/
-        # Delete quoted strings, quote symbols(>)
-        bodystring = bodystring.gsub(/^[>]+[ ]/m, '').gsub(/^[>]$/m, '')
-      elsif Sisimai::MIME.is_mimeencoded(mailheader['subject'])
-        # Decode MIME-Encoded "Subject:" header
-        mailheader['subject'] = Sisimai::MIME.mimedecode(mailheader['subject'].split(/[ ]/))
-        mailheader['subject'].scrub!('?')
-      end
       bodystring = bodystring.scrub('?').delete("\r")
 
+      haveloaded = {}
+      parseddata = nil
+      modulename = ''
       if hookmethod.is_a? Proc
         # Call the hook method
         begin
-          p = {
-            'datasrc' => 'email',
-            'headers' => mailheader,
-            'message' => bodystring,
-            'bounces' => nil
-          }
+          p = { 'headers' => mailheader, 'message' => bodystring }
           havecaught = hookmethod.call(p)
         rescue StandardError => ce
           warn ' ***warning: Something is wrong in hook method :' << ce.to_s
         end
       end
 
-      bodystring << EndOfEmail
-      haveloaded = {}
-      parseddata = nil
-
       catch :PARSER do
         while true
-          # 1. Sisimai::ARF
-          # 2. User-Defined Module
-          # 3. MTA Module Candidates to be tried on first
-          # 4. Sisimai::Lhost::*
-          # 5. Sisimai::RFC3464
+          # 1. User-Defined Module
+          # 2. MTA Module Candidates to be tried on first
+          # 3. Sisimai::Lhost::*
+          # 4. Sisimai::RFC3464
+          # 5. Sisimai::ARF
           # 6. Sisimai::RFC3834
-          if Sisimai::ARF.is_arf(mailheader)
-            # Feedback Loop message
-            parseddata = Sisimai::ARF.make(mailheader, bodystring)
-            throw :PARSER if parseddata
-          end
-
           while r = argvs['tobeloaded'].shift do
             # Call user defined MTA modules
             next if haveloaded[r]
             parseddata = Module.const_get(r).make(mailheader, bodystring)
             haveloaded[r] = true
+            modulename = r
             throw :PARSER if parseddata
           end
 
-          argvs['tryonfirst'].concat(DefaultSet)
-          while r = argvs['tryonfirst'].shift do
+          [argvs['tryonfirst'], DefaultSet].flatten.each do |r|
             # Try MTA module candidates
             next if haveloaded[r]
-            require r.gsub('::', '/').downcase
+            require LhostTable[r]
             parseddata = Module.const_get(r).make(mailheader, bodystring)
             haveloaded[r] = true
+            modulename = r
+            throw :PARSER if parseddata
+          end
+
+          unless haveloaded['Sisimai::RFC3464']
+            # When the all of Sisimai::Lhost::* modules did not return bounce
+            # data, call Sisimai::RFC3464;
+            require 'sisimai/rfc3464'
+            parseddata = Sisimai::RFC3464.make(mailheader, bodystring)
+            modulename = 'RFC3464'
             throw :PARSER if parseddata
           end
 
-          # When the all of Sisimai::Lhost::* modules did not return bounce
-          # data, call Sisimai::RFC3464;
-          require 'sisimai/rfc3464'
-          parseddata = Sisimai::RFC3464.make(mailheader, bodystring)
-          break if parseddata
+          unless haveloaded['Sisimai::ARF']
+            # Feedback Loop message
+            require 'sisimai/arf'
+            parseddata = Sisimai::ARF.make(mailheader, bodystring) if Sisimai::ARF.is_arf(mailheader)
+            throw :PARSER if parseddata
+          end
 
-          # Try to parse the message as auto reply message defined in RFC3834
-          require 'sisimai/rfc3834'
-          parseddata = Sisimai::RFC3834.make(mailheader, bodystring)
-          break if parseddata
+          unless haveloaded['Sisimai::RFC3834']
+            # Try to parse the message as auto reply message defined in RFC3834
+            require 'sisimai/rfc3834'
+            parseddata = Sisimai::RFC3834.make(mailheader, bodystring)
+            modulename = 'RFC3834'
+            throw :PARSER if parseddata
+          end
 
-          # as of now, we have no sample email for coding this block
-          break
+          break # as of now, we have no sample email for coding this block
         end
       end
+      return nil unless parseddata
 
-      parseddata['catch'] = havecaught if parseddata
+      parseddata['catch'] = havecaught
+      modulename = modulename.sub(/\A.+::/, '')
+      parseddata['ds'].each do |e|
+        e['agent'] = modulename unless e['agent']
+        e.each_key { |a| e[a] ||= '' }  # Replace nil with ""
+      end
       return parseddata
     end