tigrcorn-transports 0.3.16.dev5__py3-none-any.whl

tigrcorn_transports/__init__.py

@@ -0,0 +1 @@
+"""Transport implementations."""

tigrcorn_transports/base.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class TransportDescriptor:
+    name: str
+    multiplexed: bool = False

tigrcorn_transports/inproc/__init__.py

@@ -0,0 +1,3 @@
+from .channel import InProcChannel
+
+__all__ = ["InProcChannel"]

tigrcorn_transports/inproc/channel.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass, field
+
+
+@dataclass(slots=True)
+class InProcChannel:
+    capacity: int = 0
+    _queue: asyncio.Queue[bytes] = field(init=False)
+
+    def __post_init__(self) -> None:
+        self._queue = asyncio.Queue(maxsize=self.capacity)
+
+    async def send(self, payload: bytes) -> None:
+        await self._queue.put(payload)
+
+    async def recv(self) -> bytes:
+        return await self._queue.get()

tigrcorn_transports/listeners/__init__.py

@@ -0,0 +1,4 @@
+from .tcp import TCPListener
+from .unix import UnixListener
+
+__all__ = ["TCPListener", "UnixListener"]

tigrcorn_transports/listeners/base.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Awaitable, Callable
+
+
+class BaseListener(ABC):
+    @abstractmethod
+    async def start(self, client_connected_cb: Callable[..., Awaitable[None]]) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def close(self) -> None:
+        raise NotImplementedError

tigrcorn_transports/listeners/inproc.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import inspect
+from collections.abc import Awaitable, Callable
+
+from .base import BaseListener
+
+
+class InProcListener(BaseListener):
+    def __init__(self) -> None:
+        self._callback: Callable[..., Awaitable[None]] | None = None
+
+    async def start(self, client_connected_cb: Callable[..., Awaitable[None]]) -> None:
+        self._callback = client_connected_cb
+
+    async def dispatch(self, *args) -> None:
+        if self._callback is None:
+            raise RuntimeError('in-process listener has not been started')
+        result = self._callback(*args)
+        if inspect.isawaitable(result):
+            await result
+
+    async def close(self) -> None:
+        self._callback = None

tigrcorn_transports/listeners/pipe.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import asyncio
+import inspect
+import os
+import stat
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+
+from tigrcorn_core.errors import ServerError
+from tigrcorn_transports.pipe.connection import PipeConnection
+
+from .base import BaseListener
+
+
+class PipeListener(BaseListener):
+    def __init__(self, path: str) -> None:
+        self.path = path
+        self._callback: Callable[..., Awaitable[None] | None] | None = None
+        self._reader_fd: int | None = None
+        self._writer_fd: int | None = None
+        self._connection: PipeConnection | None = None
+        self._loop: asyncio.AbstractEventLoop | None = None
+        self._tasks: set[asyncio.Task[None]] = set()
+
+    async def start(self, client_connected_cb):
+        if not hasattr(os, 'mkfifo'):
+            raise ServerError('named pipes are not available on this platform')
+        self._callback = client_connected_cb
+        self._loop = asyncio.get_running_loop()
+        path = Path(self.path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        if path.exists():
+            mode = path.stat().st_mode
+            if not stat.S_ISFIFO(mode):
+                raise ServerError(f'{self.path!r} exists and is not a FIFO')
+        else:
+            os.mkfifo(path)
+        self._reader_fd = os.open(path, os.O_RDONLY | os.O_NONBLOCK)
+        self._writer_fd = os.open(path, os.O_WRONLY | os.O_NONBLOCK)
+        self._connection = PipeConnection(path=self.path, read_fd=self._reader_fd, write_fd=self._writer_fd)
+        self._loop.add_reader(self._reader_fd, self._on_readable)
+
+    def _on_readable(self) -> None:
+        if self._reader_fd is None or self._callback is None or self._connection is None:
+            return
+        try:
+            data = os.read(self._reader_fd, 65536)
+        except BlockingIOError:
+            return
+        if not data:
+            return
+        result = self._callback(self._connection, data)
+        if inspect.isawaitable(result):
+            task = asyncio.create_task(result)
+            self._tasks.add(task)
+            task.add_done_callback(self._tasks.discard)
+
+    async def close(self) -> None:
+        if self._loop is not None and self._reader_fd is not None:
+            self._loop.remove_reader(self._reader_fd)
+        for task in list(self._tasks):
+            task.cancel()
+        for fd in (self._reader_fd, self._writer_fd):
+            if fd is not None:
+                try:
+                    os.close(fd)
+                except OSError:
+                    pass
+        self._reader_fd = None
+        self._writer_fd = None
+        self._connection = None

tigrcorn_transports/listeners/registry.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from tigrcorn_transports.listeners.inproc import InProcListener
+from tigrcorn_transports.listeners.pipe import PipeListener
+from tigrcorn_transports.listeners.tcp import TCPListener
+from tigrcorn_transports.listeners.udp import UDPListener
+from tigrcorn_transports.listeners.unix import UnixListener
+
+LISTENER_TYPES = {
+    "tcp": TCPListener,
+    "udp": UDPListener,
+    "unix": UnixListener,
+    "pipe": PipeListener,
+    "inproc": InProcListener,
+}

tigrcorn_transports/listeners/tcp.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import asyncio
+import socket
+from collections.abc import Awaitable, Callable
+from contextlib import suppress
+from typing import Any
+
+from tigrcorn_security.tls import wrap_server_tls_connection
+from tigrcorn_transports.tcp.socketopts import configure_socket
+
+from .base import BaseListener
+
+
+class TCPListener(BaseListener):
+    def __init__(
+        self,
+        host: str,
+        port: int,
+        backlog: int = 2048,
+        ssl: Any = None,
+        *,
+        reuse_port: bool = False,
+        reuse_address: bool = True,
+        nodelay: bool = True,
+        fd: int | None = None,
+        sock: socket.socket | None = None,
+    ) -> None:
+        self.host = host
+        self.port = port
+        self.backlog = backlog
+        self.ssl = ssl
+        self.reuse_port = reuse_port
+        self.reuse_address = reuse_address
+        self.nodelay = nodelay
+        self.fd = fd
+        self.sock = sock
+        self.server: asyncio.AbstractServer | None = None
+
+    def _get_socket(self) -> socket.socket | None:
+        if self.sock is not None:
+            return self.sock
+        if self.fd is None:
+            return None
+        sock = socket.socket(fileno=self.fd)
+        sock.setblocking(False)
+        configure_socket(sock, nodelay=self.nodelay)
+        self.sock = sock
+        return sock
+
+    async def start(self, client_connected_cb: Callable[..., Awaitable[None]]) -> None:
+        ssl_param = None
+        if self.ssl is None:
+            callback = client_connected_cb
+        elif hasattr(self.ssl, 'certificate_pem') and hasattr(self.ssl, 'private_key_pem'):
+            async def callback(raw_reader: asyncio.StreamReader, raw_writer: asyncio.StreamWriter) -> None:
+                try:
+                    connection = await wrap_server_tls_connection(raw_reader, raw_writer, self.ssl)
+                except Exception:
+                    raw_writer.close()
+                    with suppress(Exception):
+                        await raw_writer.wait_closed()
+                    return
+                await client_connected_cb(connection, connection)
+        else:
+            callback = client_connected_cb
+            ssl_param = self.ssl
+
+        existing_sock = self._get_socket()
+        if existing_sock is not None:
+            self.server = await asyncio.start_server(callback, sock=existing_sock, ssl=ssl_param, backlog=self.backlog)
+        else:
+            self.server = await asyncio.start_server(
+                callback,
+                host=self.host,
+                port=self.port,
+                backlog=self.backlog,
+                ssl=ssl_param,
+                reuse_port=self.reuse_port,
+                reuse_address=self.reuse_address,
+            )
+        sockets = self.server.sockets or []
+        for sock in sockets:
+            configure_socket(sock, nodelay=self.nodelay)
+
+    async def close(self) -> None:
+        if self.server is not None:
+            self.server.close()
+            await self.server.wait_closed()
+            self.server = None

tigrcorn_transports/listeners/udp.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import asyncio
+import inspect
+import socket
+from collections.abc import Awaitable, Callable
+
+from tigrcorn_transports.udp.endpoint import UDPEndpoint
+from tigrcorn_transports.udp.packet import UDPPacket
+from tigrcorn_transports.udp.socketopts import configure_udp_socket
+
+from .base import BaseListener
+
+
+class _UDPProtocol(asyncio.DatagramProtocol):
+    def __init__(self, callback: Callable[..., Awaitable[None] | None]) -> None:
+        self.callback = callback
+        self.transport: asyncio.DatagramTransport | None = None
+        self.endpoint: UDPEndpoint | None = None
+        self.tasks: set[asyncio.Task[None]] = set()
+
+    def connection_made(self, transport: asyncio.BaseTransport) -> None:
+        self.transport = transport  # runtime transport provided by asyncio
+        sockname = transport.get_extra_info('sockname')
+        sock = transport.get_extra_info('socket')
+        if sock is not None:
+            configure_udp_socket(sock)
+        self.endpoint = UDPEndpoint(transport=transport, local_addr=sockname)
+
+    def datagram_received(self, data: bytes, addr) -> None:  # type: ignore[override]
+        if self.endpoint is None:
+            return
+        packet = UDPPacket(data=data, addr=addr)
+        result = self.callback(packet, self.endpoint)
+        if inspect.isawaitable(result):
+            task = asyncio.create_task(result)
+            self.tasks.add(task)
+            task.add_done_callback(self.tasks.discard)
+
+    def connection_lost(self, exc: Exception | None) -> None:
+        for task in list(self.tasks):
+            task.cancel()
+
+
+class UDPListener(BaseListener):
+    def __init__(self, host: str, port: int, *, reuse_port: bool = False, fd: int | None = None, sock: socket.socket | None = None) -> None:
+        self.host = host
+        self.port = port
+        self.reuse_port = reuse_port
+        self.fd = fd
+        self.sock = sock
+        self.transport: asyncio.DatagramTransport | None = None
+        self.protocol: _UDPProtocol | None = None
+
+    def _get_socket(self) -> socket.socket | None:
+        if self.sock is not None:
+            return self.sock
+        if self.fd is None:
+            return None
+        sock = socket.socket(fileno=self.fd)
+        sock.setblocking(False)
+        configure_udp_socket(sock)
+        self.sock = sock
+        return sock
+
+    async def start(self, client_connected_cb):
+        loop = asyncio.get_running_loop()
+        existing_sock = self._get_socket()
+        transport, protocol = await loop.create_datagram_endpoint(
+            lambda: _UDPProtocol(client_connected_cb),
+            local_addr=None if existing_sock is not None else (self.host, self.port),
+            reuse_port=self.reuse_port if existing_sock is None else None,
+            sock=existing_sock,
+        )
+        self.transport = transport
+        self.protocol = protocol
+
+    async def close(self) -> None:
+        if self.transport is not None:
+            self.transport.close()
+            self.transport = None
+            self.protocol = None

tigrcorn_transports/listeners/unix.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import asyncio
+import socket
+from collections.abc import Awaitable, Callable
+from contextlib import suppress
+from pathlib import Path
+from typing import Any
+
+from tigrcorn_security.tls import wrap_server_tls_connection
+from tigrcorn_core.utils.net import ensure_parent_dir
+
+from .base import BaseListener
+
+
+class UnixListener(BaseListener):
+    def __init__(self, path: str, backlog: int = 2048, ssl: Any = None, *, fd: int | None = None, sock: socket.socket | None = None) -> None:
+        self.path = path
+        self.backlog = backlog
+        self.ssl = ssl
+        self.fd = fd
+        self.sock = sock
+        self.server: asyncio.AbstractServer | None = None
+
+    def _get_socket(self) -> socket.socket | None:
+        if self.sock is not None:
+            return self.sock
+        if self.fd is None:
+            return None
+        sock = socket.socket(fileno=self.fd)
+        sock.setblocking(False)
+        self.sock = sock
+        return sock
+
+    async def start(self, client_connected_cb: Callable[..., Awaitable[None]]) -> None:
+        path = Path(self.path) if self.path else None
+        existing_sock = self._get_socket()
+        if existing_sock is None and path is not None:
+            ensure_parent_dir(str(path))
+            if path.exists():
+                path.unlink()
+
+        ssl_param = None
+        if self.ssl is None:
+            callback = client_connected_cb
+        elif hasattr(self.ssl, 'certificate_pem') and hasattr(self.ssl, 'private_key_pem'):
+            async def callback(raw_reader: asyncio.StreamReader, raw_writer: asyncio.StreamWriter) -> None:
+                try:
+                    connection = await wrap_server_tls_connection(raw_reader, raw_writer, self.ssl)
+                except Exception:
+                    raw_writer.close()
+                    with suppress(Exception):
+                        await raw_writer.wait_closed()
+                    return
+                await client_connected_cb(connection, connection)
+        else:
+            callback = client_connected_cb
+            ssl_param = self.ssl
+
+        if existing_sock is not None:
+            self.server = await asyncio.start_unix_server(callback, sock=existing_sock, ssl=ssl_param, backlog=self.backlog)
+        else:
+            self.server = await asyncio.start_unix_server(callback, path=self.path, backlog=self.backlog, ssl=ssl_param)
+
+    async def close(self) -> None:
+        if self.server is not None:
+            self.server.close()
+            await self.server.wait_closed()
+            self.server = None

tigrcorn_transports/pipe/__init__.py

@@ -0,0 +1,3 @@
+from .connection import PipeConnection
+
+__all__ = ["PipeConnection"]

tigrcorn_transports/pipe/connection.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class PipeConnection:
+    path: str
+    read_fd: int
+    write_fd: int | None = None
+
+    def read(self, n: int = 65536) -> bytes:
+        return os.read(self.read_fd, n)
+
+    def write(self, data: bytes) -> int:
+        if self.write_fd is None:
+            raise OSError('pipe is not writable')
+        return os.write(self.write_fd, data)

tigrcorn_transports/py.typed

@@ -0,0 +1 @@
+

tigrcorn_transports/quic/__init__.py

@@ -0,0 +1,108 @@
+from .crypto import (
+    QUIC_V1_INITIAL_SALT,
+    QuicPacketProtectionKeys,
+    aes_gcm_decrypt,
+    aes_gcm_encrypt,
+    apply_header_protection,
+    derive_initial_packet_protection_keys,
+    derive_initial_secret,
+    derive_quic_packet_protection_keys,
+    derive_secret,
+    generate_connection_id,
+    hkdf_expand_label,
+    hkdf_extract,
+    make_integrity_tag,
+    packet_nonce,
+    protect_payload,
+    remove_header_protection,
+    unprotect_payload,
+    unprotect_quic_packet,
+    protect_quic_packet,
+)
+from .datagrams import QuicDatagram, QuicHeader, QuicPacketType, decode_datagram, encode_datagram
+from .packets import (
+    QuicLongHeaderPacket,
+    QuicLongHeaderType,
+    QuicRetryPacket,
+    QuicShortHeaderPacket,
+    QuicStatelessResetPacket,
+    QuicVersionNegotiationPacket,
+    decode_packet,
+    decode_long_header_packet,
+    decode_short_header_packet,
+    parse_stateless_reset,
+)
+from .streams import QuicStreamFrame, QuicAckFrame, QuicConnectionCloseFrame, QuicMaxDataFrame, QuicMaxStreamDataFrame
+
+__all__ = [
+    'QuicConnection',
+    'QuicEvent',
+    'QuicDatagram',
+    'QuicHeader',
+    'QuicPacketType',
+    'QuicStreamFrame',
+    'QuicAckFrame',
+    'QuicConnectionCloseFrame',
+    'QuicMaxDataFrame',
+    'QuicMaxStreamDataFrame',
+    'decode_datagram',
+    'encode_datagram',
+    'QuicLongHeaderPacket',
+    'QuicLongHeaderType',
+    'QuicRetryPacket',
+    'QuicShortHeaderPacket',
+    'QuicStatelessResetPacket',
+    'QuicVersionNegotiationPacket',
+    'decode_packet',
+    'decode_long_header_packet',
+    'decode_short_header_packet',
+    'parse_stateless_reset',
+    'QUIC_V1_INITIAL_SALT',
+    'QuicPacketProtectionKeys',
+    'aes_gcm_encrypt',
+    'aes_gcm_decrypt',
+    'apply_header_protection',
+    'remove_header_protection',
+    'protect_quic_packet',
+    'unprotect_quic_packet',
+    'derive_initial_secret',
+    'derive_initial_packet_protection_keys',
+    'derive_quic_packet_protection_keys',
+    'hkdf_extract',
+    'hkdf_expand_label',
+    'packet_nonce',
+    'derive_secret',
+    'generate_connection_id',
+    'make_integrity_tag',
+    'protect_payload',
+    'unprotect_payload',
+    'QuicTlsHandshakeDriver',
+    'TransportParameters',
+    'generate_self_signed_certificate',
+    'QuicLossRecovery',
+]
+
+
+def __getattr__(name: str):
+    if name in {"QuicConnection", "QuicEvent"}:
+        from .connection import QuicConnection, QuicEvent
+
+        mapping = {
+            "QuicConnection": QuicConnection,
+            "QuicEvent": QuicEvent,
+        }
+        return mapping[name]
+    if name in {"QuicTlsHandshakeDriver", "TransportParameters", "generate_self_signed_certificate"}:
+        from .handshake import QuicTlsHandshakeDriver, TransportParameters, generate_self_signed_certificate
+
+        mapping = {
+            "QuicTlsHandshakeDriver": QuicTlsHandshakeDriver,
+            "TransportParameters": TransportParameters,
+            "generate_self_signed_certificate": generate_self_signed_certificate,
+        }
+        return mapping[name]
+    if name == "QuicLossRecovery":
+        from .recovery import QuicLossRecovery
+
+        return QuicLossRecovery
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")