pypcapkit 1.3.5.post6__pp310-none-any.whl

pcapkit/foundation/reassembly/__init__.py

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=unused-import
+"""Fragmented Packets Reassembly
+===================================
+
+.. module:: pcapkit.foundation.reassembly
+
+:mod:`pcapkit.foundation.reassembly` bases on algorithms described
+in :rfc:`791` and :rfc:`815`, implements datagram reassembly
+of IP and TCP packets.
+
+"""
+# Base Class for Reassembly
+from pcapkit.foundation.reassembly.reassembly import Reassembly
+from pcapkit.foundation.reassembly.ip import IP as IP_Reassembly
+
+# Reassembly for IP
+from pcapkit.foundation.reassembly.ipv4 import IPv4 as IPv4_Reassembly
+from pcapkit.foundation.reassembly.ipv6 import IPv6 as IPv6_Reassembly
+
+# Reassembly for TCP
+from pcapkit.foundation.reassembly.tcp import TCP as TCP_Reassembly
+
+__all__ = [
+    'IPv4_Reassembly', 'IPv6_Reassembly',   # IP Reassembly
+    'TCP_Reassembly',                       # TCP Reassembly
+]
+
+from typing import TYPE_CHECKING
+
+from pcapkit.corekit.infoclass import Info, info_final
+
+if TYPE_CHECKING:
+    from typing import Optional
+
+
+@info_final
+class ReassemblyManager(Info):
+    """Reassembly Manager."""
+
+    #: IPv4 reassembly.
+    ipv4: 'IPv4_Reassembly'
+    #: IPv6 reassembly.
+    ipv6: 'IPv6_Reassembly'
+    #: TCP reassembly.
+    tcp: 'TCP_Reassembly'
+
+    if TYPE_CHECKING:
+        def __init__(self, ipv4: 'Optional[IPv4_Reassembly]', ipv6: 'Optional[IPv6_Reassembly]', tcp: 'Optional[TCP_Reassembly]') -> 'None': ...  # pylint: disable=unused-argument,super-init-not-called,multiple-statements,line-too-long

pcapkit/foundation/reassembly/data/__init__.py

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+"""data models for reassembly"""
+
+# IP reassembly
+from pcapkit.foundation.reassembly.data.ip import Buffer as IP_Buffer
+from pcapkit.foundation.reassembly.data.ip import BufferID as IP_BufferID
+from pcapkit.foundation.reassembly.data.ip import Datagram as IP_Datagram
+from pcapkit.foundation.reassembly.data.ip import DatagramID as IP_DatagramID
+from pcapkit.foundation.reassembly.data.ip import Packet as IP_Packet
+
+# TCP reassembly
+from pcapkit.foundation.reassembly.data.tcp import Buffer as TCP_Buffer
+from pcapkit.foundation.reassembly.data.tcp import BufferID as TCP_BufferID
+from pcapkit.foundation.reassembly.data.tcp import Datagram as TCP_Datagram
+from pcapkit.foundation.reassembly.data.tcp import DatagramID as TCP_DatagramID
+from pcapkit.foundation.reassembly.data.tcp import Fragment as TCP_Fragment
+from pcapkit.foundation.reassembly.data.tcp import HoleDiscriptor as TCP_HoleDiscriptor
+from pcapkit.foundation.reassembly.data.tcp import Packet as TCP_Packet
+
+__all__ = [
+    'IP_Packet', 'IP_DatagramID', 'IP_Datagram', 'IP_Buffer',
+    'IP_BufferID',
+
+    'TCP_Packet', 'TCP_DatagramID', 'TCP_Datagram', 'TCP_Buffer',
+    'TCP_Fragment', 'TCP_HoleDiscriptor', 'TCP_BufferID',
+]
+
+from typing import TYPE_CHECKING
+
+from pcapkit.corekit.infoclass import Info, info_final
+
+if TYPE_CHECKING:
+    from typing import Optional
+
+
+@info_final
+class ReassemblyData(Info):
+    """Data storage for reassembly."""
+
+    #: IPv4 reassembled data.
+    ipv4: 'tuple[IP_Datagram, ...]'
+    #: IPv6 reassembled data.
+    ipv6: 'tuple[IP_Datagram, ...]'
+    #: TCP reassembled data.
+    tcp: 'tuple[TCP_Datagram, ...]'
+
+    if TYPE_CHECKING:
+        def __init__(self, ipv4: 'Optional[tuple[IP_Datagram, ...]]', ipv6: 'Optional[tuple[IP_Datagram, ...]]', tcp: 'Optional[tuple[TCP_Datagram, ...]]') -> 'None': ...  # pylint: disable=unused-argument,super-init-not-called,multiple-statements,line-too-long

pcapkit/foundation/reassembly/data/ip.py

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+"""data models for IP reassembly"""
+
+from typing import TYPE_CHECKING, Generic, TypeVar
+
+from pcapkit.corekit.infoclass import Info, info_final
+from pcapkit.utilities.compat import Tuple
+
+__all__ = [
+    'Packet', 'DatagramID', 'Datagram', 'Buffer', 'BufferID',
+]
+
+if TYPE_CHECKING:
+    from ipaddress import IPv4Address, IPv6Address
+    from typing import Optional, overload
+
+    from typing_extensions import Literal, TypeAlias
+
+    from pcapkit.const.reg.transtype import TransType
+    from pcapkit.protocols.protocol import ProtocolBase as Protocol
+
+_AT = TypeVar('_AT', 'IPv4Address', 'IPv6Address')
+
+#: Buffer ID.
+BufferID: 'TypeAlias' = Tuple[_AT, _AT, int, 'TransType']
+
+
+@info_final
+class Packet(Info, Generic[_AT]):
+    """Data model for :term:`IPv4 <reasm.ipv4.packet>` and/or
+    :term:`IPv6 <reasm.ipv6.packet>` packet representation.."""
+
+    #: Buffer ID.
+    bufid: 'BufferID'
+    #: Original packet range number.
+    num: 'int'
+    #: Fragment offset.
+    fo: 'int'
+    #: Internet header length.
+    ihl: 'int'
+    #: More fragments flag.
+    mf: 'bool'
+    #: Total length, header included.
+    tl: 'int'
+    #: Raw :obj:`bytes` type header.
+    header: 'bytes'
+    #: Raw :obj:`bytearray` type payload.
+    payload: 'bytearray'
+
+    if TYPE_CHECKING:
+        def __init__(self, bufid: 'tuple[_AT, _AT, int, TransType]', num: 'int', fo: 'int', ihl: 'int', mf: 'bool', tl: 'int', header: 'bytes', payload: 'bytearray') -> 'None': ...  # pylint: disable=unused-argument,super-init-not-called,multiple-statements,line-too-long,redefined-builtin
+
+
+@info_final
+class DatagramID(Info, Generic[_AT]):
+    """Data model for :term:`IPv4 <reasm.ipv4.datagram>` and/or
+    :term:`IPv6 <reasm.ipv6.datagram>` original packet identifier."""
+
+    #: Source address.
+    src: '_AT'
+    #: Destination address.
+    dst: '_AT'
+    #: IP protocol identifier.
+    id: 'int'
+    #: Payload protocol type.
+    proto: 'TransType'
+
+    if TYPE_CHECKING:
+        def __init__(self, src: '_AT', dst: '_AT', id: 'int', proto: 'TransType') -> 'None': ...  # pylint: disable=unused-argument,super-init-not-called,multiple-statements,line-too-long,redefined-builtin
+
+
+@info_final
+class Datagram(Info, Generic[_AT]):
+    """Data model for :term:`IPv4 <reasm.ipv4.datagram>` and/or
+    :term:`IPv6 <reasm.ipv6.datagram>` reassembled datagram."""
+
+    #: Completed flag.
+    completed: 'bool'
+    #: Original packet identifier.
+    id: 'DatagramID[_AT]'
+    #: Packet numbers.
+    index: 'tuple[int, ...]'
+    #: Initial IP header.
+    header: 'bytes'
+    #: Reassembled IP payload.
+    payload: 'bytes | tuple[bytes, ...]'
+    #: Parsed IP payload.
+    packet: 'Optional[Protocol]'
+
+    if TYPE_CHECKING:
+        @overload  #pylint: disable=used-before-assignment
+        def __init__(self, completed: 'Literal[True]', id: 'DatagramID[_AT]', index: 'tuple[int, ...]', header: 'bytes', payload: 'bytes', packet: 'Protocol') -> 'None': ...  # pylint: disable=unused-argument,super-init-not-called,multiple-statements,line-too-long,redefined-builtin
+
+        @overload
+        def __init__(self, completed: 'Literal[False]', id: 'DatagramID[_AT]', index: 'tuple[int, ...]', header: 'bytes', payload: 'tuple[bytes, ...]', packet: 'None') -> 'None': ...  # pylint: disable=unused-argument,super-init-not-called,multiple-statements,line-too-long,redefined-builtin
+
+        def __init__(self, completed: 'bool', id: 'DatagramID[_AT]', index: 'tuple[int, ...]', header: 'bytes', payload: 'bytes | tuple[bytes, ...]', packet: 'Optional[Protocol]') -> 'None': ...  # pylint: disable=unused-argument,super-init-not-called,multiple-statements,line-too-long,redefined-builtin
+
+
+@info_final
+class Buffer(Info, Generic[_AT]):
+    """Data model for :term:`IPv4 <reasm.ipv4.buffer>` and/or
+    :term:`IPv6 <reasm.ipv6.buffer>` reassembly buffer entry."""
+
+    #: Total data length.
+    TDL: 'int'
+    #: Fragment received bit table.
+    RCVBT: 'bytearray'
+    #: List of reassembled packets.
+    index: 'list[int]'
+    #: Header buffer.
+    header: 'bytes'
+    #: Data buffer, holes set to ``b'\x00'``.
+    datagram: 'bytearray'
+
+    if TYPE_CHECKING:
+        def __init__(self, TDL: 'int', RCVBT: 'bytearray', index: 'list[int]', header: 'bytes', datagram: 'bytearray') -> 'None': ...  # pylint: disable=unused-argument,super-init-not-called,multiple-statements,line-too-long,redefined-builtin

pcapkit/foundation/reassembly/data/tcp.py

@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*-
+"""data models for TCP reassembly"""
+
+from typing import TYPE_CHECKING, Generic, TypeVar
+
+from pcapkit.corekit.infoclass import Info, info_final
+from pcapkit.utilities.compat import Tuple
+
+__all__ = [
+    'Packet', 'DatagramID', 'Datagram', 'HoleDiscriptor',
+    'Fragment', 'Buffer', 'BufferID',
+]
+
+if TYPE_CHECKING:
+    from ipaddress import IPv4Address, IPv6Address
+    from typing import Optional, overload
+
+    from typing_extensions import Literal, TypeAlias
+
+    from pcapkit.protocols.protocol import ProtocolBase as Protocol
+
+_AT = TypeVar('_AT', 'IPv4Address', 'IPv6Address')
+
+#: Buffer ID.
+BufferID: 'TypeAlias' = Tuple[_AT, int, _AT, int]
+
+
+@info_final
+class Packet(Info):
+    """Data model for :term:`TCP <reasm.tcp.packet>` packet representation."""
+
+    #: Buffer ID.
+    bufid: 'BufferID'
+    #: Data sequence number.
+    dsn: 'int'
+    #: Acknowledgment number.
+    ack: 'int'
+    #: Original packet range number.
+    num: 'int'
+    #: Synchronise flag.
+    syn: 'bool'
+    #: Finish flag.
+    fin: 'bool'
+    #: Reset connection flag.
+    rst: 'bool'
+    #: Payload length, header excluded.
+    len: 'int'
+    #: This sequence number.
+    first: 'int'
+    #: Next (wanted) sequence number.
+    last: 'int'
+    #: Raw :obj:`bytes` type header.
+    header: 'bytes'
+    #: Raw :obj:`bytearray` type payload.
+    payload: 'bytearray'
+
+    if TYPE_CHECKING:
+        def __init__(self, bufid: 'BufferID', dsn: 'int', ack: 'int', num: 'int', syn: 'bool', fin: 'bool', rst: 'bool', len: 'int', first: 'int', last: 'int', header: 'bytes', payload: 'bytearray') -> 'None': ...  # pylint: disable=unused-argument,super-init-not-called,multiple-statements,line-too-long,redefined-builtin
+
+
+@info_final
+class DatagramID(Info, Generic[_AT]):
+    """Data model for :term:`TCP <reasm.tcp.datagram>` original packet identifier."""
+
+    #: Source address.
+    src: 'tuple[_AT, int]'
+    #: Destination address.
+    dst: 'tuple[_AT, int]'
+    #: Original packet ACK number.
+    ack: 'int'
+
+    if TYPE_CHECKING:
+        def __init__(self, src: 'tuple[_AT, int]', dst: 'tuple[_AT, int]', ack: 'int') -> 'None': ...  # pylint: disable=unused-argument,super-init-not-called,multiple-statements,line-too-long,redefined-builtin
+
+
+@info_final
+class Datagram(Info, Generic[_AT]):
+    """Data model for :term:`TCP <reasm.tcp.datagram>`."""
+
+    #: Completed flag.
+    completed: 'bool'
+    #: Original packet identifier.
+    id: 'DatagramID[_AT]'
+    #: Packet numbers.
+    index: 'tuple[int, ...]'
+    #: Initial TCP header.
+    header: 'bytes'
+    #: Reassembled payload (application layer data).
+    payload: 'bytes | tuple[bytes, ...]'
+    #: Parsed reassembled payload.
+    packet: 'Optional[Protocol]'
+
+    if TYPE_CHECKING:
+        @overload  # pylint: disable=used-before-assignment
+        def __init__(self, completed: 'Literal[True]', id: 'DatagramID[_AT]', index: 'tuple[int, ...]', header: 'bytes', payload: 'bytes', packet: 'Protocol') -> 'None': ...  # pylint: disable=unused-argument,super-init-not-called,multiple-statements,line-too-long,redefined-builtin
+
+        @overload
+        def __init__(self, completed: 'Literal[False]', id: 'DatagramID[_AT]', index: 'tuple[int, ...]', header: 'bytes', payload: 'tuple[bytes, ...]', packet: 'None') -> 'None': ...  # pylint: disable=unused-argument,super-init-not-called,multiple-statements,line-too-long,redefined-builtin
+
+        def __init__(self, completed: 'bool', id: 'DatagramID[_AT]', index: 'tuple[int, ...]', header: 'bytes', payload: 'bytes | tuple[bytes, ...]', packet: 'Optional[Protocol]') -> 'None': ...  # pylint: disable=unused-argument,super-init-not-called,multiple-statements,line-too-long,redefined-builtin
+
+
+@info_final
+class HoleDiscriptor(Info):
+    """Data model for :term:`TCP <reasm.tcp.buffer>` hole descriptor."""
+
+    #: Start of hole.
+    first: 'int'
+    #: Stop of hole.
+    last: 'int'
+
+    if TYPE_CHECKING:
+        def __init__(self, first: 'int', last: 'int') -> 'None': ...  # pylint: disable=unused-argument,super-init-not-called,multiple-statements,line-too-long,redefined-builtin
+
+
+@info_final
+class Fragment(Info):
+    """Data model for :term:`TCP <reasm.tcp.buffer>` ACK list fragment item."""
+
+    #: List of reassembled packets.
+    ind: 'list[int]'
+    #: ISN of payload buffer.
+    isn: 'int'
+    #: Length of payload buffer.
+    len: 'int'
+    #: Reassembled payload holes set to b'\x00'.
+    raw: 'bytearray'
+
+    if TYPE_CHECKING:
+        def __init__(self, ind: 'list[int]', isn: 'int', len: 'int', raw: 'bytearray') -> 'None': ...  # pylint: disable=unused-argument,super-init-not-called,multiple-statements,line-too-long,redefined-builtin
+
+
+@info_final
+class Buffer(Info):
+    """Data model for :term:`TCP <reasm.tcp.buffer>` buffer entry."""
+
+    #: Hole descriptor list.
+    hdl: 'list[HoleDiscriptor]'
+    #: Initial TCP header.
+    hdr: 'bytes'
+    #: ACK list.
+    ack: 'dict[int, Fragment]'
+
+    if TYPE_CHECKING:
+        def __init__(self, hdl: 'list[HoleDiscriptor]', hdr: 'bytes', ack: 'dict[int, Fragment]') -> 'None': ...  # pylint: disable=unused-argument,super-init-not-called,multiple-statements,line-too-long,redefined-builtin

pcapkit/foundation/reassembly/ip.py

@@ -0,0 +1,192 @@
+# -*- coding: utf-8 -*-
+"""IP Datagram Reassembly
+============================
+
+.. module:: pcapkit.foundation.reassembly.ip
+
+:mod:`pcapkit.foundation.reassembly.ip` contains
+:class:`~pcapkit.foundation.reassembly.ip.IP`
+only, which reconstructs fragmented IP packets back to
+origin. The following algorithm implement is based on IP
+reassembly procedure introduced in :rfc:`791`, using
+``RCVBT`` (fragment receivedbit table). Though another
+algorithm is explained in :rfc:`815`, replacing ``RCVBT``,
+however, this implement still used the elder one.
+
+"""
+from typing import TYPE_CHECKING, Generic
+
+from pcapkit.foundation.reassembly.data.ip import (_AT, Buffer, BufferID, Datagram, DatagramID,
+                                                   Packet)
+from pcapkit.foundation.reassembly.reassembly import ReassemblyBase as Reassembly
+
+if TYPE_CHECKING:
+    from typing import Type
+
+    from pcapkit.const.reg.transtype import TransType
+    from pcapkit.protocols.internet.ip import IP as IP_Protocol
+
+__all__ = ['IP']
+
+
+class IP(Reassembly[Packet[_AT], Datagram[_AT], BufferID, Buffer[_AT]], Generic[_AT]):  # pylint: disable=abstract-method
+    """Reassembly for IP payload.
+
+    Args:
+        strict: if return all datagrams (including those not
+                implemented) when submit
+        store: if store reassembled datagram in memory, i.e.,
+            :attr:`self._dtgram <pcapkit.foundation.reassembly.reassembly.Reassembly._dtgram>`
+            (if not, datagram will be discarded after callback)
+
+    Important:
+        This class is not intended to be instantiated directly,
+        but rather used as a base class for the protocol-aware
+        reassembly classes.
+
+    """
+    if TYPE_CHECKING:
+        protocol: 'Type[IP_Protocol]'
+
+    ##########################################################################
+    # Methods.
+    ##########################################################################
+
+    def reassembly(self, info: 'Packet[_AT]') -> 'None':
+        """Reassembly procedure.
+
+        Arguments:
+            info: info dict of packets to be reassembled
+
+        """
+        # clear cache
+        self._flag_n = False
+        self.__cached__.clear()
+
+        BUFID = info.bufid  # Buffer Identifier
+        FO = info.fo        # Fragment Offset
+        IHL = info.ihl      # Internet Header Length
+        MF = info.mf        # More Fragments flag
+        TL = info.tl        # Total Length
+
+        # when non-fragmented (possibly discarded) packet received
+        if not FO and not MF:
+            if BUFID in self._buffer:
+                self._dtgram.extend(
+                    self.submit(self._buffer.pop(BUFID), bufid=BUFID)
+                )
+                return
+
+        # initialise buffer with BUFID
+        if BUFID not in self._buffer:
+            self._buffer[BUFID] = Buffer(
+                TDL=-1,                              # Total Data Length
+                RCVBT=bytearray(8191),              # Fragment Received Bit Table
+                index=[],                           # index record
+                header=b'' if FO else info.header,  # header buffer
+                datagram=bytearray(65535),          # data buffer
+            )
+        else:
+            # put header into header buffer
+            if not FO:  # pylint: disable=else-if-used
+                self._buffer[BUFID].__update__(header=info.header)
+
+        # append packet index
+        self._buffer[BUFID].index.append(info.num)
+
+        # put data into data buffer
+        start = FO
+        stop = TL - IHL + FO
+        self._buffer[BUFID].datagram[start:stop] = info.payload
+
+        # set RCVBT bits (in 8 octets)
+        start = FO // 8
+        stop = FO // 8 + (TL - IHL + 7) // 8
+        self._buffer[BUFID].RCVBT[start:stop] = b'\x01' * (stop - start + 1)
+
+        # get total data length (header excludes)
+        TDL = 0
+        if not MF:
+            TDL = TL - IHL + FO
+            self._buffer[BUFID].__update__(TDL=TDL)
+
+        # when datagram is reassembled in whole
+        start = 0
+        stop = (TDL + 7) // 8
+        if TDL and all(self._buffer[BUFID].RCVBT[start:stop]):
+            self._dtgram.extend(
+                self.submit(self._buffer.pop(BUFID), bufid=BUFID, checked=True)
+            )
+
+    def submit(self, buf: 'Buffer[_AT]', *, bufid: 'tuple[_AT, _AT, int, TransType]',  # type: ignore[override] # pylint: disable=arguments-differ
+               checked: 'bool' = False) -> 'list[Datagram[_AT]]':
+        """Submit reassembled payload.
+
+        Arguments:
+            buf: buffer dict of reassembled packets
+            bufid: buffer identifier
+            checked: buffer consistency checked flag
+
+        Returns:
+            Reassembled packets.
+
+        """
+        TDL = buf.TDL
+        RCVBT = buf.RCVBT
+        index = buf.index
+        header = buf.header
+        datagram = buf.datagram
+
+        start = 0
+        stop = (TDL + 7) // 8
+        flag = checked or (TDL and all(RCVBT[start:stop]))
+        # if datagram is not implemented
+        if not flag and self._flag_s:
+            data = []  # type: list[bytes]
+            byte = bytearray()
+            # extract received payload
+            for (bctr, bit) in enumerate(RCVBT):
+                if bit:     # received bit
+                    this = bctr * 8
+                    that = this + 8
+                    byte += datagram[this:that]
+                else:       # missing bit
+                    if byte:    # strip empty payload
+                        data.append(bytes(byte))
+                    byte = bytearray()
+            # strip empty packets
+            if data or header:
+                packet = Datagram(
+                    completed=False,
+                    id=DatagramID(
+                        src=bufid[0],
+                        dst=bufid[1],
+                        id=bufid[2],
+                        proto=bufid[3],
+                    ),
+                    index=tuple(index),
+                    header=header,
+                    payload=tuple(data),
+                    packet=None,
+                )
+        # if datagram is reassembled in whole
+        else:
+            payload = datagram[:TDL]
+            packet = Datagram(
+                completed=True,
+                id=DatagramID(
+                    src=bufid[0],
+                    dst=bufid[1],
+                    id=bufid[2],
+                    proto=bufid[3],
+                ),
+                index=tuple(index),
+                header=header,
+                payload=bytes(payload),
+                packet=self.protocol.analyze(bufid[3], bytes(payload)),
+            )
+
+        ret = [packet]
+        for callback in self.__callback_fn__:
+            callback(ret)
+        return ret

pcapkit/foundation/reassembly/ipv4.py

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+"""IPv4 Datagram Reassembly
+==============================
+
+.. module:: pcapkit.foundation.reassembly.ipv4
+
+:mod:`pcapkit.foundation.reassembly.ipv4` contains
+:class:`~pcapkit.foundation.reassembly.ipv4.IPv4`
+only, which reconstructs fragmented IPv4 packets back to
+origin. Please refer to :doc:`ip` for more information.
+
+"""
+from pcapkit.foundation.reassembly.ip import IP
+from pcapkit.protocols.internet.ipv4 import IPv4 as IPv4_Protocol
+
+__all__ = ['IPv4']
+
+
+# BUG: It is supposed to be ``IP[IPv4Address]``. But somehow Python
+# thinks that ``IP`` should take 4 arguments as in its parent class
+# ``Reassembly``. So we have to drop the type hint here.
+class IPv4(IP):
+    """Reassembly for IPv4 payload.
+
+    Args:
+        strict: if return all datagrams (including those not
+                implemented) when submit
+        store: if store reassembled datagram in memory, i.e.,
+            :attr:`self._dtgram <pcapkit.foundation.reassembly.reassembly.Reassembly._dtgram>`
+            (if not, datagram will be discarded after callback)
+
+    Example:
+        >>> from pcapkit.foundation.reassembly import IPv4
+        # Initialise instance:
+        >>> ipv4_reassembly = IPv4()
+        # Call reassembly:
+        >>> ipv4_reassembly(packet_dict)
+        # Fetch result:
+        >>> result = ipv4_reassembly.datagram
+
+    """
+
+    ##########################################################################
+    # Defaults.
+    ##########################################################################
+
+    #: Protocol name of current reassembly object.
+    __protocol_name__ = 'IPv4'
+    #: Protocol of current reassembly object.
+    __protocol_type__ = IPv4_Protocol

pcapkit/foundation/reassembly/ipv6.py

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+"""IPv6 Datagram Reassembly
+==============================
+
+.. module:: pcapkit.foundation.reassembly.ipv6
+
+:mod:`pcapkit.foundation.reassembly.ipv6` contains
+:class:`~pcapkit.foundation.reassembly.ipv6.IPv6`
+only, which reconstructs fragmented IPv6 packets back to
+origin. Please refer to :doc:`ip` for more information.
+
+"""
+from pcapkit.foundation.reassembly.ip import IP
+from pcapkit.protocols.internet.ipv6 import IPv6 as IPv6_Protocol
+
+__all__ = ['IPv6']
+
+
+# BUG: It is supposed to be ``IP[IPv6Address]``. But somehow Python
+# thinks that ``IP`` should take 4 arguments as in its parent class
+# ``Reassembly``. So we have to drop the type hint here.
+class IPv6(IP):
+    """Reassembly for IPv6 payload.
+
+    Args:
+        strict: if return all datagrams (including those not
+                implemented) when submit
+        store: if store reassembled datagram in memory, i.e.,
+            :attr:`self._dtgram <pcapkit.foundation.reassembly.reassembly.Reassembly._dtgram>`
+            (if not, datagram will be discarded after callback)
+
+    Example:
+        >>> from pcapkit.foundation.reassembly import IPv6
+        # Initialise instance:
+        >>> ipv6_reassembly = IPv6()
+        # Call reassembly:
+        >>> ipv6_reassembly(packet_dict)
+        # Fetch result:
+        >>> result = ipv6_reassembly.datagram
+
+    """
+
+    ##########################################################################
+    # Defaults.
+    ##########################################################################
+
+    #: Protocol name of current reassembly object.
+    __protocol_name__ = 'IPv6'
+    #: Protocol of current reassembly object.
+    __protocol_type__ = IPv6_Protocol