eml-parser 4.1.0__tar.gz → 4.2.0__tar.gz

{eml_parser-4.1.0 → eml_parser-4.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: eml_parser
-Version: 4.1.0
+Version: 4.2.0
 Summary: Python EML parser library
 Project-URL: Homepage, https://github.com/GOVCERT-LU/eml_parser
 Project-URL: Documentation, https://eml-parser.readthedocs.io/

{eml_parser-4.1.0 → eml_parser-4.2.0}/eml_parser/decode.py

@@ -278,7 +278,7 @@ def robust_string2date(line: str) -> datetime.datetime:
             # Now we are facing an invalid date.
             return datetime.datetime.fromisoformat(default_date)
 
-    if date_.tzname() is None:
+    if date_.utcoffset() is None:
         return date_.replace(tzinfo=datetime.UTC)
 
     return date_

{eml_parser-4.1.0 → eml_parser-4.2.0}/eml_parser/regexes.py

@@ -162,9 +162,6 @@ url_drop_chars_table = str.maketrans('', '', '\t\n\r')
 # A (quoted) value starting with a scheme followed by slashes or backslashes, i.e. http:\\\\host\\path
 url_backslash_scheme_regex = re.compile(r"""[\"\']?[a-z][a-z0-9+.\-]*:[\\/]{2}""", re.IGNORECASE)
 
-date_regex = re.compile(r""";[ \w\s:,+\-()]+$""")
-cleanline_regex = re.compile(r"""(^[;\s]{0,}|[;\s]{0,}$)""")
-
 escape_special_regex_chars = re.compile(r"""([\^$\[\]()+?.])""")
 
 window_slice_regex = re.compile(r"""\s""")

eml_parser-4.2.0/eml_parser/routing.py

@@ -0,0 +1,216 @@
+"""This module is used for parsing the received lines into a machine readable structure."""
+
+import datetime as dt
+import typing
+
+import regex
+
+import eml_parser.decode
+import eml_parser.regexes
+
+# What cleanline() removes: the semicolon and everything the regular expression class \s matches (all Unicode white space).
+_CLEANLINE_CHARS = ';' + ''.join(char for char in map(chr, range(0x3001)) if char.isspace())
+
+_DELIMITERS = str.maketrans('()[],;<>"', '         ')
+
+# The domain of an address in angle brackets (the sender in "(envelope-from <a@b>)", a message id) is no relay.
+_ANGLE_ADDRESS = regex.compile(r"""<[^<>\s]*@[^<>\s]*>""")
+
+# What a date can consist of: words, numbers, and the separators of its time and zone. Anything else is not a date, e.g. "-04= 00".
+_DATE = regex.compile(r"""[\w\s:,+.\-]+""")
+
+# A host name in a received line: labels of letters, digits, hyphens and underscores (Exchange and Lotus servers use them: `mail_gw1.example.com`),
+# any label may be a single character (`mail10.m.example.net`). The last label (TLD) consists of letters only, or is punycode (`xn--p1ai`): ids
+# (`1.b9.b1afe75`), versions (`v82.22`, `8.12.0.beta16`) and the like are no hosts. A name followed by `/<digit>` is a mailer version
+# (`8.12.0.beta16/8.12.0`). The labels are matched possessively (a label only if another one follows, labels do not start with a hyphen): the last label can only be the TLD, and
+# backtracking would make the scan quadratic on long runs of `a.a.a.`. An optional `*.` is dropped, the domain of user@host is a host, user.name@host is not.
+_HOST = regex.compile(r"""(?<![\w.\-/])(?:\*\.)?((?:\w[\w\-]*\.(?=\w))++(?:[^\W\d_]{2,}|xn--[\w\-]+))(?![\w\-@]|\.\w|/\d)""")
+
+# The tokens which matter for the structure of a received line. Parentheses delimit comments, which are skipped when looking for the keywords.
+# A keyword is a whole word, i.e. it is not part of a host name or an address (toby, before, nearby, ...).
+_STRUCTURE = regex.compile(r"""[()]|;|(?<![^\s);\[])(?:from|by|with|for)(?=[\s(]|$)|(?<=\s)received:(?=\s)""")
+
+
+def cleanline(line: str) -> str:
+    """Remove space and ; from start/end of line.
+
+    Args:
+        line (str): Line to clean.
+
+    Returns:
+        str: Cleaned string.
+    """
+    return line.strip(_CLEANLINE_CHARS)
+
+
+def get_domain_ip(line: str) -> list[str]:
+    """Method returns all domains, IPv4 and IPv6 addresses found in a given string.
+
+    Args:
+        line (str): String to search in.
+
+    Returns:
+        list: Unique list of strings with matches, in order of first appearance (domains, then IPv4, then IPv6 addresses).
+    """
+    found: list[str] = []
+
+    # Brackets and parentheses delimit a host as well as white space does: "by notes.example.com(Lotus SMTP MTA)", "by [mail.example.com]"
+    line = line.translate(_DELIMITERS)
+
+    if '.' in line:
+        found += _HOST.findall(line)
+        found += eml_parser.regexes.ipv4_regex.findall(line)
+
+    if ':' in line:
+        found += eml_parser.regexes.ipv6_regex.findall(line)
+
+    return list(dict.fromkeys(found))
+
+
+def _remove_comments(line: str, comments: list[tuple[int, int]], start: int) -> str:
+    """Cut the comments out of the end of a line and normalise the white space.
+
+    Args:
+        line: The line.
+        comments: Start and end of the comments in the line (nested ones too, as an enclosing parenthesis might never be closed).
+        start: Position in the line to start at.
+
+    Returns:
+        str: The text from start to the end of the line, without comments.
+    """
+    parts = []
+    for comment_start, comment_end in sorted(comments):
+        if comment_end > start:
+            parts.append(line[start : max(start, comment_start)])
+            start = max(start, comment_end)
+
+    parts.append(line[start:])
+
+    return ' '.join(' '.join(parts).split())
+
+
+def _parse_date(line: str, comments: list[tuple[int, int]], separators: list[int]) -> dt.datetime | None:
+    """Parse the date behind the last semicolon of a received line.
+
+    Args:
+        line: The line.
+        comments: Start and end of the comments in the line.
+        separators: Positions of the semicolons outside of comments.
+
+    Returns:
+        The date, or None if there is none. An unparsable date is not reported (robust_string2date() would make up a default date), nor is
+        one which is not made of date characters, as dateutil ignores whatever it does not know and returns a wrong time.
+    """
+    if not separators:
+        return None
+
+    # A line wrapped in brackets ends with one
+    date = _remove_comments(line, comments, separators[-1] + 1).removesuffix(']').rstrip()
+    if not _DATE.fullmatch(date) or not any(char.isdigit() for char in date):
+        return None
+
+    parsed_date = eml_parser.decode.robust_string2date(date)
+    return None if parsed_date.isoformat() == eml_parser.decode.default_date else parsed_date
+
+
+def parserouting(line: str, email_regex: regex.Pattern[str] = eml_parser.regexes.email_no_force_tld_regex) -> dict[str, typing.Any]:
+    """This method tries to parse an e-mail header received line and extract machine-readable information.
+
+    Note that there are a large number of formats for these lines
+    and a lot of weird ones which are not commonly used.
+    We try our best to match a large number of formats.
+
+    The line is split in one pass. The first *from*, *by*, *with* and *for* outside of comments (parentheses) start a section, which ends where
+    the next one starts. The last section ends at the semicolon in front of the date. The text of a section, comments included, is the value
+    of *with*, and is searched for hosts and addresses for *from*, *by* and *for*.
+
+    Args:
+        line (str): Received line to be parsed.
+        email_regex (regex.Pattern[str], optional): Pattern used to extract e-mail addresses from the 'for' field.
+
+    Returns:
+        dict: Returns a dict with the extracted information.
+    """
+    out: dict[str, typing.Any] = {'src': line}
+    line = line.lower()
+
+    # Collect the structural tokens outside of comments. A closing parenthesis removes everything since its opening one; an unbalanced
+    # opening parenthesis does not start a comment.
+    open_comments: list[tuple[int, int]] = []
+    comments: list[tuple[int, int]] = []
+    tokens: list[tuple[str, int, int]] = []
+    for match in _STRUCTURE.finditer(line):
+        kind = match.group()
+
+        if kind == '(':
+            open_comments.append((len(tokens), match.start()))
+        elif kind == ')':
+            if open_comments:
+                mark, start = open_comments.pop()
+                del tokens[mark:]
+                comments.append((start, match.end()))
+        else:
+            tokens.append((kind, match.start(), match.end()))
+
+    # The first occurrence of each keyword starts a section, later ones are part of the text. The last semicolon is the one in front of the date.
+    sections: dict[str, tuple[int, int]] = {}
+    separators: list[int] = []
+    for kind, start, end in tokens:
+        if kind == ';':
+            separators.append(start)
+        elif kind == 'received:':
+            # Detect "sticked lines"
+            out['warning'] = ['Merged Received headers']
+            return out
+        elif kind not in sections:
+            sections[kind] = (start, end)
+
+    if not sections:
+        # Lines such as "(qmail 4711 invoked by uid 500); 28 Sep 2002 16:21:17 -0000" have a date but no relay.
+        out['warning'] = ['Nothing Parsable']
+        date = _parse_date(line, comments, separators)
+        if date is not None:
+            out['date'] = date
+        return out
+
+    ordered = sorted((start, end, keyword) for keyword, (start, end) in sections.items())
+    for position, (_, end, keyword) in enumerate(ordered):
+        if position + 1 < len(ordered):
+            stop = ordered[position + 1][0]
+        else:
+            # The last section ends at the first semicolon after it.
+            stop = next((start for start in separators if start > end), len(line))
+
+        value = cleanline(line[end:stop])
+        if value:
+            out[keyword] = value
+
+    date = _parse_date(line, comments, separators)
+    if date is not None:
+        out['date'] = date
+
+    # Fixup for "From" in "for" field
+    # ie google, do that...
+    if out.get('for'):
+        # include spaces in test, otherwise there will be an exception with domains containing "from" in itself
+        if ' from ' in out['for']:
+            before, _, after = out['for'].partition(' from ')
+            out['for'] = before
+            out['from'] = f'{out.get("from", "")} {after}'
+
+        found = email_regex.findall(out['for'])
+        if found:
+            out['for'] = list(dict.fromkeys(found))
+        else:
+            del out['for']
+
+    # Now.. find IP and Host in from and by. The domain of an address in angle brackets, e.g. the one of the sender in
+    # "(envelope-from <a@sender.example>)" or of a message id, is no relay.
+    for keyword in ('from', 'by'):
+        if out.get(keyword):
+            text = _ANGLE_ADDRESS.sub(' ', out[keyword]) if '<' in out[keyword] else out[keyword]
+            out[keyword] = get_domain_ip(text)
+            if not out[keyword]:  # if array is empty remove
+                del out[keyword]
+
+    return out

eml_parser-4.2.0/tests/test_date_offset.py

@@ -0,0 +1,23 @@
+import datetime
+
+import pytest
+
+import eml_parser.decode
+
+
+@pytest.mark.parametrize(
+    ('line', 'expected'),
+    [
+        # Fractional seconds are not understood by the email module, dateutil parses these and returns an offset without a name.
+        ('Mon, 5 Oct 2026 09:12:44.123 +0200', '2026-10-05T09:12:44.123000+02:00'),
+        ('Mon, 5 Oct 2026 09:12:44.123 -0500', '2026-10-05T09:12:44.123000-05:00'),
+        ('Mon, 5 Oct 2026 09:12:44.123 +0000', '2026-10-05T09:12:44.123000+00:00'),
+        ('Fri, 29 Jan 2021 07:24:22.501 +0530', '2021-01-29T07:24:22.501000+05:30'),
+    ],
+)
+def test_offset_of_dateutil_dates_is_kept(line: str, expected: str) -> None:
+    assert eml_parser.decode.robust_string2date(line).isoformat() == expected
+
+
+def test_date_without_offset_is_utc() -> None:
+    assert eml_parser.decode.robust_string2date('Mon, 5 Oct 2026 09:12:44.123').utcoffset() == datetime.timedelta(0)

{eml_parser-4.1.0 → eml_parser-4.2.0}/tests/test_routing.py

@@ -45,6 +45,7 @@ class TestRouting:
                 # Tests a received entry which has *from* as part of a field.
                 """Received: by f321.i.example.com with local (envelope-from <b8u3hkqlkj@example.com>) id 1khYpb-0001XE-KE for someone@here-from-there.com; Tue, 24 Nov 2020 16:58:07 +0300""",
                 {
+                    'by': ['f321.i.example.com'],
                     'for': ['someone@here-from-there.com'],
                     'src': 'Received: by f321.i.example.com with local (envelope-from <b8u3hkqlkj@example.com>) id 1khYpb-0001XE-KE for someone@here-from-there.com; Tue, 24 Nov 2020 16:58:07 +0300',
                     'with': 'local (envelope-from <b8u3hkqlkj@example.com>) id 1khypb-0001xe-ke',
@@ -55,7 +56,9 @@ class TestRouting:
                 # C.f. github issue #54; unsupported line; point of this test is to make sure we properly catch related exceptions
                 r"""Received: from)by ismtpd0112p1sjc2.abc.net (SG) with ESMTP id\n B4glDdmiQcqJYrMuLIqjUQfor <p-j.a@sdf.com>; Fri, 29 Jan 2021\n 07:24:22.501 +0000 (UTC)""",
                 {
-                    'src': r'Received: from)by ismtpd0112p1sjc2.abc.net (SG) with ESMTP id\n B4glDdmiQcqJYrMuLIqjUQfor <p-j.a@sdf.com>; Fri, 29 Jan 2021\n 07:24:22.501 +0000 (UTC)'
+                    'src': r'Received: from)by ismtpd0112p1sjc2.abc.net (SG) with ESMTP id\n B4glDdmiQcqJYrMuLIqjUQfor <p-j.a@sdf.com>; Fri, 29 Jan 2021\n 07:24:22.501 +0000 (UTC)',
+                    'by': ['ismtpd0112p1sjc2.abc.net'],
+                    'with': r'esmtp id\n b4glddmiqcqjyrmuliqjuqfor <p-j.a@sdf.com>',
                 },
             ),
         }

eml_parser-4.2.0/tests/test_routing_structure.py

@@ -0,0 +1,219 @@
+import pytest
+
+import eml_parser.routing
+
+TAIL = '; Mon, 5 Oct 2026 09:12:44 +0200'
+
+
+def parse(line: str) -> dict:
+    return eml_parser.routing.parserouting(line)
+
+
+@pytest.mark.parametrize(
+    ('line', 'expected_from', 'expected_by'),
+    [
+        # a host name ending in a keyword must not start a section
+        ('from toby (toby.example.com [192.0.2.1]) by mx.example.org with ESMTP' + TAIL, ['toby.example.com', '192.0.2.1'], ['mx.example.org']),
+        ('from before.example.org (x [192.0.2.7]) by mx.example.org' + TAIL, ['before.example.org', '192.0.2.7'], ['mx.example.org']),
+        ('from ruby.example.org ([192.0.2.8]) by nearby.example.org with ESMTP' + TAIL, ['ruby.example.org', '192.0.2.8'], ['nearby.example.org']),
+        # keywords in comments are not keywords
+        ('from a.example.com (a.example.com [192.0.2.1]) (using TLS by default) by b.example.com' + TAIL, ['a.example.com', '192.0.2.1'], ['b.example.com']),
+        ('from a.example.com ([192.0.2.1]) by b.example.com (Postfix, from userid 1000) with ESMTP' + TAIL, ['a.example.com', '192.0.2.1'], ['b.example.com']),
+        # an unbalanced opening parenthesis does not swallow the rest
+        ('from a.example.com (a.example.com [192.0.2.1] by b.example.com with ESMTP' + TAIL, ['a.example.com', '192.0.2.1'], ['b.example.com']),
+        # upper case
+        ('FROM A.EXAMPLE.COM (A.EXAMPLE.COM [192.0.2.1]) BY B.EXAMPLE.COM WITH ESMTP' + TAIL, ['a.example.com', '192.0.2.1'], ['b.example.com']),
+    ],
+)
+def test_sections(line: str, expected_from: list[str], expected_by: list[str]) -> None:
+    result = parse(line)
+
+    assert result['from'] == expected_from
+    assert result['by'] == expected_by
+
+
+def test_hosts_are_in_order_of_appearance() -> None:
+    result = parse('from mail.example.com (mail.example.com [192.0.2.1] [2001:db8::1]) by mx.example.org' + TAIL)
+
+    assert result['from'] == ['mail.example.com', '192.0.2.1', '2001:db8::1']
+
+
+@pytest.mark.parametrize(
+    ('line', 'expected_by'),
+    [
+        # version numbers are no host names
+        ('from a.example.com by mx.example.org (Exim 4.96) id 1' + TAIL, ['mx.example.org']),
+        ('from a.example.com by mx.example.org (8.12.2/8.12.2/20020902/$Revision: 1.30 $) with SMTP' + TAIL, ['mx.example.org']),
+        # the domain of an address in angle brackets is no relay
+        ('from a.example.com by mx.example.org (envelope-from <s@sender.example>) id 1' + TAIL, ['mx.example.org']),
+        ('from a.example.com by mx.example.org with SMTP id <B001@msg.example>' + TAIL, ['mx.example.org']),
+    ],
+)
+def test_by_contains_only_relays(line: str, expected_by: list[str]) -> None:
+    assert parse(line)['by'] == expected_by
+
+
+def test_ident_host_of_sendmail_is_kept() -> None:
+    result = parse('from client (user@c-24-98-25-152.atl.example.com [24.98.25.152]) by mx.example.org with SMTP' + TAIL)
+
+    assert result['from'] == ['c-24-98-25-152.atl.example.com', '24.98.25.152']
+
+
+def test_empty_sections_are_omitted() -> None:
+    result = parse('from by mx.example.org with ;')
+
+    assert 'from' not in result
+    assert result['by'] == ['mx.example.org']
+    assert 'with' not in result
+
+
+def test_repeated_keyword_belongs_to_the_previous_section() -> None:
+    result = parse('from a.example.com by b.example.com for <x@example.com> from c.example.com' + TAIL)
+
+    assert result['for'] == ['x@example.com']
+    assert result['from'] == ['a.example.com', 'c.example.com']
+
+
+def test_for_addresses_are_in_order_of_appearance() -> None:
+    result = parse('from a.example.com by b.example.com for <z@example.com> <a@example.com>' + TAIL)
+
+    assert result['for'] == ['z@example.com', 'a@example.com']
+
+
+@pytest.mark.parametrize(
+    ('line', 'expected'),
+    [
+        ('from a.example.com by b.example.com' + TAIL + ' (CEST)', '2026-10-05T09:12:44+02:00'),
+        ('from a.example.com by b.example.com; Mon, 5 Oct 2026 09:12:44.123 -0500', '2026-10-05T09:12:44.123000-05:00'),
+        ('from a.example.com by b.example.com; 5 Oct 2026 07:12:44 -0000', '2026-10-05T07:12:44+00:00'),
+    ],
+)
+def test_date(line: str, expected: str) -> None:
+    assert parse(line)['date'].isoformat() == expected
+
+
+@pytest.mark.parametrize(
+    'line', ['from a.example.com by b.example.com', 'from a.example.com by b.example.com; not a date', 'from a.example.com by b.example.com;']
+)
+def test_no_date_is_invented(line: str) -> None:
+    assert 'date' not in parse(line)
+
+
+def test_merged_and_unparsable_lines() -> None:
+    assert parse('from a.example.com by b.example.com ; mon, 5 oct 2026 09:12:44 +0200 received: from c.example.com by d.example.com')['warning'] == [
+        'Merged Received headers'
+    ]
+    assert parse('(qmail 12345 invoked by uid 0); 22 Aug 2002 08:28:38 -0000')['warning'] == ['Nothing Parsable']
+
+
+@pytest.mark.parametrize('filler', [';', '(', ')', ' ', '(x) ', 'by ', 'a.'])
+def test_parsing_time_is_linear(filler: str) -> None:
+    """Runs of semicolons and spaces took seconds (quadratic) in the old implementation, the others are included for completeness."""
+    result = parse('from a.example.com ' + filler * 50_000 + 'x by b.example.com' + TAIL)
+
+    assert result['by'] == ['b.example.com'] or 'by' not in result
+
+
+@pytest.mark.parametrize(
+    ('text', 'expected'),
+    [('', ''), ('  ; x ;  ', 'x'), ('; ; x　;', 'x'), ('x', 'x')],
+)
+def test_cleanline_unicode_whitespace(text: str, expected: str) -> None:
+    assert eml_parser.routing.cleanline(text) == expected
+
+
+@pytest.mark.parametrize(
+    ('line', 'expected_by'),
+    [
+        # a comment directly behind the host name
+        (
+            'from a.example.com by notes.example.com(Lotus SMTP MTA v4.6.5 (863.2 5-20-1999)) id 86256895.00832fb3 ; Wed, 1 Mar 2000 17:52:54 -0600',
+            ['notes.example.com'],
+        ),
+        # a host in brackets
+        (
+            'from elpmime02.example.com ([192.0.2.90]) by [mail.example.com] (GroupWise SMTP/MIME daemon 4.1 v3) ; Mon, 19 Jun 2000 17:21:00 -0700',
+            ['mail.example.com'],
+        ),
+        # ids and versions are no hosts: mailer message ids and versions
+        (
+            'from a.example.com by imo-m10.mx.example.net (mail_out_v31_r1.9.) id 2.73.172b0394 (2519) for <ken@example.com>; Tue, 4 Dec 2001 13:02:04 -0500',
+            ['imo-m10.mx.example.net'],
+        ),
+        ('from a.example.com by mx.example.com (v82.22) with ESMTP id MAILINYE410-1115115900; Thu, 15 Nov 2001 11:59:00 -0500', ['mx.example.com']),
+        (
+            'from a.example.com by mx.example.com (8.10.1/8.10.1/external_corp-1.08) with ESMTP id g0mgoa021678; Tue, 22 Jan 2002 10:24:10 -0600',
+            ['mx.example.com'],
+        ),
+    ],
+)
+def test_by_in_real_world_formats(line: str, expected_by: list[str]) -> None:
+    assert parse(line)['by'] == expected_by
+
+
+def test_line_in_brackets() -> None:
+    result = parse(
+        '[from pobox3.example.org (pobox3.example.org [192.0.2.242]) by motgate4.example.org (motgate4 2.1) with ESMTP id haa08361; Tue, 13 Nov 2001 07:51:10 -0700 (MST)]'
+    )
+
+    assert result['from'] == ['pobox3.example.org', '192.0.2.242']
+    assert result['by'] == ['motgate4.example.org']
+
+
+@pytest.mark.parametrize(
+    'tail',
+    [
+        '; tue, 15 aug 2000 gmt',  # no time
+        '; wed, 21 feb 2001 19:29: 59 -0500',  # blank in the time
+        '; tue, 15 aug 2000 08:57:09 -04= 00',  # left over of a quoted-printable line break, dateutil would ignore it and return a wrong zone
+        '; of, 15 ssa 2000 09:40:38 -0600',
+    ],
+)
+def test_garbage_is_not_a_date(tail: str) -> None:
+    assert 'date' not in parse('from a.example.com by b.example.com' + tail)
+
+
+@pytest.mark.parametrize(
+    ('text', 'expected'),
+    [
+        ('mail10.m.example.net', ['mail10.m.example.net']),  # single character labels
+        ('mail_gw1.example.com', ['mail_gw1.example.com']),  # underscore, used by Exchange and Lotus servers
+        ('a.example.com, b.example.org;', ['a.example.com', 'b.example.org']),  # separated by comma
+        ('*.example.com', ['example.com']),  # wildcard
+        ('user.name@mx.example.com', ['mx.example.com']),  # local part of an address
+        ('id 1.b9.b1afe75 id x.bd.69a6d55', []),  # message ids
+        ('(8.12.0.beta16/8.12.0 v82.22 Exim 4.96)', []),  # versions
+        ('xn--mx-example.xn--p1ai', ['xn--mx-example.xn--p1ai']),  # punycode TLD
+    ],
+)
+def test_get_domain_ip_host_names(text: str, expected: list[str]) -> None:
+    assert eml_parser.routing.get_domain_ip(text) == expected
+
+
+def test_unclosed_parenthesis_does_not_hide_the_date() -> None:
+    result = parse(
+        'from a.example.com by b.example.org (8.12.2/BASENAME(x.example, .mc):RCS(rev: 1.23 ) with ESMTP id g99GvDmX; Wed, 9 Oct 2002 12:57:14 -0400 (EDT)'
+    )
+
+    assert result['by'] == ['b.example.org', 'x.example']
+    assert result['date'].isoformat() == '2002-10-09T12:57:14-04:00'
+
+
+def test_date_of_a_line_without_relay() -> None:
+    result = parse('(qmail 18301 invoked by uid 500); 28 Sep 2002 16:21:17 -0000')
+
+    assert result['warning'] == ['Nothing Parsable']
+    assert result['date'].isoformat() == '2002-09-28T16:21:17+00:00'
+    assert 'by' not in result
+
+
+def test_date_of_a_line_in_brackets() -> None:
+    result = parse('[from a.example.com by b.example.org with ESMTP; Wed, 28 Aug 2002 01:29:22 -0700  ]')
+
+    assert result['date'].isoformat() == '2002-08-28T01:29:22-07:00'
+
+
+def test_host_scan_is_linear() -> None:
+    """The scan for host names backtracked over every label of a long run of labels (400 000 characters took 17 s)."""
+    assert eml_parser.routing.get_domain_ip('a.' * 200_000 + 'x') == []
+    assert eml_parser.routing.get_domain_ip('a.' * 200_000 + 'example.com') == ['a.' * 200_000 + 'example.com']

eml_parser-4.1.0/eml_parser/routing.py

@@ -1,153 +0,0 @@
-"""This module is used for parsing the received lines into a machine readable structure."""
-
-import re
-import typing
-
-import regex
-
-import eml_parser.decode
-import eml_parser.regexes
-
-
-def cleanline(line: str) -> str:
-    """Remove space and ; from start/end of line.
-
-    Args:
-        line (str): Line to clean.
-
-    Returns:
-        str: Cleaned string.
-    """
-    if line == '':
-        return line
-
-    return eml_parser.regexes.cleanline_regex.sub('', line)
-
-
-def get_domain_ip(line: str) -> list[str]:
-    """Method returns all domains, IPv4 and IPv6 addresses found in a given string.
-
-    Args:
-        line (str): String to search in.
-
-    Returns:
-        list: Unique list of strings with matches
-    """
-    m = eml_parser.regexes.dom_regex.findall(' ' + line) + eml_parser.regexes.ipv4_regex.findall(line) + eml_parser.regexes.ipv6_regex.findall(line)
-
-    return list(set(m))
-
-
-def parserouting(line: str, email_regex: regex.Pattern[str] = eml_parser.regexes.email_no_force_tld_regex) -> dict[str, typing.Any]:
-    """This method tries to parse an e-mail header received line and extract machine-readable information.
-
-    Note that there are a large number of formats for these lines
-    and a lot of weird ones which are not commonly used.
-    We try our best to match a large number of formats.
-
-    Args:
-        line (str): Received line to be parsed.
-        email_regex (regex.Pattern[str], optional): Pattern used to extract e-mail addresses from the 'for' field.
-
-    Returns:
-        dict: Returns a dict with the extracted information.
-    """
-    #    if re.findall(reg_date, line):
-    #        return 'date\n'
-    # Preprocess the line to simplify from/by/with/for border detection.
-    out = {}  # type: typing.Dict[str, typing.Any]  # Result
-    out['src'] = line
-    line = line.lower()  # Convert everything to lowercase
-    npline = line.replace(')', ' ) ')  # normalise space # Re-space () ")by " exists often
-    npline = npline.replace('(', ' ( ')  # normalise space # Re-space ()
-    npline = npline.replace(';', ' ; ')  # normalise space # Re-space ;
-    npline = eml_parser.decode.noparenthesis(npline)  # Remove any "()"
-    npline = ' '.join(npline.split())  # normalise space
-    npline = npline.strip('\n')  # Remove any new-line
-    raw_find_data = eml_parser.regexes.date_regex.findall(npline)  # extract date on end line.
-
-    # Detect "sticked lines"
-    if ' received: ' in npline:
-        out['warning'] = ['Merged Received headers']
-        return out
-
-    if raw_find_data:
-        npdate = raw_find_data[0]  # Remove spaces and starting ;
-        npdate = npdate.lstrip(';')  # Remove Spaces and stating ; from date
-        npdate = npdate.strip()
-    else:
-        npdate = ''
-
-    npline = npline.replace(npdate, '')  # Remove date from input line
-    npline = npline.strip(' ')  # Remove any border WhiteSpace
-
-    borders = ['from ', 'by ', 'with ', 'for ']
-
-    # Scan the line to determine the order, and presence of each "from/by/with/for" words
-    raw_matches: list[tuple[int, str]] = []
-    for word in borders:
-        pos = npline.find(word)
-        if pos != -1:
-            raw_matches.append((pos, word))
-
-    if not raw_matches:
-        out['warning'] = ['Nothing Parsable']
-        return out
-
-    # Sort keywords sequentially by their appearance order in the header
-    tout = sorted(raw_matches, key=lambda match: match[0])
-
-    reg = ''
-    for i, item in enumerate(tout):
-        field = item[1].strip()
-        kw = item[1]
-
-        # Capture lazily until the next keyword
-        reg += kw + r'(?P<' + field + r'>.*?)'
-
-        if i + 1 >= len(tout):
-            # Last field captures lazily until a date separator ';' or end of string
-            reg += '(?:;|$)'
-
-    reparse = re.compile(reg)
-    reparseg = reparse.search(line)
-
-    # Fill the data
-    if reparseg is not None:
-        for item in borders:  # type: ignore
-            try:
-                out[item.strip()] = cleanline(reparseg.group(item.strip()))  # type: ignore
-            except (LookupError, ValueError, AttributeError):
-                pass
-
-    if npdate:
-        out['date'] = eml_parser.decode.robust_string2date(npdate)
-
-    # Fixup for "From" in "for" field
-    # ie google, do that...
-    if out.get('for'):
-        # include spaces in test, otherwise there will be an exception with domains containing "from" in itself
-        if ' from ' in out.get('for', ''):
-            temp = re.split(' from ', out['for'])
-            out['for'] = temp[0]
-            out['from'] = f"""{out['from']} {' '.join(temp[1:])}"""
-
-        m = email_regex.findall(out['for'])
-        if m:
-            out['for'] = list(set(m))
-        else:
-            del out['for']
-
-    # Now.. find IP and Host in from
-    if out.get('from'):
-        out['from'] = get_domain_ip(out['from'])
-        if not out.get('from', []):  # if array is empty remove
-            del out['from']
-
-    # Now.. find IP and Host in from
-    if out.get('by'):
-        out['by'] = get_domain_ip(out['by'])
-        if not out.get('by', []):  # If array is empty remove
-            del out['by']
-
-    return out