sisimai 4.16.0-java

data/lib/sisimai/mail.rb

@@ -0,0 +1,82 @@
+module Sisimai
+  # Sisimai::Mail is a handler of UNIX mbox or Maildir for reading each mail. It is
+  # wrapper class of Sisimai::Mail::Mbox and Sisimai::Mail::Maildir classes.
+  class Mail
+    # Imported from p5-Sisimail/lib/Sisimai/Mail.pm
+    @@roaccessors = [
+      :path,  # [String] path to mbox or Maildir/
+      :type,  # [String] Data type: mailbox, maildir, or stdin
+    ]
+    @@rwaccessors = [
+      :mail,  # [Sisimai::Mail::Mbox, Sisimai::Mail::Maildir] Object
+    ]
+    @@roaccessors.each { |e| attr_reader   e }
+    @@rwaccessors.each { |e| attr_accessor e }
+
+    # Constructor of Sisimai::Mail
+    # @param    [String] argv1        Path to mbox or Maildir/
+    # @return   [Sisimai::Mail, Nil]  Object or Undef if the argument was wrong
+    def initialize(argv1)
+      classname = nil
+      parameter = { 'path' => argv1, 'type' => nil, 'mail' => nil }
+
+      if argv1.is_a?(::String)
+        # Path to mail or '<STDIN>' ?
+        if argv1 == '<STDIN>'
+          # Sisimai::Mail.new('<STDIN>')
+          classname = sprintf('%s::STDIN', self.class)
+          parameter['type'] = 'stdin'
+          parameter['path'] = $stdin
+
+        else
+          # The argumenet is a mailbox or a Maildir/.
+          mediatype = File.ftype(argv1)
+
+          if mediatype == 'file'
+            # The argument is a file, it is an mbox or email file in Maildir/
+            classname = sprintf('%s::Mbox', self.class)
+            parameter['type'] = 'mailbox'
+
+          elsif mediatype == 'directory'
+            # The agument is not a file, it is a Maildir/
+            classname = sprintf('%s::Maildir', self.class)
+            parameter['type'] = 'maildir'
+          end
+        end
+
+      elsif argv1.is_a?(IO)
+        # Read from STDIN
+        # The argument neither a mailbox nor a Maildir/.
+        classname = sprintf('%s::STDIN', self.class)
+        parameter['type'] = 'stdin'
+
+      end
+
+      return nil unless classname
+
+      classpath = classname.gsub('::', '/').downcase
+      require classpath
+      parameter['mail'] = Module.const_get(classname).new(parameter['path'])
+
+      @path = parameter['path']
+      @type = parameter['type']
+      @mail = parameter['mail']
+    end
+
+    # Mbox/Maildir reader, works as an iterator.
+    # @return   [String] Contents of mbox/Maildir
+    def read
+      return nil unless mail
+      return mail.read
+    end
+
+    # Close the handle
+    # @return   [True,False]  true:  Successfully closed the handle
+    #                         false: Mail handle is not defined
+    def close
+      return false unless mail.handle
+      mail.handle = nil
+      return true
+    end
+  end
+end

data/lib/sisimai/mail/maildir.rb

@@ -0,0 +1,82 @@
+module Sisimai
+  class Mail
+    # 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
+      @@roaccessors = [
+        :dir,     # [String] Path to Maildir/
+        :size,    # [Integer] The number of entires in the directory
+      ]
+      @@rwaccessors = [
+        :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/
+        :offset,  # [Integer]  Offset position for seeking
+        :handle,  # [IO::Dir] Directory handle
+      ]
+      @@roaccessors.each { |e| attr_reader   e }
+      @@rwaccessors.each { |e| attr_accessor e }
+
+      # 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
+      def initialize(argv1)
+        raise Errno::ENOENT  unless File.exist?(argv1)
+        raise Errno::ENOTDIR unless File.ftype(argv1) == 'directory'
+
+        @path   = nil
+        @size   = Dir.entries(argv1).size
+        @dir    = argv1
+        @file   = nil
+        @offset = 0
+        @inodes = {}
+        @handle = Dir.open(argv1)
+      end
+
+      # Maildir reader, works as a iterator.
+      # @return       [String] Contents of file in Maildir/
+      def read
+        return nil unless self.offset < self.size
+
+        seekhandle = self.handle
+        readbuffer = ''
+
+        begin
+          while r = seekhandle.read do
+            # Read each file in the directory
+            self.offset = seekhandle.pos
+            next if r == '.' || r == '..'
+
+            emailindir = sprintf('%s/%s', self.dir, r)
+            emailindir = emailindir.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.key?(emailinode)
+
+            filehandle = File.open(emailindir, 'r')
+            readbuffer = filehandle.read
+            filehandle.close
+
+            self.inodes[emailinode] = 1
+            self.path = emailindir
+            self.file = r
+
+            break
+          end
+
+          seekhandle.close unless self.offset < self.size
+        end
+
+        return readbuffer
+      end
+
+    end
+  end
+end
+

data/lib/sisimai/mail/mbox.rb

@@ -0,0 +1,69 @@
+module Sisimai
+  class Mail
+    # Sisimai::Mail::Mbox is a mailbox file (UNIX mbox) reader.
+    class Mbox
+      # Imported from p5-Sisimail/lib/Sisimai/Mail/Mbox.pm
+      @@roaccessors = [
+        :dir,     # [String]  Directory name of the mbox
+        :file,    # [String]  File name of the mbox
+        :path,    # [String]  Path to mbox
+        :size,    # [Integer] File size of the mbox
+      ]
+      @@rwaccessors = [
+        :offset,  # [Integer]  Offset position for seeking
+        :handle,  # [IO::File] File handle
+      ]
+      @@roaccessors.each { |e| attr_reader   e }
+      @@rwaccessors.each { |e| attr_accessor e }
+
+      # Constructor of Sisimai::Mail::Mbox
+      # @param    [String] argv1            Path to mbox
+      # @return   [Sisimai::Mail::Mbox,Nil] Object or nil if the argument is not
+      #                                     specified or does not exist
+      def initialize(argv1)
+        raise Errno::ENOENT   unless File.exist?(argv1)
+        raise 'is not a file' unless File.ftype(argv1) == 'file'
+
+        @path   = argv1
+        @dir    = File.dirname(argv1)
+        @file   = File.basename(argv1)
+        @size   = File.size(argv1)
+        @offset = 0
+        @handle = File.open(argv1, 'r')
+      end
+
+      # Mbox reader, works as an iterator.
+      # @return   [String] Contents of mbox
+      def read
+        return nil unless self.offset < self.size
+
+        seekoffset = self.offset || 0
+        filehandle = self.handle
+        readbuffer = ''
+        frombuffer = ''
+
+        begin
+          seekoffset = 0 if seekoffset < 0
+          filehandle.seek(seekoffset, 0)
+
+          filehandle.each_line do |r|
+            # Read the UNIX mbox file from 'From ' to the next 'From '
+            if r[0, 5] == 'From ' && readbuffer.size > 0
+              frombuffer = r
+              break
+            end
+            readbuffer << r
+          end
+
+          seekoffset = filehandle.pos - frombuffer.bytesize
+          frombuffer = ''
+          self.offset = seekoffset
+          filehandle.close unless self.offset < self.size
+        end
+
+        return readbuffer.to_s
+      end
+    end
+  end
+end
+

data/lib/sisimai/mail/stdin.rb

@@ -0,0 +1,53 @@
+module Sisimai
+  class Mail
+    # Sisimai::Mail::STDIN is a reader for getting contents of each email from
+    # STDIN
+    class STDIN
+      # Imported from p5-Sisimail/lib/Sisimai/Mail/STDIN.pm
+      @@roaccessors = [
+        :path,    # [String]  Path to mbox
+        :name,    # [String]  File name of the mbox
+        :size,    # [Integer] File size of the mbox
+      ]
+      @@rwaccessors = [
+        :offset,  # [Integer]  Offset position for seeking
+        :handle,  # [IO::File] File handle
+      ]
+      @@roaccessors.each do |e| attr_reader   e end
+      @@rwaccessors.each do |e| attr_accessor e end
+
+      # Constructor of Sisimai::Mail::STDIN
+      # @param    [IO::STDIN] stdin      Standard-In
+      # @return   [Sisimai::Mail::STDIN] Object
+      def initialize(stdin = $stdin)
+        raise 'is not an IO object' unless stdin.is_a?(IO)
+
+        @path   = '<STDIN>'
+        @name   = '<STDIN>'
+        @size   = nil
+        @offset = 0
+        @handle = stdin
+      end
+
+      # Mbox reader, works as a iterator.
+      # @return   [String] Contents of mbox
+      def read
+        readhandle = self.handle
+        readbuffer = ''
+
+        begin
+          readhandle = STDIN unless readhandle
+          while r = readhandle.gets
+            break if readbuffer.size > 0 && r[0, 5] == 'From '
+            readbuffer << r
+          end
+        ensure
+          readhandle.close
+        end
+
+        return readbuffer
+      end
+    end
+  end
+end
+

data/lib/sisimai/mda.rb

@@ -0,0 +1,152 @@
+module Sisimai
+  # Sisimai::MDA - Error message parser for MDA
+  module MDA
+    # Imported from p5-Sisimail/lib/Sisimai/MDA.pm
+    class << self
+      Re0 = {
+        :from => %r/\A(?:Mail Delivery Subsystem|MAILER-DAEMON|postmaster)/i,
+      }
+      Re1 = {
+        # 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/,
+        'mail.local' => %r/\Amail[.]local: /,
+        'procmail'   => %r/\Aprocmail: /,
+        'maildrop'   => %r/\Amaildrop: /,
+        'vpopmail'   => %r/\Avdelivermail: /,
+        'vmailmgr'   => %r/\Avdeliver: /,
+      }
+      Re2 = %r{\A(?>
+         Your[ ]message[ ]to[ ].+[ ]was[ ]automatically[ ]rejected:\z
+        |(?:mail[.]local|procmail|maildrop|vdelivermail|vdeliver):[ ]
+        )
+      }x
+
+      # dovecot/src/deliver/mail-send.c:94
+      ReFailure = {
+        'dovecot' => {
+          'userunknown' => %r/\AMailbox doesn't exist: /i,
+          'mailboxfull' => %r{\A(?:
+             Quota[ ]exceeded # Dovecot 1.2 dovecot/src/plugins/quota/quota.c
+            |Quota[ ]exceeded[ ][(]mailbox[ ]for[ ]user[ ]is[ ]full[)]  # dovecot/src/plugins/quota/quota.c
+            |Not[ ]enough[ ]disk[ ]space
+            )
+          }xi,
+        },
+        'mail.local' => {
+          'userunknown' => %r{[:][ ](?:
+             unknown[ ]user[:]
+            |User[ ]unknown
+            |Invalid[ ]mailbox[ ]path
+            |User[ ]missing[ ]home[ ]directory
+            )
+          }xi,
+          'mailboxfull' => %r{(?:
+             Disc[ ]quota[ ]exceeded
+            |Mailbox[ ]full[ ]or[ ]quota[ ]exceeded
+            )
+          }xi,
+          'systemerror' => %r/Temporary file write error/i,
+        },
+        'procmail' => {
+          'mailboxfull' => %r/Quota exceeded while writing/i,
+          'systemfull'  => %r/No space left to finish writing/i,
+        },
+        'maildrop' => {
+          'userunknown' => %r{(?:
+             Invalid[ ]user[ ]specified[.]
+            |Cannot[ ]find[ ]system[ ]user
+            )
+          }xi,
+          'mailboxfull' => %r/maildir over quota[.]\z/i,
+        },
+        'vpopmail' => {
+          'userunknown' => %r/Sorry, no mailbox here by that name[.]/i,
+          'filtered'    => %r{(?:
+             account[ ]is[ ]locked[ ]email[ ]bounced
+            |user[ ]does[ ]not[ ]exist,[ ]but[ ]will[ ]deliver[ ]to[ ]
+            )
+          }xi,
+          'mailboxfull' => %r/(?:domain|user) is over quota/i,
+        },
+        'vmailmgr' => {
+          'userunknown' => %r{(?>
+             Invalid[ ]or[ ]unknown[ ](?:base[ ]user[ ]or[ ]domain|virtual[ ]user)
+            |User[ ]name[ ]does[ ]not[ ]refer[ ]to[ ]a[ ]virtual[ ]user/
+            )
+          }ix,
+          'mailboxfull' => %r/Delivery failed due to system quota violation/i,
+        },
+      }
+
+      # 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 Undef if it failed to parse or the
+      #                                   arguments are missing
+      def scan(mhead, mbody)
+        return nil unless mhead
+        return nil unless mbody
+        return nil if mhead.keys.size == 0
+        return nil if mbody.empty?
+
+        return nil unless mhead['from'] =~ Re0[:from]
+
+        agentname0 = ''   # [String] MDA name
+        reasonname = ''   # [String] Error reason
+        bouncemesg = ''   # [String] Error message
+        hasdivided = mbody.split("\n")
+        linebuffer = []
+
+        hasdivided.each do |e|
+          # Check each line with each MDA's symbol regular expression.
+          if agentname0 == ''
+            # Try to match with each regular expression
+            next unless e.size > 0;
+            next unless e =~ Re2
+
+            Re1.each_key do |f|
+              # Detect the agent name from the line
+              next unless e =~ Re1[f]
+              agentname0 = f
+              break
+            end
+          end
+
+          # Append error message lines to @linebuffer
+          linebuffer << e
+          break unless e.size > 0
+        end
+
+        return nil unless agentname0.size > 0
+        return nil unless linebuffer.size > 0
+
+        ReFailure[agentname0].each_key do |e|
+          # Detect an error reason from message patterns of the MDA.
+          linebuffer.each do |f|
+            # Try to match with each regular expression
+            next unless f =~ ReFailure[agentname0][e]
+            reasonname = e
+            bouncemesg = f
+            break
+          end
+          break if bouncemesg.size > 0 && reasonname.size > 0
+        end
+
+        return {
+          'mda'     => agentname0,
+          'reason'  => reasonname || '',
+          'message' => bouncemesg || '',
+        }
+      end
+    end
+  end
+end
+

data/lib/sisimai/message.rb

@@ -0,0 +1,525 @@
+module Sisimai
+  # Sisimai::Message convert bounce email text to data structure. It resolve email
+  # text into an UNIX From line, the header part of the mail, delivery status, and
+  # RFC822 header part. When the email given as a argument of "new" method is not a
+  # bounce email, the method returns nil.
+  class Message
+    # Imported from p5-Sisimail/lib/Sisimai/Message.pm
+    require 'sisimai/arf'
+    require 'sisimai/mime'
+    require 'sisimai/order'
+    require 'sisimai/string'
+    require 'sisimai/rfc3834'
+    require 'sisimai/rfc5322'
+
+    @@rwaccessors = [
+      :from,    # [String] UNIX From line
+      :header,  # [Hash]   Header part of a email
+      :ds,      # [Array]  Parsed data by Sisimai::MTA::*
+      :rfc822,  # [Hash]   Header part of the original message
+    ]
+    @@rwaccessors.each { |e| attr_accessor e }
+
+    EndOfEmail = Sisimai::String.EOM
+    RFC822Head = Sisimai::RFC5322.HEADERFIELDS
+    RFC3834Set = Sisimai::RFC3834.headerlist.map { |e| e.downcase }
+    HeaderList = [
+      'from', 'to', 'date', 'subject', 'content-type', 'reply-to', 'message-id',
+      'received', 'content-transfer-encoding', 'return-path', 'x-mailer',
+    ]
+    MultiHeads = { 'received' => true }
+    IgnoreList = { 'dkim-signature' => true }
+    Indicators = {
+      :begin => (1 << 1),
+      :endof => (1 << 2),
+    }
+    DefaultSet = Sisimai::Order.another
+    PatternSet = Sisimai::Order.by('subject')
+    ExtHeaders = Sisimai::Order.headers
+
+    # Constructor of Sisimai::Message
+    # @param         [String] data      Email text data
+    # @param         [Hash] argvs       Module to be loaded
+    # @options argvs [String] data      Entire email message
+    # @return        [Sisimai::Message] Structured email data or Undef if each
+    #                                   value of the arguments are missing
+    def initialize(data: '', **argvs)
+      return nil if data.empty?
+
+      email = data
+      email = email.scrub('?')
+      email = email.gsub("\r\n", "\n")
+      methodargv = { 'data' => email }
+
+      [:'load', :'order'].each do |e|
+        # Order of MTA, MSP modules
+        next unless argvs.key?(e)
+        next unless argvs[e].is_a? Array
+        next if argvs[e].empty?
+        methodargv[e.to_s] = argvs[e]
+      end
+
+      parameters = Sisimai::Message.make(methodargv)
+      return nil unless parameters
+      return nil unless parameters.key?('ds')
+
+      @from   = parameters['from']
+      @header = parameters['header']
+      @ds     = parameters['ds']
+      @rfc822 = parameters['rfc822']
+    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
+    # @return        [Hash]         Resolved data structure
+    def self.make(argvs)
+      email = argvs['data']
+
+      processing = { 'from' => '', 'header' => {}, 'rfc822' => '', 'ds' => [] }
+      mtamodules = []
+      extheaders = ExtHeaders
+      tobeloaded = []
+      headerargv = {}
+
+      %w|load order|.each do |e|
+        # The order of MTA modules specified by user
+        next unless argvs.key?(e)
+        next unless argvs[e].is_a? Array
+        next if argvs[e].empty?
+
+        mtamodules.concat(argvs['order']) if e == 'order'
+        next unless e == 'load'
+
+        # Load user defined MTA module
+        argvs['load'].each do |v|
+          # Load user defined MTA module
+          begin
+            require v.to_s.gsub('::', '/').downcase
+          rescue LoadError
+            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
+
+      mtamodules.each do |e|
+        # Append the custom order of MTA modules
+        next if tobeloaded.index(e)
+        tobeloaded << e
+      end
+
+      # 0. Split email data to headers and a body part.
+      aftersplit = Sisimai::Message.divideup(email)
+      return nil if aftersplit.empty?
+
+      # 1. Convert email headers from text to hash reference
+      headerargv['extheaders'] = extheaders
+      headerargv['tryonfirst'] = []
+      processing['from']   = aftersplit['from']
+      processing['header'] = Sisimai::Message.headers(aftersplit['header'], headerargv)
+
+      # 3. Check headers for detecting MTA/MSP module
+      if headerargv['tryonfirst'].empty?
+        headerargv['tryonfirst'].concat(Sisimai::Message.makeorder(processing['header']))
+      end
+
+      # 4. Rewrite message body for detecting the bounce reason
+      methodargv = {
+        'mail' => processing,
+        'body' => aftersplit['body'],
+        'tryonfirst' => headerargv['tryonfirst'],
+        'tobeloaded' => tobeloaded,
+      }
+      bouncedata = Sisimai::Message.parse(methodargv)
+
+      return nil unless bouncedata
+      return nil if bouncedata.empty?
+      processing['ds'] = bouncedata['ds']
+
+      # 5. Rewrite headers of the original message in the body part
+      rfc822part = bouncedata['rfc822']
+      rfc822part = aftersplit['body'] if rfc822part.empty?
+      processing['rfc822'] = Sisimai::Message.takeapart(rfc822part)
+
+      return processing
+    end
+
+    # Divide email data up headers and a body part.
+    # @param         [String] email  Email data
+    # @return        [Hash]          Email data after split
+    def self.divideup(email)
+      return {} if email.empty?
+
+      email = email.scrub('?')
+      email = email.gsub(/[ \t]+$/, '')
+      email = email.gsub(/^[ \t]+$/, '')
+      hasdivided = email.split("\n")
+      return {} if hasdivided.empty?
+
+      readcursor = 0
+      aftersplit = { 'from' => '', 'header' => '', 'body' => '' }
+      pseudofrom = 'MAILER-DAEMON Tue Feb 11 00:00:00 2014'
+
+      if hasdivided[0][0, 5] == 'From '
+        # From MAILER-DAEMON Tue Feb 11 00:00:00 2014
+        aftersplit['from'] = hasdivided.shift
+        aftersplit['from'] = aftersplit['from'].delete("\n").delete("\r")
+      end
+
+      # Split email data to headers and a body part.
+      hasdivided.each do |e|
+        # Split email data to headers and a body part.
+        e = e.delete("\r").delete("\n")
+        e = e.gsub(/[ \t]+\z/, '')
+
+        if readcursor & Indicators[:endof] > 0
+          # The body part of the email
+          aftersplit['body'] += e + "\n"
+
+        else
+          # The boundary for splitting headers and a body part does not
+          # appeare yet.
+          if e.empty?
+            # Blank line, it is a boundary of headers and a body part
+            readcursor |= Indicators[:endof] if readcursor & Indicators[:begin] > 0
+
+          else
+            # The header part of the email
+            aftersplit['header'] += e + "\n"
+            readcursor |= Indicators[:begin]
+          end
+        end
+      end
+      return {} if aftersplit['header'].empty?
+      return {} if aftersplit['body'].empty?
+
+      aftersplit['from'] = pseudofrom if aftersplit['from'].empty?
+      return aftersplit
+    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'] || []
+
+      HeaderList.each { |e| structured[e] = nil  }
+      HeaderList.each { |e| allheaders[e] = true }
+      RFC3834Set.each { |e| allheaders[e] = true }
+      MultiHeads.each_key { |e| structured[e.downcase] = [] }
+      extheaders.each_key { |e| allheaders[e] = true }
+
+      heads.split("\n").each do |e|
+        # Convert email headers to hash
+        if cv = e.match(/\A([^ ]+?)[:][ ]*(.+?)\z/)
+          # split the line into a header name and a header content
+          lhs = cv[1]
+          rhs = cv[2]
+
+          currheader = lhs.downcase
+          next unless allheaders.key?(currheader)
+
+          if MultiHeads.key?(currheader)
+            # Such as 'Received' header, there are multiple headers in a single
+            # email message.
+            rhs = rhs.tr("\t", ' ')
+            rhs = rhs.squeeze(' ')
+            structured[currheader] << rhs
+
+          else
+            # Other headers except "Received" and so on
+            if extheaders[currheader]
+              # MTA specific header
+              extheaders[currheader].keys.each do |r|
+                next if argvs['tryonfirst'].index(r)
+                argvs['tryonfirst'] << r
+              end
+            end
+            structured[currheader] = rhs
+          end
+
+        elsif cv = e.match(/\A[ \t]+(.+?)\z/)
+          # Ignore header?
+          next if IgnoreList[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
+        end
+      end
+      return structured
+    end
+
+    # Check headers for detecting MTA/MSP module and returns the order of modules
+    # @param         [Hash] heads   Email header data
+    # @return        [Array]        Order of MTA/MSP 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
+      PatternSet.each_key do |e|
+        # Get MTA list from the subject header
+        next unless heads['subject'] =~ e
+
+        # Matched and push MTA list
+        order.concat(PatternSet[e])
+        break
+      end
+      return order
+    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
+
+      # Convert from string to hash reference
+      heads = heads.gsub(/^[>]+[ ]/m, '')
+
+      takenapart = {}
+      hasdivided = heads.split("\n")
+      previousfn = '' # Previous field name
+      borderline = '__MIME_ENCODED_BOUNDARY__'
+      mimeborder = {}
+
+      hasdivided.each do |e|
+        # Header name as a key, The value of header as a value
+        if cv = e.match(/\A([-0-9A-Za-z]+?)[:][ ]*(.*)\z/)
+          # Header
+          lhs = cv[1].downcase
+          rhs = cv[2]
+          previousfn = ''
+
+          next unless RFC822Head.key?(lhs)
+          previousfn = lhs
+          takenapart[previousfn] = rhs unless takenapart[previousfn]
+
+        else
+          # Continued line from the previous line
+          next unless e =~ /\A[ \t]+/
+          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
+            if previousfn == 'subject'
+              # Subject: header
+              takenapart[previousfn] += borderline + e
+
+            else
+              # Is not Subject header
+              takenapart[previousfn] += e
+            end
+            mimeborder[previousfn] = true
+
+          else
+            # ASCII Characters only: Not MIME-Encoded
+            e = e.lstrip
+            takenapart[previousfn]  += e
+            mimeborder[previousfn] ||= false
+          end
+        end
+      end
+
+      if takenapart['subject']
+        # Convert MIME-Encoded subject
+        v = takenapart['subject']
+
+        if Sisimai::String.is_8bit(v)
+          # The value of ``Subject'' header is including multibyte character,
+          # is not MIME-Encoded text.
+          v = 'MULTIBYTE CHARACTERS HAVE BEEN REMOVED'
+
+        else
+          # MIME-Encoded subject field or ASCII characters only
+          r = []
+          if mimeborder['subject']
+            # split the value of Subject by $borderline
+            v.split(borderline).each do |m|
+              # Insert value to the array if the string is MIME encoded text
+              r << m if Sisimai::MIME.is_mimeencoded(m)
+            end
+          else
+            # Subject line is not MIME encoded
+            r << v
+          end
+          v = Sisimai::MIME.mimedecode(r)
+        end
+        takenapart['subject'] = v
+      end
+      return takenapart
+    end
+
+    # Parse bounce mail with each MTA/MSP module
+    # @param               [Hash] argvs    Processing message entity.
+    # @param options argvs [Hash] mail     Email message entity
+    # @param options mail  [String] from   From line of mbox
+    # @param options mail  [Hash]   header Email header data
+    # @param options mail  [String] rfc822 Original message part
+    # @param options mail  [Array]  ds     Delivery status list(parsed data)
+    # @param options argvs [String] body   Email message body
+    # @param options argvs [Array] tryonfirst  MTA/MSP module list to load on first
+    # @param options argvs [Array] tobeloaded  User defined MTA module list
+    # @return              [Hash]          Parsed and structured bounce mails
+    def self.parse(argvs)
+      mesgentity = argvs['mail']
+      bodystring = argvs['body']
+      tryonfirst = argvs['tryonfirst'] || []
+      tobeloaded = argvs['tobeloaded'] || []
+      mailheader = mesgentity['header']
+
+      return nil unless argvs['mail']
+      return nil unless argvs['body']
+
+      # PRECHECK_EACH_HEADER:
+      # Set empty string if the value is nil
+      mailheader['from']         ||= ''
+      mailheader['subject']      ||= ''
+      mailheader['content-type'] ||= ''
+
+      # Decode BASE64 Encoded message body, rewrite.
+      mesgformat = (mailheader['content-type'] || '').downcase
+      ctencoding = (mailheader['content-transfer-encoding'] || '').downcase
+
+      if mesgformat =~ %r|text/plain;|
+        # Content-Type: text/plain; charset=UTF-8
+        if ctencoding == 'base64' || ctencoding == 'quoted-printable'
+          # Content-Transfer-Encoding: base64
+          # Content-Transfer-Encoding: quoted-printable
+          if ctencoding == 'base64'
+            # Content-Transfer-Encoding: base64
+            bodystring = Sisimai::MIME.base64d(bodystring)
+
+          else
+            # Content-Transfer-Encoding: quoted-printable
+            bodystring = Sisimai::MIME.qprintd(bodystring)
+          end
+        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'] =~ /\A[ \t]*fwd?:/i
+        # Delete quoted strings, quote symbols(>)
+        bodystring = bodystring.gsub(/^[>]+[ ]/m, '')
+        bodystring = bodystring.gsub(/^[>]$/m, '')
+      end
+      bodystring += EndOfEmail
+      haveloaded  = {}
+      scannedset  = nil
+
+      catch :SCANNER do
+        loop do
+          # 1. Sisimai::ARF
+          # 2. User-Defined Module
+          # 3. MTA Module Candidates to be tried on first
+          # 4. Sisimai::MTA::* and MSP::*
+          # 5. Sisimai::RFC3464
+          # 6. Sisimai::RFC3834
+          #
+          if Sisimai::ARF.is_arf(mailheader)
+            # Feedback Loop message
+            scannedset = Sisimai::ARF.scan(mailheader, bodystring)
+            throw :SCANNER if scannedset
+          end
+
+          tobeloaded.each do |r|
+            # Call user defined MTA modules
+            next if haveloaded[r]
+            begin
+              require r.gsub('::', '/').downcase
+            rescue LoadError => ce
+              warn ' ***warning: Failed to load ' + ce.to_s
+              next
+            end
+            scannedset = Module.const_get(r).scan(mailheader, bodystring)
+            haveloaded[r] = true
+            throw :SCANNER if scannedset
+          end
+
+          tryonfirst.each do |r|
+            # Try MTA module candidates which are detected from MTA specific
+            # mail headers on first
+            next if haveloaded.key?(r)
+            begin
+              require r.gsub('::', '/').downcase
+            rescue LoadError => ce
+              warn ' ***warning: ' + ce.to_s
+              next
+            end
+            scannedset = Module.const_get(r).scan(mailheader, bodystring)
+            haveloaded[r] = true
+            throw :SCANNER if scannedset
+          end
+
+          DefaultSet.each do |r|
+            # MTA/MSP modules which does not have MTA specific header and did
+            # not match with any regular expressions of Subject header.
+            next if haveloaded.key?(r)
+            begin
+              scannedset = Module.const_get(r).scan(mailheader, bodystring)
+              haveloaded[r] = true
+              throw :SCANNER if scannedset
+            rescue => ce
+              warn ' ***warning: ' + ce.to_s
+              next
+            end
+
+          end
+
+          # When the all of Sisimai::MTA::* modules did not return bounce data,
+          # call Sisimai::RFC3464;
+          require 'sisimai/rfc3464'
+          scannedset = Sisimai::RFC3464.scan(mailheader, bodystring)
+          break if scannedset
+
+          # Try to parse the message as auto reply message defined in RFC3834
+          require 'sisimai/rfc3834'
+          scannedset = Sisimai::RFC3834.scan(mailheader, bodystring)
+          break if scannedset
+
+          # as of now, we have no sample email for coding this block
+          break
+        end
+      end
+      return scannedset
+    end
+
+  end
+end
+