Sockets match CPython sockets. simpletest.py runs.

Author: BiffoBear

adafruit_wiznet5k/adafruit_wiznet5k.py

@@ -264,11 +264,13 @@ def get_host_by_name(self, hostname: str) -> bytes:
         :return Union[int, bytes]: a 4 bytearray.
         """
         if self._debug:
-            print("* Get host by name")
+            print(f"* Get host by name : {hostname}")
         if isinstance(hostname, str):
             hostname = bytes(hostname, "utf-8")
         # Return IP assigned by DHCP
-        _dns_client = dns.DNS(self, self._dns, debug=self._debug)
+        _dns_client = dns.DNS(
+            self, self.pretty_ip(bytearray(self._dns)), debug=self._debug
+        )
         ret = _dns_client.gethostbyname(hostname)
         if self._debug:
             print("* Resolved IP: ", ret)

adafruit_wiznet5k/adafruit_wiznet5k_dhcp.py

@@ -267,8 +267,9 @@ def parse_dhcp_response(
 
         :return Union[Tuple[int, bytes], Tuple[int, int]]: DHCP packet type.
         """
+        global _BUFF  # pylint: disable=global-statement
         # store packet in buffer
-        _BUFF = self._sock.recv()
+        _BUFF = bytearray(self._sock.recv(len(_BUFF)))
         if self._debug:
             print("DHCP Response: ", _BUFF)
 
@@ -403,8 +404,10 @@ def _dhcp_state_machine(self) -> None:
                 self._dhcp_state = STATE_DHCP_WAIT
             else:
                 self._sock.settimeout(self._response_timeout)
-                self._sock.bind((None, 68))
-                self._sock.connect((self.dhcp_server_ip, DHCP_SERVER_PORT))
+                self._sock.bind(("", 68))
+                self._sock.connect(
+                    (".".join(map(str, self.dhcp_server_ip)), DHCP_SERVER_PORT)
+                )
                 if self._last_lease_time == 0 or time.monotonic() > (
                     self._last_lease_time + self._lease_time
                 ):
@@ -423,7 +426,7 @@ def _dhcp_state_machine(self) -> None:
                     self._dhcp_state = STATE_DHCP_REQUEST
 
         elif self._dhcp_state == STATE_DHCP_DISCOVER:
-            if self._sock.available():
+            if self._sock._available():  # pylint: disable=protected-access
                 if self._debug:
                     print("* DHCP: Parsing OFFER")
                 msg_type, xid = self.parse_dhcp_response()
@@ -448,7 +451,7 @@ def _dhcp_state_machine(self) -> None:
                         print("* DHCP: Received DHCP Message is not OFFER")
 
         elif self._dhcp_state == STATE_DHCP_REQUEST:
-            if self._sock.available():
+            if self._sock._available():  # pylint: disable=protected-access
                 if self._debug:
                     print("* DHCP: Parsing ACK")
                 msg_type, xid = self.parse_dhcp_response()

adafruit_wiznet5k/adafruit_wiznet5k_dns.py

@@ -15,6 +15,8 @@
 """
 from __future__ import annotations
 
+import gc
+
 try:
     from typing import TYPE_CHECKING, Union, Tuple
 
@@ -54,7 +56,7 @@ def __init__(
         self,
         iface: WIZNET5K,
         dns_address: Union[str, Tuple[int, int, int, int]],
-        debug: bool = False,
+        debug: bool = True,
     ) -> None:
         """
         :param adafruit_wiznet5k.WIZNET5K: Ethernet network connection.
@@ -66,7 +68,6 @@ def __init__(
         socket.set_interface(iface)
         self._sock = socket.socket(type=socket.SOCK_DGRAM)
         self._sock.settimeout(1)
-
         self._dns_server = dns_address
         self._host = b""
         self._request_id = 0  # request identifier
@@ -80,6 +81,7 @@ def gethostbyname(self, hostname: bytes) -> Union[int, bytes]:
 
         :return Union[int, bytes] The IPv4 address if successful, -1 otherwise.
         """
+
         if self._dns_server is None:
             return INVALID_SERVER
         self._host = hostname
@@ -88,7 +90,7 @@ def gethostbyname(self, hostname: bytes) -> Union[int, bytes]:
         self._build_dns_question()
 
         # Send DNS request packet
-        self._sock.bind((None, DNS_PORT))
+        self._sock.bind(("", DNS_PORT))
         self._sock.connect((self._dns_server, DNS_PORT))
         if self._debug:
             print("* DNS: Sending request packet...")
@@ -225,6 +227,7 @@ def _parse_dns_response(
                 print("* DNS ERROR: Unexpected Data Length: ", data_len)
             return -1
         ptr += 2
+        gc.collect()
         # Return address
         return self._pkt_buf[ptr : ptr + 4]
 

adafruit_wiznet5k/adafruit_wiznet5k_socket.py

@@ -186,6 +186,8 @@ def gethostbyname(hostname: str) -> str:
 
     :return str: IPv4 address (a string of the form '0.0.0.0').
     """
+    if _is_ipv4_string(hostname):
+        return hostname
     address = _the_interface.get_host_by_name(hostname)
     address = "{}.{}.{}.{}".format(address[0], address[1], address[2], address[3])
     return address
@@ -297,7 +299,9 @@ def bind(self, address: Tuple[Optional[str], int]) -> None:
         :raises ValueError: If the IPv4 address specified is not the address
             assigned to the WIZNET5K interface.
         """
-        if not self._listen_port:
+        if self._listen_port:
+            raise ConnectionError("The socket is already bound.")
+        if address[0]:
             if gethostbyname(address[0]) != _the_interface.pretty_ip(
                 _the_interface.ip_address
             ):
@@ -307,18 +311,16 @@ def bind(self, address: Tuple[Optional[str], int]) -> None:
                         _the_interface.pretty_ip(_the_interface.ip_address)
                     )
                 )
-            self._listen_port = address[1]
-            # For UDP servers we need to open the socket here because we won't call
-            # listen
-            if self._sock_type == SOCK_DGRAM:
-                _the_interface.socket_listen(
-                    self._socknum,
-                    self._listen_port,
-                    wiznet5k.adafruit_wiznet5k.SNMR_UDP,
-                )
-                self._buffer = b""
-        else:
-            raise ConnectionError("The socket is already bound.")
+        self._listen_port = address[1]
+        # For UDP servers we need to open the socket here because we won't call
+        # listen
+        if self._sock_type == SOCK_DGRAM:
+            _the_interface.socket_listen(
+                self._socknum,
+                self._listen_port,
+                wiznet5k.adafruit_wiznet5k.SNMR_UDP,
+            )
+            self._buffer = b""
 
     def listen(self, backlog: int = 0) -> None:
         """
@@ -379,7 +381,10 @@ def connect(self, address: Tuple[str, int]) -> None:
         if self._listen_port is not None:
             _the_interface.src_port = self._listen_port
         result = _the_interface.socket_connect(
-            self._socknum, bytes(gethostbyname(address[0])), address[1], self._sock_type
+            self._socknum,
+            _the_interface.unpretty_ip(gethostbyname(address[0])),
+            address[1],
+            self._sock_type,
         )
         _the_interface.src_port = 0
         if not result:
@@ -467,8 +472,6 @@ def _embed_recv(
 
         :return bytes: All data available from the connection.
         """
-        # print("Socket read", bufsize)
-        ret = None
         avail = self._available()
         if avail:
             if self._sock_type == SOCK_STREAM:
@@ -477,7 +480,6 @@ def _embed_recv(
                 self._buffer += _the_interface.read_udp(self._socknum, avail)[1]
         gc.collect()
         ret = self._buffer
-        # print("RET ptr:", id(ret), id(self._buffer))
         self._buffer = b""
         gc.collect()
         return ret
@@ -597,7 +599,6 @@ def settimeout(self, value: Optional[float]) -> None:
 
         :param fOptional[float] value: Socket read timeout in seconds.
         """
-        # TODO: Implement None and 0.0 as valid once all socket funcs can handle them.
         if value is None or (isinstance(value, (int, float)) and value >= 0):
             self._timeout = value
         else: