sisimai 4.25.5 → 4.25.6

data/lib/sisimai/mail/maildir.rb

@@ -1,23 +1,22 @@
 module Sisimai
   class Mail
-    # Sisimai::Mail::Maildir is a reader for getting contents of each email in the
-    # Maildir/ directory.
+    # Sisimai::Mail::Maildir is a reader for getting contents of each email in
+    # the Maildir/ directory.
     class Maildir
       # Imported from p5-Sisimail/lib/Sisimai/Mail/Maildir.pm
       # :dir    [String] Path to Maildir/
-      # :size   [Integer] The number of entires in the directory
+      # :size   [Integer] The number of files/directories in the Maildir/
       # :path   [String] Path to each file
       # :file,  [String] Each file name of a mail in the Maildir/
-      # :inodes [Array]  i-node List of files in the Maildir/
-      # :count  [Integer] The number of file has read
+      # :offset [Integer] The number of email files in the Maildir/
       # :handle [IO::Dir] Directory handle
-      attr_reader :dir, :size
-      attr_accessor :path, :file, :inodes, :count, :handle
+      attr_reader :dir
+      attr_accessor :size, :path, :file, :offset, :handle
 
       # Constructor of Sisimai::Mail::Maildir
-      # @param    [String] argvs                Path to Maildir/
-      # @return   [Sisimai::Mail::Maildir,Nil]  Object or nil if the argument is
-      #                                         not a directory or does not exist
+      # @param    [String] argvs            Path to Maildir/
+      # @return   [Sisimai::Mail::Maildir]  Object
+      #           [Nil]                     is not a directory or does not exist
       def initialize(argv1)
         raise Errno::ENOENT  unless File.exist?(argv1)
         raise Errno::ENOTDIR unless File.ftype(argv1) == 'directory'
@@ -26,45 +25,45 @@ module Sisimai
         @size   = Dir.entries(argv1).size
         @dir    = argv1
         @file   = nil
-        @inodes = {}
-        @count  = 0
+        @offset = 0
         @handle = Dir.open(argv1)
       end
 
       # Maildir reader, works as a iterator.
       # @return       [String] Contents of file in Maildir/
       def read
-        return nil unless self.count < self.size
-
+        return nil unless self.offset < self.size
         seekhandle = self.handle
         readbuffer = ''
 
         begin
           while r = seekhandle.read do
             # Read each file in the directory
-            next if r == '.' || r == '..'
+            if r == '.' || r == '..'
+              # Is a directory
+              self.offset += 1
+              next
+            end
 
             emailindir = (self.dir + '/' + r).squeeze('/')
-            next unless File.ftype(emailindir) == 'file'
-            next unless File.size(emailindir) > 0
-            next unless File.readable?(emailindir)
-
-            emailinode = File.stat(emailindir).ino
-            next if self.inodes[emailinode]
+            if File.ftype(emailindir) != 'file' ||
+               File.size(emailindir) == 0 ||
+               File.readable?(emailindir) == false
+              # The file is not a file, is empty, is not readable
+              self.offset += 1
+              next
+            end
 
             File.open(emailindir, 'r:UTF-8') do |f|
               readbuffer = f.read
             end
 
-            self.inodes[emailinode] = 1
-            self.path = emailindir
-            self.file = r
-
+            self.offset += 1
+            self.path    = emailindir
+            self.file    = r
             break
           end
-
-          self.count += 1
-          seekhandle.close unless self.count < self.size
+          seekhandle.close unless self.offset < self.size
         end
 
         return readbuffer

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

@@ -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,49 +12,29 @@ 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?
-
       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
 
-      methodargv = { 'data' => email, 'hook' => argvs[:hook] || nil, 'field' => field }
+      methodargv = { 'data' => email, 'hook' => argvs[:hook] || nil }
       [:load, :order].each do |e|
         # Order of MTA modules
         next unless argvs[e]
@@ -85,7 +65,6 @@ module Sisimai
     # @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
@@ -110,35 +89,41 @@ module Sisimai
       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)
+      processing['header'] = Sisimai::Message.makemap(aftersplit['header'])
 
-      # 3. Check headers for detecting MTA modules
-      if headerargv['tryonfirst'].empty?
-        headerargv['tryonfirst'] += Sisimai::Message.makeorder(processing['header'])
+      # 3. Decode and rewrite the "Subject:" header
+      unless processing['header']['subject'].empty?
+        # Decode MIME-Encoded "Subject:" header
+        s = processing['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['body'] = aftersplit['body'].gsub(/^[>]+[ ]/, '').gsub(/^[>]$/, '')
+        end
+        processing['header']['subject'] = q
       end
 
       # 4. Rewrite message body for detecting the bounce reason
+      tryonfirst = Sisimai::Order.make(processing['header']['subject'])
       methodargv = {
         'hook' => hookmethod,
         'mail' => processing,
         'body' => aftersplit['body'],
-        'tryonfirst' => headerargv['tryonfirst'],
+        'tryonfirst' => tryonfirst,
         'tobeloaded' => tobeloaded,
       }
       return nil unless bouncedata = Sisimai::Message.parse(methodargv)
       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
+      %w|ds catch rfc822|.each { |e| processing[e] = bouncedata[e] }
       p = bouncedata['rfc822']
       p = aftersplit['body'] if p.empty?
-      processing['rfc822'] = p.is_a?(::String) ? Sisimai::Message.takeapart(p) : p
+      processing['rfc822'] = p.is_a?(::String) ? Sisimai::Message.makemap(p, true) : p
 
       return processing
     end
@@ -171,12 +156,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,92 +169,6 @@ 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
@@ -283,7 +176,6 @@ module Sisimai
       return nil if email.empty?
 
       block = { 'from' => '', 'header' => '', 'body' => '' }
-      email.scrub!('?')
       email.gsub!(/\r\n/, "\n")  if email.include?("\r\n")
       email.gsub!(/[ \t]+$/, '') if email =~ /[ \t]+$/
 
@@ -299,82 +191,59 @@ module Sisimai
         block['from'] = 'MAILER-DAEMON Tue Feb 11 00:00:00 2014'
       end
 
-      block['body'] << "\n"
+      block['header'] << "\n" unless block['header'].end_with?("\n")
+      block['body']   << "\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 +265,6 @@ module Sisimai
       bodystring = argvs['body']
       hookmethod = argvs['hook'] || nil
       havecaught = nil
-
       return nil unless mailheader
 
       # PRECHECK_EACH_HEADER:
@@ -408,7 +276,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,21 +299,11 @@ 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
@@ -462,59 +319,68 @@ module Sisimai
         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