refactor: (cont) merge transport/windows -> platform/windows

Author: zjkmxy

src/ndn/app_support/dispatcher.py

@@ -17,7 +17,7 @@
 # -----------------------------------------------------------------------------
 from typing import Optional
 from ..encoding import NonStrictName, Name, BinaryStr, InterestParam, FormalName
-from ..types import Validator, Route
+from ..types import Route
 from ..name_tree import NameTrie, PrefixTreeNode
 
 

src/ndn/client_conf.py

@@ -85,8 +85,8 @@ def resolve_location(item: str, value: str) -> str:
 
 
 def default_keychain(pib: str, tpm: str) -> Keychain:
-    pib_schema, pib_loc = pib.split(':')
-    tpm_schema, tpm_loc = tpm.split(':')
+    pib_schema, pib_loc = pib.split(':', 1)
+    tpm_schema, tpm_loc = tpm.split(':', 1)
     if tpm_schema == 'tpm-file':
         tpm = TpmFile(tpm_loc)
     elif tpm_schema == 'tpm-osxkeychain':

src/ndn/encoding/tlv_model.py

@@ -683,7 +683,7 @@ def encoded_length(self, markers: Optional[dict] = None) -> int:
         ret = 0
         for field in self._encoded_fields:
             ret += field.encoded_length(field.get_value(self), markers)
-        markers[f'##encoded_length'] = ret
+        markers['##encoded_length'] = ret
         return ret
 
     def encode(self,
@@ -706,8 +706,8 @@ def encode(self,
         """
         if markers is None:
             markers = {}
-        if f'##encoded_length' in markers:
-            length = markers[f'##encoded_length']
+        if '##encoded_length' in markers:
+            length = markers['##encoded_length']
         else:
             length = self.encoded_length(markers)
         if wire is None:

src/ndn/platform/general.py

@@ -64,3 +64,7 @@ def default_tpm_schema(self) -> str:
     @abc.abstractmethod
     def default_tpm_paths(self) -> List[str]:
         pass
+
+    @abc.abstractmethod
+    async def open_unix_connection(self, path=None):
+        pass

src/ndn/platform/linux.py

@@ -16,6 +16,7 @@
 # limitations under the License.
 # -----------------------------------------------------------------------------
 import os
+import asyncio as aio
 from .general import Platform
 
 
@@ -40,3 +41,6 @@ def default_tpm_schema(self):
 
     def default_tpm_paths(self):
         return [os.path.expanduser(r'~/.ndn/ndnsec-key-file')]
+
+    async def open_unix_connection(self, path=None):
+        return await aio.open_unix_connection(path)

src/ndn/platform/osx.py

@@ -17,6 +17,7 @@
 # -----------------------------------------------------------------------------
 import os
 import sys
+import asyncio as aio
 from ctypes import cdll, c_void_p, c_ubyte, POINTER, c_int32, c_ulong, c_uint16
 from .general import Platform
 if sys.platform == 'darwin':
@@ -133,3 +134,6 @@ def default_tpm_schema(self):
 
     def default_tpm_paths(self):
         return [os.path.expanduser(r'~/.ndn/ndnsec-key-file')]
+
+    async def open_unix_connection(self, path=None):
+        return await aio.open_unix_connection(path)

src/ndn/platform/windows.py

@@ -16,10 +16,22 @@
 # limitations under the License.
 # -----------------------------------------------------------------------------
 import os
+import aenum
+import socket
+import asyncio as aio
 import ctypes as c
 from .general import Platform
 
 
+class SockaddrUn(c.Structure):
+    _fields_ = [("sun_family", c.c_ushort), ("sun_path", c.c_char * 108)]
+
+
+aenum.extend_enum(socket.AddressFamily, "AF_UNIX", 1)
+AF_UNIX = socket.AddressFamily(1)
+NULL = 0
+
+
 class Cng:
     __instance = None
 
@@ -45,7 +57,7 @@ def client_conf_paths(self):
 
     def default_transport(self):
         # Note: %TEMP% won't be redirected even when the executable is a MSIX/MicrosoftStore app
-        return 'unix://' + os.path.expandvars(r'%TEMP%\ndn\nfd.sock')
+        return 'unix://' + os.path.expandvars(r'%TEMP%\nfd.sock')
 
     def default_pib_schema(self):
         return 'pib-sqlite3'
@@ -60,3 +72,71 @@ def default_tpm_schema(self):
     def default_tpm_paths(self):
         return [os.path.expandvars(r'%LOCALAPPDATA%\ndn\ndnsec-key-file'),
                 os.path.expandvars(r'%USERPROFILE%\ndn\ndnsec-key-file')]
+
+    @staticmethod
+    def _iocp_connect(proactor, conn, address):
+        # _overlapped.WSAConnect(conn.fileno(), address)
+        addr = SockaddrUn(AF_UNIX.value, address.encode() + b"\0")
+        winsock = c.windll.ws2_32
+        winsock.connect(conn.fileno(), addr, 110)
+
+        fut = proactor._loop.create_future()
+        fut.set_result(None)
+        return fut
+
+    @staticmethod
+    async def _create_unix_connection(
+            loop, protocol_factory, path=None, *,
+            ssl=None, sock=None,
+            server_hostname=None,
+            ssl_handshake_timeout=None):
+        assert server_hostname is None or isinstance(server_hostname, str)
+        if ssl:
+            if server_hostname is None:
+                raise ValueError(
+                    'you have to pass server_hostname when using ssl')
+        else:
+            if server_hostname is not None:
+                raise ValueError('server_hostname is only meaningful with ssl')
+            if ssl_handshake_timeout is not None:
+                raise ValueError(
+                    'ssl_handshake_timeout is only meaningful with ssl')
+
+        if path is not None:
+            if sock is not None:
+                raise ValueError(
+                    'path and sock can not be specified at the same time')
+
+            path = os.fspath(path)
+            sock = socket.socket(AF_UNIX, socket.SOCK_STREAM, 0)
+            try:
+                sock.setblocking(False)
+                # await loop.sock_connect(sock, path)
+                await Win32._iocp_connect(loop._proactor, sock, path)
+            except OSError:
+                sock.close()
+                raise
+
+        else:
+            if sock is None:
+                raise ValueError('no path and sock were specified')
+            if sock.family != AF_UNIX or sock.type != socket.SOCK_STREAM:
+                raise ValueError(
+                    f'A UNIX Domain Stream Socket was expected, got {sock!r}')
+            sock.setblocking(False)
+
+        transport, protocol = await loop._create_connection_transport(
+            sock, protocol_factory, ssl, server_hostname,
+            ssl_handshake_timeout=ssl_handshake_timeout)
+        return transport, protocol
+
+    async def open_unix_connection(self, path=None):
+        """
+        Similar to `open_connection` but works with UNIX Domain Sockets.
+        """
+        loop = aio.events.get_running_loop()
+        reader = aio.StreamReader(limit=2 ** 16, loop=loop)
+        protocol = aio.StreamReaderProtocol(reader, loop=loop)
+        transport, _ = await Win32._create_unix_connection(loop, lambda: protocol, path)
+        writer = aio.StreamWriter(transport, protocol, reader, loop)
+        return reader, writer

src/ndn/security/tpm/tpm_cng.py

@@ -16,5 +16,5 @@
 # limitations under the License.
 # -----------------------------------------------------------------------------
 import sys
-if sys.platform == 'darwin':
+if sys.platform == 'win32':
     from ...platform.windows import Cng

src/ndn/transport/stream_socket.py

@@ -17,12 +17,10 @@
 # -----------------------------------------------------------------------------
 import io
 import abc
-import sys
 import asyncio as aio
 from typing import Optional, Callable, Coroutine, Any
 from ..encoding.tlv_var import read_tl_num_from_stream
-if sys.platform.startswith('win32'):
-    from .windows import open_unix_connection
+from ..platform import Platform
 
 
 class Face(metaclass=abc.ABCMeta):
@@ -84,10 +82,7 @@ def __init__(self, path: str = ''):
             self.path = path
 
     async def open(self):
-        if sys.platform.startswith('win32'):
-            self.reader, self.writer = await open_unix_connection(self.path)
-        else:
-            self.reader, self.writer = await aio.open_unix_connection(self.path)
+        self.reader, self.writer = await Platform().open_unix_connection(self.path)
         self.running = True