aioble/l2cap: Convert OSError EINVAL to L2CAPDisconnectedError

When the BLE peer disconnects during an L2CAP transfer, ble.l2cap_send(),
ble.l2cap_recvinto(), and ble.l2cap_disconnect() raise OSError with errno
EINVAL because the connection handle or CID is no longer valid.

Callers catch L2CAPDisconnectedError (now a DeviceDisconnectedError
subclass) for clean disconnect handling, but the raw OSError was not
being converted — it fell through to generic exception handlers.

Wrap all three call sites:
- send(): catch OSError EINVAL, raise L2CAPDisconnectedError
- recvinto(): catch OSError EINVAL, raise L2CAPDisconnectedError
- disconnect(): catch OSError EINVAL, set _cid = None, return cleanly

Author: pi-anl

micropython/bluetooth/aioble/aioble/l2cap.py

@@ -4,6 +4,7 @@
 from micropython import const
 
 import asyncio
+import errno
 
 from .core import ble, log_error, register_irq_handler
 from .device import DeviceConnection, DeviceDisconnectedError
@@ -118,10 +119,17 @@ async def recvinto(self, buf, timeout_ms=None):
         self._assert_connected()
 
         # Extract up to len(buf) bytes from the channel buffer.
-        n = ble.l2cap_recvinto(self._connection._conn_handle, self._cid, buf)
+        try:
+            n = ble.l2cap_recvinto(self._connection._conn_handle, self._cid, buf)
 
-        # Check if there's still remaining data in the channel buffers.
-        self._data_ready = ble.l2cap_recvinto(self._connection._conn_handle, self._cid, None) > 0
+            # Check if there's still remaining data in the channel buffers.
+            self._data_ready = (
+                ble.l2cap_recvinto(self._connection._conn_handle, self._cid, None) > 0
+            )
+        except OSError as e:
+            if e.errno == errno.EINVAL:
+                raise L2CAPDisconnectedError()
+            raise
 
         return n
 
@@ -141,11 +149,16 @@ async def send(self, buf, timeout_ms=None, chunk_size=None):
                 await self.flush(timeout_ms)
             # l2cap_send returns True if you can send immediately.
             self._assert_connected()
-            self._stalled = not ble.l2cap_send(
-                self._connection._conn_handle,
-                self._cid,
-                mv[offset : offset + chunk_size],
-            )
+            try:
+                self._stalled = not ble.l2cap_send(
+                    self._connection._conn_handle,
+                    self._cid,
+                    mv[offset : offset + chunk_size],
+                )
+            except OSError as e:
+                if e.errno == errno.EINVAL:
+                    raise L2CAPDisconnectedError()
+                raise
             offset += chunk_size
 
     async def flush(self, timeout_ms=None):
@@ -161,7 +174,14 @@ async def disconnect(self, timeout_ms=1000):
             return
 
         # Wait for the cid to be cleared by the disconnect IRQ.
-        ble.l2cap_disconnect(self._connection._conn_handle, self._cid)
+        try:
+            ble.l2cap_disconnect(self._connection._conn_handle, self._cid)
+        except OSError as e:
+            if e.errno == errno.EINVAL:
+                # Channel already closed by peer — treat as disconnected.
+                self._cid = None
+                return
+            raise
         await self.disconnected(timeout_ms)
 
     async def disconnected(self, timeout_ms=1000):