pypcapkit 1.5.0__cp315-none-any.whl

pcapkit/__init__.py

@@ -0,0 +1,132 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=wrong-import-position,unused-import,unused-wildcard-import
+"""Stream PCAP File Extractor
+================================
+
+.. module:: pcapkit
+
+:mod:`pcapkit` is an independent open source library, using only
+`DictDumper`_ as its formatted output dumper.
+
+Unlike popular PCAP file extractors, such as `Scapy`_,
+`DPKT`_ and `PyShark`_, :mod:`pcapkit` uses streaming
+strategy to read input files. That is to read frame by
+frame, decrease occupation on memory, as well as enhance
+efficiency in some way.
+
+In :mod:`pcapkit`, all files can be described as the following
+components.
+
+- Interface (:mod:`pcapkit.interface`)
+
+  User interface for the :mod:`pcapkit` library, which
+  standardises and simplifies the usage of this library.
+
+- Foundation (:mod:`pcapkit.foundation`)
+
+  Synthesises file I/O and protocol analysis, coordinates
+  information exchange in all network layers, as well as
+  provides the fundamental functions for :mod:`pcapkit`.
+
+- Protocols (:mod:`pcapkit.protocols`)
+
+  Collection of all protocol families, with detailed
+  implementation and methods.
+
+- Utilities (:mod:`pcapkit.utilities`)
+
+  Auxiliary functions and tools for :mod:`pcapkit`.
+
+- CoreKit (:mod:`pcapkit.corekit`)
+
+  Core utilities for :mod:`pcapkit` implementation, mainly
+  for internal data structure and processing.
+
+- ToolKit (:mod:`pcapkit.toolkit`)
+
+  Auxiliary tools for :mod:`pcapkit` to support the multiple
+  extraction engines with a unified interface.
+
+- DumpKit (:mod:`pcapkit.dumpkit`)
+
+  File output formatters for :mod:`pcapkit`.
+
+- Constants (:mod:`pcapkit.const`)
+
+  Constant enumerations used in :mod:`pcapkit` for protocol
+  family extraction and representation.
+
+- Vendor Crawlers (:mod:`pcapkit.vendor`)
+
+  Web crawlers that generate the constant enumerations in
+  :mod:`pcapkit.const`.
+
+"""
+###############################################################################
+# conda ``_extern`` module support
+
+import os
+import sys
+
+_extern = os.path.join(os.path.dirname(os.path.realpath(__file__)), '_extern')
+if os.path.exists(_extern):
+    sys.path.append(_extern)
+
+###############################################################################
+
+import warnings
+
+import tbtrim
+
+from pcapkit.utilities.exceptions import BaseError
+from pcapkit.utilities.logging import DEVMODE
+from pcapkit.utilities.warnings import DevModeWarning
+
+# set up sys.excepthook
+if DEVMODE:
+    warnings.showwarning('development mode enabled', DevModeWarning,
+                         filename=__file__, lineno=0,
+                         line=f"PCAPKIT_DEVMODE={os.environ.get('PCAPKIT_DEVMODE', '1')}")
+else:
+    ROOT = os.path.dirname(os.path.realpath(__file__))
+    tbtrim.set_trim_rule(lambda filename: ROOT in os.path.realpath(filename),
+                         exception=BaseError, strict=False)
+
+from pcapkit.interface import *
+from pcapkit.protocols import *
+
+__all__ = [
+    'extract', 'reassemble', 'trace',                       # Interface Functions
+
+    'TREE', 'JSON', 'PLIST', 'PCAP',                        # Format Macros
+    'LINK', 'INET', 'TRANS', 'APP', 'RAW',                  # Layer Macros
+    'DPKT', 'Scapy', 'PyShark', 'PCAPKit',                  # Engine Macros
+    'PyPCAP', 'PCAP_CT', 'PyPCAPFile',                      # Engine Macros
+
+    'LINKTYPE', 'ETHERTYPE', 'TRANSTYPE', 'APPTYPE',        # Protocol Numbers
+
+    'Header', 'Frame',                                      # PCAP Headers
+    'PCAPNG',                                               # PCAPNG Format
+
+    'NoPayload',                                            # No Payload
+    'Raw',                                                  # Raw Packet
+
+    'ARP', 'C_Tag', 'Ethernet', 'InARP', 'L2TP',            # Link Layer
+    'L2TPv2', 'Loopback', 'S_Tag', 'VLAN',
+
+    'AH', 'ESP', 'IP', 'IPsec', 'IPv4', 'IPv6', 'IPX',      # Internet Layer
+    'HIP', 'HOPOPT', 'IPv6_Frag', 'IPv6_Ext', 'IPv6_Opts', 'IPv6_Route', 'MH',
+                                                            # IPv6 Extension Header
+
+    'TCP', 'UDP', 'SCTP',                                   # Transport Layer
+
+    'FTP', 'FTP_DATA',                                      # Application Layer
+    'HTTP', 'HTTPv1', 'HTTPv2', 'NGAP', 'OSPF',
+    'RARP', 'DRARP',
+
+    'Data',                                                 # Protocol Data
+    'Schema',                                               # Protocol Schema
+]
+
+#: version number
+__version__ = '1.5.0'

pcapkit/__main__.py

@@ -0,0 +1,166 @@
+# -*- coding: utf-8 -*-
+"""Command Line Tool
+=======================
+
+.. module:: pcapkit.__main__
+
+.. important::
+
+   The |emoji|_ package is optional. Without it, importing this module
+   warns :class:`~pcapkit.utilities.warnings.EmojiWarning` and the verbose
+   messages print as plain text.
+
+:mod:`pcapkit.__main__` was originally the module file of
+|jspcapy|_, which is deprecated and merged with :mod:`pcapkit`.
+
+"""
+import argparse
+import sys
+from typing import TYPE_CHECKING
+
+from pcapkit import __version__
+from pcapkit.foundation.extraction import Extractor
+from pcapkit.interface import JSON, PLIST, TREE
+from pcapkit.utilities.compat import ModuleNotFoundError  # pylint: disable=redefined-builtin
+from pcapkit.utilities.exceptions import stacklevel
+from pcapkit.utilities.warnings import EmojiWarning, warn
+
+try:
+    import emoji
+except ModuleNotFoundError:
+    warn("dependency package 'emoji' not found",
+         EmojiWarning, stacklevel=stacklevel())
+
+__all__ = ['main']
+
+if TYPE_CHECKING:
+    from argparse import ArgumentParser
+
+
+def get_parser() -> 'ArgumentParser':
+    """CLI argument parser."""
+    parser = argparse.ArgumentParser(prog='pcapkit-cli',
+                                     description='PCAP file extractor and formatted dumper')
+    parser.add_argument('-V', '--version', action='version', version=__version__)
+    parser.add_argument('fin', metavar='input-file-name',
+                        help=('The name of the input PCAP or PCAP-NG file. With '
+                              '`--auto-extension`, ".pcap" is appended unless its '
+                              'extension is already ".pcap", ".cap" or ".pcapng". '
+                              'Use "-" to read from standard input.'))
+    parser.add_argument('-o', '--output', action='store', metavar='file-name', dest='fout',
+                        help=('The name of the output report file. If it is omitted, '
+                              '"out" is used. With `--auto-extension`, the extension '
+                              'of the output format (e.g. ".json") is appended if '
+                              'absent. With `--files`, the directory each frame\'s '
+                              'report is written to.'))
+    parser.add_argument('-f', '--format', action='store', metavar='format', dest='format',
+                        help=('The format of the report: "json", "plist" (or "xml"), '
+                              '"tree" (or "text", "txt") or "pcap" (or "cap"). Takes '
+                              'precedence over `--json`, `--plist` and `--tree`. With '
+                              'no format option, "tree" is used.'))
+    parser.add_argument('-j', '--json', action='store_true', default=False,
+                        help=('Write the report as JSON, as `--format json` does. '
+                              'Ignored if `--format` is given.'))
+    parser.add_argument('-p', '--plist', action='store_true', default=False,
+                        help=('Write the report as a macOS property list, as '
+                              '`--format plist` does. Ignored if `--format` or '
+                              '`--json` is given.'))
+    parser.add_argument('-t', '--tree', action='store_true', default=False,
+                        help=('Write the report as tree view text, as `--format tree` '
+                              'does; this is the default. Ignored if `--format`, '
+                              '`--json` or `--plist` is given.'))
+    parser.add_argument('-a', '--auto-extension', action='store_true', default=False,
+                        help=('Append missing file extensions: ".pcap" to the input '
+                              'file name, and the extension of the output format '
+                              '(e.g. ".json") to the output file name unless `--files` '
+                              'is set.'))
+    parser.add_argument('-v', '--verbose', action='store_true', default=False,
+                        help=('Print the input name, the protocol chain of each '
+                              'frame, and where the report is stored.'))
+    parser.add_argument('-F', '--files', action='store_true', default=False,
+                        help=('Write a report file per frame, in the directory named '
+                              'by `--output`.'))
+    parser.add_argument('-E', '--engine', action='store', dest='engine', default='default', metavar='PKG',
+                        help=('The extraction engine, case-insensitive: "default" (or '
+                              '"pcapkit"), or a third-party one such as "dpkt" or '
+                              '"scapy", which needs its package installed. An unknown '
+                              'or unavailable engine falls back to "default".'))
+    parser.add_argument('-P', '--protocol', action='store', dest='protocol', default=None, metavar='PROTOCOL',
+                        help=('Stop dissecting each frame after this protocol, e.g. '
+                              '"IPv4" (case-insensitive); the rest of the frame is '
+                              'kept as raw data. Third-party engines ignore it.'))
+    # NOTE: ``choices`` rather than a free-form string, because the layer names
+    # are a closed set (``pcapkit.foundation.extraction.Layers``) and a name
+    # outside it is not rejected anywhere downstream -- it simply never matches a
+    # protocol's ``__layer__`` and the parse silently runs to the top of the
+    # stack, which is the failure mode GH-356 was about. ``type=str.lower`` keeps
+    # ``-L Internet`` accepted, matching ``Extractor.__init__``, which lowercases
+    # the value anyway.
+    #
+    # The defaults are :data:`None` and not the ``'None'``/``'null'`` strings:
+    # ``Extractor.__init__`` substitutes its own sentinels for an
+    # omitted value, so passing the strings would only work because it happens to
+    # lowercase ``'None'`` into the sentinel it wants.
+    parser.add_argument('-L', '--layer', action='store', dest='layer', default=None, metavar='LAYER',
+                        type=str.lower, choices=['link', 'internet', 'transport', 'application', 'none'],
+                        help=('Stop dissecting each frame after its protocol in this '
+                              'layer: "link", "internet", "transport" or "application" '
+                              '(case-insensitive); "none", the default, sets no limit. '
+                              'Third-party engines ignore it.'))
+    parser.add_argument('-B', '--buffer-save', action='store_true', default=False,
+                        help=('Save a copy of the input to a file as it is read. Only '
+                              'an input that is not seekable, such as a pipe on '
+                              'standard input, is saved.'))
+    parser.add_argument('-O', '--buffer-path', action='store', metavar='file-name', dest='buffer_path',
+                        help=('The name of the file `--buffer-save` writes. If it is '
+                              'omitted, a temporary file is used and then deleted.'))
+    return parser
+
+
+def main() -> 'int':
+    """Entrypoint."""
+    parser = get_parser()
+    args = parser.parse_args()
+
+    if args.format:
+        fmt = args.format
+    elif args.json:
+        fmt = JSON
+    elif args.plist:
+        fmt = PLIST
+    elif args.tree:
+        fmt = TREE
+    else:
+        fmt = None
+
+    no_eof = args.fin == '-'
+    if args.fin == '-':
+        args.fin = sys.stdin.buffer
+
+    extractor = Extractor(store=False, auto=not args.verbose,
+                          fin=args.fin, fout=args.fout,
+                          files=args.files, format=fmt,
+                          layer=args.layer, protocol=args.protocol,
+                          engine=args.engine, extension=args.auto_extension,
+                          verbose=args.verbose, buffer_save=args.buffer_save,
+                          no_eof=no_eof, buffer_path=args.buffer_path)  # type: ignore[var-annotated]
+
+    if args.verbose:
+        try:
+            print(emoji.emojize(f":police_car_light: Loading file {extractor.input!r}"))
+        except (UnicodeEncodeError, NameError):  # may trigger if emoji not installed
+            print(f"[*] Loading file {extractor.input!r}")
+
+        for _ in extractor:
+            pass
+
+        try:
+            print(emoji.emojize(f":beer_mug: Report file{'s' if args.files else ''} stored in {extractor.output!r}"))
+        except (UnicodeEncodeError, NameError):  # may trigger if emoji not installed
+            print(f"[*] Report file{'s' if args.files else ''} stored in {extractor.output!r}")
+
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

pcapkit/all.py

@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=unused-import,unused-wildcard-import,wildcard-import
+"""Library Index
+===================
+
+.. module:: pcapkit.all
+
+:mod:`pcapkit` has defined various and numerous functions
+and classes, which have different features and purposes.
+To make a simple index for this library, :mod:`pcapkit.all`
+contains all things from :mod:`pcapkit`.
+
+"""
+from pcapkit import const
+from pcapkit.corekit import *
+from pcapkit.dumpkit import *
+from pcapkit.foundation import *
+from pcapkit.interface import *
+from pcapkit.protocols import *
+from pcapkit.toolkit import *
+from pcapkit.utilities import *  # pylint: disable=redefined-builtin
+
+#from pcapkit import vendor
+
+# tools for Scapy engine
+from pcapkit.toolkit.scapy import packet2chain as scapy_packet2chain  # isort: skip
+from pcapkit.toolkit.scapy import packet2dict as scapy_packet2dict  # isort: skip
+from pcapkit.toolkit.scapy import ipv4_reassembly as scapy_ipv4_reassembly  # isort: skip
+from pcapkit.toolkit.scapy import ipv6_reassembly as scapy_ipv6_reassembly  # isort: skip
+from pcapkit.toolkit.scapy import tcp_reassembly as scapy_tcp_reassembly  # isort: skip
+from pcapkit.toolkit.scapy import tcp_traceflow as scapy_tcp_traceflow  # isort: skip
+
+# tools for DPKT engine
+from pcapkit.toolkit.dpkt import ipv6_hdr_len as dpkt_ipv6_hdr_len  # isort: skip
+from pcapkit.toolkit.dpkt import packet2chain as dpkt_packet2chain  # isort: skip
+from pcapkit.toolkit.dpkt import packet2dict as dpkt_packet2dict  # isort: skip
+from pcapkit.toolkit.dpkt import ipv4_reassembly as dpkt_ipv4_reassembly  # isort: skip
+from pcapkit.toolkit.dpkt import ipv6_reassembly as dpkt_ipv6_reassembly  # isort: skip
+from pcapkit.toolkit.dpkt import tcp_reassembly as dpkt_tcp_reassembly  # isort: skip
+from pcapkit.toolkit.dpkt import tcp_traceflow as dpkt_tcp_traceflow  # isort: skip
+
+# tools for PyShark engine
+from pcapkit.toolkit.pyshark import packet2dict as pyshark_packet2dict  # isort: skip
+from pcapkit.toolkit.pyshark import tcp_traceflow as pyshark_tcp_traceflow  # isort: skip
+
+__all__ = [
+    # pcapkit.const
+    'const',
+
+    # # pcapkit.vendor
+    # 'vendor',
+
+    # pcapkit.corekit
+    'EnumRegistry',                                         # Enum Registry
+    'Info', 'info_final',                                   # Info Class
+    'MultiInfo', 'OrderedMultiInfo',
+    'ProtoChain',                                           # ProtoChain
+    'VersionInfo',                                          # Version
+    'NumberField', 'Int32Field', 'UInt32Field',             # numeric protocol fields
+    'Int16Field', 'UInt16Field', 'Int64Field', 'UInt64Field',
+    'Int8Field', 'UInt8Field', 'EnumField', 'PortEnumField',
+    'BytesField', 'StringField', 'BitField',                # text protocol fields
+    'PaddingField',
+    'ConditionalField', 'PayloadField', 'SchemaField',      # misc protocol fields
+    'SwitchField', 'ForwardMatchField', 'NoValueField',
+    'IPv4AddressField', 'IPv6AddressField',                 # IP address protocol fields
+    'IPv4InterfaceField', 'IPv6InterfaceField',
+    'ListField', 'OptionField',                             # container protocol fields
+    'SeekableReader',                                       # Seekable Reader
+    'MultiDict', 'OrderedMultiDict',                        # Multi Dict
+    'ModuleDescriptor',                                     # Module Descriptor
+
+    # pcapkit.dumpkit
+    'PCAPIO',                                               # PCAP Dumper
+    'NotImplementedIO',                                     # Simulated I/O
+
+    # pcapkit.foundation
+    'Extractor',                                            # Extraction
+    'TraceFlowManager', 'TCP_TraceFlow',                    # Trace Flow
+
+    # pcapkit.foundation.reassembly
+    'ReassemblyManager',                                    # Reassembly Manager
+    'IPv4_Reassembly', 'IPv6_Reassembly',                   # IP Reassembly
+    'TCP_Reassembly',                                       # TCP Reassembly
+
+    # pcapkit.foundation.registry
+    'register_protocol',
+    'register_protocol_code',
+    'register_linktype',
+    'register_pcap', 'register_pcapng',
+    'register_ethertype',
+    'register_transtype',
+    'register_ipv4_option', 'register_hip_parameter', 'register_hopopt_option',
+    'register_ipv6_opts_option', 'register_ipv6_route_routing',
+    'register_mh_message', 'register_mh_option', 'register_mh_extension',
+    'register_apptype',
+    'register_tcp', 'register_udp', 'register_sctp',
+    'register_tcp_option', 'register_tcp_mp_option',
+    'register_http_frame',
+    'register_pcapng_block', 'register_pcapng_option', 'register_pcapng_secrets',
+    'register_pcapng_record',
+    'register_extractor_engine',
+    'register_dumper',
+    'register_extractor_dumper', 'register_traceflow_dumper',
+    'register_extractor_reassembly', 'register_extractor_traceflow',
+    'register_reassembly_ipv4_callback', 'register_reassembly_ipv6_callback',
+    'register_reassembly_tcp_callback', 'register_traceflow_tcp_callback',
+
+    # pcapkit.interface
+    'extract', 'reassemble', 'trace',                       # Interface Functions
+    'TREE', 'JSON', 'PLIST', 'PCAP',                        # Format Macros
+    'LINK', 'INET', 'TRANS', 'APP', 'RAW',                  # Layer Macros
+    'DPKT', 'Scapy', 'PyShark', 'PCAPKit',                  # Engine Macros
+    'PyPCAP', 'PCAP_CT', 'PyPCAPFile',                      # Engine Macros
+
+    # pcapkit.protocols
+    'LINKTYPE', 'ETHERTYPE', 'TRANSTYPE', 'APPTYPE',        # Protocol Numbers
+    'Header', 'Frame',                                      # PCAP Headers
+    'PCAPNG',                                               # PCAPNG Format
+    'NoPayload',                                            # No Payload
+    'Raw',                                                  # Raw Packet
+    'ARP', 'C_Tag', 'Ethernet', 'InARP', 'L2TP', 'L2TPv2',
+    'Loopback', 'S_Tag', 'VLAN',                            # Link Layer
+    'AH', 'ESP', 'IP', 'IPsec', 'IPv4', 'IPv6', 'IPX',      # Internet Layer
+    'HIP', 'HOPOPT', 'IPv6_Ext', 'IPv6_Frag', 'IPv6_Opts', 'IPv6_Route', 'MH',
+                                                            # IPv6 Extension Header
+    'TCP', 'UDP', 'SCTP',                                   # Transport Layer
+    'FTP', 'FTP_DATA',                                      # Application Layer
+    'HTTP', 'HTTPv1', 'HTTPv2', 'NGAP', 'OSPF', 'RARP', 'DRARP',
+    'Schema', 'schema',                                     # Protocol Schema
+    'Data', 'data',                                         # Protocol Data
+
+    # pcapkit.toolkit
+    'ipv4_reassembly', 'ipv6_reassembly', 'tcp_reassembly', 'tcp_traceflow',
+    'pcapng_ipv4_reassembly', 'pcapng_ipv6_reassembly', 'pcapng_tcp_reassembly', 'pcapng_tcp_traceflow',
+    'pcapng_block2frame',                                   # default engine
+    'dpkt_ipv6_hdr_len', 'dpkt_packet2chain', 'dpkt_packet2dict',
+    'dpkt_ipv4_reassembly', 'dpkt_ipv6_reassembly', 'dpkt_tcp_reassembly', 'dpkt_tcp_traceflow',
+                                                            # DPKT engine
+    'pyshark_packet2dict', 'pyshark_tcp_traceflow',         # PyShark engine
+    'scapy_packet2chain', 'scapy_packet2dict',
+    'scapy_ipv4_reassembly', 'scapy_ipv6_reassembly', 'scapy_tcp_reassembly', 'scapy_tcp_traceflow',
+                                                            # Scapy engine
+
+    # pcapkit.utilities -- unlisted: its names stay reachable as attributes, but
+    # ``import *`` leaves out generic helpers such as ``warn``, ``reset``,
+    # ``configure`` and ``detect``
+]

pcapkit/const/__init__.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=unused-import, unused-wildcard-import
+"""Constant Enumerations
+===========================
+
+This module contains all constant enumerations of :mod:`pcapkit`, which are
+automatically generated from the :mod:`pcapkit.vendor` module.
+
+"""
+
+# IANA registration
+from pcapkit.const.reg import *
+
+# Miscellaneous
+from pcapkit.const.pcapng import *
+
+# per protocol
+from pcapkit.const.arp import *
+from pcapkit.const.esp import *
+from pcapkit.const.ftp import *
+from pcapkit.const.hip import *
+from pcapkit.const.http import *
+from pcapkit.const.ipv4 import *
+from pcapkit.const.ipv6 import *
+from pcapkit.const.ipx import *
+from pcapkit.const.l2tp import *
+from pcapkit.const.mh import *
+from pcapkit.const.ngap import *
+from pcapkit.const.ospf import *
+from pcapkit.const.sctp import *
+from pcapkit.const.tcp import *
+from pcapkit.const.vlan import *
+
+__all__ = [
+    # Protocol Registration
+    'ETHERTYPE', 'LINKTYPE', 'TRANSTYPE', 'APPTYPE',
+    # ARP
+    'ARP_Hardware', 'ARP_Operation',
+    # ESP
+    'ESP_Cipher', 'ESP_Integrity',
+    # FTP
+    'FTP_Command', 'FTP_ReturnCode',
+    # HIP
+    'HIP_Certificate', 'HIP_Cipher', 'HIP_DITypes', 'HIP_ECDSACurve', 'HIP_ECDSALowCurve',
+    'HIP_ESPTransformSuite', 'HIP_Group', 'HIP_HIAlgorithm', 'HIP_HITSuite', 'HIP_NATTraversal',
+    'HIP_NotifyMessage', 'HIP_Packet', 'HIP_Parameter', 'HIP_Registration', 'HIP_RegistrationFailure',
+    'HIP_Suite', 'HIP_Transport', 'HIP_EdDSACurve',
+    # HTTP
+    'HTTP_ErrorCode', 'HTTP_Frame', 'HTTP_Method', 'HTTP_Setting', 'HTTP_Status',
+    # IPv4
+    'IPv4_ClassificationLevel', 'IPv4_OptionClass', 'IPv4_OptionNumber', 'IPv4_ProtectionAuthority',
+    'IPv4_QSFunction', 'IPv4_RouterAlert', 'IPv4_ToSDelay', 'IPv4_ToSECN', 'IPv4_ToSPrecedence',
+    'IPv4_ToSReliability', 'IPv4_ToSThroughput', 'IPv4_TSFlag',
+    # IPv6
+    'IPv6_ExtensionHeader', 'IPv6_Option', 'IPv6_QSFunction', 'IPv6_RouterAlert', 'IPv6_Routing',
+    'IPv6_SeedID', 'IPv6_SMFDPDMode', 'IPv6_TaggerID', 'IPv6_OptionAction',
+    # IPX
+    'IPX_Packet', 'IPX_Socket',
+    # L2TP
+    'L2TP_Type',
+    # MH
+    'MH_Packet', 'MH_Option', 'MH_DNSStatusCode', 'MH_ACKStatusCode',
+    'MH_MNIDSubtype', 'MH_StatusCode', 'MH_EnumeratingAlgorithm',
+    'MH_AuthSubtype', 'MH_HandoffType', 'MH_AccessType',
+    'MH_BindingUpdateFlag', 'MH_BindingACKFlag', 'MH_DSMIPv6HomeAddress',
+    'MH_BindingRevocation', 'MH_RevocationTrigger', 'MH_RevocationStatusCode',
+    'MH_HomeAddressReply', 'MH_DHCPSupportMode', 'MH_HandoverInitiateFlag',
+    'MH_HandoverACKFlag', 'MH_HandoverInitiateStatus', 'MH_HandoverACKStatus',
+    'MH_FlowIDStatus', 'MH_FlowIDSuboption', 'MH_TrafficSelector',
+    'MH_MNGroupID', 'MH_DSMIP6TLSPacket', 'MH_ANISuboption', 'MH_OperatorID',
+    'MH_UpdateNotificationReason', 'MH_UpdateNotificationACKStatus',
+    'MH_FlowBindingType', 'MH_FlowBindingIndicationTrigger',
+    'MH_FlowBindingACKStatus', 'MH_FlowBindingAction', 'MH_QoSAttribute',
+    'MH_LMAControlledMAGSuboption', 'MH_LLACode', 'MH_CGAType',
+    'MH_CGAExtension', 'MH_CGASec', 'MH_BindingError',
+    # NGAP
+    'NGAP_ProcedureCode', 'NGAP_ProtocolIE',
+    # OSPF
+    'OSPF_Authentication', 'OSPF_Packet',
+    # SCTP
+    'SCTP_Chunk', 'SCTP_Parameter', 'SCTP_CauseCode', 'SCTP_PayloadProtocolIdentifier',
+    # TCP
+    'TCP_Checksum', 'TCP_Option', 'TCP_MPTCPOption', 'TCP_Flags',
+    # VLAN
+    'VLAN_PriorityLevel',
+    # PCAPNG
+    'PCAPNG_BlockType', 'PCAPNG_OptionType', 'PCAPNG_HashAlgorithm',
+    'PCAPNG_VerdictType', 'PCAPNG_RecordType', 'PCAPNG_SecretsType',
+    'PCAPNG_FilterType', 'PCAPNG_TLSKeyLabel',
+]

pcapkit/const/arp/__init__.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=unused-import
+""":class:`~pcapkit.protocols.link.arp.ARP` Constant Enumerations
+=====================================================================
+
+This module contains all constant enumerations of :class:`~pcapkit.protocols.link.arp.ARP`
+and :class:`~pcapkit.protocols.application.rarp.RARP` implementations. Available
+enumerations include:
+
+.. list-table::
+
+   * - :class:`ARP_Hardware <pcapkit.const.arp.hardware.Hardware>`
+     - ARP Hardware Types [*]_
+   * - :class:`ARP_Operation <pcapkit.const.arp.operation.Operation>`
+     - Operation Codes [*]_
+
+.. [*] https://www.iana.org/assignments/arp-parameters/arp-parameters.xhtml#arp-parameters-2
+.. [*] https://www.iana.org/assignments/arp-parameters/arp-parameters.xhtml#arp-parameters-1
+
+"""
+
+from pcapkit.const.arp.hardware import Hardware as ARP_Hardware
+from pcapkit.const.arp.operation import Operation as ARP_Operation
+
+__all__ = ['ARP_Hardware', 'ARP_Operation']