cubesat-space-protocol-py 1.0.0__py3-none-any.whl

csp_py/__init__.py

@@ -0,0 +1,18 @@
+from .packet import CspId, CspPacket, CspPacketPriority, CspPacketFlags
+from .router import CspRouter
+from .node import CspNode
+from .packet_handler import IPacketHandler
+
+from .services.ping_client import ping
+
+
+__all__ = [
+    'CspId',
+    'CspPacket',
+    'CspPacketPriority',
+    'CspPacketFlags',
+    'CspRouter',
+    'CspNode',
+    'IPacketHandler',
+    'ping',
+]

csp_py/crc32.py

@@ -0,0 +1,78 @@
+import struct
+from csp_py.packet import CspPacket
+from .router import CspRouter
+
+
+CRC_TABLE = [
+    0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4, 0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB,
+	0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B, 0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24,
+	0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B, 0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384,
+	0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54, 0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B,
+	0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A, 0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35,
+	0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5, 0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA,
+	0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45, 0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A,
+	0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A, 0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595,
+	0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48, 0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957,
+	0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687, 0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198,
+	0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927, 0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38,
+	0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8, 0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7,
+	0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096, 0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789,
+	0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859, 0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46,
+	0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9, 0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6,
+	0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36, 0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829,
+	0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C, 0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93,
+	0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043, 0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C,
+	0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3, 0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC,
+	0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C, 0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033,
+	0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652, 0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D,
+	0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D, 0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982,
+	0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D, 0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622,
+	0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2, 0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED,
+	0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530, 0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F,
+	0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF, 0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0,
+	0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F, 0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540,
+	0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90, 0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F,
+	0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE, 0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1,
+	0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321, 0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E,
+	0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81, 0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E,
+	0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E, 0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351,
+]
+
+
+def calculate_crc32(data: bytes) -> int:
+    crc = 0xFFFF_FFFF
+    for b in data:
+        crc = CRC_TABLE[(crc ^ b) & 0xFF] ^ (crc >> 8)
+
+    return crc ^ 0xFFFF_FFFF
+
+
+def register_crc32_filters(router: CspRouter) -> None:
+    async def incoming_filter(packet: CspPacket) -> CspPacket | None:
+        if (packet.packet_id.flags & 1) == 0:
+            return packet
+
+        payload = packet.data[:-4]
+
+        if len(payload) < 4:
+            return None
+
+        received_checksum = struct.unpack('!I', packet.data[-4:])[0]
+        calculated_checksum = calculate_crc32(payload)
+
+        if received_checksum != calculated_checksum:
+            return None
+
+        return packet.with_data(payload)
+
+    async def outgoing_filter(packet: CspPacket) -> CspPacket:
+        if (packet.packet_id.flags & 1) == 0:
+            return packet
+
+        payload = packet.data
+        checksum = calculate_crc32(payload)
+
+        return packet.with_data(payload + struct.pack('!I', checksum))
+
+    router.incoming_packet_filters.append(incoming_filter)
+    router.outgoing_packet_filters.append(outgoing_filter)

csp_py/interface.py

@@ -0,0 +1,19 @@
+from abc import ABC, abstractmethod
+from typing import Protocol
+
+from .packet import CspPacket
+
+
+class CspPacketSink(Protocol):
+    def __call__(self, packet: CspPacket) -> None:
+        raise NotImplementedError()
+
+
+class ICspInterface(ABC):
+    @abstractmethod
+    def set_packet_sink(self, sink: CspPacketSink) -> None:
+        pass
+
+    @abstractmethod
+    async def send(self, packet: CspPacket) -> None:
+        raise NotImplementedError()

csp_py/interfaces/can/__init__.py

@@ -0,0 +1,6 @@
+from .can_interface import CspCanInterface
+
+
+__all__ = [
+    'CspCanInterface',
+]

csp_py/interfaces/can/can_interface.py

@@ -0,0 +1,180 @@
+from dataclasses import dataclass
+import struct
+from typing import Any, Awaitable, Callable
+
+from csp_py import CspPacket, CspId, CspPacketPriority, CspPacketFlags
+from csp_py.interface import ICspInterface, CspPacketSink
+
+
+@dataclass
+class CfpIdFields:
+    begin: bool
+    end: bool
+    priority: CspPacketPriority
+    dst: int
+    sender: int
+    sc: int
+    fc: int
+
+    def as_key(self) -> tuple[int, int, CspPacketPriority, int]:
+        return (self.dst, self.sender, self.priority, self.sc)
+
+    def as_num(self) -> int:
+        def pack_field(value: int, *, mask: int, offset: int) -> int:
+            return (value & mask) << offset
+        
+        r = 0
+        r |= pack_field(self.begin, mask=0x1, offset=1)
+        r |= pack_field(self.end, mask=0x1, offset=0)
+        r |= pack_field(self.priority.value, mask=0x3, offset=27)
+        r |= pack_field(self.dst, mask=0x3FFF, offset=13)
+        r |= pack_field(self.sender, mask=0x3F, offset=7)
+        r |= pack_field(self.sc, mask=0x3, offset=5)
+        r |= pack_field(self.fc, mask=0x7, offset=2)
+        return r
+
+@dataclass
+class CfpHeaderFields:
+    src: int
+    dport: int
+    sport: int
+    flags: CspPacketFlags
+
+    def as_bytes(self) -> bytes:
+        def pack_field(value: int, *, mask: int, offset: int) -> int:
+            return (value & mask) << offset
+        
+        r = 0
+        r |= pack_field(self.src, mask=0x3FFF, offset=18)
+        r |= pack_field(self.dport, mask=0x3F, offset=12)
+        r |= pack_field(self.sport, mask=0x3F, offset=6)
+        r |= pack_field(self.flags, mask=0x3F, offset=0)
+        return struct.pack('!I', r)
+
+
+def parse_csp_can_frame_id(can_id: int) -> CfpIdFields:
+    def extract_field(*, offset: int, mask: int) -> int:
+        return (can_id >> offset) & mask
+
+    return CfpIdFields(
+            begin=extract_field(mask=0x1, offset=1) == 1,
+            end=extract_field(mask=0x1, offset=0) == 1,
+            priority=CspPacketPriority(extract_field(mask=0x3, offset=27)),
+            dst=extract_field(mask=0x3FFF, offset=13),
+            sender=extract_field(mask=0x3F, offset=7),
+            sc=extract_field(mask=0x3, offset=5),
+            fc=extract_field(mask=0x7, offset=2),
+        )
+
+def parse_csp_can_header(data: bytes) -> tuple[CfpHeaderFields, bytes]:
+    assert len(data) >= 4
+    num, = struct.unpack('!I', data[:4])
+
+    def extract_field(*, offset: int, mask: int) -> int:
+        return int((num >> offset) & mask)
+
+    return CfpHeaderFields(
+        src=extract_field(mask=0x3FFF, offset=18),
+        dport=extract_field(mask=0x3F, offset=12),
+        sport=extract_field(mask=0x3F, offset=6),
+        flags=CspPacketFlags(extract_field(mask=0x3F, offset=0)),
+    ), data[4:]
+
+class CfpReassemblyTracker:
+    def __init__(self, id_header: CfpIdFields, header: CfpHeaderFields) -> None:
+        self._data = bytearray()
+        self._id_header = id_header
+        self._header = header
+
+    def append(self, data: bytes) -> None:
+        self._data.extend(data)
+
+    def capture(self) -> CspPacket:
+        return CspPacket(
+            packet_id=CspId(
+                priority=self._id_header.priority,
+                flags=self._header.flags,
+                src=self._header.src,
+                dst=self._id_header.dst,
+                dport=self._header.dport,
+                sport=self._header.sport,
+            ),
+            data=bytes(self._data),
+        )
+
+class CspCanInterface(ICspInterface):
+    def __init__(self) -> None:
+        self._in_flight: dict[Any, CfpReassemblyTracker] = {}
+        self._packet_sink: CspPacketSink | None = None
+        self._sender_counter = 0
+
+        self.send_can_frame: Callable[[int, bytes], Awaitable[None]] | None = None
+
+    def set_packet_sink(self, sink: CspPacketSink) -> None:
+        self._packet_sink = sink
+
+    async def send(self, packet: CspPacket) -> None:
+        data = packet.data
+
+        fragments = []
+
+        fragments.append(data[:4])
+        data = data[4:]
+
+        while len(data) > 0:
+            fragments.append(data[:8])
+            data = data[8:]
+
+        if len(fragments) == 1:
+            await self._send_singleton_frame(packet)
+        else:
+            await self._send_multi_frame(packet, fragments)
+
+    async def _send_singleton_frame(self, packet: CspPacket) -> None:
+        raise NotImplementedError()
+
+    async def _send_multi_frame(self, packet: CspPacket, fragments: list[bytes]) -> None:
+        [begin, *middle, end] = fragments
+
+        header = CfpHeaderFields(
+            src=packet.packet_id.src,
+            dport=packet.packet_id.dport,
+            sport=packet.packet_id.sport,
+            flags=packet.packet_id.flags,
+        )
+
+        begin = header.as_bytes() + begin
+
+        await self._send_frame(CfpIdFields(begin=True, end=False, priority=packet.packet_id.priority, dst=packet.packet_id.dst, sender=packet.packet_id.src, sc=self._sender_counter, fc=0), begin)
+
+        for idx, f in enumerate(middle):
+            await self._send_frame(CfpIdFields(begin=False, end=False, priority=packet.packet_id.priority, dst=packet.packet_id.dst, sender=packet.packet_id.src, sc=self._sender_counter, fc=idx + 1), f)
+
+        await self._send_frame(CfpIdFields(begin=False, end=True, priority=packet.packet_id.priority, dst=packet.packet_id.dst, sender=packet.packet_id.src, sc=self._sender_counter, fc=len(fragments) - 1), end)
+
+    async def _send_frame(self, id_fields: CfpIdFields, data: bytes) -> None:
+        can_id = id_fields.as_num()
+        assert self.send_can_frame is not None
+        await self.send_can_frame(can_id, data)
+
+
+    async def on_can_frame(self, can_id: int, data: bytes) -> None:
+        parsed_id = parse_csp_can_frame_id(can_id)
+
+        key = parsed_id.as_key()
+
+        if parsed_id.begin:
+            if len(data) < 4:
+                print('[csp.py] Invalid data length')
+                return
+
+            header, data = parse_csp_can_header(data)
+
+            self._in_flight[key] = CfpReassemblyTracker(parsed_id, header)
+
+        self._in_flight[key].append(data)
+
+        if parsed_id.end:
+            full_packet = self._in_flight.pop(key).capture()
+            assert self._packet_sink is not None
+            self._packet_sink(full_packet)

csp_py/interfaces/interface_pair.py

@@ -0,0 +1,39 @@
+from csp_py.interface import ICspInterface, CspPacketSink
+from csp_py.packet import CspPacket
+
+
+class InterfacePair:
+    def __init__(self) -> None:
+        self._iface1 = InterfacePair._InterfaceOrPair()
+        self._iface2 = InterfacePair._InterfaceOrPair()
+
+        self._iface1.set_other_iface(self._iface2)
+        self._iface2.set_other_iface(self._iface1)
+
+    @property
+    def iface1(self) -> ICspInterface:
+        return self._iface1
+    
+    @property
+    def iface2(self) -> ICspInterface:
+        return self._iface2
+    
+
+    class _InterfaceOrPair(ICspInterface):
+        def __init__(self) -> None:
+            self._packet_sink: CspPacketSink | None = None
+            self._other_iface: InterfacePair._InterfaceOrPair | None = None
+
+        def set_packet_sink(self, sink: CspPacketSink) -> None:
+            self._packet_sink = sink
+
+        def set_other_iface(self, other_iface: 'InterfacePair._InterfaceOrPair') -> None:
+            self._other_iface = other_iface
+
+        async def send(self, packet: CspPacket) -> None:
+            assert self._other_iface is not None
+            self._other_iface.incoming_packet(packet)
+
+        def incoming_packet(self, packet: CspPacket) -> None:
+            assert self._packet_sink is not None
+            self._packet_sink(packet)

csp_py/interfaces/lo_interface.py

@@ -0,0 +1,16 @@
+from csp_py.interface import ICspInterface, CspPacketSink
+from csp_py.packet import CspPacket
+
+
+class LoInterface(ICspInterface):
+    def __init__(self) -> None:
+        super().__init__()
+        self._packet_sink: CspPacketSink | None  = None
+
+    def set_packet_sink(self, sink: CspPacketSink) -> None:
+        self._packet_sink = sink
+
+    async def send(self, packet: CspPacket) -> None:
+        sink = self._packet_sink
+        assert sink is not None
+        sink(packet)

csp_py/interfaces/serializing_interface.py

@@ -0,0 +1,81 @@
+from dataclasses import dataclass
+import struct
+from typing import Protocol
+
+from ..interface import ICspInterface, CspPacketSink
+from csp_py import CspPacket, CspId, CspPacketPriority, CspPacketFlags
+
+
+@dataclass(frozen=True)
+class FieldInfo:
+    mask: int
+    offset: int
+
+    def extract(self, value: int) -> int:
+        return (value >> self.offset) & self.mask
+    
+    def pack(self, value: int) -> int:
+        return (value & self.mask) << self.offset
+
+
+class CspIdLayout:
+    Priority = FieldInfo(3, 46)
+    Destination = FieldInfo(0x3FFF, 32)
+    Source = FieldInfo(0x3FFF, 18)
+    DestinationPort = FieldInfo(0x3F, 12)
+    SourcePort = FieldInfo(0x3F, 6)
+    Flags = FieldInfo(0x3F, 0)
+
+    @staticmethod
+    def from_int(value: int) -> CspId:
+        return CspId(
+            priority=CspPacketPriority(CspIdLayout.Priority.extract(value)),
+            dst=CspIdLayout.Destination.extract(value),
+            src=CspIdLayout.Source.extract(value),
+            dport=CspIdLayout.DestinationPort.extract(value),
+            sport=CspIdLayout.SourcePort.extract(value),
+            flags=CspPacketFlags(CspIdLayout.Flags.extract(value)),
+        )
+    
+    @staticmethod
+    def to_int(id: CspId) -> int:
+        return (
+            CspIdLayout.Priority.pack(id.priority.value) |
+            CspIdLayout.Destination.pack(id.dst) |
+            CspIdLayout.Source.pack(id.src) |
+            CspIdLayout.DestinationPort.pack(id.dport) |
+            CspIdLayout.SourcePort.pack(id.sport) |
+            CspIdLayout.Flags.pack(id.flags.value)
+        )
+
+class SerializedFrameSink(Protocol):
+    async def __call__(self, frame: bytes) -> None:
+        ...
+
+
+class CspSerializingInterface(ICspInterface):
+    def __init__(self, on_frame: SerializedFrameSink) -> None:
+        self._frame_sink = on_frame
+        self._packet_sink: CspPacketSink | None = None
+
+    def set_packet_sink(self, sink: CspPacketSink) -> None:
+        self._packet_sink = sink
+
+    async def send(self, packet: CspPacket) -> None:
+        header_num = CspIdLayout.to_int(packet.packet_id)
+        header = struct.pack('!Q', header_num)[2:]
+        frame = header + packet.data
+        await self._frame_sink(frame)
+
+    async def on_incoming_frame(self, frame: bytes) -> None:
+        header = b'\x00\x00' + frame[:6]
+        payload = frame[6:]
+        header_num, =  struct.unpack('!Q', header)
+        incoming_id = CspIdLayout.from_int(header_num)
+        packet = CspPacket(
+            packet_id=incoming_id,
+            data=payload,
+        )
+        sink = self._packet_sink
+        assert sink is not None
+        sink(packet)

csp_py/node.py

@@ -0,0 +1,54 @@
+from .router import CspRouter
+from .packet import CspPacket, CspPacketFlags
+from .packet_handler import IPacketHandler
+from .services.ping import CspPingHandler
+from .socket import CspSocketHandler, CspBoundSocket, CspListeningSocket, CspClientConnection
+from .interfaces.lo_interface import LoInterface
+from .crc32 import register_crc32_filters
+
+
+class CspNode:
+    def __init__(self, *, default_send_flags: CspPacketFlags = CspPacketFlags.Zero) -> None:
+        self._default_send_flags = default_send_flags
+        self.router = CspRouter()
+        self.router.local_packet_handler = self._on_local_packet
+
+        self.router.add_interface(LoInterface(), address=0, netmask_bits=14)
+
+        register_crc32_filters(self.router)
+
+        self._socket_handler = CspSocketHandler()
+
+        self._handlers: list[IPacketHandler] = []
+
+        self.add_packet_handler(CspPingHandler())
+        self.add_packet_handler(self._socket_handler)
+
+    def add_packet_handler(self, handler: IPacketHandler) -> None:
+        handler.set_send_packet(self._send_packet)
+        self._handlers.append(handler)
+
+    def bound_socket(self, port: int | None, *, send_flags: CspPacketFlags=CspPacketFlags.Inherit) -> CspBoundSocket:
+        return self._socket_handler.bound_socket(port, send_flags=send_flags)
+    
+    def listen(self, port: int | None, *, send_flags: CspPacketFlags=CspPacketFlags.Inherit) -> CspListeningSocket:
+        return self._socket_handler.listen(port, send_flags=send_flags)
+    
+    async def connect(self, *, dst: int, port: int, local_port: int | None = None, send_flags: CspPacketFlags=CspPacketFlags.Inherit) -> CspClientConnection:
+        return await self._socket_handler.connect(dst, port, local_port, send_flags=send_flags)
+
+    async def _on_local_packet(self, packet: CspPacket) -> None:
+        try:
+            for handler in self._handlers:
+                if await handler.on_packet(packet):
+                    return
+            
+            print('No handler for packet', packet)
+        except Exception as e:
+            print('Exception in packet handler', e)
+            raise e
+        
+    async def _send_packet(self, packet: CspPacket) -> None:
+        resolved_flags = packet.packet_id.flags.resolve(self._default_send_flags)
+        packet = packet.with_id(packet.packet_id.with_flags(resolved_flags))
+        await self.router.send_packet(packet)

csp_py/packet.py

@@ -0,0 +1,85 @@
+from dataclasses import dataclass
+from enum import Enum, IntFlag
+
+
+class CspPacketPriority(Enum):
+    Critical = 0
+    High = 1
+    Normal = 2
+    Low = 3
+
+
+class CspPacketFlags(IntFlag):
+    Zero = 0
+    CRC32 = 1
+
+    Inherit = 0xFF00_0000
+
+    def resolve(self, inherit: 'CspPacketFlags') -> 'CspPacketFlags':
+        if CspPacketFlags.Inherit in self:
+            v = self - CspPacketFlags.Inherit
+            v |= inherit
+            return CspPacketFlags(v).resolve(CspPacketFlags.Zero)
+        else:
+            return CspPacketFlags(self)
+
+
+@dataclass(frozen=True)
+class CspId:
+    src: int
+    dst: int
+    dport: int
+    sport: int
+    flags: CspPacketFlags = CspPacketFlags.Zero
+    priority: CspPacketPriority = CspPacketPriority.Normal
+
+    def reply_id(self) -> 'CspId':
+        return CspId(
+            priority=self.priority,
+            flags=self.flags,
+            src=self.dst,
+            dst=self.src,
+            dport=self.sport,
+            sport=self.dport,
+        )
+
+    def with_source(self, src: int) -> 'CspId':
+        return CspId(
+            priority=self.priority,
+            flags=self.flags,
+            src=src,
+            dst=self.dst,
+            dport=self.dport,
+            sport=self.sport,
+        )
+    
+    def with_flags(self, flags: CspPacketFlags) -> 'CspId':
+        return CspId(
+            priority=self.priority,
+            flags=flags,
+            src=self.src,
+            dst=self.dst,
+            dport=self.dport,
+            sport=self.sport,
+        )
+
+
+@dataclass(frozen=True)
+class CspPacket:
+    packet_id: CspId
+    header: bytes = b''
+    data: bytes = b''
+
+    def with_id(self, new_id: CspId) -> 'CspPacket':
+        return CspPacket(
+            packet_id=new_id,
+            header=self.header,
+            data=self.data,
+        )
+
+    def with_data(self, new_data: bytes) -> 'CspPacket':
+        return CspPacket(
+            packet_id=self.packet_id,
+            header=self.header,
+            data=new_data,
+        )

csp_py/packet_handler.py

@@ -0,0 +1,24 @@
+from abc import ABC, abstractmethod
+from typing import Protocol
+
+from .packet import CspPacket
+
+
+class IPacketHandler(ABC):
+    class SendPacket(Protocol):
+        async def __call__(self, packet: CspPacket) -> None:
+            raise NotImplementedError()
+
+    def __init__(self) -> None:
+        self._send_packet: IPacketHandler.SendPacket | None = None
+
+    def set_send_packet(self, send_packet: SendPacket) -> None:
+        self._send_packet = send_packet
+
+    async def send_packet(self, packet: CspPacket) -> None:
+        assert self._send_packet is not None
+        await self._send_packet(packet)
+
+    @abstractmethod
+    async def on_packet(self, packet: CspPacket) -> bool:
+        raise NotImplementedError()

csp_py/router.py

@@ -0,0 +1,149 @@
+import asyncio
+from dataclasses import dataclass
+from typing import Awaitable, Callable, Protocol
+
+from .interface import ICspInterface
+from .packet import CspPacket
+from .rtable import CspRoutingTable
+
+
+@dataclass(frozen=True)
+class CspInterfaceAddress:
+    address: int
+    network_address_bits: int
+
+    @property
+    def network_mask(self) -> int:
+        # TODO: const for address length
+        return ((1 << self.network_address_bits) - 1) << (14 - self.network_address_bits)
+    
+    @property
+    def broadcast_address(self) -> int:
+        return (~self.network_mask) & 0x3FFF
+
+    @property
+    def network_address(self) -> int:
+        return self.address & self.network_mask
+
+    def contains_address(self, address: int) -> bool:
+        other = CspInterfaceAddress(address=address, network_address_bits=self.network_address_bits)
+        return self.network_address == other.network_address
+
+
+class CspRouterFilter(Protocol):
+    async def __call__(self, packet: CspPacket) -> CspPacket | None:
+        ...
+
+
+class CspRouter:
+    def __init__(self) -> None:
+        self._interfaces: list[tuple[CspInterfaceAddress, ICspInterface]] = []
+        self._incoming_packets = asyncio.Queue[tuple[ICspInterface, CspPacket]]()
+        self.rtable = CspRoutingTable()
+        self.local_packet_handler: Callable[[CspPacket], Awaitable[None]] | None = None
+
+        self.incoming_packet_filters: list[CspRouterFilter] = []
+        self.routed_packet_filters: list[CspRouterFilter] = []
+        self.outgoing_packet_filters: list[CspRouterFilter] = []
+
+    def push_packet(self, iface: ICspInterface,  packet: CspPacket) -> None:
+        self._incoming_packets.put_nowait((iface, packet))
+
+    async def arun(self) -> None:
+        while True:
+            await self.process_one_incoming_packet()
+
+    async def process_one_incoming_packet(self) -> None:
+        src_iface, packet = await self._incoming_packets.get()
+
+        [src_address] = [addr for addr, iface in self._interfaces if iface == src_iface]
+
+        to_localhost = packet.packet_id.dst in [src_address.address, src_address.broadcast_address]
+        if to_localhost:
+            await self._process_incoming_packet(packet)
+            return
+        
+        target = self._find_outgoing_interface(packet.packet_id.dst)
+
+        if target is None:
+            return
+        
+        target_address, target_iface = target
+
+        if target_iface == src_iface:
+            return
+
+        if target_address.address == packet.packet_id.dst:
+            return
+
+        await self._process_routed_packet(packet, target_iface)
+
+    async def _on_packet_to_local(self, packet: CspPacket) -> None:
+        assert self.local_packet_handler is not None
+        await self.local_packet_handler(packet)
+
+    def add_interface(self, interface: ICspInterface, *, address: int, netmask_bits: int) -> None:
+        iface_address = CspInterfaceAddress(address=address, network_address_bits=netmask_bits)
+
+        if any(addr.network_address == iface_address.network_address and addr.network_address_bits != 14 for addr, _ in self._interfaces):
+            raise ValueError('An interface with the same network address already exists')
+
+        self._interfaces.append((iface_address, interface))
+
+        
+        def sink_packet(packet: CspPacket) -> None:
+            self.push_packet(interface, packet)
+
+        interface.set_packet_sink(sink_packet)
+
+    async def send_packet(self, packet: CspPacket) -> None:
+        assert isinstance(packet.data, bytes) or isinstance(packet.data, bytearray)
+
+        target = self._find_outgoing_interface(packet.packet_id.dst)
+        
+        if target is None:
+            raise ValueError("no interface matched the packet destination")
+        
+        iface_addr, iface = target
+
+        packet = packet.with_id(packet.packet_id.with_source(iface_addr.address))
+        await self._process_outgoing_packet(packet, iface)
+
+    def _find_outgoing_interface(self, target: int) -> tuple[CspInterfaceAddress, ICspInterface] | None:
+        ifaces = [(addr, iface) for addr, iface in self._interfaces if addr.contains_address(target)]
+
+        if len(ifaces) == 1:
+            return ifaces[0]
+        
+        if len(ifaces) > 1:
+            raise ValueError('More than one interface matched the packet destination')
+        
+        iface_by_route = self.rtable.iface_for_address(target)
+
+        if iface_by_route is None:
+            return None
+    
+        [iface_addr] = [addr for (addr, iface) in self._interfaces if iface == iface_by_route]
+        return iface_addr, iface_by_route
+
+    async def _process_outgoing_packet(self, packet: CspPacket, iface: ICspInterface) -> None:
+        for f in self.outgoing_packet_filters:
+            filter_result = await f(packet)
+            if filter_result is None:
+                return
+            packet = filter_result
+        await iface.send(packet)
+
+    async def _process_routed_packet(self, packet: CspPacket, to_matching_interface: ICspInterface) -> None:
+        await to_matching_interface.send(packet)
+
+    async def _process_incoming_packet(self, packet: CspPacket) -> None:
+        for f in self.incoming_packet_filters:
+            filter_result = await f(packet)
+            if filter_result is None:
+                return
+            packet = filter_result
+            if packet is None:
+                return
+
+        await self._on_packet_to_local(packet)

csp_py/rtable.py

@@ -0,0 +1,49 @@
+from dataclasses import dataclass
+
+from .interface import ICspInterface
+
+
+@dataclass(frozen=True)
+class Route:
+    network_address: int
+    netmask_bits: int
+    iface: ICspInterface
+
+    def __post_init__(self) -> None:
+        assert (self.network_address & ~self.netmask) == 0, 'Network address must have node address set to 0'
+
+    @property
+    def netmask(self) -> int:
+        return ((1 << self.netmask_bits) - 1) << (14 - self.netmask_bits)
+
+    def routes_to_address(self, target: int) -> bool:
+        target_network = target & self.netmask
+        return target_network == self.network_address
+
+
+class CspRoutingTable:
+    def __init__(self) -> None:
+        self._routes: list[Route] = []
+
+    def add_entry(self, *, network_address: int, netmask_bits: int, iface: ICspInterface) -> None:
+        if any(route for route in self._routes if route.network_address == network_address and route.netmask_bits == netmask_bits):
+            raise ValueError('Duplicate route entry')
+        # TODO: check for duplicate entry
+        self._routes.append(Route(
+            network_address=network_address,
+            netmask_bits=netmask_bits, 
+            iface=iface
+        ))
+
+    def iface_for_address(self, address: int) -> ICspInterface | None:
+        matching_routes = [route for route in self._routes if route.routes_to_address(address)]
+        
+        if len(matching_routes) == 0:
+            return None
+        
+        if len(matching_routes) == 1:
+            return matching_routes[0].iface
+
+        matching_routes = list(sorted(matching_routes, key=lambda r: r.netmask_bits, reverse=True))
+
+        return matching_routes[0].iface

csp_py/services/ping.py

@@ -0,0 +1,17 @@
+from ..packet_handler import IPacketHandler
+from ..packet import CspPacket, CspPacketFlags
+
+
+class CspPingHandler(IPacketHandler):
+    async def on_packet(self, packet: CspPacket) -> bool:
+        if packet.packet_id.dport == 1:
+            response = CspPacket(
+                packet_id=packet.packet_id.reply_id(),
+                header=packet.header,
+                data=packet.data,
+            )
+            await self.send_packet(response)
+            return True
+        else:
+            return False
+

csp_py/services/ping_client.py

@@ -0,0 +1,16 @@
+import time
+
+from ..node import CspNode
+from ..packet import CspPacketFlags
+
+
+async def ping(node: CspNode, *, dst: int, size: int = 100, send_flags: CspPacketFlags = CspPacketFlags.Inherit) -> float:
+    sock = await node.connect(dst=dst, port=1, send_flags=send_flags)
+    data = bytes([i % 256 for i in range(size)])
+    
+    start = time.monotonic()
+    await sock.send(data)
+    response = await sock.recv()
+    stop = time.monotonic()
+    assert response.data == data, f'{response!r} != {data!r}'
+    return stop - start

csp_py/socket.py

@@ -0,0 +1,269 @@
+from abc import ABC, abstractmethod
+import asyncio
+from csp_py.packet_handler import IPacketHandler
+from .packet import CspPacket, CspId, CspPacketPriority, CspPacketFlags
+
+
+# TODO: separate impl
+
+class BindAnyPort:
+    pass
+
+
+Port = int | BindAnyPort
+
+class CspPortHandler(ABC):
+    @abstractmethod
+    async def _add_incoming_packet(self, packet: CspPacket) -> None:
+        pass
+
+class CspServerConnection:
+    def __init__(self, owner: 'CspListeningSocket', dst: int, port: int, local_port: int) -> None:
+        self._owner = owner
+        self._dst: int | None = dst
+        self._port: int | None = port
+        self._local_port: int | None = local_port
+        self._pending_packets = asyncio.Queue[CspPacket]()
+
+    @property
+    def remote_address(self) -> int:
+        assert self._dst is not None
+        return self._dst
+
+    @property
+    def remote_port(self) -> int:
+        assert self._port is not None
+        return self._port
+
+    @property
+    def local_port(self) -> int:
+        assert self._local_port is not None
+        return self._local_port
+
+    def __del__(self) -> None:
+        self.close()
+    
+    def close(self) -> None:
+        if self._dst is not None and self._port is not None:
+            self._owner._delete_connection(self._dst, self._port)
+            self._dst = None
+            self._port = None
+
+    async def send(self, data: bytes) -> None:
+        assert self._dst is not None 
+        assert self._port is not None
+        assert self._local_port is not None
+        await self._owner._send_to(dst=self._dst, port=self._port, local_port=self._local_port, data=data)
+
+    async def recv(self) -> CspPacket:
+        return await self._pending_packets.get()
+    
+    async def _add_incoming_packet(self, packet: CspPacket) -> None:
+        await self._pending_packets.put(packet)
+
+
+class CspBoundSocket(CspPortHandler):
+    def __init__(self, handler: 'CspSocketHandler', port: Port, send_flags: CspPacketFlags) -> None:
+        self._handler = handler
+        self._port: Port | None = None
+        self._pending_packets = asyncio.Queue[CspPacket]()
+        self._handler.bind(port, self)
+        self._port = port
+        self._send_flags = send_flags
+
+    def __del__(self) -> None:
+        self.close()
+
+    def close(self) -> None:
+        if self._port is not None:
+            self._handler.unbind(self._port)
+
+        self._port = None
+
+    async def send_to(self, *, dst: int, port: int, data: bytes) -> None:
+        assert self._port is not None
+        assert not isinstance(self._port, BindAnyPort)
+        packet = CspPacket(
+            packet_id=CspId(
+                priority=CspPacketPriority.Normal, # TODO
+                flags=self._send_flags,
+                src=0,
+                sport=self._port,
+                dst=dst,
+                dport=port,
+            ),
+            data=data,
+        )
+        await self._handler.send_packet(packet)
+
+    async def _add_incoming_packet(self, packet: CspPacket) -> None:
+        await self._pending_packets.put(packet)
+
+    async def send_reply(self, request: CspPacket, response: bytes) -> None:
+        assert self._port is not None
+
+        if not isinstance(self._port, BindAnyPort) and request.packet_id.dport != self._port:
+            raise ValueError(f'Invalid destination port in request (port in request {request.packet_id.dport} but bound to {self._port})')
+
+        packet = CspPacket(
+            packet_id=CspId(
+                priority=CspPacketPriority.Normal, # TODO
+                flags=self._send_flags,
+                src=0,
+                sport=request.packet_id.dport,
+                dst=request.packet_id.src,
+                dport=request.packet_id.sport,
+            ),
+            data=response,
+        )
+        await self._handler.send_packet(packet)
+    
+    async def recv_from(self) -> CspPacket:
+        return await self._pending_packets.get()
+
+
+class CspListeningSocket(CspPortHandler):
+    ConnectionId = tuple[int, int]
+
+    def __init__(self, owner: 'CspSocketHandler', local_port: Port, send_flags: CspPacketFlags) -> None:
+        self._owner = owner
+        self._local_port: Port | None = None
+        owner.bind(local_port, self)
+        self._local_port = local_port
+        self._send_flags = send_flags
+        self._connections: dict[CspListeningSocket.ConnectionId, CspServerConnection] = {}
+        self._pending_packets = asyncio.Queue[CspPacket]()
+        self._pending_connections = asyncio.Queue[CspListeningSocket.ConnectionId]()
+
+    def __del__(self) -> None:
+        self.close()
+
+    async def accept(self) -> CspServerConnection:
+        conn_id = await self._pending_connections.get()
+        return self._connections[conn_id]
+    
+    def close(self) -> None:
+        if self._local_port is not None:
+            self._owner.unbind(self._local_port)
+            self._local_port = None
+    
+    async def _add_incoming_packet(self, packet: CspPacket) -> None:
+        connection_id = self._conn_id(packet)
+        connection = self._connections.get(connection_id, None)
+        if connection is not None:
+            await connection._add_incoming_packet(packet)
+        else:
+            connection = CspServerConnection(self, packet.packet_id.src, packet.packet_id.sport, packet.packet_id.dport)
+            self._connections[connection_id] = connection
+            await connection._add_incoming_packet(packet)
+            await self._pending_connections.put(connection_id)
+
+    def _delete_connection(self, address: int, port: int) -> None:
+        del self._connections[(address, port)]
+
+    async def _send_to(self, *, dst: int, port: int, local_port: int, data: bytes) -> None:
+        assert self._local_port is not None
+
+        packet = CspPacket(
+            packet_id=CspId(
+                dst=dst,
+                dport=port,
+                src=0,
+                sport=local_port,
+                flags=self._send_flags,
+                priority=CspPacketPriority.Normal
+            ),
+            header=b'',
+            data=data
+        )
+        await self._owner.send_packet(packet)
+
+    @staticmethod
+    def _conn_id(packet: CspPacket) -> ConnectionId:
+        return (packet.packet_id.src, packet.packet_id.sport)
+
+
+class CspClientConnection:
+    def __init__(self, socket: CspBoundSocket, remote_address: int, remote_port: int) -> None:
+        super().__init__()
+        self._socket = socket
+        self._remote_address = remote_address
+        self._remote_port = remote_port
+
+    async def send(self, data: bytes) -> None:
+        await self._socket.send_to(dst=self._remote_address, port=self._remote_port, data=data)
+    
+    async def recv(self) -> CspPacket:
+        while True:
+            packet = await self._socket.recv_from()
+
+            if packet.packet_id.src == self._remote_address and packet.packet_id.sport == self._remote_port:
+                return packet
+    
+    def close(self) -> None:
+        self._socket.close()
+
+    @staticmethod
+    async def _connect(local_socket: CspBoundSocket, dst: int, port: int, local_port: int) -> 'CspClientConnection':
+        return CspClientConnection(local_socket, dst, port)
+
+
+class CspSocketHandler(IPacketHandler):
+    ANY_PORT = 0xFFFF_FFFF
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._ports: dict[int, CspPortHandler] = {}
+
+    def bound_socket(self, port: int | None, *, send_flags: CspPacketFlags) -> CspBoundSocket:
+        bind_to: Port | None = port 
+        if bind_to is None:
+            bind_to = BindAnyPort()
+        socket = CspBoundSocket(self, bind_to, send_flags=send_flags)
+        return socket
+
+    def listen(self, port: int | None, *, send_flags: CspPacketFlags) -> CspListeningSocket:
+        bind_to: Port | None = port 
+        if bind_to is None:
+            bind_to = BindAnyPort()
+        socket = CspListeningSocket(self, bind_to, send_flags=send_flags)
+        return socket
+    
+    async def connect(self, remote_address: int, remote_port: int, local_port: int | None, *, send_flags: CspPacketFlags) -> CspClientConnection:
+        if local_port is None:
+            local_port = self._find_free_port()
+        local_socket = self.bound_socket(local_port, send_flags=send_flags)
+        connection = await CspClientConnection._connect(local_socket, remote_address, remote_port, local_port)
+        return connection
+
+    async def on_packet(self, packet: CspPacket) -> bool:
+        handler = self._ports.get(packet.packet_id.dport)
+        if handler is None:
+            handler = self._ports.get(self.ANY_PORT)
+
+        if handler is None:
+            return False
+
+        await handler._add_incoming_packet(packet)
+        return True
+
+    def bind(self, port: Port, handler: CspPortHandler) -> None:
+        if isinstance(port, BindAnyPort):
+            port = self.ANY_PORT
+
+        if port in self._ports:
+            raise ValueError('Port already bound')
+
+        self._ports[port] = handler
+
+    def unbind(self, port: Port) -> None:
+        if isinstance(port, BindAnyPort):
+            port = self.ANY_PORT
+        del self._ports[port]
+
+    def _find_free_port(self) -> int:
+        for i in range(32, 64):  # TODO: global consts?
+            if i not in self._ports:
+                return i
+            
+        raise ValueError('No free port found')

cubesat_space_protocol_py-1.0.0.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: cubesat-space-protocol-py
+Version: 1.0.0
+Summary: Cubsat Space Protocol (CSP) native Python implementation
+Author: KP Labs
+License-Expression: MIT
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12

cubesat_space_protocol_py-1.0.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+csp_py/__init__.py,sha256=g-S_psXooUNB_qiPIY12XATsbYFYRq6bIULuR5WGnxM,370
+csp_py/crc32.py,sha256=t0bARi9zfnGkQr55qWebFLvXE7d985VjmgFP4CHhnqA,4309
+csp_py/interface.py,sha256=M_lRma0JnNvolMcV05KptAV2DpcS8-N2C9qfnlcxDWQ,446
+csp_py/node.py,sha256=2XWv21PzOG8xm-jfPGkX8Ret3c9WNeuvNRMWzvxKVF4,2389
+csp_py/packet.py,sha256=29lRdWlPMHUso-lllh7noGcTnu6UTtuYbrOFApsWcLs,2000
+csp_py/packet_handler.py,sha256=mckU9wCGhMCwbxKxyBOsOFl4rz7uOB-uw_Aiy8VdYKY,723
+csp_py/router.py,sha256=GkyQY49RaJgO7srhKwWafL5Vrquyj_VsspT0n-7aBUA,5425
+csp_py/rtable.py,sha256=uTstBRf-5A6nkcH4Qn3T-LhWLENY4AF6zfGgR8oereU,1657
+csp_py/socket.py,sha256=UwcIYWYZedzxC4xRkKKVhUhYH19-pVsUqkaemk0kRNc,9307
+csp_py/interfaces/interface_pair.py,sha256=twds2GSnWV9N4SiRi9EWfOtAu4fuDqRDuHn2OrIArog,1300
+csp_py/interfaces/lo_interface.py,sha256=4-bj17qDePQ6XVvifXUlYU9PanQmUs7NjXztOLYPP_s,479
+csp_py/interfaces/serializing_interface.py,sha256=Z4epr_YSeLhz8PoDIfgkKX1-NcWc29cjp4bdSqksvKM,2617
+csp_py/interfaces/can/__init__.py,sha256=E5bpXhyRsl-yavIDq6tWtLl_9IrdJx_3FfL6SAD4meU,82
+csp_py/interfaces/can/can_interface.py,sha256=jDEZouu5Qqdt_51ZYJAfmKcwZtXjuph45ldVy3h5naU,6231
+csp_py/services/ping.py,sha256=WFtmm4i6uyA5S955YMON5BBjvbQbo9zzTOnaCkglG1w,513
+csp_py/services/ping_client.py,sha256=FR4kS3YCBqtbLOTMcx-LwwKkj6Wa-o0NVc_BYSPL0sk,527
+cubesat_space_protocol_py-1.0.0.dist-info/METADATA,sha256=ET6ChTlOsrAS9oqJI4LRQv3Dz2JFIPJXqmaMIlsaikM,319
+cubesat_space_protocol_py-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cubesat_space_protocol_py-1.0.0.dist-info/licenses/LICENSE,sha256=uuYQfDvWdCQlm3e_bkuGvNeJg_t9KMVnGQPQO1toMK0,1063
+cubesat_space_protocol_py-1.0.0.dist-info/RECORD,,

cubesat_space_protocol_py-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

cubesat_space_protocol_py-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 KP Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.