pypcapkit 1.3.3.post1__cp313-none-any.whl

pcapkit/vendor/pcapng/verdict_type.py

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+"""Verdict Types
+===================
+
+.. module:: pcapkit.vendor.pcapng.verdict_type
+
+This module contains the vendor crawler for **Verdict Types**,
+which is automatically generating :class:`pcapkit.const.pcapng.verdict_type.VerdictType`.
+
+"""
+
+import collections
+import sys
+from typing import TYPE_CHECKING
+
+from pcapkit.vendor.default import Vendor
+
+if TYPE_CHECKING:
+    from collections import Counter
+
+__all__ = ['VerdictType']
+
+#: Verdict type registry.
+DATA = {
+    0: 'Hardware',
+    1: 'Linux_eBPF_TC',
+    2: 'Linux_eBPF_XDP',
+}  # type: dict[int, str]
+
+
+class VerdictType(Vendor):
+    """Verdict Types"""
+
+    #: Value limit checker.
+    FLAG = 'isinstance(value, int) and 0x00 <= value <= 0xFF'
+
+    def request(self) -> 'dict[int, str]':  # type: ignore[override] # pylint: disable=arguments-differ
+        """Fetch registry data.
+
+        Returns:
+            Registry data (:data:`~pcapkit.vendor.pcapng.verdict_type.DATA`).
+
+        """
+        return DATA
+
+    def count(self, data: 'dict[int, str]') -> 'Counter[str]':  # type: ignore[override]
+        """Count field records.
+
+        Args:
+            data: Registry data.
+
+        Returns:
+            Field recordings.
+
+        """
+        return collections.Counter(map(self.safe_name, data.values()))
+
+    def process(self, data: 'dict[int, str]') -> 'tuple[list[str], list[str]]':  # type: ignore[override]
+        """Process registry data.
+
+        Args:
+            data: Registry data.
+
+        Returns:
+            Enumeration fields and missing fields.
+
+        """
+        enum = []  # type: list[str]
+        miss = [
+            "return extend_enum(cls, 'Unassigned_%d' % value, value)",
+        ]
+        for code, name in DATA.items():
+            renm = self.rename(name, code)  # type: ignore[arg-type]
+            enum.append(f"{renm} = {code}".ljust(76))
+        return enum, miss
+
+
+if __name__ == '__main__':
+    sys.exit(VerdictType())  # type: ignore[arg-type]

pcapkit/vendor/reg/__init__.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=unused-import
+"""Protocol Type Registry Vendor Crawlers
+============================================
+
+.. module:: pcapkit.vendor.reg
+
+This module contains all vendor crawlers of protocol type registry
+implementations. Available enumerations include:
+
+.. list-table::
+
+   * - :class:`LINKTYPE <pcapkit.vendor.reg.linktype.LinkType>`
+     - Link-Layer Header Type Values [*]_
+   * - :class:`ETHERTYPE <pcapkit.vendor.reg.ethertype.EtherType>`
+     - Ethertype IEEE 802 Numbers [*]_
+   * - :class:`TRANSTYPE <pcapkit.vendor.reg.transtype.TransType>`
+     - Transport Layer Protocol Numbers [*]_
+   * - :class:`APPTYPE <pcapkit.vendor.reg.apptype.AppType>`
+     - Application Layer Protocol Numbers (Service Name and Transport Protocol Port Number Registry) [*]_
+
+.. [*] http://www.tcpdump.org/linktypes.html
+.. [*] https://www.iana.org/assignments/ieee-802-numbers/ieee-802-numbers.xhtml#ieee-802-numbers-1
+.. [*] https://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml#protocol-numbers-1
+.. [*] https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml?
+
+"""
+
+from pcapkit.vendor.reg.apptype import AppType
+from pcapkit.vendor.reg.ethertype import EtherType
+from pcapkit.vendor.reg.linktype import LinkType
+from pcapkit.vendor.reg.transtype import TransType
+
+__all__ = ['EtherType', 'LinkType', 'TransType', 'AppType']

pcapkit/vendor/reg/apptype.py

@@ -0,0 +1,338 @@
+# -*- coding: utf-8 -*-
+"""Application Layer Protocol Numbers
+========================================
+
+.. module:: pcapkit.vendor.reg.apptype
+
+This module contains the vendor crawler for **Application Layer Protocol Numbers**,
+which is automatically generating :class:`pcapkit.const.reg.apptype.AppType`.
+
+"""
+
+import collections
+import csv
+import keyword
+import re
+import sys
+import textwrap
+from typing import TYPE_CHECKING, Callable
+
+from pcapkit.vendor.default import Vendor
+
+if TYPE_CHECKING:
+    from collections import Counter, OrderedDict
+    from typing import Callable
+
+__all__ = ['AppType']
+
+LINE = lambda NAME, DOCS, FLAG, ENUM, MISS, MODL: f'''\
+# -*- coding: utf-8 -*-
+# mypy: disable-error-code=assignment
+# pylint: disable=line-too-long,consider-using-f-string
+"""{(name := DOCS.split(' [', maxsplit=1)[0])}
+{'=' * (len(name) + 6)}
+
+.. module:: {MODL.replace('vendor', 'const')}
+
+This module contains the constant enumeration for **{name}**,
+which is automatically generated from :class:`{MODL}.{NAME}`.
+
+"""
+from collections import defaultdict
+from typing import TYPE_CHECKING
+
+from aenum import IntFlag, StrEnum, auto, extend_enum
+
+from pcapkit.utilities.compat import show_flag_values
+
+__all__ = ['{NAME}']
+
+if TYPE_CHECKING:
+    from typing import Any, DefaultDict, Type
+
+
+class TransportProtocol(IntFlag):
+    """Transport layer protocol."""
+
+    undefined = 0
+
+    #: Transmission Control Protocol.
+    tcp = auto()
+    #: User Datagram Protocol.
+    udp = auto()
+    #: Stream Control Transmission Protocol.
+    sctp = auto()
+    #: Datagram Congestion Control Protocol.
+    dccp = auto()
+
+    @staticmethod
+    def get(key: 'int | str') -> 'TransportProtocol':
+        """Backport support for original codes.
+
+        Args:
+            key: Key to get enum item.
+
+        :meta private:
+        """
+        if isinstance(key, int):
+            return TransportProtocol(key)
+        if key.lower() in TransportProtocol.__members__:
+            return TransportProtocol[key.lower()]  # type: ignore[misc]
+        max_val = max(TransportProtocol.__members__.values())
+        return extend_enum(TransportProtocol, key.lower(), max_val * 2)
+
+
+class {NAME}(StrEnum):
+    """[{NAME}] {DOCS}"""
+
+    if TYPE_CHECKING:
+        #: Service name.
+        svc: 'str'
+        #: Port number.
+        port: 'int'
+        #: Transport protocol.
+        proto: 'TransportProtocol'
+
+    #: Mapping of members based on transport protocol.
+    __members_proto__: 'DefaultDict[TransportProtocol, dict[int, {NAME}]]' = defaultdict(dict)
+
+    def __new__(cls, value: 'int', name: 'str' = '<null>',
+                proto: 'TransportProtocol' = TransportProtocol.undefined) -> 'Type[{NAME}]':
+        temp = '%s [%d - %s]' % (name, value, proto.name)
+
+        obj = str.__new__(cls, temp)
+        obj._value_ = temp
+
+        obj.svc = name
+        obj.port = value
+        obj.proto = proto
+
+        for namespace in show_flag_values(proto):
+            cls.__members_proto__[TransportProtocol(namespace)][value] = obj
+        if proto is TransportProtocol.undefined:
+            cls.__members_proto__[proto][value] = obj
+
+        return obj
+
+    def __repr__(self) -> 'str':
+        return "<%s.%s: %d [%s]>" % (self.__class__.__name__, self.svc, self.port, self.proto.name)
+
+    def __str__(self) -> 'str':
+        return '%s [%d - %s]' % (self.svc, self.port, self.proto.name)
+
+    def __int__(self) -> 'int':
+        return self.port
+
+    def __lt__(self, other: '{NAME}') -> 'bool':
+        return self.port < other
+
+    def __gt__(self, other: '{NAME}') -> 'bool':
+        return self.port > other
+
+    def __le__(self, other: '{NAME}') -> 'bool':
+        return self.port <= other
+
+    def __ge__(self, other: '{NAME}') -> 'bool':
+        return self.port >= other
+
+    def __eq__(self, other: 'Any') -> 'bool':
+        return self.port == other
+
+    def __ne__(self, other: 'Any') -> 'bool':
+        return self.port != other
+
+    def __hash__(self) -> 'int':
+        return hash(self.port)
+
+    {ENUM}
+
+    @staticmethod
+    def get(key: 'int | str', default: 'int' = -1, *,
+            proto: 'TransportProtocol | str' = TransportProtocol.undefined) -> '{NAME}':
+        """Backport support for original codes.
+
+        Args:
+            key: Key to get enum item.
+            default: Default value if not found.
+            proto: Transport protocol of the enum item.
+
+        :meta private:
+        """
+        if isinstance(key, int):
+            if isinstance(proto, str):
+                proto = TransportProtocol.get(proto.lower())
+            temp_ns = {NAME}.__members_proto__.get(proto, {{}})
+            if key in temp_ns:
+                return temp_ns[key]
+            try:
+                ret = {NAME}._missing_(key)
+                if ret is None:
+                    raise ValueError
+            except ValueError:
+
+                ret = extend_enum({NAME}, 'PORT_%d_%s' % (key, proto.name), key, 'unknown', proto)
+            return ret
+        if key in {NAME}.__members_proto__:
+            return getattr({NAME}, key)
+        return extend_enum({NAME}, key, default, key)
+
+    @classmethod
+    def _missing_(cls, value: 'int') -> '{NAME}':
+        """Lookup function used when value is not found.
+
+        Args:
+            value: Value to get enum item.
+
+        """
+        if not ({FLAG}):
+            raise ValueError('%r is not a valid %s' % (value, cls.__name__))
+        if value in cls.__members_proto__.get(TransportProtocol.undefined, {{}}):  # type: ignore[call-overload]
+            return cls.__members_proto__[TransportProtocol.undefined][value]  # type: ignore[index]
+        {MISS}
+        {'' if ''.join(MISS.splitlines()[-1:]).startswith('return') else 'return super()._missing_(value)'}
+'''.strip()  # type: Callable[[str, str, str, str, str, str], str]
+
+
+class AppType(Vendor):
+    """Application Layer Protocol Numbers"""
+
+    #: Value limit checker.
+    FLAG = 'isinstance(value, int) and 0 <= value <= 65535'
+    #: Link to registry.
+    LINK = 'https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.csv'
+
+    def count(self, data: 'list[str]') -> 'Counter[str]':
+        """Count field records."""
+        reader = csv.reader(data)
+        next(reader)  # header
+        return collections.Counter(map(lambda item: '[%s] %s' % (item[2], item[0].strip() or self.safe_name(item[3].strip())),
+                                       filter(lambda item: len(item[1].split('-')) != 2, reader)))
+
+    @staticmethod
+    def wrap_comment(text: 'str') -> 'str':
+        """Wraps long-length text to shorter lines of comments.
+
+        Args:
+            text: Source text.
+
+        Returns:
+            Wrapped comments.
+
+        """
+        return '\n    #:   '.join(textwrap.wrap(text.strip(), 76))
+
+    def process(self, data: 'list[str]') -> 'tuple[list[str], list[str]]':
+        """Process registry data.
+
+        Args:
+            data: Registry data.
+
+        Returns:
+            Enumeration fields and missing fields.
+
+        """
+        reader = csv.reader(data)
+        next(reader)  # header
+
+        enum = []  # type: list[str]
+        miss = []  # type: list[str]
+
+        line = collections.OrderedDict()  # type: OrderedDict[str, list[str]]
+        for item in reader:
+            svc = item[0].strip().lower() or self.safe_name(item[3].strip()).lower()
+            port = item[1].strip() or '-1'
+            proto = 'TransportProtocol.get(%r)' % (item[2].strip().lower() or 'undefined')
+            desc = item[3].strip()
+
+            temp = []  # type: list[str]
+            #for rfc in filter(lambda s: 'RFC' in s, re.split(r'\[|\]', item[8])):
+            #    temp.append(f'[{rfc[:3]} {rfc[3:]}]')
+            for rfc in filter(None, map(lambda s: s.strip(), re.split(r'\[|\]', item[8]))):
+                if 'RFC' in rfc and re.match(r'\d+', rfc[3:]):
+                    match = re.fullmatch(r'RFC(?P<rfc>\d+)(, Section (?P<sec>.*?))?', rfc)
+                    if match is None:
+                        temp.append(f'[{rfc}]')
+                    else:
+                        if match.group('sec') is not None:
+                            temp.append(f'[:rfc:`{match.group("rfc")}#{match.group("sec")}`]')
+                        else:
+                            temp.append(f'[:rfc:`{match.group("rfc")}`]')
+                else:
+                    temp.append(f'[{rfc}]'.replace('_', ' '))
+            cmmt = self.wrap_comment(re.sub(r'\s+', r' ',
+                                            '[%s] %s %s' % (item[2].strip().upper() or 'N/A',
+                                                            desc, ''.join(temp))))  # pylint: disable=consider-using-f-string
+
+            try:
+                code, _ = port, int(port)
+                if port == '-1':
+                    code = 'null'
+                renm = self.rename(svc, code)
+
+                if f'{renm}_{code}' in line:
+                    renm = f'{renm}_{code}'
+
+                if renm in line:
+                    if port == line[renm][1]:
+                        line[renm][2] = f'{line[renm][2]} | {proto}'
+                        if line[renm][3].startswith('-'):
+                            line[renm][3] = f'{line[renm][3]}\n    #: - {cmmt}'
+                        else:
+                            line[renm][3] = f'- {line[renm][3]}\n    #: - {cmmt}'
+                    else:
+                        line[f'{renm}_{line[renm][1]}'] = line[renm]
+                        line[f'{renm}_{code}'] = [svc, port, proto, cmmt]
+                        del line[renm]
+                else:
+                    line[renm] = [svc, port, proto, cmmt]
+
+                # if port == '-1':
+                #     continue
+                # proto_name = item[2].strip().lower()
+
+                # if proto_name:
+                #     renm = f'PORT_{code}_{proto_name}'
+                # else:
+                #     renm = f'PORT_{code}'
+                # line[renm] = [svc, code, proto, cmmt]
+            except ValueError:
+                start, stop = port.split('-')
+
+                miss.append(f'if {start} <= value <= {stop}:')
+                miss.append(f'    #: {cmmt}')
+                miss.append(f"    return extend_enum(cls, '{self.safe_name(svc)}_%d' % value, value, {svc!r}, {proto})")
+
+        for key, (svc, code, proto, cmmt) in line.items():
+            if keyword.iskeyword(key):
+                key = '%s_' % key
+
+            pres = f"{key}: 'AppType' = {code}, {svc!r}, {proto}"
+            if cmmt.startswith('-'):
+                sufs = f'#: {cmmt}'
+            else:
+                sufs = '#: %s' % cmmt.replace('    #:   ', '    #: ')
+
+            enum.append(f'{sufs}\n    {pres}')
+
+        return enum, miss
+
+    def context(self, data: 'list[str]') -> 'str':
+        """Generate constant context.
+
+        Args:
+            data: CSV data.
+
+        Returns:
+            Constant context.
+
+        """
+        enum, miss = self.process(data)
+
+        ENUM = '\n\n    '.join(map(lambda s: s.rstrip(), enum)).strip()
+        MISS = '\n        '.join(map(lambda s: s.rstrip(), miss)).strip()
+
+        return LINE(self.NAME, self.DOCS, self.FLAG, ENUM, MISS, self.__module__)
+
+
+if __name__ == '__main__':
+    sys.exit(AppType())  # type: ignore[arg-type]

pcapkit/vendor/reg/ethertype.py

@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+"""Ethertype IEEE 802 Numbers
+================================
+
+.. module:: pcapkit.vendor.reg.ethertype
+
+This module contains the vendor crawler for **Ethertype IEEE 802 Numbers**,
+which is automatically generating :class:`pcapkit.const.reg.ethertype.EtherType`.
+
+"""
+
+import collections
+import csv
+import re
+import sys
+from typing import TYPE_CHECKING
+
+from pcapkit.vendor.default import Vendor
+
+if TYPE_CHECKING:
+    from collections import Counter
+    from typing import Optional
+
+__all__ = ['EtherType']
+
+
+class EtherType(Vendor):
+    """Ethertype IEEE 802 Numbers"""
+
+    #: Value limit checker.
+    FLAG = 'isinstance(value, int) and 0x0000 <= value <= 0xFFFF'
+    #: Link to registry.
+    LINK = 'https://www.iana.org/assignments/ieee-802-numbers/ieee-802-numbers-1.csv'
+
+    def count(self, data: 'list[str]') -> 'Counter[str]':
+        """Count field records.
+
+        Args:
+            data: CSV data.
+
+        Returns:
+            Field recordings.
+
+        """
+        reader = csv.reader(data)
+        next(reader)  # header
+        return collections.Counter(map(lambda item: self.safe_name(item[4]),
+                                       filter(lambda item: len(item[1].split('-')) != 2, reader)))
+
+    def rename(self, name: 'str', code: 'str', *, original: 'Optional[str]' = None) -> 'str':  # pylint: disable=redefined-outer-name
+        """Rename duplicated fields.
+
+        Args:
+            name: Field name.
+            code: Field code.
+
+        Keyword Args:
+            original: Original field name (extracted from CSV records).
+
+        Returns:
+            Revised field name.
+
+        """
+        if self.record[self.safe_name(name)] > 1:
+            name = f'{name}_0x{code}'
+        return self.safe_name(name)
+
+    def process(self, data: 'list[str]') -> 'tuple[list[str], list[str]]':
+        """Process CSV data.
+
+        Args:
+            data: CSV data.
+
+        Returns:
+            Enumeration fields and missing fields.
+
+        """
+        reader = csv.reader(data)
+        next(reader)  # header
+
+        enum = []  # type: list[str]
+        miss = []  # type: list[str]
+        for item in reader:
+            name = item[4]
+            rfcs = item[5]
+
+            temp = []  # type: list[str]
+            for rfc in filter(None, re.split(r'\[|\]', rfcs)):
+                if 'RFC' in rfc and re.match(r'\d+', rfc[3:]):
+                    #temp.append(f'[{rfc[:3]} {rfc[3:]}]')
+                    temp.append(f'[:rfc:`{rfc[3:]}`]')
+                else:
+                    temp.append(f'[{rfc}]'.replace('_', ' '))
+            tmp1 = re.sub(r'( )( )*', ' ', f"{''.join(temp)}".replace('\n', ' ')) if rfcs else ''
+            tmp2 = re.sub(r'\r*\n', ' ', tmp1, re.MULTILINE)
+            tmp3 = name.replace('\n', ' ')
+            desc = self.wrap_comment(f"{tmp3} {tmp2}")
+
+            try:
+                code, _ = item[1], int(item[1], base=16)
+                renm = re.sub(r'( )( )*', ' ', self.rename(name, code).replace('\n', ' '))
+
+                pres = f'{renm} = 0x{code}'
+                sufs = f'#: {desc}'
+
+                # if len(pres) > 74:
+                #     sufs = f"\n{' '*80}{sufs}"
+
+                # enum.append(f'{pres.ljust(76)}{sufs}')
+                enum.append(f'{sufs}\n    {pres}')
+            except ValueError:
+                start, stop = item[1].split('-')
+
+                miss.append(f'if 0x{start} <= value <= 0x{stop}:')
+                miss.append(f'    #: {desc}')
+                miss.append(f"    return extend_enum(cls, '{self.safe_name(name)}_0x%s' % hex(value)[2:].upper().zfill(4), value)")  # pylint: disable=line-too-long
+        return enum, miss
+
+
+if __name__ == '__main__':
+    sys.exit(EtherType())  # type: ignore[arg-type]

pcapkit/vendor/reg/linktype.py

@@ -0,0 +1,110 @@
+# -*- coding: utf-8 -*-
+"""Link-Layer Header Type Values
+===================================
+
+.. module:: pcapkit.vendor.reg.linktype
+
+This module contains the vendor crawler for **Link-Layer Header Type Values**,
+which is automatically generating :class:`pcapkit.const.reg.linktype.LinkType`.
+
+"""
+
+import collections
+import re
+import sys
+from typing import TYPE_CHECKING
+
+import bs4
+
+from pcapkit.vendor.default import Vendor
+
+if TYPE_CHECKING:
+    from collections import Counter
+
+    from bs4.element import Tag
+
+__all__ = ['LinkType']
+
+
+class LinkType(Vendor):
+    """Link-Layer Header Type Values"""
+
+    #: Value limit checker.
+    FLAG = 'isinstance(value, int) and 0x00000000 <= value <= 0xFFFFFFFF'
+    #: Link to registry.
+    LINK = 'http://www.tcpdump.org/linktypes.html'
+
+    def count(self, data: 'list[str]') -> 'Counter[str]':
+        """Count field records."""
+        return collections.Counter()
+
+    def request(self, text: 'str') -> 'list[Tag]':  # type: ignore[override] # pylint: disable=signature-differs
+        """Fetch registry table.
+
+        Args:
+            text: Context from :attr:`~LinkType.LINK`.
+
+        Returns:
+            Rows (``tr``) from registry table (``table``).
+
+        """
+        soup = bs4.BeautifulSoup(text, 'html5lib')
+        table = soup.select('table.linktypedlt')[0]
+        return table.select('tr')[1:]
+
+    def process(self, data: 'list[Tag]') -> 'tuple[list[str], list[str]]':
+        """Process registry data.
+
+        Args:
+            data: Registry data.
+
+        Returns:
+            Enumeration fields and missing fields.
+
+        """
+        enum = []  # type: list[str]
+        miss = [
+            "return extend_enum(cls, 'Unassigned_%d' % value, value)",
+        ]
+        for content in data:
+            name = content.select('td.symbol')[0].text.strip()[9:].strip()
+            temp = content.select('td.number')[0].text.strip()
+            desc = content.select('td.symbol')[1].text.strip()
+            cmmt = re.sub(r'\s+', ' ', content.select('td')[3].text.strip()).replace("''", '``').replace('_', r'\_')
+
+            if not name:
+                name = desc[4:]
+
+            try:
+                code, _ = temp, int(temp)
+
+                pres = f"{name} = {code}"
+                if desc:
+                    sufs = "#: %s" % self.wrap_comment(f"[``{desc}``] {cmmt}")  # pylint: disable=consider-using-f-string
+                else:
+                    sufs = "#: %s" % self.wrap_comment(cmmt)
+
+                # if len(pres) > 74:
+                #     sufs = f"\n{' '*80}{sufs}"
+
+                # enum.append(f'{pres.ljust(76)}{sufs}')
+                enum.append(f'{sufs}\n    {pres}')
+            except ValueError:
+                start, stop = map(int, temp.split('–'))
+                for code in range(start, stop+1):
+                    name = f'USER{code-start}'
+                    desc = f'DLT_USER{code-start}'
+
+                    pres = f"{name} = {code}"
+                    sufs = "#: %s" % self.wrap_comment(f"[``{desc}``] {cmmt}")  # pylint: disable=consider-using-f-string
+
+                    # if len(pres) > 74:
+                    #     sufs = f"\n{' '*80}{sufs}"
+
+                    # enum.append(f'{pres.ljust(76)}{sufs}')
+                    enum.append(f'{sufs}\n    {pres}')
+        return enum, miss
+
+
+if __name__ == '__main__':
+    sys.exit(LinkType())  # type: ignore[arg-type]