bumble 0.0.220__py3-none-any.whl → 0.0.222__py3-none-any.whl

bumble/l2cap.py

@@ -20,21 +20,14 @@ from __future__ import annotations
 import asyncio
 import dataclasses
 import enum
+import itertools
 import logging
 import struct
 from collections import deque
-from collections.abc import Sequence
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    ClassVar,
-    Iterable,
-    Optional,
-    SupportsBytes,
-    TypeVar,
-    Union,
-)
+from collections.abc import Callable, Iterable, Sequence
+from typing import TYPE_CHECKING, Any, ClassVar, SupportsBytes, TypeVar
+
+from typing_extensions import override
 
 from bumble import hci, utils
 from bumble.colors import color
@@ -69,7 +62,12 @@ L2CAP_MIN_LE_MTU     = 23
 L2CAP_MIN_BR_EDR_MTU = 48
 L2CAP_MAX_BR_EDR_MTU = 65535
 
-L2CAP_DEFAULT_MTU = 2048  # Default value for the MTU we are willing to accept
+L2CAP_DEFAULT_MTU              = 2048  # Default value for the MTU we are willing to accept
+L2CAP_DEFAULT_MPS              = 1010  # Default value for the MPS we are willing to accept
+DEFAULT_TX_WINDOW_SIZE         = 63
+DEFAULT_MAX_RETRANSMISSION     = 1
+DEFAULT_RETRANSMISSION_TIMEOUT = 2.0
+DEFAULT_MONITOR_TIMEOUT        = 12.0
 
 L2CAP_DEFAULT_CONNECTIONLESS_MTU = 1024
 
@@ -133,29 +131,65 @@ L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_MTU             = 2048
 L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_MPS             = 2048
 L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_INITIAL_CREDITS = 256
 
-L2CAP_MAXIMUM_TRANSMISSION_UNIT_CONFIGURATION_OPTION_TYPE = 0x01
-
-L2CAP_MTU_CONFIGURATION_PARAMETER_TYPE = 0x01
-
 # fmt: on
 # pylint: enable=line-too-long
 
 
+class TransmissionMode(utils.OpenIntEnum):
+    '''See Bluetooth spec @ Vol 3, Part A - 5.4. Retransmission and Flow Control option'''
+
+    BASIC = 0x00
+    RETRANSMISSION = 0x01
+    FLOW_CONTROL = 0x02
+    ENHANCED_RETRANSMISSION = 0x03
+    STREAMING = 0x04
+
+
 # -----------------------------------------------------------------------------
 # Classes
 # -----------------------------------------------------------------------------
 # pylint: disable=invalid-name
 
 
+class L2capError(ProtocolError):
+    def __init__(self, error_code, error_name='', details=''):
+        super().__init__(error_code, 'L2CAP', error_name, details)
+
+
 @dataclasses.dataclass
 class ClassicChannelSpec:
-    psm: Optional[int] = None
+    '''Spec of L2CAP Channel over Classic Transport.
+
+    Attributes:
+        psm: PSM of channel. This is optional for server, and when it is None, a PSM
+            will be allocated.
+        mtu: Maximum Transmission Unit.
+        mps: Maximum PDU payload Size.
+        tx_window_size: The size of the transmission window for Flow Control mode,
+            Retransmission mode, and Enhanced Retransmission mode.
+        max_retransmission: The number of transmissions of a single I-frame that L2CAP
+            is allowed to try in Retransmission mode and Enhanced Retransmission mode.
+        retransmission_timeout: The timeout of retransmission in seconds.
+        monitor_timeout: The interval at which S-frames should be transmitted on the
+            return channel when no frames are received on the forward channel.
+        mode: The transmission mode to use.
+        fcs_enabled: Whether to enable FCS (Frame Check Sequence).
+    '''
+
+    psm: int | None = None
     mtu: int = L2CAP_DEFAULT_MTU
+    mps: int = L2CAP_DEFAULT_MPS
+    tx_window_size: int = DEFAULT_TX_WINDOW_SIZE
+    max_retransmission: int = DEFAULT_MAX_RETRANSMISSION
+    retransmission_timeout: float = DEFAULT_RETRANSMISSION_TIMEOUT
+    monitor_timeout: float = DEFAULT_MONITOR_TIMEOUT
+    mode: TransmissionMode = TransmissionMode.BASIC
+    fcs_enabled: bool = False
 
 
 @dataclasses.dataclass
 class LeCreditBasedChannelSpec:
-    psm: Optional[int] = None
+    psm: int | None = None
     mtu: int = L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_MTU
     mps: int = L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_MPS
     max_credits: int = L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_INITIAL_CREDITS
@@ -183,20 +217,29 @@ class L2CAP_PDU:
     See Bluetooth spec @ Vol 3, Part A - 3 DATA PACKET FORMAT
     '''
 
-    @staticmethod
-    def from_bytes(data: bytes) -> L2CAP_PDU:
+    @classmethod
+    def from_bytes(cls, data: bytes) -> L2CAP_PDU:
         # Check parameters
         if len(data) < 4:
             raise InvalidPacketError('not enough data for L2CAP header')
 
-        _, l2cap_pdu_cid = struct.unpack_from('<HH', data, 0)
-        l2cap_pdu_payload = data[4:]
+        length, l2cap_pdu_cid = struct.unpack_from('<HH', data, 0)
+        l2cap_pdu_payload = data[4 : 4 + length]
 
-        return L2CAP_PDU(l2cap_pdu_cid, l2cap_pdu_payload)
+        return cls(l2cap_pdu_cid, l2cap_pdu_payload)
 
     def __bytes__(self) -> bytes:
-        header = struct.pack('<HH', len(self.payload), self.cid)
-        return header + self.payload
+        return self.to_bytes(with_fcs=False)
+
+    def to_bytes(self, with_fcs: bool = False) -> bytes:
+        length = len(self.payload)
+        if with_fcs:
+            length += 2
+        header = struct.pack('<HH', length, self.cid)
+        body = header + self.payload
+        if with_fcs:
+            body += struct.pack('<H', utils.crc_16(body))
+        return body
 
     def __init__(self, cid: int, payload: bytes) -> None:
         self.cid = cid
@@ -206,6 +249,117 @@ class L2CAP_PDU:
         return f'{color("L2CAP", "green")} [CID={self.cid}]: {self.payload.hex()}'
 
 
+class ControlField:
+    '''
+    See Bluetooth spec @ Vol 3, Part A - 3.3.2 Control field.
+    '''
+
+    class FieldType(utils.OpenIntEnum):
+        I_FRAME = 0x00
+        S_FRAME = 0x01
+
+    class SegmentationAndReassembly(utils.OpenIntEnum):
+        UNSEGMENTED = 0x00
+        START = 0x01
+        END = 0x02
+        CONTINUATION = 0x03
+
+    class SupervisoryFunction(utils.OpenIntEnum):
+        #  Receiver Ready
+        RR = 0
+        #  Reject
+        REJ = 1
+        #  Receiver Not Ready
+        RNR = 2
+        #  Select Reject
+        SREJ = 3
+
+    class RetransmissionBit(utils.OpenIntEnum):
+        NORMAL = 0x00
+        RETRANSMISSION = 0x01
+
+    req_seq: int
+    frame_type: ClassVar[FieldType]
+
+    def __bytes__(self) -> bytes:
+        raise NotImplementedError()
+
+
+class EnhancedControlField(ControlField):
+    """Base control field used in Enhanced Retransmission and Streaming Mode."""
+
+    final: int
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> EnhancedControlField:
+        frame_type = data[0] & 0x01
+        if frame_type == cls.FieldType.I_FRAME:
+            return InformationEnhancedControlField.from_bytes(data)
+        elif frame_type == cls.FieldType.S_FRAME:
+            return SupervisoryEnhancedControlField.from_bytes(data)
+        else:
+            raise InvalidArgumentError(f'Invalid frame type: {frame_type}')
+
+
+@dataclasses.dataclass
+class InformationEnhancedControlField(EnhancedControlField):
+    tx_seq: int
+    sar: int
+    req_seq: int = 0
+    final: int = 1
+
+    frame_type = EnhancedControlField.FieldType.I_FRAME
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> EnhancedControlField:
+        return cls(
+            tx_seq=(data[0] >> 1) & 0b0111111,
+            final=(data[0] >> 7) & 0b1,
+            req_seq=(data[1] & 0b00111111),
+            sar=(data[1] >> 6) & 0b11,
+        )
+
+    def __bytes__(self) -> bytes:
+        return bytes(
+            [
+                self.frame_type | (self.tx_seq << 1) | (self.final << 7),
+                self.req_seq | (self.sar << 6),
+            ]
+        )
+
+
+@dataclasses.dataclass
+class SupervisoryEnhancedControlField(EnhancedControlField):
+    supervision_function: int = ControlField.SupervisoryFunction.RR
+    poll: int = 0
+    req_seq: int = 0
+    final: int = 0
+
+    frame_type = EnhancedControlField.FieldType.S_FRAME
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> EnhancedControlField:
+        return cls(
+            supervision_function=(data[0] >> 2) & 0b11,
+            poll=(data[0] >> 4) & 0b1,
+            final=(data[0] >> 7) & 0b1,
+            req_seq=(data[1] & 0b1111111),
+        )
+
+    def __bytes__(self) -> bytes:
+        return bytes(
+            [
+                (
+                    self.frame_type
+                    | (self.supervision_function << 2)
+                    | self.poll << 7
+                    | (self.final << 7)
+                ),
+                self.req_seq,
+            ]
+        )
+
+
 # -----------------------------------------------------------------------------
 @dataclasses.dataclass
 class L2CAP_Control_Frame:
@@ -217,7 +371,7 @@ class L2CAP_Control_Frame:
     fields: ClassVar[hci.Fields] = ()
     code: int = dataclasses.field(default=0, init=False)
     name: str = dataclasses.field(default='', init=False)
-    _payload: Optional[bytes] = dataclasses.field(default=None, init=False)
+    _payload: bytes | None = dataclasses.field(default=None, init=False)
 
     identifier: int
 
@@ -248,14 +402,16 @@ class L2CAP_Control_Frame:
         return frame
 
     @staticmethod
-    def decode_configuration_options(data: bytes) -> list[tuple[int, bytes]]:
+    def decode_configuration_options(
+        data: bytes,
+    ) -> list[tuple[L2CAP_Configure_Request.ParameterType, bytes]]:
         options = []
         while len(data) >= 2:
             value_type = data[0]
             length = data[1]
             value = data[2 : 2 + length]
             data = data[2 + length :]
-            options.append((value_type, value))
+            options.append((L2CAP_Configure_Request.ParameterType(value_type), value))
 
         return options
 
@@ -398,6 +554,15 @@ class L2CAP_Configure_Request(L2CAP_Control_Frame):
     See Bluetooth spec @ Vol 3, Part A - 4.4 CONFIGURATION REQUEST
     '''
 
+    class ParameterType(utils.OpenIntEnum):
+        MTU = 0x01
+        FLUSH_TIMEOUT = 0x02
+        QOS = 0x03
+        RETRANSMISSION_AND_FLOW_CONTROL = 0x04
+        FCS = 0x05
+        EXTENDED_FLOW_SPEC = 0x06
+        EXTENDED_WINDOW_SIZE = 0x07
+
     destination_cid: int = dataclasses.field(metadata=hci.metadata(2))
     flags: int = dataclasses.field(metadata=hci.metadata(2))
     options: bytes = dataclasses.field(metadata=hci.metadata('*'))
@@ -484,17 +649,18 @@ class L2CAP_Information_Request(L2CAP_Control_Frame):
         EXTENDED_FEATURES_SUPPORTED = 0x0002
         FIXED_CHANNELS_SUPPORTED = 0x0003
 
-    EXTENDED_FEATURE_FLOW_MODE_CONTROL = 0x0001
-    EXTENDED_FEATURE_RETRANSMISSION_MODE = 0x0002
-    EXTENDED_FEATURE_BIDIRECTIONAL_QOS = 0x0004
-    EXTENDED_FEATURE_ENHANCED_RETRANSMISSION_MODE = 0x0008
-    EXTENDED_FEATURE_STREAMING_MODE = 0x0010
-    EXTENDED_FEATURE_FCS_OPTION = 0x0020
-    EXTENDED_FEATURE_EXTENDED_FLOW_SPEC = 0x0040
-    EXTENDED_FEATURE_FIXED_CHANNELS = 0x0080
-    EXTENDED_FEATURE_EXTENDED_WINDOW_SIZE = 0x0100
-    EXTENDED_FEATURE_UNICAST_CONNECTIONLESS_DATA = 0x0200
-    EXTENDED_FEATURE_ENHANCED_CREDIT_BASE_FLOW_CONTROL = 0x0400
+    class ExtendedFeatures(hci.SpecableFlag):
+        FLOW_MODE_CONTROL = 0x0001
+        RETRANSMISSION_MODE = 0x0002
+        BIDIRECTIONAL_QOS = 0x0004
+        ENHANCED_RETRANSMISSION_MODE = 0x0008
+        STREAMING_MODE = 0x0010
+        FCS_OPTION = 0x0020
+        EXTENDED_FLOW_SPEC = 0x0040
+        FIXED_CHANNELS = 0x0080
+        EXTENDED_WINDOW_SIZE = 0x0100
+        UNICAST_CONNECTIONLESS_DATA = 0x0200
+        ENHANCED_CREDIT_BASE_FLOW_CONTROL = 0x0400
 
     info_type: int = dataclasses.field(metadata=InfoType.type_metadata(2))
 
@@ -661,7 +827,7 @@ class L2CAP_Credit_Based_Connection_Response(L2CAP_Control_Frame):
     mtu: int = dataclasses.field(metadata=hci.metadata(2))
     mps: int = dataclasses.field(metadata=hci.metadata(2))
     initial_credits: int = dataclasses.field(metadata=hci.metadata(2))
-    result: int = dataclasses.field(metadata=Result.type_metadata(2))
+    result: Result = dataclasses.field(metadata=Result.type_metadata(2))
     destination_cid: Sequence[int] = dataclasses.field(
         metadata=L2CAP_Credit_Based_Connection_Request.CID_METADATA
     )
@@ -702,6 +868,273 @@ class L2CAP_Credit_Based_Reconfigure_Response(L2CAP_Control_Frame):
     result: int = dataclasses.field(metadata=Result.type_metadata(2))
 
 
+# -----------------------------------------------------------------------------
+class Processor:
+    def __init__(self, channel: ClassicChannel) -> None:
+        self.channel = channel
+
+    def send_sdu(self, sdu: bytes) -> None:
+        self.channel.send_pdu(sdu)
+
+    def on_pdu(self, pdu: bytes) -> None:
+        self.channel.on_sdu(pdu)
+
+
+# TODO: Handle retransmission
+class EnhancedRetransmissionProcessor(Processor):
+    MAX_SEQ_NUM = 64
+
+    @dataclasses.dataclass
+    class _PendingPdu:
+        payload: bytes
+        tx_seq: int
+        sar: InformationEnhancedControlField.SegmentationAndReassembly
+        sdu_length: int = 0
+        req_seq: int = 0
+
+        def __bytes__(self) -> bytes:
+            return (
+                bytes(
+                    InformationEnhancedControlField(
+                        tx_seq=self.tx_seq,
+                        req_seq=self.req_seq,
+                        sar=self.sar,
+                    )
+                )
+                + (
+                    struct.pack('<H', self.sdu_length)
+                    if self.sar
+                    == InformationEnhancedControlField.SegmentationAndReassembly.START
+                    else b''
+                )
+                + self.payload
+            )
+
+    _last_acked_tx_seq: int = 0
+    _last_acked_rx_seq: int = 0
+    _next_tx_seq: int = 0
+    _req_seq_num: int = 0
+    _remote_is_busy: bool = False
+    _in_sdu: bytes = b''
+
+    _num_receiver_ready_polls_sent: int = 0
+    _pending_pdus: list[_PendingPdu]
+    _tx_window: list[_PendingPdu]
+    _monitor_handle: asyncio.TimerHandle | None = None
+    _receiver_ready_poll_handle: asyncio.TimerHandle | None = None
+
+    # Timeout, in seconds.
+    monitor_timeout: float
+    retransmission_timeout: float
+
+    def __init__(
+        self,
+        channel: ClassicChannel,
+        peer_tx_window_size: int = DEFAULT_TX_WINDOW_SIZE,
+        peer_max_retransmission: int = DEFAULT_MAX_RETRANSMISSION,
+        peer_mps: int = L2CAP_DEFAULT_MPS,
+    ):
+        spec = channel.spec
+        self.mps = spec.mps
+        self.peer_mps = peer_mps
+        self.peer_tx_window_size = peer_tx_window_size
+        self._pending_pdus = []
+        self._tx_window = []
+        self.monitor_timeout = spec.monitor_timeout
+        self.channel = channel
+        self.retransmission_timeout = spec.retransmission_timeout
+        self.peer_max_retransmission = peer_max_retransmission
+
+    def _monitor(self) -> None:
+        if (
+            self.peer_max_retransmission <= 0
+            or self._num_receiver_ready_polls_sent < self.peer_max_retransmission
+        ):
+            self._send_receiver_ready_poll()
+            self._start_monitor()
+        else:
+            logger.error("Max retransmission exceeded")
+
+    def _receiver_ready_poll(self) -> None:
+        self._send_receiver_ready_poll()
+        self._start_monitor()
+
+    def _start_monitor(self) -> None:
+        if self._monitor_handle:
+            self._monitor_handle.cancel()
+        self._monitor_handle = asyncio.get_running_loop().call_later(
+            self.monitor_timeout, self._monitor
+        )
+
+    def _start_receiver_ready_poll(self) -> None:
+        if self._receiver_ready_poll_handle:
+            self._receiver_ready_poll_handle.cancel()
+        self._num_receiver_ready_polls_sent = 0
+
+        self._receiver_ready_poll_handle = asyncio.get_running_loop().call_later(
+            self.retransmission_timeout, self._receiver_ready_poll
+        )
+
+    def _send_receiver_ready_poll(self) -> None:
+        self._num_receiver_ready_polls_sent += 1
+        self._send_s_frame(
+            supervision_function=SupervisoryEnhancedControlField.SupervisoryFunction.RR,
+            final=1,
+        )
+
+    def _get_next_tx_seq(self) -> int:
+        seq_num = self._next_tx_seq
+        self._next_tx_seq = (self._next_tx_seq + 1) % self.MAX_SEQ_NUM
+        return seq_num
+
+    @override
+    def send_sdu(self, sdu: bytes) -> None:
+        if len(sdu) <= self.peer_mps:
+            pdu = self._PendingPdu(
+                payload=sdu,
+                tx_seq=self._get_next_tx_seq(),
+                req_seq=self._req_seq_num,
+                sar=InformationEnhancedControlField.SegmentationAndReassembly.UNSEGMENTED,
+            )
+            self._pending_pdus.append(pdu)
+        else:
+            for offset in range(0, len(sdu), self.peer_mps):
+                payload = sdu[offset : offset + self.peer_mps]
+                if offset == 0:
+                    sar = (
+                        InformationEnhancedControlField.SegmentationAndReassembly.START
+                    )
+                elif offset + len(payload) >= len(sdu):
+                    sar = InformationEnhancedControlField.SegmentationAndReassembly.END
+                else:
+                    sar = (
+                        InformationEnhancedControlField.SegmentationAndReassembly.CONTINUATION
+                    )
+                pdu = self._PendingPdu(
+                    payload=payload,
+                    tx_seq=self._get_next_tx_seq(),
+                    req_seq=self._req_seq_num,
+                    sar=sar,
+                    sdu_length=len(sdu),
+                )
+                self._pending_pdus.append(pdu)
+        self._process_output()
+
+    @override
+    def on_pdu(self, pdu: bytes) -> None:
+        control_field = EnhancedControlField.from_bytes(pdu)
+        self._update_ack_seq(control_field.req_seq, control_field.final != 0)
+        if isinstance(control_field, InformationEnhancedControlField):
+            if control_field.tx_seq != self._req_seq_num:
+                logger.error(
+                    "tx_seq != self._req_seq_num, tx_seq: %d, self._req_seq_num: %d",
+                    control_field.tx_seq,
+                    self._req_seq_num,
+                )
+                return
+            self._req_seq_num = (control_field.tx_seq + 1) % self.MAX_SEQ_NUM
+
+            if (
+                control_field.sar
+                == InformationEnhancedControlField.SegmentationAndReassembly.START
+            ):
+                # Drop Control Field(2) + SDU Length(2)
+                self._in_sdu += pdu[4:]
+            else:
+                # Drop Control Field(2)
+                self._in_sdu += pdu[2:]
+            if control_field.sar in (
+                InformationEnhancedControlField.SegmentationAndReassembly.END,
+                InformationEnhancedControlField.SegmentationAndReassembly.UNSEGMENTED,
+            ):
+                self.channel.on_sdu(self._in_sdu)
+                self._in_sdu = b''
+
+            # If sink doesn't trigger any I-frame, ack this frame.
+            if self._req_seq_num != self._last_acked_rx_seq:
+                self._send_s_frame(
+                    supervision_function=SupervisoryEnhancedControlField.SupervisoryFunction.RR,
+                    final=0,
+                )
+        elif isinstance(control_field, SupervisoryEnhancedControlField):
+            self._remote_is_busy = (
+                control_field.supervision_function
+                == SupervisoryEnhancedControlField.SupervisoryFunction.RNR
+            )
+
+            if control_field.supervision_function in (
+                SupervisoryEnhancedControlField.SupervisoryFunction.RR,
+                SupervisoryEnhancedControlField.SupervisoryFunction.RNR,
+            ):
+                if control_field.poll:
+                    self._send_s_frame(
+                        supervision_function=SupervisoryEnhancedControlField.SupervisoryFunction.RR,
+                        final=1,
+                    )
+            else:
+                # TODO: Handle Retransmission.
+                pass
+
+    def _process_output(self) -> None:
+        if self._remote_is_busy:
+            logger.debug("Remote is busy")
+            return
+        if self._monitor_handle:
+            logger.debug("Monitor handle is not None")
+            return
+
+        pdu_to_send = self.peer_tx_window_size - len(self._tx_window)
+        for pdu in itertools.islice(self._pending_pdus, pdu_to_send):
+            self._send_i_frame(pdu)
+        self._pending_pdus = self._pending_pdus[pdu_to_send:]
+
+    def _send_i_frame(self, pdu: _PendingPdu) -> None:
+        pdu.req_seq = self._req_seq_num
+
+        self._start_receiver_ready_poll()
+        self._tx_window.append(pdu)
+        self.channel.send_pdu(bytes(pdu))
+        self._last_acked_rx_seq = self._req_seq_num
+
+    def _send_s_frame(
+        self,
+        supervision_function: SupervisoryEnhancedControlField.SupervisoryFunction,
+        final: int,
+    ) -> None:
+        self.channel.send_pdu(
+            SupervisoryEnhancedControlField(
+                supervision_function=supervision_function,
+                final=final,
+                req_seq=self._req_seq_num,
+            )
+        )
+        self._last_acked_rx_seq = self._req_seq_num
+
+    def _update_ack_seq(self, new_seq: int, is_poll_response: bool) -> None:
+        num_frames_acked = (new_seq - self._last_acked_tx_seq) % self.MAX_SEQ_NUM
+        if num_frames_acked > len(self._tx_window):
+            logger.error(
+                "Received acknowledgment for %d frames but only %d frames are pending",
+                num_frames_acked,
+                len(self._tx_window),
+            )
+            return
+        if is_poll_response and self._monitor_handle:
+            self._monitor_handle.cancel()
+            self._monitor_handle = None
+
+        del self._tx_window[:num_frames_acked]
+        self._last_acked_tx_seq = new_seq
+        if (
+            self._last_acked_tx_seq == self._next_tx_seq
+            and self._receiver_ready_poll_handle
+        ):
+            self._receiver_ready_poll_handle.cancel()
+            self._receiver_ready_poll_handle = None
+
+        self._process_output()
+
+
 # -----------------------------------------------------------------------------
 class ClassicChannel(utils.EventEmitter):
     class State(enum.IntEnum):
@@ -731,14 +1164,15 @@ class ClassicChannel(utils.EventEmitter):
     EVENT_OPEN = "open"
     EVENT_CLOSE = "close"
 
-    connection_result: Optional[asyncio.Future[None]]
-    disconnection_result: Optional[asyncio.Future[None]]
-    response: Optional[asyncio.Future[bytes]]
-    sink: Optional[Callable[[bytes], Any]]
+    connection_result: asyncio.Future[None] | None
+    disconnection_result: asyncio.Future[None] | None
+    response: asyncio.Future[bytes] | None
+    sink: Callable[[bytes], Any] | None
     state: State
     connection: Connection
     mtu: int
     peer_mtu: int
+    processor: Processor
 
     def __init__(
         self,
@@ -747,14 +1181,14 @@ class ClassicChannel(utils.EventEmitter):
         signaling_cid: int,
         psm: int,
         source_cid: int,
-        mtu: int,
+        spec: ClassicChannelSpec,
     ) -> None:
         super().__init__()
         self.manager = manager
         self.connection = connection
         self.signaling_cid = signaling_cid
         self.state = self.State.CLOSED
-        self.mtu = mtu
+        self.mtu = spec.mtu
         self.peer_mtu = L2CAP_MIN_BR_EDR_MTU
         self.psm = psm
         self.source_cid = source_cid
@@ -762,26 +1196,47 @@ class ClassicChannel(utils.EventEmitter):
         self.connection_result = None
         self.disconnection_result = None
         self.sink = None
+        self.fcs_enabled = spec.fcs_enabled
+        self.spec = spec
+        self.mode = spec.mode
+        # Configure mode-specific processor later on configure request.
+        self.processor = Processor(self)
+        if self.mode not in (
+            TransmissionMode.BASIC,
+            TransmissionMode.ENHANCED_RETRANSMISSION,
+        ):
+            raise InvalidArgumentError(f"Mode {spec.mode} is not supported")
 
     def _change_state(self, new_state: State) -> None:
         logger.debug(f'{self} state change -> {color(new_state.name, "cyan")}')
         self.state = new_state
 
-    def send_pdu(self, pdu: Union[SupportsBytes, bytes]) -> None:
+    def write(self, sdu: bytes) -> None:
+        self.processor.send_sdu(sdu)
+
+    def send_pdu(self, pdu: SupportsBytes | bytes) -> None:
         if self.state != self.State.OPEN:
             raise InvalidStateError('channel not open')
-        self.manager.send_pdu(self.connection, self.destination_cid, pdu)
+        self.manager.send_pdu(
+            self.connection, self.destination_cid, pdu, self.fcs_enabled
+        )
 
     def send_control_frame(self, frame: L2CAP_Control_Frame) -> None:
         self.manager.send_control_frame(self.connection, self.signaling_cid, frame)
 
     def on_pdu(self, pdu: bytes) -> None:
+        if self.fcs_enabled:
+            # Drop FCS.
+            pdu = pdu[:-2]
+        self.processor.on_pdu(pdu)
+
+    def on_sdu(self, sdu: bytes) -> None:
         if self.sink:
             # pylint: disable=not-callable
-            self.sink(pdu)
+            self.sink(sdu)
         else:
             logger.warning(
-                color('received pdu without a pending request or sink', 'red')
+                color('received sdu without a pending request or sink', 'red')
             )
 
     async def connect(self) -> None:
@@ -811,10 +1266,8 @@ class ClassicChannel(utils.EventEmitter):
         finally:
             self.connection_result = None
 
-    async def disconnect(self) -> None:
-        if self.state != self.State.OPEN:
-            raise InvalidStateError('invalid state')
-
+    def _disconnect_sync(self) -> None:
+        """For internal sync disconnection."""
         self._change_state(self.State.WAIT_DISCONNECT)
         self.send_control_frame(
             L2CAP_Disconnection_Request(
@@ -827,7 +1280,21 @@ class ClassicChannel(utils.EventEmitter):
         # Create a future to wait for the state machine to get to a success or error
         # state
         self.disconnection_result = asyncio.get_running_loop().create_future()
-        return await self.disconnection_result
+
+    def _abort_connection_result(self, message: str = 'Connection failure') -> None:
+        # Cancel pending connection result.
+        if self.connection_result and not self.connection_result.done():
+            self.connection_result.set_exception(
+                L2capError(error_code=0, error_name=message)
+            )
+
+    async def disconnect(self) -> None:
+        if self.state != self.State.OPEN:
+            raise InvalidStateError('invalid state')
+
+        self._disconnect_sync()
+        if self.disconnection_result:
+            return await self.disconnection_result
 
     def abort(self) -> None:
         if self.state == self.State.OPEN:
@@ -835,20 +1302,40 @@ class ClassicChannel(utils.EventEmitter):
             self.emit(self.EVENT_CLOSE)
 
     def send_configure_request(self) -> None:
-        options = L2CAP_Control_Frame.encode_configuration_options(
-            [
+        options: list[tuple[int, bytes]] = [
+            (
+                L2CAP_Configure_Request.ParameterType.MTU,
+                struct.pack('<H', self.mtu),
+            )
+        ]
+        if self.mode == TransmissionMode.ENHANCED_RETRANSMISSION:
+            options.append(
                 (
-                    L2CAP_MAXIMUM_TRANSMISSION_UNIT_CONFIGURATION_OPTION_TYPE,
-                    struct.pack('<H', self.mtu),
+                    L2CAP_Configure_Request.ParameterType.RETRANSMISSION_AND_FLOW_CONTROL,
+                    struct.pack(
+                        '<BBBHHH',
+                        TransmissionMode.ENHANCED_RETRANSMISSION,
+                        self.spec.tx_window_size,
+                        self.spec.max_retransmission,
+                        int(self.spec.retransmission_timeout * 1000),
+                        int(self.spec.monitor_timeout * 1000),
+                        self.spec.mps,
+                    ),
                 )
-            ]
-        )
+            )
+        if self.fcs_enabled:
+            options.append(
+                (
+                    L2CAP_Configure_Request.ParameterType.FCS,
+                    bytes([1 if self.fcs_enabled else 0]),
+                )
+            )
         self.send_control_frame(
             L2CAP_Configure_Request(
                 identifier=self.manager.next_identifier(self.connection),
                 destination_cid=self.destination_cid,
                 flags=0x0000,
-                options=options,
+                options=L2CAP_Control_Frame.encode_configuration_options(options),
             )
         )
 
@@ -884,9 +1371,8 @@ class ClassicChannel(utils.EventEmitter):
             self._change_state(self.State.CLOSED)
             if self.connection_result:
                 self.connection_result.set_exception(
-                    ProtocolError(
+                    L2capError(
                         response.result,
-                        'l2cap',
                         L2CAP_Connection_Response.Result(response.result).name,
                     )
                 )
@@ -903,20 +1389,111 @@ class ClassicChannel(utils.EventEmitter):
 
         # Decode the options
         options = L2CAP_Control_Frame.decode_configuration_options(request.options)
+        # Result to options
+        replied_options = list[tuple[int, bytes]]()
+        result = L2CAP_Configure_Response.Result.SUCCESS
+        new_mode = TransmissionMode.BASIC
         for option in options:
-            if option[0] == L2CAP_MTU_CONFIGURATION_PARAMETER_TYPE:
-                self.peer_mtu = struct.unpack('<H', option[1])[0]
-                logger.debug(f'peer MTU = {self.peer_mtu}')
+            match option[0]:
+                case L2CAP_Configure_Request.ParameterType.MTU:
+                    self.peer_mtu = struct.unpack('<H', option[1])[0]
+                    logger.debug('Peer MTU = %d', self.peer_mtu)
+                    replied_options.append(option)
+                case (
+                    L2CAP_Configure_Request.ParameterType.RETRANSMISSION_AND_FLOW_CONTROL
+                ):
+                    (
+                        mode,
+                        peer_tx_window_size,
+                        peer_max_retransmission,
+                        peer_retransmission_timeout,
+                        peer_monitor_timeout,
+                        peer_mps,
+                    ) = struct.unpack_from('<BBBHHH', option[1])
+                    new_mode = TransmissionMode(mode)
+                    logger.debug(
+                        'Peer requests Retransmission or Flow Control: mode=%s,'
+                        ' tx_window_size=%s,'
+                        ' max_retransmission=%s,'
+                        ' retransmission_timeout=%s,'
+                        ' monitor_timeout=%s,'
+                        ' mps=%s',
+                        new_mode.name,
+                        peer_tx_window_size,
+                        peer_max_retransmission,
+                        peer_retransmission_timeout,
+                        peer_monitor_timeout,
+                        peer_mps,
+                    )
+                    if new_mode != self.mode:
+                        logger.error('Mode mismatch, abort connection')
+                        self._abort_connection_result(
+                            'Abort on configuration - mode mismatch'
+                        )
+                        self._disconnect_sync()
+                        return
+
+                    if new_mode == TransmissionMode.BASIC:
+                        replied_options.append(option)
+                    elif new_mode == TransmissionMode.ENHANCED_RETRANSMISSION:
+                        self.processor = self.manager.make_mode_processor(
+                            self,
+                            mode=new_mode,
+                            peer_tx_window_size=peer_tx_window_size,
+                            peer_max_retransmission=peer_max_retransmission,
+                            peer_monitor_timeout=peer_monitor_timeout,
+                            peer_retransmission_timeout=peer_retransmission_timeout,
+                            peer_mps=peer_mps,
+                        )
+                        replied_options.append(option)
+                    else:
+                        logger.error("Mode %s is not supported", new_mode.name)
+                        self._abort_connection_result(
+                            'Abort on configuration - unsupported mode'
+                        )
+                        self._disconnect_sync()
+                        return
+
+                case L2CAP_Configure_Request.ParameterType.FCS:
+                    enabled = option[1][0] != 0
+                    logger.debug("Peer requests FCS: %s", enabled)
+                    if (
+                        L2CAP_Information_Request.ExtendedFeatures.FCS_OPTION
+                        in self.manager.extended_features
+                    ):
+                        self.fcs_enabled = enabled
+                        replied_options.append(option)
+                    else:
+                        logger.error("Frame Check Sequence is not supported")
+                        result = (
+                            L2CAP_Configure_Response.Result.FAILURE_UNACCEPTABLE_PARAMETERS
+                        )
+                        replied_options = [option]
+                        break
+                case _:
+                    logger.debug(
+                        "Reject unimplemented option %s[%s]",
+                        option[0].name,
+                        option[1].hex(),
+                    )
+                    result = L2CAP_Configure_Response.Result.FAILURE_UNKNOWN_OPTIONS
+                    replied_options = [option]
+                    break
 
         self.send_control_frame(
             L2CAP_Configure_Response(
                 identifier=request.identifier,
                 source_cid=self.destination_cid,
                 flags=0x0000,
-                result=L2CAP_Configure_Response.Result.SUCCESS,
-                options=request.options,  # TODO: don't accept everything blindly
+                result=result,
+                options=L2CAP_Control_Frame.encode_configuration_options(
+                    replied_options
+                ),
             )
         )
+        if result != L2CAP_Configure_Response.Result.SUCCESS:
+            return
+
         if self.state == self.State.WAIT_CONFIG:
             self._change_state(self.State.WAIT_SEND_CONFIG)
             self.send_configure_request()
@@ -969,25 +1546,19 @@ class ClassicChannel(utils.EventEmitter):
             # TODO: decide how to fail gracefully
 
     def on_disconnection_request(self, request: L2CAP_Disconnection_Request) -> None:
-        if self.state in (self.State.OPEN, self.State.WAIT_DISCONNECT):
-            self.send_control_frame(
-                L2CAP_Disconnection_Response(
-                    identifier=request.identifier,
-                    destination_cid=request.destination_cid,
-                    source_cid=request.source_cid,
-                )
+        self.send_control_frame(
+            L2CAP_Disconnection_Response(
+                identifier=request.identifier,
+                destination_cid=request.destination_cid,
+                source_cid=request.source_cid,
             )
-            self._change_state(self.State.CLOSED)
-            self.emit(self.EVENT_CLOSE)
-            self.manager.on_channel_closed(self)
-        else:
-            logger.warning(color('invalid state', 'red'))
+        )
+        self._abort_connection_result()
+        self._change_state(self.State.CLOSED)
+        self.emit(self.EVENT_CLOSE)
+        self.manager.on_channel_closed(self)
 
     def on_disconnection_response(self, response: L2CAP_Disconnection_Response) -> None:
-        if self.state != self.State.WAIT_DISCONNECT:
-            logger.warning(color('invalid state', 'red'))
-            return
-
         if (
             response.destination_cid != self.destination_cid
             or response.source_cid != self.source_cid
@@ -1026,22 +1597,23 @@ class LeCreditBasedChannel(utils.EventEmitter):
         CONNECTION_ERROR = 5
 
     out_queue: deque[bytes]
-    connection_result: Optional[asyncio.Future[LeCreditBasedChannel]]
-    disconnection_result: Optional[asyncio.Future[None]]
-    in_sdu: Optional[bytes]
-    out_sdu: Optional[bytes]
+    connection_result: asyncio.Future[LeCreditBasedChannel] | None
+    disconnection_result: asyncio.Future[None] | None
+    in_sdu: bytes | None
+    out_sdu: bytes | None
     state: State
     connection: Connection
-    sink: Optional[Callable[[bytes], Any]]
+    sink: Callable[[bytes], Any] | None
 
     EVENT_OPEN = "open"
     EVENT_CLOSE = "close"
+    EVENT_ATT_MTU_UPDATE = "att_mtu_update"
 
     def __init__(
         self,
         manager: ChannelManager,
         connection: Connection,
-        le_psm: int,
+        psm: int,
         source_cid: int,
         destination_cid: int,
         mtu: int,
@@ -1055,7 +1627,7 @@ class LeCreditBasedChannel(utils.EventEmitter):
         super().__init__()
         self.manager = manager
         self.connection = connection
-        self.le_psm = le_psm
+        self.psm = psm
         self.source_cid = source_cid
         self.destination_cid = destination_cid
         self.mtu = mtu
@@ -1075,6 +1647,7 @@ class LeCreditBasedChannel(utils.EventEmitter):
         self.connection_result = None
         self.disconnection_result = None
         self.drained = asyncio.Event()
+        self.att_mtu = 0  # Filled by GATT client or server later.
 
         self.drained.set()
 
@@ -1092,7 +1665,7 @@ class LeCreditBasedChannel(utils.EventEmitter):
         elif new_state == self.State.DISCONNECTED:
             self.emit(self.EVENT_CLOSE)
 
-    def send_pdu(self, pdu: Union[SupportsBytes, bytes]) -> None:
+    def send_pdu(self, pdu: SupportsBytes | bytes) -> None:
         self.manager.send_pdu(self.connection, self.destination_cid, pdu)
 
     def send_control_frame(self, frame: L2CAP_Control_Frame) -> None:
@@ -1111,7 +1684,7 @@ class LeCreditBasedChannel(utils.EventEmitter):
         self._change_state(self.State.CONNECTING)
         request = L2CAP_LE_Credit_Based_Connection_Request(
             identifier=identifier,
-            le_psm=self.le_psm,
+            le_psm=self.psm,
             source_cid=self.source_cid,
             mtu=self.mtu,
             mps=self.mps,
@@ -1149,6 +1722,9 @@ class LeCreditBasedChannel(utils.EventEmitter):
     def abort(self) -> None:
         if self.state == self.State.CONNECTED:
             self._change_state(self.State.DISCONNECTED)
+        if self.state == self.State.CONNECTING:
+            if self.connection_result is not None:
+                self.connection_result.cancel()
 
     def on_pdu(self, pdu: bytes) -> None:
         if self.sink is None:
@@ -1239,9 +1815,8 @@ class LeCreditBasedChannel(utils.EventEmitter):
             self._change_state(self.State.CONNECTED)
         else:
             self.connection_result.set_exception(
-                ProtocolError(
+                L2capError(
                     response.result,
-                    'l2cap',
                     L2CAP_LE_Credit_Based_Connection_Response.Result(
                         response.result
                     ).name,
@@ -1252,6 +1827,22 @@ class LeCreditBasedChannel(utils.EventEmitter):
         # Cleanup
         self.connection_result = None
 
+    def on_enhanced_connection_response(
+        self, destination_cid: int, response: L2CAP_Credit_Based_Connection_Response
+    ) -> None:
+        if (
+            response.result
+            == L2CAP_Credit_Based_Connection_Response.Result.ALL_CONNECTIONS_SUCCESSFUL
+        ):
+            self.destination_cid = destination_cid
+            self.peer_mtu = response.mtu
+            self.peer_mps = response.mps
+            self.credits = response.initial_credits
+            self.connected = True
+            self._change_state(self.State.CONNECTED)
+        else:
+            self._change_state(self.State.CONNECTION_ERROR)
+
     def on_credits(self, credits: int) -> None:  # pylint: disable=redefined-builtin
         self.credits += credits
         logger.debug(f'received {credits} credits, total = {self.credits}')
@@ -1287,6 +1878,10 @@ class LeCreditBasedChannel(utils.EventEmitter):
             self.disconnection_result.set_result(None)
             self.disconnection_result = None
 
+    def on_att_mtu_update(self, mtu: int) -> None:
+        self.att_mtu = mtu
+        self.emit(self.EVENT_ATT_MTU_UPDATE, mtu)
+
     def flush_output(self) -> None:
         self.out_queue.clear()
         self.out_sdu = None
@@ -1364,7 +1959,7 @@ class LeCreditBasedChannel(utils.EventEmitter):
         return (
             f'CoC({self.source_cid}->{self.destination_cid}, '
             f'State={self.state.name}, '
-            f'PSM={self.le_psm}, '
+            f'PSM={self.psm}, '
             f'MTU={self.mtu}/{self.peer_mtu}, '
             f'MPS={self.mps}/{self.peer_mps}, '
             f'credits={self.credits}/{self.peer_credits})'
@@ -1379,14 +1974,14 @@ class ClassicChannelServer(utils.EventEmitter):
         self,
         manager: ChannelManager,
         psm: int,
-        handler: Optional[Callable[[ClassicChannel], Any]],
-        mtu: int,
+        handler: Callable[[ClassicChannel], Any] | None,
+        spec: ClassicChannelSpec,
     ) -> None:
         super().__init__()
         self.manager = manager
         self.handler = handler
         self.psm = psm
-        self.mtu = mtu
+        self.spec = spec
 
     def on_connection(self, channel: ClassicChannel) -> None:
         self.emit(self.EVENT_CONNECTION, channel)
@@ -1406,7 +2001,7 @@ class LeCreditBasedChannelServer(utils.EventEmitter):
         self,
         manager: ChannelManager,
         psm: int,
-        handler: Optional[Callable[[LeCreditBasedChannel], Any]],
+        handler: Callable[[LeCreditBasedChannel], Any] | None,
         max_credits: int,
         mtu: int,
         mps: int,
@@ -1432,14 +2027,24 @@ class LeCreditBasedChannelServer(utils.EventEmitter):
 # -----------------------------------------------------------------------------
 class ChannelManager:
     identifiers: dict[int, int]
-    channels: dict[int, dict[int, Union[ClassicChannel, LeCreditBasedChannel]]]
+    channels: dict[int, dict[int, ClassicChannel | LeCreditBasedChannel]]
     servers: dict[int, ClassicChannelServer]
     le_coc_channels: dict[int, dict[int, LeCreditBasedChannel]]
     le_coc_servers: dict[int, LeCreditBasedChannelServer]
     le_coc_requests: dict[int, L2CAP_LE_Credit_Based_Connection_Request]
-    fixed_channels: dict[int, Optional[Callable[[int, bytes], Any]]]
-    _host: Optional[Host]
-    connection_parameters_update_response: Optional[asyncio.Future[int]]
+    fixed_channels: dict[int, Callable[[int, bytes], Any] | None]
+    pending_credit_based_connections: dict[
+        int,
+        dict[
+            int,
+            tuple[
+                asyncio.Future[None],
+                list[LeCreditBasedChannel],
+            ],
+        ],
+    ]
+    _host: Host | None
+    connection_parameters_update_response: asyncio.Future[int] | None
 
     def __init__(
         self,
@@ -1459,7 +2064,10 @@ class ChannelManager:
         )  # LE CoC channels, mapped by connection and destination cid
         self.le_coc_servers = {}  # LE CoC - Servers accepting connections, by PSM
         self.le_coc_requests = {}  # LE CoC connection requests, by identifier
-        self.extended_features = extended_features
+        self.pending_credit_based_connections = (
+            {}
+        )  # Credit-based connection request contexts, by connection handle and identifier
+        self.extended_features = set(extended_features)
         self.connectionless_mtu = connectionless_mtu
         self.connection_parameters_update_response = None
 
@@ -1501,18 +2109,26 @@ class ChannelManager:
 
         raise OutOfResourcesError('no free CID available')
 
-    @staticmethod
-    def find_free_le_cid(channels: Iterable[int]) -> int:
+    @classmethod
+    def find_free_le_cid(cls, channels: Iterable[int]) -> int | None:
+        cids = cls.find_free_le_cids(channels, 1)
+        return cids[0] if cids else None
+
+    @classmethod
+    def find_free_le_cids(cls, channels: Iterable[int], count: int) -> list[int]:
         # Pick the smallest valid CID that's not already in the list
         # (not necessarily the most efficient algorithm, but the list of CID is
         # very small in practice)
+        cids: list[int] = []
         for cid in range(
             L2CAP_LE_U_DYNAMIC_CID_RANGE_START, L2CAP_LE_U_DYNAMIC_CID_RANGE_END + 1
         ):
             if cid not in channels:
-                return cid
+                cids.append(cid)
+                if len(cids) == count:
+                    return cids
 
-        raise OutOfResourcesError('no free CID')
+        return []
 
     def next_identifier(self, connection: Connection) -> int:
         identifier = (self.identifiers.setdefault(connection.handle, 0) + 1) % 256
@@ -1534,7 +2150,7 @@ class ChannelManager:
     def create_classic_server(
         self,
         spec: ClassicChannelSpec,
-        handler: Optional[Callable[[ClassicChannel], Any]] = None,
+        handler: Callable[[ClassicChannel], Any] | None = None,
     ) -> ClassicChannelServer:
         if not spec.psm:
             # Find a free PSM
@@ -1563,14 +2179,14 @@ class ChannelManager:
                     raise InvalidArgumentError('invalid PSM')
                 check >>= 8
 
-        self.servers[spec.psm] = ClassicChannelServer(self, spec.psm, handler, spec.mtu)
+        self.servers[spec.psm] = ClassicChannelServer(self, spec.psm, handler, spec)
 
         return self.servers[spec.psm]
 
     def create_le_credit_based_server(
         self,
         spec: LeCreditBasedChannelSpec,
-        handler: Optional[Callable[[LeCreditBasedChannel], Any]] = None,
+        handler: Callable[[LeCreditBasedChannel], Any] | None = None,
     ) -> LeCreditBasedChannelServer:
         if not spec.psm:
             # Find a free PSM
@@ -1599,20 +2215,30 @@ class ChannelManager:
 
         return self.le_coc_servers[spec.psm]
 
-    def on_disconnection(self, connection_handle: int, _reason: int) -> None:
-        logger.debug(f'disconnection from {connection_handle}, cleaning up channels')
-        if connection_handle in self.channels:
-            for _, channel in self.channels[connection_handle].items():
+    def on_disconnection(self, connection_handle: int, reason: int) -> None:
+        del reason  # unused.
+        logger.debug('disconnection from %d, cleaning up channels', connection_handle)
+        if channels := self.channels.pop(connection_handle, None):
+            for channel in channels.values():
                 channel.abort()
-            del self.channels[connection_handle]
-        if connection_handle in self.le_coc_channels:
-            for _, channel in self.le_coc_channels[connection_handle].items():
-                channel.abort()
-            del self.le_coc_channels[connection_handle]
-        if connection_handle in self.identifiers:
-            del self.identifiers[connection_handle]
+        if le_coc_channels := self.le_coc_channels.pop(connection_handle, None):
+            for le_coc_channel in le_coc_channels.values():
+                le_coc_channel.abort()
+        if pending_credit_based_connections := self.pending_credit_based_connections.pop(
+            connection_handle, None
+        ):
+            for future, _ in pending_credit_based_connections.values():
+                if not future.done():
+                    future.cancel("ACL disconnected")
+        self.identifiers.pop(connection_handle, None)
 
-    def send_pdu(self, connection, cid: int, pdu: Union[SupportsBytes, bytes]) -> None:
+    def send_pdu(
+        self,
+        connection: Connection,
+        cid: int,
+        pdu: SupportsBytes | bytes,
+        with_fcs: bool = False,
+    ) -> None:
         pdu_str = pdu.hex() if isinstance(pdu, bytes) else str(pdu)
         pdu_bytes = bytes(pdu)
         logger.debug(
@@ -1620,7 +2246,9 @@ class ChannelManager:
             f'on connection [0x{connection.handle:04X}] (CID={cid}) '
             f'{connection.peer_address}: {len(pdu_bytes)} bytes, {pdu_str}'
         )
-        self.host.send_l2cap_pdu(connection.handle, cid, pdu_bytes)
+        self.host.send_acl_sdu(
+            connection.handle, L2CAP_PDU(cid, bytes(pdu)).to_bytes(with_fcs=with_fcs)
+        )
 
     def on_pdu(self, connection: Connection, cid: int, pdu: bytes) -> None:
         if cid in (L2CAP_SIGNALING_CID, L2CAP_LE_SIGNALING_CID):
@@ -1714,7 +2342,6 @@ class ChannelManager:
                         identifier=request.identifier,
                         destination_cid=request.source_cid,
                         source_cid=0,
-                        # pylint: disable=line-too-long
                         result=L2CAP_Connection_Response.Result.CONNECTION_REFUSED_NO_RESOURCES_AVAILABLE,
                         status=0x0000,
                     ),
@@ -1726,7 +2353,7 @@ class ChannelManager:
                 f'creating server channel with cid={source_cid} for psm {request.psm}'
             )
             channel = ClassicChannel(
-                self, connection, cid, request.psm, source_cid, server.mtu
+                self, connection, cid, request.psm, source_cid, server.spec
             )
             connection_channels[source_cid] = channel
 
@@ -1745,7 +2372,6 @@ class ChannelManager:
                     identifier=request.identifier,
                     destination_cid=request.source_cid,
                     source_cid=0,
-                    # pylint: disable=line-too-long
                     result=L2CAP_Connection_Response.Result.CONNECTION_REFUSED_PSM_NOT_SUPPORTED,
                     status=0x0000,
                 ),
@@ -1974,106 +2600,100 @@ class ChannelManager:
         cid: int,
         request: L2CAP_LE_Credit_Based_Connection_Request,
     ) -> None:
-        if request.le_psm in self.le_coc_servers:
-            server = self.le_coc_servers[request.le_psm]
-
-            # Check that the CID isn't already used
-            le_connection_channels = self.le_coc_channels.setdefault(
-                connection.handle, {}
-            )
-            if request.source_cid in le_connection_channels:
-                logger.warning(f'source CID {request.source_cid} already in use')
-                self.send_control_frame(
-                    connection,
-                    cid,
-                    L2CAP_LE_Credit_Based_Connection_Response(
-                        identifier=request.identifier,
-                        destination_cid=0,
-                        mtu=server.mtu,
-                        mps=server.mps,
-                        initial_credits=0,
-                        # pylint: disable=line-too-long
-                        result=L2CAP_LE_Credit_Based_Connection_Response.Result.CONNECTION_REFUSED_SOURCE_CID_ALREADY_ALLOCATED,
-                    ),
-                )
-                return
-
-            # Find a free CID for this new channel
-            connection_channels = self.channels.setdefault(connection.handle, {})
-            source_cid = self.find_free_le_cid(connection_channels)
-            if source_cid is None:  # Should never happen!
-                self.send_control_frame(
-                    connection,
-                    cid,
-                    L2CAP_LE_Credit_Based_Connection_Response(
-                        identifier=request.identifier,
-                        destination_cid=0,
-                        mtu=server.mtu,
-                        mps=server.mps,
-                        initial_credits=0,
-                        # pylint: disable=line-too-long
-                        result=L2CAP_LE_Credit_Based_Connection_Response.Result.CONNECTION_REFUSED_NO_RESOURCES_AVAILABLE,
-                    ),
-                )
-                return
-
-            # Create a new channel
-            logger.debug(
-                f'creating LE CoC server channel with cid={source_cid} for psm '
-                f'{request.le_psm}'
+        if not (server := self.le_coc_servers.get(request.le_psm)):
+            logger.info(
+                f'No LE server for connection 0x{connection.handle:04X} '
+                f'on PSM {request.le_psm}'
             )
-            channel = LeCreditBasedChannel(
-                self,
+            self.send_control_frame(
                 connection,
-                request.le_psm,
-                source_cid,
-                request.source_cid,
-                server.mtu,
-                server.mps,
-                request.initial_credits,
-                request.mtu,
-                request.mps,
-                server.max_credits,
-                True,
+                cid,
+                L2CAP_LE_Credit_Based_Connection_Response(
+                    identifier=request.identifier,
+                    destination_cid=0,
+                    mtu=L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_MTU,
+                    mps=L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_MPS,
+                    initial_credits=0,
+                    result=L2CAP_LE_Credit_Based_Connection_Response.Result.CONNECTION_REFUSED_LE_PSM_NOT_SUPPORTED,
+                ),
             )
-            connection_channels[source_cid] = channel
-            le_connection_channels[request.source_cid] = channel
+            return
 
-            # Respond
+        # Check that the CID isn't already used
+        le_connection_channels = self.le_coc_channels.setdefault(connection.handle, {})
+        if request.source_cid in le_connection_channels:
+            logger.warning(f'source CID {request.source_cid} already in use')
             self.send_control_frame(
                 connection,
                 cid,
                 L2CAP_LE_Credit_Based_Connection_Response(
                     identifier=request.identifier,
-                    destination_cid=source_cid,
+                    destination_cid=0,
                     mtu=server.mtu,
                     mps=server.mps,
-                    initial_credits=server.max_credits,
-                    # pylint: disable=line-too-long
-                    result=L2CAP_LE_Credit_Based_Connection_Response.Result.CONNECTION_SUCCESSFUL,
+                    initial_credits=0,
+                    result=L2CAP_LE_Credit_Based_Connection_Response.Result.CONNECTION_REFUSED_SOURCE_CID_ALREADY_ALLOCATED,
                 ),
             )
+            return
 
-            # Notify
-            server.on_connection(channel)
-        else:
-            logger.info(
-                f'No LE server for connection 0x{connection.handle:04X} '
-                f'on PSM {request.le_psm}'
-            )
+        # Find a free CID for this new channel
+        connection_channels = self.channels.setdefault(connection.handle, {})
+        source_cid = self.find_free_le_cid(connection_channels)
+        if source_cid is None:  # Should never happen!
             self.send_control_frame(
                 connection,
                 cid,
                 L2CAP_LE_Credit_Based_Connection_Response(
                     identifier=request.identifier,
                     destination_cid=0,
-                    mtu=L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_MTU,
-                    mps=L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_MPS,
+                    mtu=server.mtu,
+                    mps=server.mps,
                     initial_credits=0,
-                    # pylint: disable=line-too-long
-                    result=L2CAP_LE_Credit_Based_Connection_Response.Result.CONNECTION_REFUSED_LE_PSM_NOT_SUPPORTED,
+                    result=L2CAP_LE_Credit_Based_Connection_Response.Result.CONNECTION_REFUSED_NO_RESOURCES_AVAILABLE,
                 ),
             )
+            return
+
+        # Create a new channel
+        logger.debug(
+            f'creating LE CoC server channel with cid={source_cid} for psm '
+            f'{request.le_psm}'
+        )
+        channel = LeCreditBasedChannel(
+            self,
+            connection,
+            request.le_psm,
+            source_cid,
+            request.source_cid,
+            server.mtu,
+            server.mps,
+            request.initial_credits,
+            request.mtu,
+            request.mps,
+            server.max_credits,
+            True,
+        )
+        connection_channels[source_cid] = channel
+        le_connection_channels[request.source_cid] = channel
+
+        # Respond
+        self.send_control_frame(
+            connection,
+            cid,
+            L2CAP_LE_Credit_Based_Connection_Response(
+                identifier=request.identifier,
+                destination_cid=source_cid,
+                mtu=server.mtu,
+                mps=server.mps,
+                initial_credits=server.max_credits,
+                # pylint: disable=line-too-long
+                result=L2CAP_LE_Credit_Based_Connection_Response.Result.CONNECTION_SUCCESSFUL,
+            ),
+        )
+
+        # Notify
+        server.on_connection(channel)
 
     def on_l2cap_le_credit_based_connection_response(
         self,
@@ -2082,11 +2702,9 @@ class ChannelManager:
         response: L2CAP_LE_Credit_Based_Connection_Response,
     ) -> None:
         # Find the pending request by identifier
-        request = self.le_coc_requests.get(response.identifier)
-        if request is None:
+        if not (request := self.le_coc_requests.pop(response.identifier, None)):
             logger.warning(color('!!! received response for unknown request', 'red'))
             return
-        del self.le_coc_requests[response.identifier]
 
         # Find the channel for this request
         channel = self.find_channel(connection.handle, request.source_cid)
@@ -2103,6 +2721,147 @@ class ChannelManager:
         # Process the response
         channel.on_connection_response(response)
 
+    def on_l2cap_credit_based_connection_request(
+        self,
+        connection: Connection,
+        cid: int,
+        request: L2CAP_Credit_Based_Connection_Request,
+    ) -> None:
+        if not (server := self.le_coc_servers.get(request.spsm)):
+            logger.info(
+                'No LE server for connection 0x%04X ' 'on PSM %d',
+                connection.handle,
+                request.spsm,
+            )
+            self.send_control_frame(
+                connection,
+                cid,
+                L2CAP_Credit_Based_Connection_Response(
+                    identifier=request.identifier,
+                    destination_cid=[],
+                    mtu=L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_MTU,
+                    mps=L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_MPS,
+                    initial_credits=0,
+                    result=L2CAP_Credit_Based_Connection_Response.Result.ALL_CONNECTIONS_REFUSED_SPSM_NOT_SUPPORTED,
+                ),
+            )
+            return
+
+        # Check that the CID isn't already used
+        le_connection_channels = self.le_coc_channels.setdefault(connection.handle, {})
+        if cid_in_use := set(request.source_cid).intersection(
+            set(le_connection_channels)
+        ):
+            logger.warning('source CID already in use: %s', cid_in_use)
+            self.send_control_frame(
+                connection,
+                cid,
+                L2CAP_Credit_Based_Connection_Response(
+                    identifier=request.identifier,
+                    mtu=server.mtu,
+                    mps=server.mps,
+                    initial_credits=0,
+                    result=L2CAP_Credit_Based_Connection_Response.Result.SOME_CONNECTIONS_REFUSED_SOURCE_CID_ALREADY_ALLOCATED,
+                    destination_cid=[],
+                ),
+            )
+            return
+
+        # Find free CIDs for new channels
+        connection_channels = self.channels.setdefault(connection.handle, {})
+        source_cids = self.find_free_le_cids(
+            connection_channels, len(request.source_cid)
+        )
+        if not source_cids:
+            self.send_control_frame(
+                connection,
+                cid,
+                L2CAP_Credit_Based_Connection_Response(
+                    identifier=request.identifier,
+                    destination_cid=[],
+                    mtu=server.mtu,
+                    mps=server.mps,
+                    initial_credits=server.max_credits,
+                    result=L2CAP_Credit_Based_Connection_Response.Result.SOME_CONNECTIONS_REFUSED_INSUFFICIENT_RESOURCES_AVAILABLE,
+                ),
+            )
+            return
+
+        for destination_cid in request.source_cid:
+            # TODO: Handle Classic channels.
+            if not (source_cid := self.find_free_le_cid(connection_channels)):
+                logger.warning("No free CIDs available")
+                break
+            # Create a new channel
+            logger.debug(
+                'creating LE CoC server channel with cid=%s for psm %s',
+                source_cid,
+                request.spsm,
+            )
+            channel = LeCreditBasedChannel(
+                self,
+                connection,
+                request.spsm,
+                source_cid,
+                destination_cid,
+                server.mtu,
+                server.mps,
+                request.initial_credits,
+                request.mtu,
+                request.mps,
+                server.max_credits,
+                True,
+            )
+            connection_channels[source_cid] = channel
+            le_connection_channels[source_cid] = channel
+            server.on_connection(channel)
+
+        # Respond
+        self.send_control_frame(
+            connection,
+            cid,
+            L2CAP_Credit_Based_Connection_Response(
+                identifier=request.identifier,
+                destination_cid=source_cids,
+                mtu=server.mtu,
+                mps=server.mps,
+                initial_credits=server.max_credits,
+                result=L2CAP_Credit_Based_Connection_Response.Result.ALL_CONNECTIONS_SUCCESSFUL,
+            ),
+        )
+
+    def on_l2cap_credit_based_connection_response(
+        self,
+        connection: Connection,
+        _cid: int,
+        response: L2CAP_Credit_Based_Connection_Response,
+    ) -> None:
+        # Find the pending request by identifier
+        pending_connections = self.pending_credit_based_connections.setdefault(
+            connection.handle, {}
+        )
+        if not (
+            pending_connection := pending_connections.pop(response.identifier, None)
+        ):
+            logger.warning(color('!!! received response for unknown request', 'red'))
+            return
+
+        connection_result, channels = pending_connection
+
+        # Process the response
+        for channel, destination_cid in zip(channels, response.destination_cid):
+            channel.on_enhanced_connection_response(destination_cid, response)
+
+        if (
+            response.result
+            == L2CAP_Credit_Based_Connection_Response.Result.ALL_CONNECTIONS_SUCCESSFUL
+        ):
+            connection_result.set_result(None)
+        else:
+            connection_result.set_exception(
+                L2capError(response.result, response.result.name)
+            )
+
     def on_l2cap_le_flow_control_credit(
         self, connection: Connection, _cid: int, credit: L2CAP_LE_Flow_Control_Credit
     ) -> None:
@@ -2138,7 +2897,7 @@ class ChannelManager:
         channel = LeCreditBasedChannel(
             manager=self,
             connection=connection,
-            le_psm=spec.psm,
+            psm=spec.psm,
             source_cid=source_cid,
             destination_cid=0,
             mtu=spec.mtu,
@@ -2184,12 +2943,12 @@ class ChannelManager:
             f'creating client channel with cid={source_cid} for psm {spec.psm}'
         )
         channel = ClassicChannel(
-            self,
-            connection,
-            L2CAP_SIGNALING_CID,
-            spec.psm,
-            source_cid,
-            spec.mtu,
+            manager=self,
+            connection=connection,
+            signaling_cid=L2CAP_SIGNALING_CID,
+            psm=spec.psm,
+            source_cid=source_cid,
+            spec=spec,
         )
         connection_channels[source_cid] = channel
 
@@ -2197,7 +2956,100 @@ class ChannelManager:
         try:
             await channel.connect()
         except BaseException as e:
-            del connection_channels[source_cid]
+            connection_channels.pop(source_cid, None)
             raise e
 
         return channel
+
+    async def create_enhanced_credit_based_channels(
+        self,
+        connection: Connection,
+        spec: LeCreditBasedChannelSpec,
+        count: int,
+    ) -> list[LeCreditBasedChannel]:
+        # Find a free CID for the new channel
+        connection_channels = self.channels.setdefault(connection.handle, {})
+        source_cids = self.find_free_le_cids(connection_channels, count)
+        if not source_cids:  # Should never happen!
+            raise OutOfResourcesError('all CIDs already in use')
+
+        if spec.psm is None:
+            raise InvalidArgumentError('PSM cannot be None')
+
+        # Create the channel
+        logger.debug(
+            'creating coc channel with cid=%s for psm %s', source_cids, spec.psm
+        )
+        channels: list[LeCreditBasedChannel] = []
+        for source_cid in source_cids:
+            channel = LeCreditBasedChannel(
+                manager=self,
+                connection=connection,
+                psm=spec.psm,
+                source_cid=source_cid,
+                destination_cid=0,
+                mtu=spec.mtu,
+                mps=spec.mps,
+                credits=0,
+                peer_mtu=0,
+                peer_mps=0,
+                peer_credits=spec.max_credits,
+                connected=False,
+            )
+            connection_channels[source_cid] = channel
+            channels.append(channel)
+
+        identifier = self.next_identifier(connection)
+        request = L2CAP_Credit_Based_Connection_Request(
+            identifier=identifier,
+            spsm=spec.psm,
+            mtu=spec.mtu,
+            mps=spec.mps,
+            initial_credits=spec.max_credits,
+            source_cid=source_cids,
+        )
+        connection_result = asyncio.get_running_loop().create_future()
+        pending_connections = self.pending_credit_based_connections.setdefault(
+            connection.handle, {}
+        )
+        pending_connections[identifier] = (connection_result, channels)
+        self.send_control_frame(
+            connection,
+            L2CAP_LE_SIGNALING_CID,
+            request,
+        )
+        # Connect
+        try:
+            await connection_result
+        except Exception:
+            logger.exception('connection failed')
+            for cid in source_cids:
+                del connection_channels[cid]
+            raise
+
+        # Remember the channel by source CID and destination CID
+        le_connection_channels = self.le_coc_channels.setdefault(connection.handle, {})
+        for channel in channels:
+            le_connection_channels[channel.destination_cid] = channel
+
+        return channels
+
+    @classmethod
+    def make_mode_processor(
+        self,
+        channel: ClassicChannel,
+        mode: TransmissionMode,
+        peer_tx_window_size: int,
+        peer_max_retransmission: int,
+        peer_retransmission_timeout: int,
+        peer_monitor_timeout: int,
+        peer_mps: int,
+    ) -> Processor:
+        del peer_retransmission_timeout, peer_monitor_timeout  # Unused.
+        if mode == TransmissionMode.BASIC:
+            return Processor(channel)
+        elif mode == TransmissionMode.ENHANCED_RETRANSMISSION:
+            return EnhancedRetransmissionProcessor(
+                channel, peer_tx_window_size, peer_max_retransmission, peer_mps
+            )
+        raise InvalidArgumentError("Mode %s is not implemented", mode.name)