Prove RUDP reordering across runtimes

This commit is contained in:
Meta Vens 2026-06-15 02:52:01 +01:00
commit 436654de75
9 changed files with 276 additions and 32 deletions

View file

@ -180,6 +180,11 @@ Current progress:
dropped data packet in both directions between TypeScript and C#/Kotlin/Python/Rust.
The drops happen below the transport connection through a UDP bridge, so the
recovery is RUDP resend/ack behavior, not application-level retry.
- The same harness now proves reliable ordered `schema` delivery survives
reordered data packets in both directions between TypeScript and
C#/Kotlin/Python/Rust. The bridge delays one packet below the transport, sends
the following packet first, and then releases the held packet; delivered frames
still surface in sequence.
- TypeScript, C#, Rust, Python, and Kotlin now share the first RUDP
fragmentation implementation: the session can split oversized reliable
ordered payloads into fragment packets, reassemble them before delivery, and
@ -190,8 +195,8 @@ Current progress:
C#/Kotlin/Python/Rust one-shot UDP peers.
- The remaining parity work is to deepen Python's server-side use of its port
and move each runtime's existing TCP/LiteNetLib/WebSocket bodies behind those
ports, then broaden RUDP interop into the full loss, reordering,
reconnect, backpressure, and schema-message matrix.
ports, then broaden RUDP interop into reconnect, backpressure, and the wider
schema-message matrix.
## RUDP Packet Contract V0

View file

@ -320,6 +320,11 @@ class CultNetRudpSession:
del now_ms
self._require_connection(packet)
self._apply_acknowledgements(packet)
expected_sequence_if_uninitialized = (
packet.sequence
if self._highest_received_sequence is None
else self._highest_received_sequence + 1
)
if packet.packet_type == CultNetRudpPacketType.ACCEPT:
self._remember_received(packet.sequence)
@ -350,7 +355,11 @@ class CultNetRudpSession:
frame, ordered, next_sequence = reassembled
if not ordered:
return CultNetRudpReceiveResult(delivered=(frame,))
return CultNetRudpReceiveResult(delivered=tuple(self._deliver_ordered(frame, next_sequence)))
return CultNetRudpReceiveResult(
delivered=tuple(
self._deliver_ordered(frame, next_sequence, expected_sequence_if_uninitialized)
)
)
def create_ack(self) -> CultNetRudpPacket:
return self._create_packet(CultNetRudpPacketType.ACK, "control", b"")
@ -472,11 +481,16 @@ class CultNetRudpSession:
max(sequences) + 1,
)
def _deliver_ordered(self, frame: CultNetRudpDeliveredFrame, next_after_frame: int) -> list[CultNetRudpDeliveredFrame]:
def _deliver_ordered(
self,
frame: CultNetRudpDeliveredFrame,
next_after_frame: int,
expected_sequence_if_uninitialized: int,
) -> list[CultNetRudpDeliveredFrame]:
next_sequence = self._ordered_next_sequence_by_channel.get(frame.channel_id)
if next_sequence is None:
self._ordered_next_sequence_by_channel[frame.channel_id] = next_after_frame
return [frame, *self._drain_ordered(frame.channel_id)]
next_sequence = min(expected_sequence_if_uninitialized, frame.sequence)
self._ordered_next_sequence_by_channel[frame.channel_id] = next_sequence
if frame.sequence < next_sequence:
return []
if frame.sequence > next_sequence:

View file

@ -256,6 +256,7 @@ class CultNetRudpSession(options: CultNetRudpSessionOptions) {
val ignoredNow = nowMs
requireConnection(packet)
applyAcknowledgements(packet)
val expectedSequenceIfUninitialized = (highestReceivedSequence ?: (packet.sequence - 1)) + 1
when (packet.packetType) {
CultNetRudpPacketType.Accept -> {
rememberReceived(packet.sequence)
@ -278,7 +279,7 @@ class CultNetRudpSession(options: CultNetRudpSessionOptions) {
rememberReceived(packet.sequence)
if (duplicate) return CultNetRudpReceiveResult()
val reassembled = reassemble(packet) ?: return CultNetRudpReceiveResult()
return CultNetRudpReceiveResult(delivered = if (reassembled.ordered) deliverOrdered(reassembled.frame, reassembled.nextSequence) else listOf(reassembled.frame))
return CultNetRudpReceiveResult(delivered = if (reassembled.ordered) deliverOrdered(reassembled.frame, reassembled.nextSequence, expectedSequenceIfUninitialized) else listOf(reassembled.frame))
}
fun createAck(): CultNetRudpPacket = createPacket(CultNetRudpPacketType.Ack, "control", ByteArray(0))
@ -364,11 +365,13 @@ class CultNetRudpSession(options: CultNetRudpSessionOptions) {
return ReassembledFrame(CultNetRudpDeliveredFrame(buffer.channelId, payload, sequences.minOrNull() ?: packet.sequence), buffer.ordered, (sequences.maxOrNull() ?: packet.sequence) + 1)
}
private fun deliverOrdered(frame: CultNetRudpDeliveredFrame, nextSequenceAfterFrame: Long): List<CultNetRudpDeliveredFrame> {
val next = orderedNextSequenceByChannel[frame.channelId]
if (next == null) {
orderedNextSequenceByChannel[frame.channelId] = nextSequenceAfterFrame
return listOf(frame) + drainOrdered(frame.channelId)
private fun deliverOrdered(
frame: CultNetRudpDeliveredFrame,
nextSequenceAfterFrame: Long,
expectedSequenceIfUninitialized: Long,
): List<CultNetRudpDeliveredFrame> {
val next = orderedNextSequenceByChannel[frame.channelId] ?: minOf(expectedSequenceIfUninitialized, frame.sequence).also {
orderedNextSequenceByChannel[frame.channelId] = it
}
if (frame.sequence < next) return emptyList()
if (frame.sequence > next) {
@ -596,6 +599,7 @@ private fun rudpServeOnce(options: Map<String, String>) {
val bindPort = options["bind-port"]?.toInt() ?: 0
val expectedClientPayload = (options["client-payload"] ?: "ts-kotlin-client-state").toByteArray(StandardCharsets.UTF_8)
val serverPayload = (options["server-payload"] ?: "kotlin-server-state").toByteArray(StandardCharsets.UTF_8)
val serverExtraPayload = options["server-extra-payload"]?.toByteArray(StandardCharsets.UTF_8)
val maxFragmentBytes = options["max-fragment-bytes"]?.toInt()
val socket = DatagramSocket(bindPort, InetAddress.getByName(bindHost)).also { it.soTimeout = 20 }
CultNetRudpSocketTransportConnection(
@ -614,6 +618,9 @@ private fun rudpServeOnce(options: Map<String, String>) {
if (frame != null) {
requireRudpFrame(frame, "schema", expectedClientPayload)
transport.send("schema", serverPayload)
if (serverExtraPayload != null) {
transport.send("schema", serverExtraPayload)
}
pollRudpAfterSend(transport, 250)
println("""{"status":"ok"}""")
return

View file

@ -466,6 +466,9 @@ fn rudp_serve_once(options: &BTreeMap<String, String>) -> Result<()> {
.get("server-payload")
.map(|value| value.as_bytes().to_vec())
.unwrap_or_else(|| b"rust-server-state".to_vec());
let server_extra_payload = options
.get("server-extra-payload")
.map(|value| value.as_bytes().to_vec());
let max_fragment_bytes = options
.get("max-fragment-bytes")
.map(|value| value.parse::<u32>())
@ -498,6 +501,9 @@ fn rudp_serve_once(options: &BTreeMap<String, String>) -> Result<()> {
));
}
transport.send("schema", server_payload.clone())?;
if let Some(extra_payload) = &server_extra_payload {
transport.send("schema", extra_payload.clone())?;
}
poll_rudp_after_send(&mut transport, Duration::from_millis(250))?;
print_json(&serde_json::json!({ "status": "ok" }))?;
return Ok(());

View file

@ -277,6 +277,10 @@ impl CultNetRudpSession {
) -> Result<CultNetRudpReceiveResult> {
self.require_connection(packet)?;
self.apply_acknowledgements(packet);
let expected_sequence_if_uninitialized = self
.highest_received_sequence
.map(|sequence| sequence + 1)
.unwrap_or(packet.sequence);
if packet.packet_type == CultNetRudpPacketType::Accept {
self.remember_received(packet.sequence);
@ -335,7 +339,7 @@ impl CultNetRudpSession {
});
};
let delivered = if ordered {
self.deliver_ordered(frame, next_sequence)
self.deliver_ordered(frame, next_sequence, expected_sequence_if_uninitialized)
} else {
vec![frame]
};
@ -548,18 +552,21 @@ impl CultNetRudpSession {
&mut self,
frame: CultNetRudpDeliveredFrame,
next_sequence_after_frame: u32,
expected_sequence_if_uninitialized: u32,
) -> Vec<CultNetRudpDeliveredFrame> {
let channel_id = frame.channel_id.clone();
let Some(next) = self
let next = if let Some(next) = self
.ordered_next_sequence_by_channel
.get(&channel_id)
.copied()
else {
self.ordered_next_sequence_by_channel
.insert(channel_id.clone(), next_sequence_after_frame);
let mut delivered = vec![frame];
delivered.extend(self.drain_ordered(&channel_id));
return delivered;
{
next
} else {
self.ordered_next_sequence_by_channel.insert(
channel_id.clone(),
expected_sequence_if_uninitialized.min(frame.sequence),
);
expected_sequence_if_uninitialized.min(frame.sequence)
};
if frame.sequence < next {

View file

@ -240,6 +240,9 @@ export class CultNetRudpSession {
receive(packet: CultNetRudpPacket, nowMs = 0): CultNetRudpReceiveResult {
this.#requireConnection(packet);
this.#applyAcknowledgements(packet);
const expectedSequenceIfUninitialized = this.#highestReceivedSequence === undefined
? packet.sequence
: this.#highestReceivedSequence + 1;
if (packet.packetType === "accept") {
this.#rememberReceived(packet.sequence);
@ -283,7 +286,7 @@ export class CultNetRudpSession {
return { delivered: [reassembled.frame] };
}
return { delivered: this.#deliverOrdered(reassembled.frame, reassembled.nextSequence) };
return { delivered: this.#deliverOrdered(reassembled.frame, reassembled.nextSequence, expectedSequenceIfUninitialized) };
}
createAck(): CultNetRudpPacket {
@ -449,14 +452,15 @@ export class CultNetRudpSession {
};
}
#deliverOrdered(frame: CultNetRudpDeliveredFrame, nextSequence: number): CultNetRudpDeliveredFrame[] {
const next = this.#orderedNextSequenceByChannel.get(frame.channelId);
#deliverOrdered(
frame: CultNetRudpDeliveredFrame,
nextSequence: number,
expectedSequenceIfUninitialized: number,
): CultNetRudpDeliveredFrame[] {
let next = this.#orderedNextSequenceByChannel.get(frame.channelId);
if (next === undefined) {
this.#orderedNextSequenceByChannel.set(frame.channelId, nextSequence);
return [
frame,
...this.#drainOrdered(frame.channelId),
];
next = Math.min(expectedSequenceIfUninitialized, frame.sequence);
this.#orderedNextSequenceByChannel.set(frame.channelId, next);
}
if (frame.sequence < next) {

View file

@ -81,6 +81,7 @@ interface RudpServerInteropPeerSpec {
interface RudpServerSpawnOptions {
clientPayload?: string;
serverPayload?: string;
serverExtraPayload?: string;
maxFragmentBytes?: number;
}
@ -138,6 +139,8 @@ from cultnet_py import (
expected_client_payload = os.environ.get("RUDP_CLIENT_PAYLOAD", "client-state").encode()
server_payload = os.environ.get("RUDP_SERVER_PAYLOAD", "python-state").encode()
server_extra_payload_raw = os.environ.get("RUDP_SERVER_EXTRA_PAYLOAD")
server_extra_payload = server_extra_payload_raw.encode() if server_extra_payload_raw else None
max_fragment_bytes_raw = os.environ.get("RUDP_MAX_FRAGMENT_BYTES")
max_fragment_bytes = int(max_fragment_bytes_raw) if max_fragment_bytes_raw else None
@ -166,6 +169,8 @@ while time.time() < deadline:
transport.close()
raise SystemExit(f"unexpected RUDP frame: {frame.channel_id!r} {frame.payload!r}")
transport.send("schema", server_payload)
if server_extra_payload is not None:
transport.send("schema", server_extra_payload)
print("OK", flush=True)
ack_deadline = time.time() + 0.25
while time.time() < ack_deadline:
@ -1166,6 +1171,123 @@ test("CultNet RUDP reliable schema response survives one dropped server data pac
}
});
test("CultNet RUDP reliable schema delivery survives reordered client data packets across runtimes", async () => {
for (const peer of rudpServerInteropPeers()) {
await peer.build();
const serverPeer = peer.spawn();
const clientSocket = await bindUdpSocket();
const lossyBridge = await createRudpLossyBridge({
remoteHost: "127.0.0.1",
remotePort: await serverPeer.ready,
shouldDelayClientPacket: (wire) => {
const packet = decodeRudpPacket(wire);
return packet.packetType === "data"
&& packet.channelId === "schema"
&& Buffer.from(packet.payload ?? []).equals(Buffer.from(peer.clientPayload));
},
});
let client: CultNetRudpSocketTransportConnection | undefined;
try {
client = new CultNetRudpSocketTransportConnection({
runtimeId: `ts-reordered-${peer.name.replace(/\W/g, "").toLowerCase()}-rudp-interop`,
socket: clientSocket,
mode: "client",
remoteHost: "127.0.0.1",
remotePort: lossyBridge.port,
connectionId: peer.connectionId,
initialSequence: 1,
resendDelayMs: 25,
resendPollMs: 5,
});
const receivedFrame = once(client, "frame");
client.connect(Buffer.from(peer.joinPayload));
await waitFor(() => client?.connected === true, `TypeScript RUDP client to complete ${peer.name} handshake through reorder bridge`);
client.send("schema", Buffer.from(peer.clientPayload));
client.send("schema", Buffer.from(`${peer.clientPayload}:second`));
const [frame] = await withTimeout(receivedFrame, 2_000, `${peer.name} RUDP response frame after reordered client data packets`);
assert.equal(frame.channelId, "schema");
assert.deepEqual(Buffer.from(frame.payload), Buffer.from(peer.expectedPayload));
assert.equal(lossyBridge.delayedClientPackets, 1, `${peer.name} bridge should delay exactly one client data packet`);
const [exitCode] = await withTimeout(once(serverPeer.child, "exit"), 2_000, `${peer.name} RUDP peer exit after reordered delivery`);
assert.equal(exitCode, 0, serverPeer.stderr.join(""));
} finally {
if (client) {
client.close();
} else {
clientSocket.close();
}
lossyBridge.close();
if (serverPeer.child.exitCode === null && !serverPeer.child.killed) {
serverPeer.child.kill("SIGTERM");
await once(serverPeer.child, "exit").catch(() => undefined);
}
}
}
});
test("CultNet RUDP reliable schema response survives reordered server data packets across runtimes", async () => {
for (const peer of rudpServerInteropPeers()) {
await peer.build();
const serverPeer = peer.spawn({
serverExtraPayload: `${peer.expectedPayload}:second`,
});
const clientSocket = await bindUdpSocket();
const lossyBridge = await createRudpLossyBridge({
remoteHost: "127.0.0.1",
remotePort: await serverPeer.ready,
shouldDelayServerPacket: (wire) => {
const packet = decodeRudpPacket(wire);
return packet.packetType === "data"
&& packet.channelId === "schema"
&& Buffer.from(packet.payload ?? []).equals(Buffer.from(peer.expectedPayload));
},
});
let client: CultNetRudpSocketTransportConnection | undefined;
try {
client = new CultNetRudpSocketTransportConnection({
runtimeId: `ts-server-reordered-${peer.name.replace(/\W/g, "").toLowerCase()}-rudp-interop`,
socket: clientSocket,
mode: "client",
remoteHost: "127.0.0.1",
remotePort: lossyBridge.port,
connectionId: peer.connectionId,
initialSequence: 1,
resendDelayMs: 25,
resendPollMs: 5,
});
const receivedFrame = once(client, "frame");
client.connect(Buffer.from(peer.joinPayload));
await waitFor(() => client?.connected === true, `TypeScript RUDP client to complete ${peer.name} handshake through server reorder bridge`);
client.send("schema", Buffer.from(peer.clientPayload));
const [frame] = await withTimeout(receivedFrame, 2_000, `${peer.name} RUDP response frame after reordered server data packets`);
assert.equal(frame.channelId, "schema");
assert.deepEqual(Buffer.from(frame.payload), Buffer.from(peer.expectedPayload));
assert.equal(lossyBridge.delayedServerPackets, 1, `${peer.name} bridge should delay exactly one server data packet`);
const [exitCode] = await withTimeout(once(serverPeer.child, "exit"), 2_000, `${peer.name} RUDP peer exit after server reorder`);
assert.equal(exitCode, 0, serverPeer.stderr.join(""));
} finally {
if (client) {
client.close();
} else {
clientSocket.close();
}
lossyBridge.close();
if (serverPeer.child.exitCode === null && !serverPeer.child.killed) {
serverPeer.child.kill("SIGTERM");
await once(serverPeer.child, "exit").catch(() => undefined);
}
}
}
});
test("CultNet RUDP fragmented schema frames cross runtime boundaries", async () => {
for (const peer of rudpServerInteropPeers()) {
await peer.build();
@ -1378,6 +1500,7 @@ function spawnPythonRudpPeer(options: RudpServerSpawnOptions = {}): RunningPytho
PYTHONPATH: cultcachePySrc,
...(options.clientPayload ? { RUDP_CLIENT_PAYLOAD: options.clientPayload } : {}),
...(options.serverPayload ? { RUDP_SERVER_PAYLOAD: options.serverPayload } : {}),
...(options.serverExtraPayload ? { RUDP_SERVER_EXTRA_PAYLOAD: options.serverExtraPayload } : {}),
...(options.maxFragmentBytes ? { RUDP_MAX_FRAGMENT_BYTES: String(options.maxFragmentBytes) } : {}),
},
stdio: ["ignore", "pipe", "pipe"],
@ -1430,6 +1553,7 @@ function spawnRustRudpServer(options: RudpServerSpawnOptions = {}): RunningPytho
"--bind-host", "127.0.0.1",
...(options.clientPayload ? ["--client-payload", options.clientPayload] : []),
...(options.serverPayload ? ["--server-payload", options.serverPayload] : []),
...(options.serverExtraPayload ? ["--server-extra-payload", options.serverExtraPayload] : []),
...(options.maxFragmentBytes ? ["--max-fragment-bytes", String(options.maxFragmentBytes)] : []),
], {
cwd: cultnetRsRoot,
@ -1487,6 +1611,7 @@ function spawnCSharpRudpServer(options: RudpServerSpawnOptions = {}): RunningPyt
"--bind-host", "127.0.0.1",
...(options.clientPayload ? ["--client-payload", options.clientPayload] : []),
...(options.serverPayload ? ["--server-payload", options.serverPayload] : []),
...(options.serverExtraPayload ? ["--server-extra-payload", options.serverExtraPayload] : []),
...(options.maxFragmentBytes ? ["--max-fragment-bytes", String(options.maxFragmentBytes)] : []),
], {
cwd: cultLibRoot,
@ -1545,6 +1670,7 @@ function spawnKotlinRudpServer(options: RudpServerSpawnOptions = {}): RunningPyt
"--bind-host", "127.0.0.1",
...(options.clientPayload ? ["--client-payload", options.clientPayload] : []),
...(options.serverPayload ? ["--server-payload", options.serverPayload] : []),
...(options.serverExtraPayload ? ["--server-extra-payload", options.serverExtraPayload] : []),
...(options.maxFragmentBytes ? ["--max-fragment-bytes", String(options.maxFragmentBytes)] : []),
], {
cwd: cultLibRoot,
@ -1686,6 +1812,8 @@ interface RudpLossyBridge {
port: number;
readonly droppedClientPackets: number;
readonly droppedServerPackets: number;
readonly delayedClientPackets: number;
readonly delayedServerPackets: number;
close(): void;
}
@ -1694,12 +1822,46 @@ async function createRudpLossyBridge(options: {
remotePort: number;
shouldDropClientPacket?: (wire: Buffer) => boolean;
shouldDropServerPacket?: (wire: Buffer) => boolean;
shouldDelayClientPacket?: (wire: Buffer) => boolean;
shouldDelayServerPacket?: (wire: Buffer) => boolean;
}): Promise<RudpLossyBridge> {
const socket = dgram.createSocket("udp4");
const remote = { address: options.remoteHost, port: options.remotePort };
let client: { address: string; port: number } | undefined;
let droppedClientPackets = 0;
let droppedServerPackets = 0;
let delayedClientPackets = 0;
let delayedServerPackets = 0;
let heldClientWire: Buffer | undefined;
let heldServerWire: Buffer | undefined;
let heldClientTimer: NodeJS.Timeout | undefined;
let heldServerTimer: NodeJS.Timeout | undefined;
const flushHeldClient = () => {
if (!heldClientWire) {
return;
}
const wire = heldClientWire;
heldClientWire = undefined;
if (heldClientTimer) {
clearTimeout(heldClientTimer);
heldClientTimer = undefined;
}
socket.send(wire, remote.port, remote.address);
};
const flushHeldServer = () => {
if (!heldServerWire || !client) {
return;
}
const wire = heldServerWire;
heldServerWire = undefined;
if (heldServerTimer) {
clearTimeout(heldServerTimer);
heldServerTimer = undefined;
}
socket.send(wire, client.port, client.address);
};
socket.on("message", (wire, sender) => {
if (sender.address === remote.address && sender.port === remote.port) {
@ -1707,8 +1869,15 @@ async function createRudpLossyBridge(options: {
droppedServerPackets += 1;
return;
}
if (delayedServerPackets === 0 && options.shouldDelayServerPacket?.(wire)) {
delayedServerPackets += 1;
heldServerWire = Buffer.from(wire);
heldServerTimer = setTimeout(flushHeldServer, 25);
return;
}
if (client) {
socket.send(wire, client.port, client.address);
flushHeldServer();
}
return;
}
@ -1718,8 +1887,15 @@ async function createRudpLossyBridge(options: {
droppedClientPackets += 1;
return;
}
if (delayedClientPackets === 0 && options.shouldDelayClientPacket?.(wire)) {
delayedClientPackets += 1;
heldClientWire = Buffer.from(wire);
heldClientTimer = setTimeout(flushHeldClient, 25);
return;
}
socket.send(wire, remote.port, remote.address);
flushHeldClient();
});
await new Promise<void>((resolveBind, rejectBind) => {
@ -1738,7 +1914,19 @@ async function createRudpLossyBridge(options: {
get droppedServerPackets() {
return droppedServerPackets;
},
get delayedClientPackets() {
return delayedClientPackets;
},
get delayedServerPackets() {
return delayedServerPackets;
},
close() {
if (heldClientTimer) {
clearTimeout(heldClientTimer);
}
if (heldServerTimer) {
clearTimeout(heldServerTimer);
}
socket.close();
},
};

View file

@ -724,6 +724,9 @@ namespace GameCult.Networking
{
RequireConnection(packet);
ApplyAcknowledgements(packet);
var expectedSequenceIfUninitialized = _highestReceivedSequence.HasValue
? _highestReceivedSequence.Value + 1
: packet.Sequence;
if (packet.PacketType == CultNetRudpPacketType.Accept)
{
@ -774,7 +777,7 @@ namespace GameCult.Networking
return new CultNetRudpReceiveResult
{
Delivered = reassembled.Ordered
? DeliverOrdered(reassembled.Frame, reassembled.NextSequence)
? DeliverOrdered(reassembled.Frame, reassembled.NextSequence, expectedSequenceIfUninitialized)
: new[] { reassembled.Frame }
};
}
@ -972,12 +975,15 @@ namespace GameCult.Networking
};
}
private IReadOnlyList<CultNetRudpDeliveredFrame> DeliverOrdered(CultNetRudpDeliveredFrame frame, uint nextSequenceAfterFrame)
private IReadOnlyList<CultNetRudpDeliveredFrame> DeliverOrdered(
CultNetRudpDeliveredFrame frame,
uint nextSequenceAfterFrame,
uint expectedSequenceIfUninitialized)
{
if (!_orderedNextSequenceByChannel.TryGetValue(frame.ChannelId, out var next))
{
_orderedNextSequenceByChannel[frame.ChannelId] = nextSequenceAfterFrame;
return new[] { frame }.Concat(DrainOrdered(frame.ChannelId)).ToArray();
next = Math.Min(expectedSequenceIfUninitialized, frame.Sequence);
_orderedNextSequenceByChannel[frame.ChannelId] = next;
}
if (frame.Sequence < next)

View file

@ -589,6 +589,9 @@ static void RudpServeOnce(Dictionary<string, string> options)
var serverPayload = Ascii(options.TryGetValue("server-payload", out var configuredServerPayload)
? configuredServerPayload
: "csharp-server-state");
var serverExtraPayload = options.TryGetValue("server-extra-payload", out var configuredServerExtraPayload)
? Ascii(configuredServerExtraPayload)
: null;
var maxFragmentBytes = options.TryGetValue("max-fragment-bytes", out var configuredMaxFragmentBytes)
? int.Parse(configuredMaxFragmentBytes, CultureInfo.InvariantCulture)
: (int?)null;
@ -622,6 +625,10 @@ static void RudpServeOnce(Dictionary<string, string> options)
{
RequireRudpFrameBytes(frame, "schema", expectedClientPayload);
transport.Send("schema", serverPayload);
if (serverExtraPayload != null)
{
transport.Send("schema", serverExtraPayload);
}
PollRudpAfterSend(transport, TimeSpan.FromMilliseconds(250));
WriteJsonLine(new { status = "ok" });
return;