pypcapkit 1.3.3.post1__cp313-none-any.whl

pcapkit/protocols/schema/__init__.py

@@ -0,0 +1,140 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=unused-wildcard-import
+"""header schema for protocols"""
+
+# Base Class for Header Schema
+from pcapkit.protocols.schema.schema import *
+
+# Link Layer Protocols
+from pcapkit.protocols.schema.link import *
+
+# Internet Layer Protocols
+from pcapkit.protocols.schema.internet import *
+
+# Transport Layer Protocols
+from pcapkit.protocols.schema.transport import *
+
+# Application Layer Protocols
+from pcapkit.protocols.schema.application import *
+
+# Utility Classes for Protocols
+from pcapkit.protocols.schema.misc import *
+
+__all__ = [
+    # Link Layer Protocols
+    'ARP',
+    'Ethernet',
+    'L2TP',
+    'OSPF', 'OSPF_CrytographicAuthentication',
+    'VLAN', 'VLAN_TCI',
+
+    # Internet Layer Protocols
+    'AH',
+    'HIP',
+    'HIP_LocatorData', 'HIP_Locator', 'HIP_ECDSACurveHostIdentity', 'HIP_ECDSALowCurveHostIdentity',
+    'HIP_EdDSACurveHostIdentity', 'HIP_HostIdentity',
+    'HIP_UnassignedParameter', 'HIP_ESPInfoParameter', 'HIP_R1CounterParameter',
+    'HIP_LocatorSetParameter', 'HIP_PuzzleParameter', 'HIP_SolutionParameter',
+    'HIP_SEQParameter', 'HIP_ACKParameter', 'HIP_DHGroupListParameter',
+    'HIP_DiffieHellmanParameter', 'HIP_HIPTransformParameter', 'HIP_HIPCipherParameter',
+    'HIP_NATTraversalModeParameter', 'HIP_TransactionPacingParameter', 'HIP_EncryptedParameter',
+    'HIP_HostIDParameter', 'HIP_HITSuiteListParameter', 'HIP_CertParameter',
+    'HIP_NotificationParameter', 'HIP_EchoRequestSignedParameter', 'HIP_RegInfoParameter',
+    'HIP_RegRequestParameter', 'HIP_RegResponseParameter', 'HIP_RegFailedParameter',
+    'HIP_RegFromParameter', 'HIP_EchoResponseSignedParameter', 'HIP_TransportFormatListParameter',
+    'HIP_ESPTransformParameter', 'HIP_SeqDataParameter', 'HIP_AckDataParameter',
+    'HIP_PayloadMICParameter', 'HIP_TransactionIDParameter', 'HIP_OverlayIDParameter',
+    'HIP_RouteDstParameter', 'HIP_HIPTransportModeParameter', 'HIP_HIPMACParameter',
+    'HIP_HIPMAC2Parameter', 'HIP_HIPSignature2Parameter', 'HIP_HIPSignatureParameter',
+    'HIP_EchoRequestUnsignedParameter', 'HIP_EchoResponseUnsignedParameter', 'HIP_RelayFromParameter',
+    'HIP_RelayToParameter', 'HIP_RouteViaParameter', 'HIP_FromParameter',
+    'HIP_RVSHMACParameter', 'HIP_RelayHMACParameter',
+    'IPv4',
+    'IPv4_UnassignedOption', 'IPv4_EOOLOption', 'IPv4_NOPOption',
+    'IPv4_SECOption', 'IPv4_LSROption', 'IPv4_TSOption',
+    'IPv4_ESECOption', 'IPv4_RROption', 'IPv4_SIDOption',
+    'IPv4_SSROption', 'IPv4_MTUPOption', 'IPv4_MTUROption',
+    'IPv4_TROption', 'IPv4_RTRALTOption', 'IPv4_QSOption',
+    'IPv4_QuickStartRequestOption', 'IPv4_QuickStartReportOption',
+    'IPv6_Frag',
+    'IPv6_Opts',
+    'IPv6_Opts_UnassignedOption', 'IPv6_Opts_PadOption', 'IPv6_Opts_TunnelEncapsulationLimitOption',
+    'IPv6_Opts_RouterAlertOption', 'IPv6_Opts_CALIPSOOption', 'IPv6_Opts_SMFIdentificationBasedDPDOption',
+    'IPv6_Opts_SMFHashBasedDPDOption', 'IPv6_Opts_PDMOption', 'IPv6_Opts_QuickStartRequestOption',
+    'IPv6_Opts_QuickStartReportOption', 'IPv6_Opts_RPLOption', 'IPv6_Opts_MPLOption', 'IPv6_Opts_ILNPOption',
+    'IPv6_Opts_LineIdentificationOption', 'IPv6_Opts_JumboPayloadOption', 'IPv6_Opts_HomeAddressOption',
+    'IPv6_Opts_IPDFFOption',
+    'IPv6_Route',
+    'IPv6_Route_UnknownType', 'IPv6_Route_SourceRoute', 'IPv6_Route_Type2', 'IPv6_Route_RPL',
+    'IPv6',
+    'IPX',
+    'MH',
+    'MH_Packet',
+    'MH_UnknownMessage', 'MH_BindingRefreshRequestMessage', 'MH_HomeTestInitMessage', 'MH_CareofTestInitMessage',
+    'MH_HomeTestMessage', 'MH_CareofTestMessage', 'MH_BindingUpdateMessage', 'MH_BindingAcknowledgementMessage',
+    'MH_BindingErrorMessage',
+    'MH_Option',
+    'MH_UnassignedOption', 'MH_PadOption', 'MH_BindingRefreshAdviceOption', 'MH_AlternateCareofAddressOption',
+    'MH_NonceIndicesOption', 'MH_AuthorizationDataOption', 'MH_MobileNetworkPrefixOption',
+    'MH_LinkLayerAddressOption', 'MH_MNIDOption', 'MH_AuthOption', 'MH_MesgIDOption', 'MH_CGAParametersRequestOption',
+    'MH_CGAParametersOption', 'MH_SignatureOption', 'MH_PermanentHomeKeygenTokenOption', 'MH_CareofTestInitOption',
+    'MH_CareofTestOption',
+    'MH_CGAParameter',
+    'MH_CGAExtension',
+    'MH_UnknownExtension', 'MH_MultiPrefixExtension',
+
+    # Transport Layer Protocols
+    'TCP',
+    'TCP_SACKBlock',
+    'TCP_Option',
+    'TCP_UnassignedOption', 'TCP_EndOfOptionList', 'TCP_NoOperation', 'TCP_MaximumSegmentSize', 'TCP_WindowScale',
+    'TCP_SACKPermitted', 'TCP_SACK', 'TCP_Echo', 'TCP_EchoReply', 'TCP_Timestamps', 'TCP_PartialOrderConnectionPermitted',  # pylint: disable=line-too-long
+    'TCP_PartialOrderServiceProfile', 'TCP_CC', 'TCP_CCNew', 'TCP_CCEcho', 'TCP_AlternateChecksumRequest',
+    'TCP_AlternateChecksumData', 'TCP_MD5Signature', 'TCP_QuickStartResponse', 'TCP_UserTimeout',
+    'TCP_Authentication', 'TCP_FastOpenCookie',
+    'TCP_MPTCP',
+    'TCP_MPTCPUnknown', 'TCP_MPTCPCapable', 'TCP_MPTCPDSS', 'TCP_MPTCPAddAddress', 'TCP_MPTCPRemoveAddress',
+    'TCP_MPTCPPriority', 'TCP_MPTCPFallback', 'TCP_MPTCPFastclose',
+    'TCP_MPTCPJoin',
+    'TCP_MPTCPJoinSYN', 'TCP_MPTCPJoinSYNACK', 'TCP_MPTCPJoinACK',
+    'UDP',
+
+    # Application Layer Protocols
+    'FTP',
+    'HTTPv1',
+    'HTTPv2',
+    'HTTPv2_FrameType',
+    'HTTPv2_UnassignedFrame', 'HTTPv2_DataFrame', 'HTTPv2_HeadersFrame', 'HTTPv2_PriorityFrame',
+    'HTTPv2_RSTStreamFrame', 'HTTPv2_SettingsFrame', 'HTTPv2_PushPromiseFrame', 'HTTPv2_PingFrame',
+    'HTTPv2_GoawayFrame', 'HTTPv2_WindowUpdateFrame', 'HTTPv2_ContinuationFrame',
+
+    # PCAP file format
+    'Header',
+    'Frame',
+
+    # PCAP-NG file format
+    'PCAPNG',
+    'PCAPNG_Option', 'PCAPNG_UnknownOption',
+    'PCAPNG_EndOfOption', 'PCAPNG_CommentOption', 'PCAPNG_CustomOption',
+    'PCAPNG_IF_NameOption', 'PCAPNG_IF_DescriptionOption', 'PCAPNG_IF_IPv4AddrOption', 'PCAPNG_IF_IPv6AddrOption',
+    'PCAPNG_IF_MACAddrOption', 'PCAPNG_IF_EUIAddrOption', 'PCAPNG_IF_SpeedOption', 'PCAPNG_IF_TSResolOption',
+    'PCAPNG_IF_TZoneOption', 'PCAPNG_IF_FilterOption', 'PCAPNG_IF_OSOption', 'PCAPNG_IF_FCSLenOption',
+    'PCAPNG_IF_TSOffsetOption', 'PCAPNG_IF_HardwareOption', 'PCAPNG_IF_TxSpeedOption', 'PCAPNG_IF_RxSpeedOption',
+    'PCAPNG_EPB_FlagsOption', 'PCAPNG_EPB_HashOption', 'PCAPNG_EPB_DropCountOption', 'PCAPNG_EPB_PacketIDOption',
+    'PCAPNG_EPB_QueueOption', 'PCAPNG_EPB_VerdictOption',
+    'PCAPNG_NS_DNSNameOption', 'PCAPNG_NS_DNSIP4AddrOption', 'PCAPNG_NS_DNSIP6AddrOption',
+    'PCAPNG_ISB_StartTimeOption', 'PCAPNG_ISB_EndTimeOption', 'PCAPNG_ISB_IFRecvOption', 'PCAPNG_ISB_IFDropOption',
+    'PCAPNG_ISB_FilterAcceptOption', 'PCAPNG_ISB_OSDropOption', 'PCAPNG_ISB_UsrDelivOption',
+    'PCAPNG_NameResolutionRecord', 'PCAPNG_UnknownRecord', 'PCAPNG_EndRecord', 'PCAPNG_IPv4Record', 'PCAPNG_IPv6Record',
+    'PCAPNG_DSBSecrets', 'PCAPNG_UnknownSecrets', 'PCAPNG_TLSKeyLog', 'PCAPNG_WireGuardKeyLog', 'PCAPNG_ZigBeeNWKKey',
+    'PCAPNG_ZigBeeAPSKey',
+    'PCAPNG_BlockType',
+    'PCAPNG_UnknownBlock', 'PCAPNG_SectionHeaderBlock', 'PCAPNG_InterfaceDescriptionBlock',
+    'PCAPNG_EnhancedPacketBlock', 'PCAPNG_SimplePacketBlock', 'PCAPNG_NameResolutionBlock',
+    'PCAPNG_InterfaceStatisticsBlock', 'PCAPNG_SystemdJournalExportBlock', 'PCAPNG_DecryptionSecretsBlock',
+    'PCAPNG_CustomBlock',
+
+    # misc protocols
+    'NoPayload',
+    'Raw',
+]

pcapkit/protocols/schema/application/__init__.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+"""header schema for application layer protocols"""
+
+# File Transfer Protocol
+from pcapkit.protocols.schema.application.ftp import FTP
+
+# Hypertext Transfer Protocol (HTTP/1.*)
+from pcapkit.protocols.schema.application.httpv1 import HTTP as HTTPv1
+
+# Hypertext Transfer Protocol (HTTP/2)
+from pcapkit.protocols.schema.application.httpv2 import HTTP as HTTPv2
+from pcapkit.protocols.schema.application.httpv2 import \
+    ContinuationFrame as HTTPv2_ContinuationFrame
+from pcapkit.protocols.schema.application.httpv2 import DataFrame as HTTPv2_DataFrame
+from pcapkit.protocols.schema.application.httpv2 import FrameType as HTTPv2_FrameType
+from pcapkit.protocols.schema.application.httpv2 import GoawayFrame as HTTPv2_GoawayFrame
+from pcapkit.protocols.schema.application.httpv2 import HeadersFrame as HTTPv2_HeadersFrame
+from pcapkit.protocols.schema.application.httpv2 import PingFrame as HTTPv2_PingFrame
+from pcapkit.protocols.schema.application.httpv2 import PriorityFrame as HTTPv2_PriorityFrame
+from pcapkit.protocols.schema.application.httpv2 import PushPromiseFrame as HTTPv2_PushPromiseFrame
+from pcapkit.protocols.schema.application.httpv2 import RSTStreamFrame as HTTPv2_RSTStreamFrame
+from pcapkit.protocols.schema.application.httpv2 import SettingsFrame as HTTPv2_SettingsFrame
+from pcapkit.protocols.schema.application.httpv2 import UnassignedFrame as HTTPv2_UnassignedFrame
+from pcapkit.protocols.schema.application.httpv2 import \
+    WindowUpdateFrame as HTTPv2_WindowUpdateFrame
+
+__all__ = [
+    # File Transfer Protocol
+    'FTP',
+
+    # Hypertext Transfer Protocol (HTTP/1.*)
+    'HTTPv1',
+
+    # Hypertext Transfer Protocol (HTTP/2)
+    'HTTPv2',
+    'HTTPv2_FrameType',
+    'HTTPv2_UnassignedFrame', 'HTTPv2_DataFrame', 'HTTPv2_HeadersFrame', 'HTTPv2_PriorityFrame',
+    'HTTPv2_RSTStreamFrame', 'HTTPv2_SettingsFrame', 'HTTPv2_PushPromiseFrame', 'HTTPv2_PingFrame',
+    'HTTPv2_GoawayFrame', 'HTTPv2_WindowUpdateFrame', 'HTTPv2_ContinuationFrame',
+]

pcapkit/protocols/schema/application/ftp.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+# mypy: disable-error-code=assignment
+"""header schema for file transfer protocol"""
+
+from typing import TYPE_CHECKING
+
+from pcapkit.corekit.fields.strings import BytesField
+from pcapkit.protocols.schema.schema import Schema, schema_final
+
+__all__ = ['FTP']
+
+
+@schema_final
+class FTP(Schema):
+    """Header schema for FTP packet."""
+
+    #: Packet data.
+    data: 'bytes' = BytesField(lambda pkt: pkt['__length__'])
+
+    if TYPE_CHECKING:
+        def __init__(self, data: 'bytes') -> 'None': ...

pcapkit/protocols/schema/application/httpv1.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+# mypy: disable-error-code=assignment
+"""header schema for HTTP/1.* protocol"""
+
+from typing import TYPE_CHECKING
+
+from pcapkit.corekit.fields.strings import BytesField
+from pcapkit.protocols.schema.schema import Schema, schema_final
+
+__all__ = ['HTTP']
+
+
+@schema_final
+class HTTP(Schema):
+    r"""Header schema for HTTP/1.\* packet."""
+
+    #: Packet data.
+    data: 'bytes' = BytesField(lambda pkt: pkt['__length__'])
+
+    if TYPE_CHECKING:
+        def __init__(self, data: 'bytes') -> 'None': ...

pcapkit/protocols/schema/application/httpv2.py

@@ -0,0 +1,384 @@
+# -*- coding: utf-8 -*-
+# mypy: disable-error-code=assignment
+"""header schema for HTTP/2 protocol"""
+
+import collections
+import enum
+from typing import TYPE_CHECKING, cast
+
+from pcapkit.const.http.error_code import ErrorCode as Enum_ErrorCode
+from pcapkit.const.http.frame import Frame as Enum_Frame
+from pcapkit.const.http.setting import Setting as Enum_Setting
+from pcapkit.corekit.fields.collections import ListField
+from pcapkit.corekit.fields.misc import ConditionalField, SchemaField, SwitchField
+from pcapkit.corekit.fields.numbers import EnumField, NumberField, UInt8Field, UInt32Field
+from pcapkit.corekit.fields.strings import BitField, BytesField, PaddingField
+from pcapkit.protocols.schema.schema import EnumSchema, Schema, schema_final
+from pcapkit.utilities.logging import SPHINX_TYPE_CHECKING
+
+__all__ = [
+    'HTTP',
+
+    'FrameType',
+    'UnassignedFrame', 'DataFrame', 'HeadersFrame', 'PriorityFrame',
+    'RSTStreamFrame', 'SettingsFrame', 'PushPromiseFrame', 'PingFrame',
+    'GoawayFrame', 'WindowUpdateFrame', 'ContinuationFrame',
+]
+
+if TYPE_CHECKING:
+    from typing import Any, Optional
+
+    from pcapkit.corekit.fields.field import FieldBase as Field
+
+if SPHINX_TYPE_CHECKING:
+    from typing_extensions import TypedDict
+
+    class FrameFlags(TypedDict):
+        """HTTP frame specific flags."""
+
+        bit_7: int
+        bit_6: int
+        bit_5: int
+        bit_4: int
+        bit_3: int
+        bit_2: int
+        bit_1: int
+        bit_0: int
+
+    class StreamID(TypedDict):
+        """Stream identifier."""
+
+        #: Steam identifier.
+        sid: int
+
+    class StreamDependency(TypedDict):
+        """Stream dependency."""
+
+        #: Exclusive flag.
+        exclusive: int
+        #: Stream dependency identifier.
+        sid: int
+
+    class WindowSize(TypedDict):
+        """Window size increment."""
+
+        #: Window size increment.
+        incr: int
+
+
+def http_frame_selector(pkt: 'dict[str, Any]') -> 'Field':
+    """Selector function for :attr:`HTTP.frame` field.
+
+    Args:
+        pkt: Packet data.
+
+    Returns:
+        Returns a :class:`~pcapkit.corekit.fields.misc.SchemaField` wrapped
+        :class:`~pcapkit.protocols.schema.application.httpv2.FrameType`
+        instance.
+
+    """
+    type = cast('Enum_Frame', pkt['type'])
+    schema = FrameType.registry[type]
+    return SchemaField(length=pkt['__length__'], schema=schema)
+
+
+@schema_final
+class HTTP(Schema):
+    """Header schema for HTTP/2 packet."""
+
+    #: Length.
+    length: 'int' = NumberField(length=3, signed=False)
+    #: Frame type.
+    type: 'Enum_Frame' = EnumField(length=1, namespace=Enum_Frame)
+    #: Frame specific flags.
+    flags: 'FrameFlags' = BitField(length=1, namespace={
+        'bit_7': (0, 1),
+        'bit_6': (1, 1),
+        'bit_5': (2, 1),
+        'bit_4': (3, 1),
+        'bit_3': (4, 1),
+        'bit_2': (5, 1),
+        'bit_1': (6, 1),
+        'bit_0': (7, 1),
+    })
+    #: Stream identifier.
+    stream: 'StreamID' = BitField(length=4, namespace={
+        'sid': (1, 31),
+    })
+    #: Frame payload.
+    frame: 'FrameType' = SwitchField(
+        selector=http_frame_selector,
+    )
+
+    if TYPE_CHECKING:
+        def __init__(self, length: 'int', type: 'Enum_Frame', flags: 'FrameFlags', stream: 'StreamID', frame: 'FrameType | bytes') -> 'None': ...
+
+
+class FrameType(EnumSchema[Enum_Frame]):
+    """Header schema for HTTP/2 frame payload."""
+
+    if TYPE_CHECKING:
+        __flags__: 'Flags'
+
+    __enum__ = collections.defaultdict(lambda: UnassignedFrame)
+
+    class Flags(enum.IntFlag):
+        """Flags enumeration for HTTP/2 frames."""
+
+    def post_process(self, packet: 'dict[str, Any]') -> 'Schema':
+        """Revise ``schema`` data after unpacking process.
+
+        Args:
+            schema: parsed schema
+            packet: Unpacked data.
+
+        Returns:
+            Revised schema.
+
+        """
+        flags = 0
+        for key, val in filter(lambda kv: kv[0].startswith('BIT_'),
+                               self.Flags.__members__.items()):
+            name = key.lower()
+            if packet['flags'][name]:
+                flags |= val
+
+        self.__flags__ = flags
+        return self
+
+
+@schema_final
+class UnassignedFrame(FrameType):
+    """Header schema for unassigned HTTP/2 frame payload."""
+
+    #: Frame payload.
+    data: 'bytes' = BytesField(length=lambda pkt: pkt['__length__'])
+
+    if TYPE_CHECKING:
+        def __init__(self, data: 'bytes') -> 'None': ...
+
+
+@schema_final
+class DataFrame(FrameType, code=Enum_Frame.DATA):
+    """Header schema for HTTP/2 ``DATA`` frames."""
+
+    class Flags(FrameType.Flags):
+        """Flags enumeration for HTTP/2 ``DATA`` frames."""
+
+        END_STREAM = BIT_0 = 0x1
+        PADDED     = BIT_3 = 0x8
+
+    #: Padding length.
+    pad_len: 'int' = ConditionalField(
+        UInt8Field(),
+        lambda pkt: pkt['flags']['bit_3'],  # PADDED
+    )
+    #: Data.
+    data: 'bytes' = BytesField(length=lambda pkt: pkt['__length__'] - pkt['pad_len'] if pkt['flags']['bit_3'] else 0)
+    #: Padding.
+    padding: 'bytes' = ConditionalField(
+        PaddingField(length=lambda pkt: pkt['pad_len']),
+        lambda pkt: pkt['flags']['bit_3'],  # PADDED
+    )
+
+    if TYPE_CHECKING:
+        def __init__(self, pad_len: 'Optional[int]', data: 'bytes') -> 'None': ...
+
+
+@schema_final
+class HeadersFrame(FrameType, code=Enum_Frame.HEADERS):
+    """Header schema for HTTP/2 ``HEADERS`` frames."""
+
+    class Flags(FrameType.Flags):
+        """Flags enumeration for HTTP/2 ``DATA`` frames."""
+
+        END_STREAM  = BIT_0 = 0x1
+        END_HEADERS = BIT_2 = 0x4
+        PADDED      = BIT_3 = 0x8
+        PRIORITY    = BIT_5 = 0x20
+
+    #: Padding length.
+    pad_len: 'int' = ConditionalField(
+        UInt8Field(),
+        lambda pkt: pkt['flags']['bit_3'],  # PADDED
+    )
+    #: Stream dependency.
+    stream_dep: 'StreamDependency' = ConditionalField(
+        BitField(length=4, namespace={
+            'exclusive': (0, 1),
+            'sid': (1, 31),
+        }),
+        lambda pkt: pkt['flags']['bit_5'],  # PRIORITY
+    )
+    #: Weight.
+    weight: 'int' = ConditionalField(
+        UInt8Field(),
+        lambda pkt: pkt['flags']['bit_5'],  # PRIORITY
+    )
+    #: Header block fragment.
+    fragment: 'bytes' = BytesField(length=lambda pkt: (
+        pkt['__length__'] - pkt['pad_len'] if pkt['flags']['bit_3'] else 0
+    ))
+    #: Padding.
+    padding: 'bytes' = ConditionalField(
+        PaddingField(length=lambda pkt: pkt['pad_len']),
+        lambda pkt: pkt['flags']['bit_3'],  # PADDED
+    )
+
+    if TYPE_CHECKING:
+        def __init__(self, pad_len: 'Optional[int]', stream_dep: 'Optional[StreamDependency]', weight: 'Optional[int]', fragment: 'bytes') -> 'None': ...
+
+
+@schema_final
+class PriorityFrame(FrameType, code=Enum_Frame.PRIORITY):
+    """Header schema for HTTP/2 ``PRIORITY`` frames."""
+
+    #: Stream dependency (exclusive, stream ID).
+    stream: 'StreamDependency' = BitField(length=4, namespace={
+        'exclusive': (0, 1),
+        'sid': (1, 31),
+    })
+    #: Weight.
+    weight: 'int' = UInt8Field()
+
+    if TYPE_CHECKING:
+        def __init__(self, stream: 'StreamDependency', weight: 'int') -> 'None': ...
+
+
+@schema_final
+class RSTStreamFrame(FrameType, code=Enum_Frame.RST_STREAM):
+    """Header schema for HTTP/2 ``RST_STREAM`` frames."""
+
+    #: Error code.
+    error: 'Enum_ErrorCode' = EnumField(length=4, namespace=Enum_ErrorCode)
+
+    if TYPE_CHECKING:
+        def __init__(self, error: 'Enum_ErrorCode') -> 'None': ...
+
+
+@schema_final
+class SettingPair(Schema):
+    """Header schema for HTTP/2 ``SETTINGS`` frame setting pairs."""
+
+    #: Identifier.
+    id: 'Enum_Setting' = EnumField(length=2, namespace=Enum_Setting)
+    #: Value.
+    value: 'int' = UInt32Field()
+
+    if TYPE_CHECKING:
+        def __init__(self, id: 'Enum_Setting', value: 'int') -> 'None': ...
+
+
+@schema_final
+class SettingsFrame(FrameType, code=Enum_Frame.SETTINGS):
+    """Header schema for HTTP/2 ``SETTINGS`` frames."""
+
+    class Flags(FrameType.Flags):
+        """Flags enumeration for HTTP/2 ``SETTINGS`` frames."""
+
+        ACK = BIT_0 = 0x1
+
+    #: Settings.
+    settings: 'list[SettingPair]' = ListField(
+        length=lambda pkt: pkt['__length__'],
+        item_type=SettingPair,  # type: ignore[arg-type]
+    )
+
+    if TYPE_CHECKING:
+        def __init__(self, settings: 'list[SettingPair] | bytes') -> 'None': ...
+
+
+@schema_final
+class PushPromiseFrame(FrameType, code=Enum_Frame.PUSH_PROMISE):
+    """Header schema for HTTP/2 ``PUSH_PROMISE`` frames."""
+
+    class Flags(FrameType.Flags):
+        """Flags enumeration for HTTP/2 ``PUSH_PROMISE`` frames."""
+
+        END_HEADERS = BIT_2 = 0x4
+        PADDED      = BIT_3 = 0x8
+
+    #: Padding length.
+    pad_len: 'int' = ConditionalField(
+        UInt8Field(),
+        lambda pkt: pkt['flags']['bit_3'],  # PADDED
+    )
+    #: Promised stream ID.
+    stream: 'StreamID' = BitField(length=4, namespace={
+        'sid': (1, 31),
+    })
+    #: Header block fragment.
+    fragment: 'bytes' = BytesField(length=lambda pkt: (
+        pkt['__length__'] - pkt['pad_len'] if pkt['flags']['bit_3'] else 0
+    ))
+    #: Padding.
+    padding: 'bytes' = ConditionalField(
+        PaddingField(length=lambda pkt: pkt['pad_len']),
+        lambda pkt: pkt['flags']['bit_3'],  # PADDED
+    )
+
+    if TYPE_CHECKING:
+        def __init__(self, pad_len: 'Optional[int]', stream: 'StreamID', fragment: 'bytes') -> 'None': ...
+
+
+@schema_final
+class PingFrame(FrameType, code=Enum_Frame.PING):
+    """Header schema for HTTP/2 ``PING`` frames."""
+
+    class Flags(FrameType.Flags):
+        """Flags enumeration for HTTP/2 ``PING`` frames."""
+
+        ACK = BIT_0 = 0x1
+
+    #: Opaque data.
+    data: 'bytes' = BytesField(length=8)
+
+    if TYPE_CHECKING:
+        def __init__(self, data: 'bytes') -> 'None': ...
+
+
+@schema_final
+class GoawayFrame(FrameType, code=Enum_Frame.GOAWAY):
+    """Header schema for HTTP/2 ``GOAWAY`` frames."""
+
+    #: Last stream ID.
+    stream: 'StreamID' = BitField(length=4, namespace={
+        'sid': (1, 31),
+    })
+    #: Error code.
+    error: 'Enum_ErrorCode' = EnumField(length=4, namespace=Enum_ErrorCode)
+    #: Additional debug data.
+    debug: 'bytes' = BytesField(length=lambda pkt: pkt['__length__'])
+
+    if TYPE_CHECKING:
+        def __init__(self, stream: 'StreamID', error: 'Enum_ErrorCode', debug: 'bytes') -> 'None': ...
+
+
+@schema_final
+class WindowUpdateFrame(FrameType, code=Enum_Frame.WINDOW_UPDATE):
+    """Header schema for HTTP/2 ``WINDOW_UPDATE`` frames."""
+
+    #: Window size increment.
+    size: 'WindowSize' = BitField(length=4, namespace={
+        'incr': (1, 31),
+    })
+
+    if TYPE_CHECKING:
+        def __init__(self, size: 'WindowSize') -> 'None': ...
+
+
+@schema_final
+class ContinuationFrame(FrameType, code=Enum_Frame.CONTINUATION):
+    """Header schema for HTTP/2 ``CONTINUATION`` frames."""
+
+    class Flags(FrameType.Flags):
+        """Flags enumeration for HTTP/2 ``CONTINUATION`` frames."""
+
+        END_HEADERS = BIT_2 = 0x4
+
+    #: Header block fragment.
+    fragment: 'bytes' = BytesField(length=lambda pkt: pkt['__length__'])
+
+    if TYPE_CHECKING:
+        def __init__(self, fragment: 'bytes') -> 'None': ...