sisimai 4.14.2

data/lib/sisimai/reason/systemerror.rb

@@ -0,0 +1,69 @@
+module Sisimai
+  module Reason
+    # Sisimai::Reason::SystemError checks the bounce reason is "systemerror" or
+    # not. This class is called only Sisimai::Reason class.
+    #
+    # This is the error that an email has bounced due to system error on the
+    # remote host such as LDAP connection failure or other internal system error.
+    #
+    #   <kijitora@example.net>:
+    #   Unable to contact LDAP server. (#4.4.3)I'm not going to try again; this
+    #   message has been in the queue too long.
+    module SystemError
+      # Imported from p5-Sisimail/lib/Sisimai/Reason/SystemError.pm
+      class << self
+        def text; return 'systemerror'; end
+
+        # Try to match that the given text and regular expressions
+        # @param    [String] argv1  String to be matched with regular expressions
+        # @return   [True,False]    false: Did not match
+        #                           true: Matched
+        def match(argv1)
+          return nil unless argv1
+          regex = %r{(?>
+             can[']t[ ]create[ ]user[ ]output[ ]file
+            |Internal[ ](?:
+               error[ ]reading[ ]data                             # Microsoft
+              |server[ ]error:[ ]Operation[ ]now[ ]in[ ]progress  # Microsoft
+              )
+            |interrupted[ ]system[ ]call
+            |it[ ](?:
+               encountered[ ]an[ ]error[ ]while[ ]being[ ]processed
+              |would[ ]create[ ]a[ ]mail[ ]loop
+              )
+            |local[ ](?:
+               configuration[ ]error
+              |error[ ]in[ ]processing
+              )
+            |loop[ ]was[ ]found[ ]in[ ]the[ ]Mail[ ]eXchanger
+            |mail[ ](?:
+               for[ ].+[ ]loops[ ]back[ ]to[ ]myself
+              |system[ ]configuration[ ]error
+              )
+            |server[ ]configuration[ ]error
+            |service[ ]currently[ ]unavailable
+            |system[ ]config[ ]error
+            |timeout[ ]waiting[ ]for[ ]input
+            )
+          }ix
+
+          return true if argv1 =~ regex
+          return false
+        end
+
+        # The bounce reason is system error or not
+        # @param    [Sisimai::Data] argvs   Object to be detected the reason
+        # @return   [True,False]            true: is system error
+        #                                   false: is not system error
+        # @see http://www.ietf.org/rfc/rfc2822.txt
+        def true(_argvs)
+          return nil
+        end
+
+      end
+    end
+  end
+end
+
+
+

data/lib/sisimai/reason/systemfull.rb

@@ -0,0 +1,45 @@
+module Sisimai
+  module Reason
+    # Sisimai::Reason::SystemFull checks the bounce reason is "systemfull" or
+    # not. This class is called only Sisimai::Reason class.
+    #
+    # This is the error that a destination mail server's disk (or spool) is full.
+    # Sisimai will set C<systemfull> to the reason of email bounce if the value
+    # of Status: field in a bounce email is "4.3.1" or "5.3.1".
+    module SystemFull
+      # Imported from p5-Sisimail/lib/Sisimai/Reason/SystemFull.pm
+      class << self
+        def text; return 'systemfull'; end
+
+        # Try to match that the given text and regular expressions
+        # @param    [String] argv1  String to be matched with regular expressions
+        # @return   [True,False]    false: Did not match
+        #                           true: Matched
+        def match(argv1)
+          return nil unless argv1
+          regex = %r{(?:
+             mail[ ]system[ ]full
+            |requested[ ]mail[ ]action[ ]aborted:[ ]exceeded[ ]storage[ ]allocation # MS Exchange
+            )
+          }ix
+
+          return true if argv1 =~ regex
+          return false
+        end
+
+        # The bounce reason is system full or not
+        # @param    [Sisimai::Data] argvs   Object to be detected the reason
+        # @return   [True,False]            true: is system full
+        #                                   false: is not system full
+        # @see http://www.ietf.org/rfc/rfc2822.txt
+        def true(_argvs)
+          return nil
+        end
+
+      end
+    end
+  end
+end
+
+
+

data/lib/sisimai/reason/toomanyconn.rb

@@ -0,0 +1,73 @@
+module Sisimai
+  module Reason
+    # Sisimai::Reason::TooManyConn checks the bounce reason is "toomanyconn" or
+    # not. This class is called only Sisimai::Reason class.
+    #
+    # This is the error that SMTP connection was rejected temporarily due to too
+    # many concurrency connections to the remote server. This reason has added
+    # in Sisimai 4.1.26 and does not exist in any version of bounceHammer.
+    #
+    #   <kijitora@example.ne.jp>: host mx02.example.ne.jp[192.0.1.20] said:
+    #     452 4.3.2 Connection rate limit exceeded. (in reply to MAIL FROM command)
+    module TooManyConn
+      # Imported from p5-Sisimail/lib/Sisimai/Reason/TooManyConn.pm
+      class << self
+        def text; return 'toomanyconn'; end
+
+        # Try to match that the given text and regular expressions
+        # @param    [String] argv1  String to be matched with regular expressions
+        # @return   [True,False]    false: Did not match
+        #                           true: Matched
+        def match(argv1)
+          return nil unless argv1
+          regex = %r{(?>
+             All[ ]available[ ]IPs[ ]are[ ]at[ ]maximum[ ]connection[ ]limit    # SendGrid
+            |connection[ ]rate[ ]limit[ ]exceeded
+            |no[ ]IPs[ ]available[ ][-][ ].+[ ]exceeds[ ]per[-]domain[ ]connection[ ]limit[ ]for
+            |Too[ ]many[ ](?:
+               connections
+              |connections[ ]from[ ]your[ ]host[.]    # Microsoft
+              |concurrent[ ]SMTP[ ]connections        # Microsoft
+              |SMTP[ ]sessions[ ]for[ ]this[ ]host    # Sendmail(daemon.c)
+              )
+            )
+          }ix
+
+          return true if argv1 =~ regex
+          return false
+        end
+
+        # Rejected by domain or address filter ?
+        # @param    [Sisimai::Data] argvs   Object to be detected the reason
+        # @return   [True,False]            true: is filtered
+        #                                   false: is not filtered
+        # @see http://www.ietf.org/rfc/rfc2822.txt
+        def true(argvs)
+          return nil unless argvs
+          return nil unless argvs.is_a? Sisimai::Data
+          return true if argvs.reason == Sisimai::Reason::TooManyConn.text
+
+          require 'sisimai/smtp/status'
+          statuscode = argvs.deliverystatus || ''
+          diagnostic = argvs.diagnosticcode || ''
+          reasontext = Sisimai::Reason::TooManyConn.text
+          tempreason = Sisimai::SMTP::Status.name(statuscode)
+          v = false
+
+          if tempreason == reasontext
+            # Delivery status code points "toomanyconn".
+            v = true
+          else
+            # Matched with a pattern in this class
+            v = true if Sisimai::Reason::TooManyConn.match(diagnostic)
+          end
+          return v
+        end
+
+      end
+    end
+  end
+end
+
+
+

data/lib/sisimai/reason/userunknown.rb

@@ -0,0 +1,194 @@
+module Sisimai
+  module Reason
+    # Sisimai::Reason::UserUnknown checks the bounce reason is "userunknown" or
+    # not. This class is called only Sisimai::Reason class.
+    #
+    # This is the error that a local part (Left hand side of @ sign) of a recipient's
+    # email address does not exist. In many case, a user has changed internet service
+    # provider, or has quit company, or the local part is misspelled. Sisimai will
+    # set "userunknown" to the reason of email bounce if the value of Status: field
+    # in a bounce email is "5.1.1", or connection was refused at SMTP RCPT command,
+    # or the contents of Diagnostic-Code: field represents that it is unknown user.
+    #
+    #   <kijitora@example.co.jp>: host mx01.example.co.jp[192.0.2.8] said:
+    #   550 5.1.1 Address rejected kijitora@example.co.jp (in reply to
+    #   RCPT TO command)
+    module UserUnknown
+      # Imported from p5-Sisimail/lib/Sisimai/Reason/UserUnknown.pm
+      class << self
+        def text; return 'userunknown'; end
+
+        # Try to match that the given text and regular expressions
+        # @param    [String] argv1  String to be matched with regular expressions
+        # @return   [True,False]    false: Did not match
+        #                           true: Matched
+        def match(argv1)
+          return nil unless argv1
+          regex = %r{(?>
+             .+[ ]user[ ]unknown
+            |[#]5[.]1[.]1[ ]bad[ ]address
+            |[<].+[>][ ]not[ ]found
+            |address[ ]does[ ]not[ ]exist
+            |address[ ]unknown
+            |archived[ ]recipient
+            |BAD[-_ ]RECIPIENT
+            |destination[ ]addresses[ ]were[ ]unknown
+            |destination[ ]server[ ]rejected[ ]recipients
+            |email[ ]address[ ]does[ ]not[ ]exist
+            |invalid[ ](?:
+               mailbox[ ]path
+              |recipient                 # Linkedin
+              )
+            |is[ ]not[ ](?:
+               a[ ]known[ ]user
+              |an[ ]active[ ]address[ ]at[ ]this[ ]host
+              )
+            |mailbox[ ](?:
+               not[ ]present
+              |not[ ]found
+              |unavailable
+              )
+            |no[ ](?:
+               account[ ]by[ ]that[ ]name[ ]here
+              |mail[ ]box[ ]available[ ]for[ ]this[ ]user
+              |mailbox[ ]found
+              |matches[ ]to[ ]nameserver[ ]query
+              |such[ ](?:
+                 mailbox
+                |person[ ]at[ ]this[ ]address
+                |recipient
+                |user(?:[ ]here)?
+                )
+              |[ ].+[ ]in[ ]name[ ]directory
+              |valid[ ]recipients[,][ ]bye    # Microsoft
+              )
+            |non[- ]?existent[ ]user
+            |not[ ](?:
+               a[ ]valid[ ]user[ ]here
+              |a[ ]local[ ]address
+              )
+            |rcpt[ ][<].+[>][ ]does[ ]not[ ]exist
+            |recipient[ ](?:
+               .+[ ]was[ ]not[ ]found[ ]in
+              |address[ ]rejected:[ ](?:
+                 access[ ]denied
+                |invalid[ ]user
+                |user[ ].+[ ]does[ ]not[ ]exist
+                |user[ ]unknown[ ]in[ ].+[ ]table
+                |unknown[ ]user
+                )
+              |does[ ]not[ ]exist(?:[ ]on[ ]this[ ]system)?
+              |is[ ]not[ ]local
+              |not[ ]found
+              |not[ ]OK
+              |unknown
+              )
+            |requested[ ]action[ ]not[ ]taken:[ ]mailbox[ ]unavailable
+            |RESOLVER[.]ADR[.]RecipNotFound # Microsoft
+            |said:[ ]550[-[ ]]5[.]1[.]1[ ].+[ ]user[ ]unknown[ ]
+            |sorry,[ ](?:
+               user[ ]unknown
+              |badrcptto
+              |no[ ]mailbox[ ]here[ ]by[ ]that[ ]name
+              )
+            |the[ ](?:
+               following[ ]recipients[ ]was[ ]undeliverable
+              |user[']s[ ]email[ ]name[ ]is[ ]not[ ]found
+              )
+            |this[ ](?:
+               address[ ]no[ ]longer[ ]accepts[ ]mail
+              |email[ ]address[ ]is[ ]wrong[ ]or[ ]no[ ]longer[ ]valid
+              |user[ ]doesn[']?t[ ]have[ ]a[ ].+[ ]account
+              )
+            |unknown[ ](?:
+               address
+              |e[-]?mail[ ]address
+              |local[- ]part
+              |mailbox
+              |recipient
+              |user
+              )
+            |user[ ](?:
+               .+[ ]was[ ]not[ ]found
+              |.+[ ]does[ ]not[ ]exist
+              |does[ ]not[ ]exist
+              |missing[ ]home[ ]directory
+              |not[ ]found     # 550 User not found. See http://mail.bigmir.net/err/2/
+              |not[ ]known
+              |unknown
+              )
+            |vdeliver:[ ]invalid[ ]or[ ]unknown[ ]virtual[ ]user
+            )
+          }ix
+
+          return true if argv1 =~ regex
+          return false
+        end
+
+        # Whether the address is "userunknown" or not
+        # @param    [Sisimai::Data] argvs   Object to be detected the reason
+        # @return   [True,False]            true: is unknown user
+        #                                   false: is not unknown user.
+        # @see http://www.ietf.org/rfc/rfc2822.txt
+        def true(argvs)
+          return nil unless argvs
+          return nil unless argvs.is_a? Sisimai::Data
+          return true if argvs.reason == Sisimai::Reason::UserUnknown.text
+
+          require 'sisimai/smtp/status'
+          prematches = ['NoRelaying', 'Blocked', 'MailboxFull', 'HasMoved']
+          matchother = false
+          statuscode = argvs.deliverystatus || ''
+          diagnostic = argvs.diagnosticcode || ''
+          reasontext = Sisimai::Reason::UserUnknown.text
+          tempreason = Sisimai::SMTP::Status.name(statuscode)
+          v = false
+
+          return false if tempreason == 'suspend'
+
+          if tempreason == reasontext
+            # *.1.1 = 'Bad destination mailbox address'
+            #   Status: 5.1.1
+            #   Diagnostic-Code: SMTP; 550 5.1.1 <***@example.jp>:
+            #     Recipient address rejected: User unknown in local recipient table
+            prematches.each do |e|
+              # Check the value of "Diagnostic-Code" with other error patterns.
+              p = 'Sisimai::Reason::' + e
+              r = nil
+              begin
+                require p.downcase.gsub('::', '/')
+                r = Module.const_get(p)
+              rescue
+                warn '***warning: Failed to load ' + p
+                next
+              end
+
+              if r.match(diagnostic)
+                # Match with reason defined in Sisimai::Reason::* except UserUnknown.
+                matchother = true
+                break
+              end
+            end
+
+            # Did not match with other message patterns
+            v = true unless matchother
+
+          else
+            # Check the last SMTP command of the session.
+            if argvs.smtpcommand == 'RCPT'
+              # When the SMTP command is not "RCPT", the session rejected by other
+              # reason, maybe.
+              v = true if Sisimai::Reason::UserUnknown.match(diagnostic)
+            end
+          end
+
+          return v
+        end
+
+      end
+    end
+  end
+end
+
+
+

data/lib/sisimai/rfc2606.rb

@@ -0,0 +1,24 @@
+module Sisimai
+  # Sisimai::RFC2606 checks that the domain part of the email address in the
+  # argument is reserved or not.
+  module RFC2606
+    # Imported from p5-Sisimail/lib/Sisimai/RFC2606.pm
+    class << self
+      # Whether domain part is Reserved or not
+      # @param    [String] dpart  Domain part
+      # @return   [True,False]    true:  is Reserved top level domain
+      #                           false: is NOT reserved top level domain
+      # @see      http://www.ietf.org/rfc/rfc2606.txt
+      def is_reserved(argv = '')
+        return false unless argv
+        return false unless argv.is_a?(::String)
+
+        return true  if argv =~ /[.](?:test|example|invalid|localhost)\z/
+        return true  if argv =~ /example[.](?:com|net|org)\z/
+        return true  if argv =~ /example[.]jp\z/
+        return true  if argv =~ /example[.](?:ac|ad|co|ed|go|gr|lg|ne|or)[.]jp\z/
+        return false
+      end
+    end
+  end
+end

data/lib/sisimai/rfc3464.rb

@@ -0,0 +1,497 @@
+module Sisimai
+  # Sisimai::RFC3464 - bounce mail parser class for Fallback.
+  module RFC3464
+    # Imported from p5-Sisimail/lib/Sisimai/RFC3464.pm
+    class << self
+      require 'sisimai/mta'
+      require 'sisimai/rfc5322'
+
+      # http://tools.ietf.org/html/rfc3464
+      Re0 = {
+        :'from'        => %r/\b(?:postmaster|mailer-daemon|root)[@]/i,
+        :'return-path' => %r/(?:[<][>]|mailer-daemon)/i,
+        :'subject'     => %r{(?>
+           delivery[ ](?:failed|failure|report)
+          |failure[ ]notice
+          |mail[ ](?:delivery|error)
+          |non[-]delivery
+          |returned[ ]mail
+          |undeliverable[ ]mail
+          |Warning:[ ]
+          )
+        }xi,
+      }
+      Re1 = {
+        :begin   => %r{\A(?>
+           Content-Type:[ ]*(?:
+             message/delivery-status
+            |message/disposition-notification
+            |text/plain;[ ]charset=
+            )
+          |The[ ]original[ ]message[ ]was[ ]received[ ]at[ ]
+          |This[ ]report[ ]relates[ ]to[ ]your[ ]message
+          |Your[ ]message[ ]was[ ]not[ ]delivered[ ]to[ ]the[ ]following[ ]recipients
+          )
+        }xi,
+        :endof   => %r/\A__END_OF_EMAIL_MESSAGE__\z/,
+        :rfc822  => %r{\A(?>
+           Content-Type:[ ]*(?:message/rfc822|text/rfc822-headers)
+          |Return-Path:[ ]*[<].+[>]\z
+          )\z
+        }xi,
+        :error   => %r/\A(?:[45]\d\d[ \t]+|[<][^@]+[@][^@]+[>]:?[ \t]+)/i,
+        :command => %r/[ ](RCPT|MAIL|DATA)[ ]+command\b/,
+      }
+
+      Indicators = Sisimai::MTA.INDICATORS
+      LongFields = Sisimai::RFC5322.LONGFIELDS
+      RFC822Head = Sisimai::RFC5322.HEADERFIELDS
+
+      def description; 'Fallback Module for MTAs'; end
+      def smtpagent;   'RFC3464'; end
+      def pattern;     return Re0; end
+      def headerlist;  return []; end
+
+      # Detect an error for RFC3464
+      # @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
+      def scan(mhead, mbody)
+        return nil unless mhead
+        return nil unless mbody
+        return nil if mhead.keys.size == 0
+        return nil if mbody.empty?
+
+        require 'sisimai/mda'
+        require 'sisimai/address'
+
+        dscontents = []; dscontents << Sisimai::MTA.DELIVERYSTATUS
+        hasdivided = mbody.split("\n")
+        havepassed = ['']
+        scannedset = Sisimai::MDA.scan(mhead, mbody)
+        rfc822next = { 'from' => false, 'to' => false, 'subject' => false }
+        rfc822part = ''   # (String) message/rfc822-headers part
+        previousfn = ''   # (String) Previous field name
+        readcursor = 0    # (Integer) Points the current cursor position
+        recipients = 0    # (Integer) The number of 'Final-Recipient' header
+        connheader = {
+          'date'  => nil, # The value of Arrival-Date header
+          'rhost' => nil, # The value of Reporting-MTA header
+          'lhost' => nil, # The value of Received-From-MTA header
+        }
+        v = nil
+
+        hasdivided.each do |e|
+          # Save the current line for the next loop
+          havepassed << e; p = havepassed[-2]
+
+          if readcursor == 0
+            # Beginning of the bounce message or delivery status part
+            if e =~ Re1[:begin]
+              readcursor |= Indicators[:'deliverystatus']
+              next
+            end
+          end
+
+          if readcursor & Indicators[:'message-rfc822'] > 0
+            # Beginning of the original message part
+            if e =~ Re1[:rfc822]
+              readcursor |= Indicators[:'message-rfc822']
+              next
+            end
+          end
+
+          if readcursor & Indicators[:'message-rfc822'] > 0
+            # After "message/rfc822"
+            if cv = e.match(/\A([-0-9A-Za-z]+?)[:][ ]*.+\z/)
+              # Get required headers only
+              lhs = cv[1].downcase
+              previousfn = ''
+              next unless RFC822Head.key?(lhs)
+
+              previousfn  = lhs
+              rfc822part += e + "\n"
+
+            elsif e =~ /\A[ \t]+/
+              # Continued line from the previous line
+              next if rfc822next[previousfn]
+              rfc822part += e + "\n" if LongFields.key?(previousfn)
+
+            else
+              # Check the end of headers in rfc822 part
+              next unless LongFields.key?(previousfn)
+              next if e.size > 0
+              rfc822next[previousfn] = true
+            end
+
+          else
+            # Before "message/rfc822"
+            next unless readcursor & Indicators[:'deliverystatus'] > 0
+            next unless e.size > 0
+
+            v = dscontents[-1]
+            if cv = e.match(/\A(?:[Ff]inal|[Oo]riginal)-[Rr]ecipient:[ ]*(?:RFC|rfc)822;[ ]*([^ ]+)\z/) ||
+               cv = e.match(/\A(?:[Ff]inal|[Oo]riginal)-[Rr]ecipient:[ ]*([^ ]+)\z/)
+              # 2.3.2 Final-Recipient field
+              #   The Final-Recipient field indicates the recipient for which this set
+              #   of per-recipient fields applies.  This field MUST be present in each
+              #   set of per-recipient data.
+              #   The syntax of the field is as follows:
+              #
+              #       final-recipient-field =
+              #           "Final-Recipient" ":" address-type ";" generic-address
+              #
+              # 2.3.1 Original-Recipient field
+              #   The Original-Recipient field indicates the original recipient address
+              #   as specified by the sender of the message for which the DSN is being
+              #   issued.
+              #
+              #       original-recipient-field =
+              #           "Original-Recipient" ":" address-type ";" generic-address
+              #
+              #       generic-address = *text
+              x = v['recipienet'] || ''
+              y = Sisimai::Address.s3s4(cv[1])
+
+              if x.size > 0 && x != y
+                # There are multiple recipient addresses in the message body.
+                dscontents << Sisimai::MTA.DELIVERYSTATUS
+                v = dscontents[-1]
+              end
+              v['recipient'] = y
+              recipients += 1
+
+            elsif cv = e.match(/\A[Xx]-[Aa]ctual-[Rr]ecipient:[ ]*(?:RFC|rfc)822;[ ]*([^ ]+)\z/)
+              # X-Actual-Recipient:
+              if cv[1] =~ /[ \t]+/
+                # X-Actual-Recipient: RFC822; |IFS=' ' && exec procmail -f- || exit 75 ...
+
+              else
+                # X-Actual-Recipient: rfc822; kijitora@neko.example.jp
+                v['alias'] = cv[1]
+              end
+
+            elsif cv = e.match(/\A[Aa]ction:[ ]*(.+)\z/)
+              # 2.3.3 Action field
+              #   The Action field indicates the action performed by the Reporting-MTA
+              #   as a result of its attempt to deliver the message to this recipient
+              #   address.  This field MUST be present for each recipient named in the
+              #   DSN.
+              #   The syntax for the action-field is:
+              #
+              #       action-field = "Action" ":" action-value
+              #       action-value =
+              #           "failed" / "delayed" / "delivered" / "relayed" / "expanded"
+              #
+              #   The action-value may be spelled in any combination of upper and lower
+              #   case characters.
+              v['action'] = cv[1].downcase
+
+              if cv = v['action'].match(/\A([^ ]+)[ ]/)
+                # failed (bad destination mailbox address)
+                v['action'] = cv[1]
+              end
+
+            elsif cv = e.match(/\A[Ss]tatus:[ ]*(\d[.]\d+[.]\d+)/)
+              # 2.3.4 Status field
+              #   The per-recipient Status field contains a transport-independent
+              #   status code that indicates the delivery status of the message to that
+              #   recipient.  This field MUST be present for each delivery attempt
+              #   which is described by a DSN.
+              #
+              #   The syntax of the status field is:
+              #
+              #       status-field = "Status" ":" status-code
+              #       status-code = DIGIT "." 1*3DIGIT "." 1*3DIGIT
+              v['status'] = cv[1]
+
+            elsif cv = e.match(/\A[Ss]tatus:[ ]*(\d+[ ]+.+)\z/)
+              # Status: 553 Exceeded maximum inbound message size
+              v['alterrors'] = cv[1]
+
+            elsif cv = e.match(/\A[Rr]emote-MTA:[ ]*(?:DNS|dns);[ ]*(.+)\z/)
+              # 2.3.5 Remote-MTA field
+              #   The value associated with the Remote-MTA DSN field is a printable
+              #   ASCII representation of the name of the "remote" MTA that reported
+              #   delivery status to the "reporting" MTA.
+              #
+              #       remote-mta-field = "Remote-MTA" ":" mta-name-type ";" mta-name
+              #
+              #   NOTE: The Remote-MTA field preserves the "while talking to"
+              #   information that was provided in some pre-existing nondelivery
+              #   reports.
+              #
+              #   This field is optional.  It MUST NOT be included if no remote MTA was
+              #   involved in the attempted delivery of the message to that recipient.
+              v['rhost'] = cv[1].downcase
+
+            elsif cv = e.match(/\A[Ll]ast-[Aa]ttempt-[Dd]ate:[ ]*(.+)\z/)
+              # 2.3.7 Last-Attempt-Date field
+              #   The Last-Attempt-Date field gives the date and time of the last
+              #   attempt to relay, gateway, or deliver the message (whether successful
+              #   or unsuccessful) by the Reporting MTA.  This is not necessarily the
+              #   same as the value of the Date field from the header of the message
+              #   used to transmit this delivery status notification: In cases where
+              #   the DSN was generated by a gateway, the Date field in the message
+              #   header contains the time the DSN was sent by the gateway and the DSN
+              #   Last-Attempt-Date field contains the time the last delivery attempt
+              #   occurred.
+              #
+              #       last-attempt-date-field = "Last-Attempt-Date" ":" date-time
+              v['date'] = cv[1]
+
+            else
+              if cv = e.match(/\A[Dd]iagnostic-[Cc]ode:[ ]*(.+?);[ ]*(.+)\z/)
+                # 2.3.6 Diagnostic-Code field
+                #   For a "failed" or "delayed" recipient, the Diagnostic-Code DSN field
+                #   contains the actual diagnostic code issued by the mail transport.
+                #   Since such codes vary from one mail transport to another, the
+                #   diagnostic-type sub-field is needed to specify which type of
+                #   diagnostic code is represented.
+                #
+                #       diagnostic-code-field =
+                #           "Diagnostic-Code" ":" diagnostic-type ";" *text
+                v['spec'] = cv[1].upcase
+                v['diagnosis'] = cv[2]
+
+              elsif cv = e.match(/\A[Dd]iagnostic-[Cc]ode:[ ]*(.+)\z/)
+                # No value of "diagnostic-type"
+                # Diagnostic-Code: 554 ...
+                v['diagnosis'] = cv[1]
+
+              elsif p =~ /\A[Dd]iagnostic-[Cc]ode:[ ]*/ && cv = e.match(/\A[ \t]+(.+)\z/)
+                # Continued line of the value of Diagnostic-Code header
+                v['diagnosis'] += ' ' + cv[1]
+                e = 'Diagnostic-Code: ' + e
+
+              else
+                if cv = e.match(/\A[Rr]eporting-MTA:[ ]*(?:DNS|dns);[ ]*(.+)\z/)
+                  # 2.2.2 The Reporting-MTA DSN field
+                  #
+                  #       reporting-mta-field =
+                  #           "Reporting-MTA" ":" mta-name-type ";" mta-name
+                  #       mta-name = *text
+                  #
+                  #   The Reporting-MTA field is defined as follows:
+                  #
+                  #   A DSN describes the results of attempts to deliver, relay, or gateway
+                  #   a message to one or more recipients.  In all cases, the Reporting-MTA
+                  #   is the MTA that attempted to perform the delivery, relay, or gateway
+                  #   operation described in the DSN.  This field is required.
+                  connheader['rhost'] ||= cv[1].downcase
+
+                elsif cv = e.match(/\A[Rr]eceived-[Ff]rom-MTA:[ ]*(?:DNS|dns);[ ]*(.+)\z/)
+                  # 2.2.4 The Received-From-MTA DSN field
+                  #   The optional Received-From-MTA field indicates the name of the MTA
+                  #   from which the message was received.
+                  #
+                  #       received-from-mta-field =
+                  #           "Received-From-MTA" ":" mta-name-type ";" mta-name
+                  #
+                  #   If the message was received from an Internet host via SMTP, the
+                  #   contents of the mta-name sub-field SHOULD be the Internet domain name
+                  #   supplied in the HELO or EHLO command, and the network address used by
+                  #   the SMTP client SHOULD be included as a comment enclosed in
+                  #   parentheses.  (In this case, the MTA-name-type will be "dns".)
+                  connheader['lhost'] = cv[1].downcase
+
+                elsif cv = e.match(/\A[Aa]rrival-[Dd]ate:[ ]*(.+)\z/)
+                  # 2.2.5 The Arrival-Date DSN field
+                  #   The optional Arrival-Date field indicates the date and time at which
+                  #   the message arrived at the Reporting MTA.  If the Last-Attempt-Date
+                  #   field is also provided in a per-recipient field, this can be used to
+                  #   determine the interval between when the message arrived at the
+                  #   Reporting MTA and when the report was issued for that recipient.
+                  #
+                  #       arrival-date-field = "Arrival-Date" ":" date-time
+                  connheader['date'] = cv[1]
+
+                else
+                  # Get error message
+                  next if e =~ /\A[ -]+/
+                  next unless e =~ Re1[:error]
+
+                  # 500 User Unknown
+                  # <kijitora@example.jp> Unknown
+                  v['alterrors'] ||= ' '
+                  v['alterrors']  += ' ' + e
+                end
+              end
+            end
+          end # End of if: rfc822
+
+        end
+
+        loop do
+          # Fallback, parse entire message body
+          break if recipients > 0
+          match = 0
+
+          # Failed to get a recipient address at code above
+          match += 1 if mhead['from']    =~ Re0[:'from']
+          match += 1 if mhead['subject'] =~ Re0[:'subject']
+
+          if mhead['return-path']
+            # Check the value of Return-Path of the message
+            match += 1 if mhead['return-path'] =~ Re0[:'return-path']
+          end
+          break unless match > 0
+
+          re_skip = %r{(?>
+             \A[-]+=
+            |\A\s+\z
+            |\A\s*--
+            |\A\s+[=]\d+
+            |\AHi[ ][!]
+            |Content-(?:Description|Disposition|Transfer-Encoding|Type):[ ]
+            |(?:name|charset)=
+            |--\z
+            |:[ ]--------
+            )
+          }xi
+          re_stop = %r{(?:
+             \AContent-Type:[ ]message/delivery-status
+            |\AHere[ ]is[ ]a[ ]copy[ ]of[ ]the[ ]first[ ]part[ ]of[ ]the[ ]message
+            |\AThe[ ]non-delivered[ ]message[ ]is[ ]attached[ ]to[ ]this[ ]message.
+            |\AReceived:[ \t]*
+            |\AReceived-From-MTA:[ \t]*
+            |\AReporting-MTA:[ \t]*
+            |\AReturn-Path:[ \t]*
+            |\AA[ ]copy[ ]of[ ]the[ ]original[ ]message[ ]below[ ]this[ ]line:
+            |Attachment[ ]is[ ]a[ ]copy[ ]of[ ]the[ ]message
+            |Below[ ]is[ ]a[ ]copy[ ]of[ ]the[ ]original[ ]message:
+            |Below[ ]this[ ]line[ ]is[ ]a[ ]copy[ ]of[ ]the[ ]message
+            |Message[ ]contains[ ].+[ ]file[ ]attachments
+            |Message[ ]text[ ]follows:[ ]
+            |Original[ ]message[ ]follows
+            |The[ ]attachment[ ]contains[ ]the[ ]original[ ]mail[ ]headers
+            |The[ ]first[ ]\d+[ ]lines[ ]
+            |Unsent[ ]Message[ ]below
+            |Your[ ]message[ ]reads[ ][(]in[ ]part[)]:
+            )
+          }xi
+          re_addr = %r{(?:
+             \A\s*
+            |\A["].+["]\s*
+            |\A[ \t]*Recipient:[ \t]*
+            |\A[ ]*Address:[ ]
+            |addressed[ ]to[ ]
+            |Could[ ]not[ ]be[ ]delivered[ ]to:[ ]
+            |delivered[ ]to[ ]+
+            |delivery[ ]failed:[ ]
+            |Did[ ]not[ ]reach[ ]the[ ]following[ ]recipient:[ ]
+            |Error-for:[ ]+
+            |Failed[ ]Recipient:[ ]
+            |Failed[ ]to[ ]deliver[ ]to[ ]
+            |generated[ ]from[ ]
+            |Intended[ ]recipient:[ ]
+            |Mailbox[ ]is[ ]full:[ ]
+            |RCPT[ ]To:
+            |SMTP[ ]Server[ ][<].+[>][ ]rejected[ ]recipient[ ]
+            |The[ ]following[ ]recipients[ ]returned[ ]permanent[ ]errors:[ ]
+            |The[ ]following[ ]message[ ]to[ ]
+            |Unknown[ ]User:[ ]
+            |undeliverable[ ]to[ ]
+            |Undeliverable[ ]Address:[ ]*
+            |You[ ]sent[ ]mail[ ]to[ ]
+            |Your[ ]message[ ]to[ ]
+            )
+            ['"]?[<]?([^\s\n\r@=]+[@][-.0-9A-Za-z]+[.][0-9A-Za-z]+)[>]?['"]?
+          }xi
+
+          b = dscontents[-1]
+          mbody.split("\n").each do |e|
+            # Get the recipient's email address and error messages.
+            break if e =~ Re1[:endof]
+            break if e =~ Re1[:rfc822]
+            break if e =~ re_stop
+
+            next if e.size == 0
+            next if e =~ re_skip
+            next if e =~ /\A[*]/
+
+            if cv = e.match(re_addr)
+              # May be an email address
+              x = b['recipient'] || ''
+              y = Sisimai::Address.s3s4(cv[1])
+
+              if x.size > 0 && x != y
+                # There are multiple recipient addresses in the message body.
+                dscontents << Sisimai::MTA.DELIVERYSTATUS
+                b = dscontents[-1]
+              end
+              b['recipient'] = y
+              b['agent'] = self.smtpagent + '::Fallback'
+              recipients += 1
+
+            elsif cv = e.match(/[(]expanded[ ]from:[ ]([^@]+[@][^@]+)[)]/)
+              # (expanded from: neko@example.jp)
+              b['alias'] = Sisimai::Address.s3s4(cv[1])
+            end
+            b['diagnosis'] ||= ''
+            b['diagnosis']  += ' ' + e
+          end
+
+          break
+        end
+
+        return nil unless recipients > 0
+        require 'sisimai/string'
+        require 'sisimai/smtp/status'
+
+        dscontents.map do |e|
+          # Set default values if each value is empty.
+          connheader.each_key { |a| e[a] ||= connheader[a] || '' }
+
+          if e.key?('alterrors') && e['alterrors'].size > 0
+            # Copy alternative error message
+            e['diagnosis'] ||= e['alterrors']
+            if e['diagnosis'] =~ /\A[-]+/ || e['diagnosis'] =~ /__\z/
+              # Override the value of diagnostic code message
+              e['diagnosis'] = e['alterrors'] if e['alterrors'].size > 0
+            end
+            e.delete('alterrors')
+          end
+          e['diagnosis'] = Sisimai::String.sweep(e['diagnosis']) || ''
+
+          if scannedset
+            # Make bounce data by the values returned from Sisimai::MDA->scan()
+            e['agent']     = scannedset['mda'] || self.smtpagent
+            e['reason']    = scannedset['reason'] || 'undefined'
+            e['diagnosis'] = scannedset['message'] if scannedset['message'].size > 0
+            e['command']   = ''
+
+          else
+            # Set the value of smtpagent
+            e['agent'] = self.smtpagent
+          end
+
+          e['status'] ||= Sisimai::SMTP::Status.find(e['diagnosis'])
+          if cv = e['diagnosis'].match(Re1[:command])
+            e['command'] = cv[1]
+          end
+
+          if mhead['received'].size > 0
+            # Get localhost and remote host name from Received header.
+            r0 = mhead['received']
+            ['lhost', 'rhost'].each { |a| e[a] ||= '' }
+            e['lhost'] = Sisimai::RFC5322.received(r0[0]).shift if e['lhost'].empty?
+            e['rhost'] = Sisimai::RFC5322.received(r0[-1]).pop  if e['rhost'].empty?
+          end
+
+          e['date'] ||= mhead['date']
+          e['spec'] ||= 'SMTP'
+          e.each_key { |a| e[a] ||= '' }
+        end
+        return { 'ds' => dscontents, 'rfc822' => rfc822part }
+      end
+
+    end
+  end
+end