Merge branch 'main' into new_dhcp_state_machine

# Conflicts:
#	adafruit_wiznet5k/adafruit_wiznet5k.py

Author: FoamyGuy

adafruit_wiznet5k/adafruit_wiznet5k.py

@@ -45,12 +45,13 @@
 
 from random import randint
 import time
+import gc
 from micropython import const
 
 from adafruit_bus_device.spi_device import SPIDevice
-from adafruit_wiznet5k.adafruit_wiznet5k_debug import debug_msg
 import adafruit_wiznet5k.adafruit_wiznet5k_dhcp as dhcp
 import adafruit_wiznet5k.adafruit_wiznet5k_dns as dns
+from adafruit_wiznet5k.adafruit_wiznet5k_debug import debug_msg
 
 # Wiznet5k Registers
 _REG_MR = const(0x0000)  # Mode
@@ -110,9 +111,9 @@
 
 # Socket n Interrupt Register
 _SNIR_SEND_OK = const(0x10)
-_SNIR_TIMEOUT = const(0x08)
+SNIR_TIMEOUT = const(0x08)
 _SNIR_RECV = const(0x04)
-_SNIR_DISCON = const(0x02)
+SNIR_DISCON = const(0x02)
 _SNIR_CON = const(0x01)
 
 _CH_SIZE = const(0x100)
@@ -149,6 +150,8 @@ class WIZNET5K:  # pylint: disable=too-many-public-methods, too-many-instance-at
     _UDP_MODE = const(0x02)
     _TLS_MODE = const(0x03)  # This is NOT currently implemented
 
+    _sockets_reserved = []
+
     # pylint: disable=too-many-arguments
     def __init__(
         self,
@@ -192,6 +195,13 @@ def __init__(
         self._ch_base_msb = 0
         if self._w5xxx_init() != 1:
             raise RuntimeError("Failed to initialize WIZnet module.")
+        if self._chip_type == "w5100s":
+            WIZNET5K._sockets_reserved = [False] * (_W5100_MAX_SOCK_NUM - 1)
+        elif self._chip_type == "w5500":
+            WIZNET5K._sockets_reserved = [False] * (_W5200_W5500_MAX_SOCK_NUM - 1)
+        else:
+            raise RuntimeError("Unrecognized chip type.")
+
         # Set MAC address
         self.mac_address = mac
         self.src_port = 0
@@ -719,23 +729,62 @@ def _send_socket_cmd(self, socket: int, cmd: int) -> None:
         while self.read_sncr(socket) != b"\x00":
             debug_msg("waiting for SNCR to clear...", self._debug)
 
-    def get_socket(self) -> int:
-        """Request, allocate and return a socket from the W5k chip.
+    def get_socket(self, *, reserve_socket=False) -> int:
+        """
+        Request, allocate and return a socket from the W5k chip.
+
+        Cycle through the sockets to find the first available one. If the called with
+        reserve_socket=True, update the list of reserved sockets (intended to be used with
+        socket.socket()). Note that reserved sockets must be released by calling
+        cancel_reservation() once they are no longer needed.
+
+        If all sockets are reserved, no sockets are available for DNS calls, etc. Therefore,
+        one socket cannot be reserved. Since socket 0 is the only socket that is capable of
+        operating in MacRAW mode, it is the non-reservable socket.
 
-        Cycle through the sockets to find the first available one, if any.
+        :param bool reserve_socket: Whether to reserve the socket.
 
-        :return int: The first available socket. Returns 0xFF if no sockets are free.
+        :returns int: The first available socket.
+
+        :raises RuntimeError: If no socket is available.
         """
-        debug_msg("get_socket", self._debug)
 
-        sock = _SOCKET_INVALID
-        for _sock in range(self.max_sockets):
-            status = self.socket_status(_sock)[0]
-            if status == SNSR_SOCK_CLOSED:
-                sock = _sock
-                break
-        debug_msg("Allocated socket #{}".format(sock), self._debug)
-        return sock
+        debug_msg("*** Get socket.", self._debug)
+        # Prefer socket zero for none reserved calls as it cannot be reserved.
+        if not reserve_socket and self.socket_status(0)[0] == SNSR_SOCK_CLOSED:
+            debug_msg("Allocated socket # 0", self._debug)
+            return 0
+        # Then check the other sockets.
+
+        #  Call garbage collection to encourage socket.__del__() be called to on any
+        #  destroyed instances. Not at all guaranteed to work!
+        gc.collect()
+        debug_msg(
+            "Reserved sockets: {}".format(WIZNET5K._sockets_reserved), self._debug
+        )
+
+        for socket_number, reserved in enumerate(WIZNET5K._sockets_reserved, start=1):
+            if (
+                not reserved
+                and self.socket_status(socket_number)[0] == SNSR_SOCK_CLOSED
+            ):
+                if reserve_socket:
+                    WIZNET5K._sockets_reserved[socket_number - 1] = True
+                    debug_msg(
+                        "Allocated socket # {}.".format(socket_number),
+                        self._debug,
+                    )
+                return socket_number
+        raise RuntimeError("Out of sockets.")
+
+    @staticmethod
+    def release_socket(socket_number):
+        """
+        Update the socket reservation list when a socket is no longer reserved.
+
+        :param int socket_number: The socket to release.
+        """
+        WIZNET5K._sockets_reserved[socket_number - 1] = False
 
     def socket_listen(
         self, socket_num: int, port: int, conn_mode: int = _SNMR_TCP
@@ -831,7 +880,7 @@ def socket_open(self, socket_num: int, conn_mode: int = _SNMR_TCP) -> int:
             time.sleep(0.00025)
 
             self.write_snmr(socket_num, conn_mode)
-            self._write_snir(socket_num, 0xFF)
+            self.write_snir(socket_num, 0xFF)
 
             if self.src_port > 0:
                 # write to socket source port
@@ -1050,7 +1099,7 @@ def socket_write(
                     "Hardware timeout while sending on socket {}.".format(socket_num)
                 )
             time.sleep(0.001)
-        self._write_snir(socket_num, _SNIR_SEND_OK)
+        self.write_snir(socket_num, _SNIR_SEND_OK)
         return ret
 
     # Socket-Register Methods
@@ -1130,14 +1179,14 @@ def read_snsr(self, sock: int) -> Optional[bytearray]:
         return self._read_socket(sock, _REG_SNSR)
 
     def read_snir(self, sock: int) -> Optional[bytearray]:
-        """Read Socket n Interrupt Register."""
+        """Read Socket n Status Register."""
         return self._read_socket(sock, _REG_SNIR)
 
     def write_snmr(self, sock: int, protocol: int) -> None:
         """Write to Socket n Mode Register."""
         self._write_socket(sock, _REG_SNMR, protocol)
 
-    def _write_snir(self, sock: int, data: int) -> None:
+    def write_snir(self, sock: int, data: int) -> None:
         """Write to Socket n Interrupt Register."""
         self._write_socket(sock, _REG_SNIR, data)
 

adafruit_wiznet5k/adafruit_wiznet5k_socket.py

@@ -227,30 +227,55 @@ def __init__(
         """
         if family != AF_INET:
             raise RuntimeError("Only AF_INET family supported by W5K modules.")
+        self._socket_closed = False
         self._sock_type = type
         self._buffer = b""
         self._timeout = _default_socket_timeout
         self._listen_port = None
 
-        self._socknum = _the_interface.get_socket()
+        self._socknum = _the_interface.get_socket(reserve_socket=True)
         if self._socknum == _SOCKET_INVALID:
             raise RuntimeError("Failed to allocate socket.")
 
+    def __del__(self):
+        _the_interface.release_socket(self._socknum)
+
     def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        _the_interface.release_socket(self._socknum)
         if self._sock_type == SOCK_STREAM:
-            self._disconnect()
-            stamp = time.monotonic()
-            while self._status == wiznet5k.adafruit_wiznet5k.SNSR_SOCK_FIN_WAIT:
-                if time.monotonic() - stamp > 1000:
-                    raise RuntimeError("Failed to disconnect socket")
-        self.close()
-        stamp = time.monotonic()
-        while self._status != wiznet5k.adafruit_wiznet5k.SNSR_SOCK_CLOSED:
-            if time.monotonic() - stamp > 1000:
-                raise RuntimeError("Failed to close socket")
+            _the_interface.write_snir(
+                self._socknum, 0xFF
+            )  # Reset socket interrupt register.
+            _the_interface.socket_disconnect(self._socknum)
+            mask = (
+                wiznet5k.adafruit_wiznet5k.SNIR_TIMEOUT
+                | wiznet5k.adafruit_wiznet5k.SNIR_DISCON
+            )
+            while not _the_interface.read_snir(self._socknum)[0] & mask:
+                pass
+        _the_interface.write_snir(
+            self._socknum, 0xFF
+        )  # Reset socket interrupt register.
+        _the_interface.socket_close(self._socknum)
+        while (
+            _the_interface.socket_status(self._socknum)[0]
+            != wiznet5k.adafruit_wiznet5k.SNSR_SOCK_CLOSED
+        ):
+            pass
+
+    # This works around problems with using a class method as a decorator.
+    def _check_socket_closed(func):  # pylint: disable=no-self-argument
+        """Decorator to check whether the socket object has been closed."""
+
+        def wrapper(self, *args, **kwargs):
+            if self._socket_closed:  # pylint: disable=protected-access
+                raise RuntimeError("The socket has been closed.")
+            return func(self, *args, **kwargs)  # pylint: disable=not-callable
+
+        return wrapper
 
     @property
     def _status(self) -> int:
@@ -289,6 +314,7 @@ def _connected(self) -> bool:
             self.close()
         return result
 
+    @_check_socket_closed
     def getpeername(self) -> Tuple[str, int]:
         """
         Return the remote address to which the socket is connected.
@@ -299,6 +325,7 @@ def getpeername(self) -> Tuple[str, int]:
             self._socknum
         )
 
+    @_check_socket_closed
     def bind(self, address: Tuple[Optional[str], int]) -> None:
         """
         Bind the socket to address. The socket must not already be bound.
@@ -344,6 +371,7 @@ def _bind(self, address: Tuple[Optional[str], int]) -> None:
             )
             self._buffer = b""
 
+    @_check_socket_closed
     def listen(self, backlog: int = 0) -> None:
         """
         Enable a server to accept connections.
@@ -355,6 +383,7 @@ def listen(self, backlog: int = 0) -> None:
         _the_interface.socket_listen(self._socknum, self._listen_port)
         self._buffer = b""
 
+    @_check_socket_closed
     def accept(
         self,
     ) -> Tuple[socket, Tuple[str, int]]:
@@ -389,6 +418,7 @@ def accept(
             raise RuntimeError("Failed to open new listening socket")
         return client_sock, addr
 
+    @_check_socket_closed
     def connect(self, address: Tuple[str, int]) -> None:
         """
         Connect to a remote socket at address.
@@ -408,6 +438,7 @@ def connect(self, address: Tuple[str, int]) -> None:
             raise RuntimeError("Failed to connect to host ", address[0])
         self._buffer = b""
 
+    @_check_socket_closed
     def send(self, data: Union[bytes, bytearray]) -> int:
         """
         Send data to the socket. The socket must be connected to a remote socket.
@@ -423,6 +454,7 @@ def send(self, data: Union[bytes, bytearray]) -> int:
         gc.collect()
         return bytes_sent
 
+    @_check_socket_closed
     def sendto(self, data: bytearray, *flags_and_or_address: any) -> int:
         """
         Send data to the socket. The socket should not be connected to a remote socket, since the
@@ -446,6 +478,7 @@ def sendto(self, data: bytearray, *flags_and_or_address: any) -> int:
         self.connect(address)
         return self.send(data)
 
+    @_check_socket_closed
     def recv(
         # pylint: disable=too-many-branches
         self,
@@ -501,6 +534,7 @@ def _embed_recv(
         gc.collect()
         return ret
 
+    @_check_socket_closed
     def recvfrom(self, bufsize: int, flags: int = 0) -> Tuple[bytes, Tuple[str, int]]:
         """
         Receive data from the socket. The return value is a pair (bytes, address) where bytes is
@@ -521,6 +555,7 @@ def recvfrom(self, bufsize: int, flags: int = 0) -> Tuple[bytes, Tuple[str, int]
             ),
         )
 
+    @_check_socket_closed
     def recv_into(self, buffer: bytearray, nbytes: int = 0, flags: int = 0) -> int:
         """
         Receive up to nbytes bytes from the socket, storing the data into a buffer
@@ -539,6 +574,7 @@ def recv_into(self, buffer: bytearray, nbytes: int = 0, flags: int = 0) -> int:
         buffer[:nbytes] = bytes_received
         return nbytes
 
+    @_check_socket_closed
     def recvfrom_into(
         self, buffer: bytearray, nbytes: int = 0, flags: int = 0
     ) -> Tuple[int, Tuple[str, int]]:
@@ -597,12 +633,15 @@ def _disconnect(self) -> None:
             raise RuntimeError("Socket must be a TCP socket.")
         _the_interface.socket_disconnect(self._socknum)
 
+    @_check_socket_closed
     def close(self) -> None:
         """
         Mark the socket closed. Once that happens, all future operations on the socket object
         will fail. The remote end will receive no more data.
         """
+        _the_interface.release_socket(self._socknum)
         _the_interface.socket_close(self._socknum)
+        self._socket_closed = True
 
     def _available(self) -> int:
         """
@@ -612,6 +651,7 @@ def _available(self) -> int:
         """
         return _the_interface.socket_available(self._socknum, self._sock_type)
 
+    @_check_socket_closed
     def settimeout(self, value: Optional[float]) -> None:
         """
         Set a timeout on blocking socket operations. The value argument can be a
@@ -628,6 +668,7 @@ def settimeout(self, value: Optional[float]) -> None:
         else:
             raise ValueError("Timeout must be None, 0.0 or a positive numeric value.")
 
+    @_check_socket_closed
     def gettimeout(self) -> Optional[float]:
         """
         Return the timeout in seconds (float) associated with socket operations, or None if no
@@ -637,6 +678,7 @@ def gettimeout(self) -> Optional[float]:
         """
         return self._timeout
 
+    @_check_socket_closed
     def setblocking(self, flag: bool) -> None:
         """
         Set blocking or non-blocking mode of the socket: if flag is false, the socket is set
@@ -659,6 +701,7 @@ def setblocking(self, flag: bool) -> None:
         else:
             raise TypeError("Flag must be a boolean.")
 
+    @_check_socket_closed
     def getblocking(self) -> bool:
         """
         Return True if socket is in blocking mode, False if in non-blocking.
@@ -670,16 +713,19 @@ def getblocking(self) -> bool:
         return self.gettimeout() == 0
 
     @property
+    @_check_socket_closed
     def family(self) -> int:
         """Socket family (always 0x03 in this implementation)."""
         return 3
 
     @property
+    @_check_socket_closed
     def type(self):
         """Socket type."""
         return self._sock_type
 
     @property
+    @_check_socket_closed
     def proto(self):
         """Socket protocol (always 0x00 in this implementation)."""
         return 0