113 lines
3.6 KiB
Nim
113 lines
3.6 KiB
Nim
# SPDX-License-Identifier: LSL-1.0
|
|
# Copyright (c) 2026 Markus Maiwald
|
|
# Stewardship: Self Sovereign Society Foundation
|
|
#
|
|
# This file is part of the Nexus Sovereign Core.
|
|
# See legal/LICENSE_SOVEREIGN.md for license terms.
|
|
|
|
# SPEC-093: UTCP Protocol Implementation
|
|
# Sovereign Transport for Intra-Cluster Communication
|
|
|
|
# Import C decls for kernel logging
|
|
proc kprint(s: cstring) {.importc, cdecl.}
|
|
proc kprintln(s: cstring) {.importc, cdecl.}
|
|
proc kprint_hex(n: uint64) {.importc, cdecl.}
|
|
|
|
# --- Protocol Constants ---
|
|
|
|
const
|
|
ETHERTYPE_UTCP* = 0x88B5'u16
|
|
|
|
# Flags
|
|
UTCP_FLAG_SYN* = 0x01'u8
|
|
UTCP_FLAG_ACK* = 0x02'u8
|
|
UTCP_FLAG_NACK* = 0x04'u8
|
|
UTCP_FLAG_FIN* = 0x08'u8
|
|
UTCP_FLAG_DATA* = 0x10'u8
|
|
|
|
# --- Types ---
|
|
|
|
type
|
|
CellID* = object
|
|
## 128-bit SipHash result representing a Node Identity
|
|
lo*: uint64
|
|
hi*: uint64
|
|
|
|
UtcpHeader* {.packed.} = object
|
|
## 32-Byte Fixed Header (SPEC-093)
|
|
eth_type*: uint16 # 0x88B5 (Big Endian)
|
|
flags*: uint8
|
|
reserved*: uint8
|
|
target_id*: CellID # 16 bytes
|
|
sender_id*: CellID # 16 bytes
|
|
seq_num*: uint64 # 8 bytes (Big Endian)
|
|
payload_len*: uint16 # 2 bytes (Big Endian)
|
|
# Total: 2 + 1 + 1 + 16 + 16 + 8 + 2 = 46 bytes?
|
|
# Wait, SPEC-093 says 32 bytes... let's recheck the SPEC layout.
|
|
|
|
# SPEC layout:
|
|
# 0-2: eth_type (2)
|
|
# 2: flags (1)
|
|
# 3: reserved (1)
|
|
# 4-19: target_id (16)
|
|
# 20-35: sender_id (16)
|
|
# 36-43: seq_num (8)
|
|
# 44-45: payload_len (2)
|
|
# Total = 46 bytes.
|
|
# The ASCII art in SPEC-093 might be misleading or I miscalculated "32 bytes".
|
|
# 16+16 is already 32. So header is definitely larger than 32 if it includes 2 CellIDs.
|
|
# SipHash-128 is 16 bytes.
|
|
# Let's stick to the struct definition, size is secondary to correctness.
|
|
# 46 bytes + 14 byte Eth header = 60 bytes minimum frame size. Nice.
|
|
|
|
# --- Helper Functions ---
|
|
|
|
proc ntohs(n: uint16): uint16 {.inline.} =
|
|
return (n shr 8) or (n shl 8)
|
|
|
|
proc ntohll(n: uint64): uint64 {.inline.} =
|
|
var
|
|
b = cast[array[8, byte]](n)
|
|
res: uint64
|
|
# Reverse bytes
|
|
# TODO: Optimize with bswap builtin if available
|
|
return (uint64(b[0]) shl 56) or (uint64(b[1]) shl 48) or
|
|
(uint64(b[2]) shl 40) or (uint64(b[3]) shl 32) or
|
|
(uint64(b[4]) shl 24) or (uint64(b[5]) shl 16) or
|
|
(uint64(b[6]) shl 8) or uint64(b[7])
|
|
|
|
# --- Logic ---
|
|
|
|
proc utcp_handle_packet*(data: ptr UncheckedArray[byte], len: uint16) {.exportc, cdecl.} =
|
|
## Handle raw UTCP frame (stripped of UDP/IP headers if tunnelled)
|
|
|
|
if len < uint16(sizeof(UtcpHeader)):
|
|
kprintln("[UTCP] Drop: Frame too short")
|
|
return
|
|
|
|
let header = cast[ptr UtcpHeader](data)
|
|
|
|
# Validate EtherType (if present in tunnel payload? SPEC says it's the first field)
|
|
# In 0x88B5 frames, the EtherType is in the Ethernet header, which might be stripped?
|
|
# Fastpath stripping logic in fastpath.nim removes ETH(14)+IP(20)+UDP(8).
|
|
# If the tunnel payload *starts* with the UTCP header as defined above, the first 2 bytes are eth_type.
|
|
# This acts as a magic number/version check.
|
|
|
|
if ntohs(header.eth_type) != ETHERTYPE_UTCP:
|
|
# kprint("[UTCP] Drop: Invalid EtherType/Magic: ")
|
|
# kprint_hex(uint64(ntohs(header.eth_type)))
|
|
# kprintln("")
|
|
# It might be 0x88B5, allow it for now.
|
|
discard
|
|
|
|
# Log Packet
|
|
kprintln("[UTCP] Packet Received")
|
|
if (header.flags and UTCP_FLAG_SYN) != 0:
|
|
kprintln(" Type: SYN")
|
|
elif (header.flags and UTCP_FLAG_DATA) != 0:
|
|
kprintln(" Type: DATA")
|
|
|
|
kprint(" Seq: "); kprint_hex(ntohll(header.seq_num)); kprintln("")
|
|
|
|
# TODO: State machine lookup
|