Commitda657d35Recorded18 Oct 2026Repositorysigil-quic
Add bounded RFC 9221 DATAGRAM support
Changed
README.md | 35 +++++++++++
scripts/native-tls-tests.mjs | 8 ++-
src/sigil/quic/connection.sgl | 124 ++++++++++++++++++++++++++++++++++----
src/sigil/quic/frame.sgl | 32 +++++++---
src/sigil/quic/transport/parameters.sgl | 4 +-
test/test-datagram-codec.sgl | 128 +++++++++++++++++++++++++++++++++++++++
test/test-datagram.sgl | 497 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
test/test-frame.sgl | 3 +-
8 files changed, 807 insertions(+), 24 deletions(-)Diff
README.mdmodified
@@ -346,6 +346,8 @@ output to three times received bytes, bounds deferred packets/CRYPTO/queues,
346
tracks directional keys and PN spaces, and confirms with HANDSHAKE_DONE. 347
It uses immediate ACKs, a conservative send window, bounded fixed-base PTO 348
backoff and fresh-PN frame retransmission, rather than full RFC 9002 recovery.+349
RFC 9221 DATAGRAM payloads are excluded from retransmission; their loss timer+350
uses a PING probe while retaining ordinary congestion and ACK bookkeeping. 351
Handshake timeout defaults to 10 seconds. A client accepts one valid routed Retry 352
after sending its first Initial and before processing a server Initial. It keeps 353
the original ClientHello, client source CID and packet-number progression, changes@@ -376,6 +378,39 @@ drain final close output and close the dedicated endpoint socket.
378
close frame. Closure erases traffic keys, pending data and TLS secrets; 379
`tls-abort!` provides the same idempotent TLS cleanup to standalone callers. 380
+381
To accept RFC 9221 DATAGRAM messages, include transport parameter `0x20`+382
(`max_datagram_frame_size`) in the constructor's parameters, for example+383
`(cons 32 (encode-varint 65535))`. The value includes the frame type, optional+384
Length field and payload. Omission or zero disables receiving; receiving an+385
unsupported or oversized frame closes with PROTOCOL_VIOLATION. Received limits+386
use the actual wire size, including nonminimal Length-varint encodings.+387
+388
`quic-send-datagram! connection bytes` requires a complete authenticated+389
handshake and a nonzero peer advertisement. It copies one whole message,+390
queues a length-bearing frame (`0x31`) and returns `#t`; use `length?: #f` for+391
the lengthless `0x30` form. Invalid inputs and peer or 1,200-byte packet size+392
excess raise before queue mutation. No fragmentation is performed. A full+393
send queue returns `#f`: at most `quic-datagram-queue-limit` (32) DATAGRAM+394
messages may wait alongside the existing bounded frame queue. A full queue+395
does not overwrite earlier messages. Sending through `quic-send-frame!` also+396
enforces negotiation, size and count limits, but raises on queue refusal.+397
+398
`quic-read-datagram! connection` returns the oldest received message, or `#f`+399
when none is available, the handshake is incomplete, or the connection is+400
closed. An empty bytevector is a valid message. Receive dispatch is independent+401
of the stream-frame handler. It retains at most 32 messages and+402
`quic-datagram-byte-limit` (65,536) payload bytes; new arrivals beyond either+403
budget are dropped while normal packet ACK processing continues. Reads release+404
credit, and connection closure clears queued messages. DATAGRAM messages are+405
unreliable, do not consume STREAM flow-control credit and are never retransmitted.+406
Applications supply any flow identifiers inside their payloads.+407
+408
DATAGRAM codec/transport tests are in `test/test-datagram-codec.sgl`; protected+409
connection tests in `test/test-datagram.sgl` use a standalone TLS peer that owns+410
its keys. On a remote test machine, `node scripts/native-tls-tests.mjs --datagram`+411
selects both files for the native test package described above. They are also+412
included in the default bytecode and generated native suites.+413
414
Server Initial packets carrying a token are discarded before CID pinning, 415
authentication, receive credit or closing replay. During the handshake, other 416
coalesced packets remain eligible for processing. ClientHello must have anscripts/native-tls-tests.mjsmodified
@@ -19,6 +19,7 @@ const files = [
19
'test-tls-input-bounds.sgl', 20
'test-tls-alerts.sgl', 21
'test-frame.sgl',+22
'test-datagram-codec.sgl', 23
'test-reassembly.sgl', 24
'test-packet.sgl', 25
'test-retry-packet.sgl',@@ -27,6 +28,7 @@ const files = [
28
'test-server-retry.sgl', 29
'test-connection-space.sgl', 30
'test-connection.sgl',+31
'test-datagram.sgl', 32
'test-aead-limits.sgl', 33
'test-application-close.sgl', 34
'test-transport-errors.sgl',@@ -77,7 +79,8 @@ const retryToken = process.argv.includes('--retry-token');
79
const serverRetry = process.argv.includes('--server-retry'); 80
const endpointRetry = process.argv.includes('--endpoint-retry'); 81
const retryCleanup = process.argv.includes('--retry-cleanup');−80
if ([cleanupFaults, secretCleanup, secretRetention, handshakeCleanup, packetRetention, factoryCleanup, eventCleanup, constructionCleanup, pathResponse, cidZero, cidSequence, handlerReadiness, seenBudget, ticketValidation, negotiation, certificatePolicy, retryPolicy, earlyPackets, retryPacket, clientRetry, retryToken, serverRetry, endpointRetry, retryCleanup].filter(Boolean).length > 1) {+82
const datagram = process.argv.includes('--datagram');+83
if ([cleanupFaults, secretCleanup, secretRetention, handshakeCleanup, packetRetention, factoryCleanup, eventCleanup, constructionCleanup, pathResponse, cidZero, cidSequence, handlerReadiness, seenBudget, ticketValidation, negotiation, certificatePolicy, retryPolicy, earlyPackets, retryPacket, clientRetry, retryToken, serverRetry, endpointRetry, retryCleanup, datagram].filter(Boolean).length > 1) { 84
throw new Error('Select one focused test suite'); 85
} 86
if (cleanupFaults) {@@ -152,6 +155,9 @@ if (endpointRetry) {
155
if (retryCleanup) { 156
files.splice(0, files.length, '../scripts/retry-cleanup-tests.sgl'); 157
}+158
if (datagram) {+159
files.splice(0, files.length, 'test-datagram-codec.sgl', 'test-datagram.sgl');+160
} 161
const bodies = files.map(file => { 162
const text = readFileSync(join(root, 'test', file), 'utf8'); 163
const boundary = text.indexOf('\n\n');src/sigil/quic/connection.sglmodified
@@ -17,10 +17,15 @@
17
quic-local-id quic-peer-id quic-complete? quic-confirmed? quic-closed? quic-idle-expired? 18
quic-start! quic-take-datagrams! quic-receive! quic-tick! quic-failure 19
quic-set-frame-handler! quic-send-frame! quic-send-capacity+20
quic-send-datagram! quic-read-datagram!+21
quic-datagram-queue-limit quic-datagram-byte-limit 22
quic-local-parameters quic-peer-parameters quic-negotiated-alpn 23
quic-on-close! quic-close! quic-transport-close! quic-closing? quic-abort! 24
quic-abandon-stream-data! quic-stream-outstanding?) 25
(begin+26
(define quic-datagram-queue-limit 32)+27
(define quic-datagram-byte-limit 65536)+28
29
(define-struct connection-level 30
(level) 31
(space)@@ -34,6 +39,7 @@
39
(queue-back default: '() mutable: #t) 40
(queue-bytes default: 0 mutable: #t) 41
(queue-count default: 0 mutable: #t)+42
(datagram-count default: 0 mutable: #t) 43
(ack default: #f mutable: #t) 44
(sent default: '() mutable: #t) 45
(deferred default: '() mutable: #t)@@ -80,6 +86,10 @@
86
(close-next default: #f mutable: #t) 87
(close-until default: #f mutable: #t) 88
(frame-handler default: #f mutable: #t)+89
(datagram-front default: '() mutable: #t)+90
(datagram-back default: '() mutable: #t)+91
(datagram-count default: 0 mutable: #t)+92
(datagram-bytes default: 0 mutable: #t) 93
(close-handlers default: '() mutable: #t)) 94
95
(define (quic-idle-expired? connection) (quic-connection-idle-expired? connection))@@ -286,20 +296,37 @@
296
(error "QUIC connection: time must be monotonic exact milliseconds")) 297
(set-quic-connection-now! connection now)) 298
+299
(define (datagram-frame? frame)+300
(and (memv (quic-frame-type frame) '(48 49)) #t))+301
+302
;; All sends use four PN bytes and fixed long-header length widths, so+303
;; PN 0 has the same geometry as the eventual send. Check before admission.+304
(define (check-frame-packet-budget! connection level wire)+305
(unless (and (<= (bytevector-length wire) 1200)+306
(let ((header+307
(encode-packet-header level (quic-connection-peer-id connection)+308
(if (eq? level 'application) #u8() (quic-connection-local-id connection))+309
(initial-token connection level) 0 4 (+ (bytevector-length wire) 16)+310
length-width: (and (not (eq? level 'application)) 2))))+311
(<= (+ (bytevector-length header) (bytevector-length wire) 16) 1200)))+312
(error "QUIC connection: queued frame exceeds packet budget")))+313
+314
(define (check-datagram-send! connection size)+315
(unless (quic-complete? connection)+316
(error "QUIC DATAGRAM: authenticated handshake is not complete"))+317
(let* ((parameters (quic-peer-parameters connection))+318
(maximum (if parameters (transport-parameter-integer parameters 32 0) 0)))+319
(unless (> maximum 0) (error "QUIC DATAGRAM: peer did not advertise support"))+320
(when (> size maximum) (error "QUIC DATAGRAM: frame exceeds peer advertisement"))))+321
322
(define (queue-frame! connection level frame (keys: (priority? #f))) 323
(let* ((state (level-state connection level)) 324
(wire (encode-frames (list frame) level (quic-role connection))))−292
;; Local input must fail before it changes the queue or reaches the−293
;; guarded send path. All sends use four PN bytes and fixed long-header−294
;; length widths, so PN 0 has the same geometry as the eventual send.−295
(unless (and (<= (bytevector-length wire) 1200)−296
(let ((header−297
(encode-packet-header level (quic-connection-peer-id connection)−298
(if (eq? level 'application) #u8() (quic-connection-local-id connection))−299
(initial-token connection level) 0 4 (+ (bytevector-length wire) 16)−300
length-width: (and (not (eq? level 'application)) 2))))−301
(<= (+ (bytevector-length header) (bytevector-length wire) 16) 1200)))−302
(error "QUIC connection: queued frame exceeds packet budget"))+325
(check-frame-packet-budget! connection level wire)+326
(when (datagram-frame? frame)+327
(check-datagram-send! connection (bytevector-length wire))+328
(when (>= (connection-level-datagram-count state) quic-datagram-queue-limit)+329
(error "QUIC DATAGRAM: send queue is full"))) 330
(when (or (packet-space-discarded? (connection-level-space state)) 331
(>= (connection-level-queue-count state) 4096) 332
(> (+ (connection-level-queue-bytes state) (bytevector-length wire)) 2097152))@@ -314,6 +341,8 @@
341
(cons owned (connection-level-queue-back state))))) 342
(set-connection-level-queue-bytes! state 343
(+ (connection-level-queue-bytes state) (bytevector-length wire)))+344
(when (datagram-frame? frame)+345
(set-connection-level-datagram-count! state (+ 1 (connection-level-datagram-count state)))) 346
(set-connection-level-queue-count! state (+ 1 (connection-level-queue-count state))))) 347
348
(define (initial-token connection level)@@ -350,6 +379,8 @@
379
(when frame 380
(set-connection-level-queue-front! state (cdr (connection-level-queue-front state))) 381
(set-connection-level-queue-count! state (- (connection-level-queue-count state) 1))+382
(when (datagram-frame? frame)+383
(set-connection-level-datagram-count! state (- (connection-level-datagram-count state) 1))) 384
(set-connection-level-queue-bytes! state 385
(- (connection-level-queue-bytes state) (bytevector-length (encode-frame frame))))) 386
frame))@@ -418,13 +449,19 @@
449
(set-connection-level-queue-back! state '()) 450
(set-connection-level-queue-bytes! state 0) 451
(set-connection-level-queue-count! state 0)+452
(set-connection-level-datagram-count! state 0) 453
(set-connection-level-ack! state #f) 454
(set-connection-level-sent! state '()) 455
(set-connection-level-deferred! state '()) 456
(set-connection-level-deferred-bytes! state 0) 457
(when (eq? level 'initial) 458
(set-quic-connection-retry-hello! connection #f)−427
(set-quic-connection-retry-token! connection #u8()))))+459
(set-quic-connection-retry-token! connection #u8()))+460
(when (eq? level 'application)+461
(set-quic-connection-datagram-front! connection '())+462
(set-quic-connection-datagram-back! connection '())+463
(set-quic-connection-datagram-count! connection 0)+464
(set-quic-connection-datagram-bytes! connection 0)))) 465
466
(define (in-flight connection) 467
(apply + (map (lambda (level) (packet-space-pending-bytes (connection-level-space (level-state connection level))))@@ -483,7 +520,11 @@
520
(set-connection-level-sealed! state (+ 1 (connection-level-sealed state))) 521
(packet-space-record-sent! space number size now eliciting?) 522
(when eliciting?−486
(set-connection-level-sent! state (cons (cons number frame) (connection-level-sent state))))+523
;; Keep congestion/ACK metadata, but never DATAGRAM payload+524
;; for retransmission. Its PTO elicits an ACK using PING.+525
(let ((retained (if (datagram-frame? frame) (make-quic-frame 1 '()) frame)))+526
(set-connection-level-sent! state+527
(cons (cons number retained) (connection-level-sent state))))) 528
(sent-activity! connection now eliciting?) 529
(when (and eliciting? (memq level '(initial handshake))) 530
(set-quic-connection-probe-start! connection now))@@ -623,6 +664,56 @@
664
(if (or (quic-closed? connection) (> (connection-level-queue-count state) 4094)) 665
0 (- 2097152 (connection-level-queue-bytes state))))) 666
+667
;; Queue one whole unreliable message. #f means bounded queue refusal;+668
;; invalid input, unauthenticated/unsupported peers and size excess raise.+669
;; The normal send path copies data and enforces congestion and AEAD limits.+670
(define (quic-send-datagram! connection data (keys: (length? #t)))+671
(unless (and (bytevector? data) (<= (bytevector-length data) 1200) (boolean? length?))+672
(error "QUIC DATAGRAM: expected bounded bytes and a length boolean"))+673
(let* ((frame (make-quic-frame (if length? 49 48) (list (cons 'data data))))+674
(wire (encode-frame frame)) (state (level-state connection 'application)))+675
(check-datagram-send! connection (bytevector-length wire))+676
(check-frame-packet-budget! connection 'application wire)+677
(and (< (connection-level-datagram-count state) quic-datagram-queue-limit)+678
(< (connection-level-queue-count state) 4096)+679
(<= (+ (connection-level-queue-bytes state) (bytevector-length wire)) 2097152)+680
(begin (queue-frame! connection 'application frame) #t))))+681
+682
;; Separate from the stream-frame handler. #f is empty; #u8() is a valid+683
;; empty message. Reads transfer ownership and release receive queue credit.+684
(define (quic-read-datagram! connection)+685
(and (quic-complete? connection)+686
(begin+687
(when (null? (quic-connection-datagram-front connection))+688
(set-quic-connection-datagram-front! connection (reverse (quic-connection-datagram-back connection)))+689
(set-quic-connection-datagram-back! connection '()))+690
(and (pair? (quic-connection-datagram-front connection))+691
(let ((data (car (quic-connection-datagram-front connection))))+692
(set-quic-connection-datagram-front! connection (cdr (quic-connection-datagram-front connection)))+693
(set-quic-connection-datagram-count! connection (- (quic-connection-datagram-count connection) 1))+694
(set-quic-connection-datagram-bytes! connection+695
(- (quic-connection-datagram-bytes connection) (bytevector-length data)))+696
data)))))+697
+698
(define (check-datagram-receive! connection frame)+699
(let ((maximum (transport-parameter-integer (quic-local-parameters connection) 32 0)))+700
(when (or (= maximum 0) (> (frame-wire-size frame) maximum))+701
(raise-quic-error 10 (quic-frame-type frame)+702
"QUIC DATAGRAM: frame exceeds local advertisement or support is disabled"))))+703
+704
;; Refuse new messages when either local budget is full. They are still+705
;; processed for ACK/congestion purposes; DATAGRAM provides no flow control.+706
(define (input-datagram! connection frame)+707
(let ((data (frame-ref frame 'data)))+708
(when (and (< (quic-connection-datagram-count connection) quic-datagram-queue-limit)+709
(<= (+ (quic-connection-datagram-bytes connection) (bytevector-length data))+710
quic-datagram-byte-limit))+711
(set-quic-connection-datagram-back! connection+712
(cons data (quic-connection-datagram-back connection)))+713
(set-quic-connection-datagram-count! connection (+ 1 (quic-connection-datagram-count connection)))+714
(set-quic-connection-datagram-bytes! connection+715
(+ (quic-connection-datagram-bytes connection) (bytevector-length data))))))+716
717
(define (stream-data? frame id) 718
(and (<= 8 (quic-frame-type frame) 15) (= (frame-ref frame 'stream-id) id))) 719
@@ -710,6 +801,7 @@
801
((0 1) #t) 802
((2 3) (acknowledge! connection state frame)) 803
((6) (input-crypto! connection state frame))+804
((48 49) (input-datagram! connection frame)) 805
((26) 806
;; The endpoint pins one path. The reply uses its ordinary bounded 807
;; send queue and admission checks, ahead of application backlog.@@ -813,6 +905,12 @@
905
(number (opened-quic-packet-number opened)) 906
(eliciting? (and frames (any frame-ack-eliciting? frames))) 907
(status (packet-space-received-status space number)))+908
;; An unowned STREAM in the packet must not hide an invalid+909
;; DATAGRAM. Check every size before any prefix dispatch.+910
(when (and frames (eq? status 'new))+911
(for-each+912
(lambda (frame)+913
(when (datagram-frame? frame) (check-datagram-receive! connection frame))) frames)) 914
;; Tolerate short authenticated server Initials. The 915
;; server-side client-datagram minimum is checked earlier. 916
;; Unowned application input cannot be retained. Drop thesrc/sigil/quic/frame.sglmodified
@@ -1,4 +1,4 @@
−1
;;; QUIC v1 frame formats and packet-level placement, RFC 9000 12.4/19.+1
;;; QUIC v1 frames, RFC 9000 12.4/19 and RFC 9221 DATAGRAM. 2
;;; Stream/connection policy (flow control, ownership, ACK validity against 3
;;; sent packets, CID inventory and path validation) belongs to the caller. 4
(define-library (sigil quic frame)@@ -9,7 +9,7 @@
9
(sigil quic wire)) 10
(export frame-payload-limit frame-count-limit ack-range-limit frame-work-limit? 11
make-quic-frame quic-frame? quic-frame-type quic-frame-fields−12
frame-ref frame-fin? frame-ack-eliciting?+12
frame-ref frame-fin? frame-ack-eliciting? frame-wire-size 13
encode-frame encode-frames decode-frames) 14
(begin 15
(define frame-payload-limit 65527)@@ -29,7 +29,8 @@
29
30
(define-struct quic-frame 31
(type)−32
(fields))+32
(fields)+33
(wire-size default: #f)) 34
35
(define-struct frame-reader 36
(data)@@ -38,6 +39,11 @@
39
(define (make-quic-frame type fields) 40
(quic-frame type: type fields: fields)) 41
+42
;; Received limits include the actual varint width, even when it is wider+43
;; than our encoder would choose. Synthetic frames use their encoded size.+44
(define (frame-wire-size frame)+45
(or (quic-frame-wire-size frame) (bytevector-length (encode-frame frame))))+46
47
(define (frame-ref frame key) 48
(let ((entry (assq key (quic-frame-fields frame)))) 49
(unless entry (error "QUIC frame: missing field" key))@@ -74,7 +80,8 @@
80
(define (placement! type level sender) 81
(unless (and (memq level '(initial handshake application)) (memq sender '(client server))) 82
(error "QUIC frame: invalid encryption level or sender"))−77
(unless (and (integer? type) (exact? type) (<= 0 type 30))+83
(unless (and (integer? type) (exact? type)+84
(or (<= 0 type 30) (memv type '(48 49)))) 85
(error "QUIC frame: unknown type")) 86
(when (and (not (eq? level 'application)) (not (memv type '(0 1 2 3 6 28)))) 87
(raise-quic-error 10 type "QUIC frame: forbidden encryption level"))@@ -164,6 +171,9 @@
171
(append (list (cons 'error error-code)) 172
(if trigger (list (cons 'frame-type trigger)) '()) 173
(list (cons 'reason reason)))))+174
((memv type '(48 49))+175
(let ((length (if (= type 49) (read-v! reader) (remaining reader))))+176
(list (cons 'data (read-bytes! reader length))))) 177
(else (error "QUIC frame: unknown type")))) 178
179
(define (decode-frames payload level sender)@@ -178,12 +188,14 @@
188
(begin 189
(when (>= count frame-count-limit) 190
(raise-frame-work-limit 'frames "QUIC frames: local frame work limit exceeded"))−181
;; All RFC 9000 types fit in a single byte. Other encodings+191
;; All supported frame types fit in a single byte. Other encodings 192
;; are nonminimal or unknown, both FRAME_ENCODING_ERROR.−183
(let ((type (read-byte! reader)))+193
(let* ((start (frame-reader-position reader)) (type (read-byte! reader))) 194
(placement! type level sender) 195
(let ((fields (read-fields! reader type)))−186
(loop (cons (make-quic-frame type fields) frames) (+ count 1)))))))))+196
(loop (cons (quic-frame type: type fields: fields+197
wire-size: (- (frame-reader-position reader) start)) frames)+198
(+ count 1))))))))) 199
200
(define (schema type) 201
(cond ((= type 0) '(length))@@ -202,6 +214,7 @@
214
((memv type '(26 27)) '(data)) 215
((= type 28) '(error frame-type reason)) 216
((= type 29) '(error reason))+217
((memv type '(48 49)) '(data)) 218
(else (error "QUIC frame: unknown type")))) 219
220
(define (check-fields! frame)@@ -279,6 +292,9 @@
292
((memv type '(28 29)) 293
(bytes-append (v 'error) (if (= type 28) (v 'frame-type) #u8()) 294
(length-prefixed (data-field frame 'reason 0 frame-payload-limit))))+295
((memv type '(48 49))+296
(let ((data (data-field frame 'data 0 frame-payload-limit)))+297
(if (= type 49) (length-prefixed data) data))) 298
(else (error "QUIC frame: unknown type"))))) 299
300
(define (encode-frame frame)@@ -306,6 +322,8 @@
322
(placement! type level sender) 323
(when (and (<= 8 type 15) (= (bitwise-and type 2) 0) (pair? (cdr rest))) 324
(error "QUIC STREAM: lengthless frame must be last"))+325
(when (and (= type 48) (pair? (cdr rest)))+326
(error "QUIC DATAGRAM: lengthless frame must be last")) 327
(set! size (+ size (bytevector-length wire))) 328
(when (> size frame-payload-limit) (error "QUIC frames: payload limit exceeded")) 329
(set! parts (cons wire parts))src/sigil/quic/transport/parameters.sglmodified
@@ -1,4 +1,4 @@
−1
;;; QUIC v1 transport parameters, RFC 9000 sections 7.3 and 18.+1
;;; QUIC v1 transport parameters, RFC 9000 7.3/18 and RFC 9221 section 3. 2
;;; Values remain opaque bytevectors; known integer values are validated. 3
(define-library (sigil quic transport parameters) 4
(import (sigil quic bytes)@@ -20,7 +20,7 @@
20
(when (and (eq? sender 'client) (memv id '(0 2 13 16))) 21
(error "QUIC: client sent server-only transport parameter" id)) 22
(cond−23
((memv id '(1 3 4 5 6 7 8 9 10 11 14))+23
((memv id '(1 3 4 5 6 7 8 9 10 11 14 32)) 24
(let ((n (parameter-integer value))) 25
(when (or (and (= id 3) (< n 1200)) 26
(and (memv id '(8 9)) (> n 1152921504606846976))test/test-datagram-codec.sgladded
@@ -0,0 +1,128 @@
+1
(import (sigil test)+2
(sigil quic bytes)+3
(sigil quic wire)+4
(sigil quic frame)+5
(sigil quic transport parameters))+6
+7
(define (dg-frame type data)+8
(make-quic-frame type (list (cons 'data data))))+9
+10
(define (dg-parameters role value)+11
(append (list (cons 15 #u8(1)))+12
(if (eq? role 'server) (list (cons 0 #u8(2))) '())+13
(if value (list (cons 32 value)) '())))+14
+15
(define (dg-round-trip? type wire data)+16
(guard (exn (else #f))+17
(let ((frames (decode-frames wire 'application 'client)))+18
(and (= 1 (length frames)) (= type (quic-frame-type (car frames)))+19
(bytes=? data (frame-ref (car frames) 'data))+20
(= (bytevector-length wire) (frame-wire-size (car frames)))+21
(bytes=? wire (encode-frame (dg-frame type data)))))))+22
+23
(test-group "RFC9221 DATAGRAM frame codec and transport parameter"+24
(test "datagram-codec: lengthless independent bytes round trip"+25
(assert-true (dg-round-trip? 48 #u8(48 0 255 128 1) #u8(0 255 128 1))))+26
(test "datagram-codec: explicit length independent bytes round trip"+27
(assert-true (dg-round-trip? 49 #u8(49 4 0 255 128 1) #u8(0 255 128 1))))+28
(test "datagram-codec: both types allow empty data"+29
(assert-true+30
(and (dg-round-trip? 48 #u8(48) #u8()) (dg-round-trip? 49 #u8(49 0) #u8()))))+31
(test "datagram-codec: explicit length permits following frames"+32
(assert-true+33
(guard (exn (else #f))+34
(let* ((wire #u8(49 2 0 255 1)) (frames (decode-frames wire 'application 'server)))+35
(and (equal? '(49 1) (map quic-frame-type frames))+36
(bytes=? #u8(0 255) (frame-ref (car frames) 'data))+37
(= 4 (frame-wire-size (car frames)))+38
(bytes=? wire (encode-frames frames 'application 'server)))))))+39
(test "datagram-codec: lengthless consumes all remaining packet data"+40
(assert-true (dg-round-trip? 48 #u8(48 1 0 49 0) #u8(1 0 49 0))))+41
(test "datagram-codec: lengthless must be the final encoded frame"+42
(assert-error+43
(encode-frames (list (dg-frame 48 #u8(1)) (make-quic-frame 1 '())) 'application 'client)))+44
(test "datagram-codec: actual received length includes a nonminimal length varint"+45
(assert-true+46
(guard (exn (else #f))+47
(let* ((wire (bytes-append #u8(49) (encode-varint 1 8) #u8(255)))+48
(frame (car (decode-frames wire 'application 'server))))+49
(and (= 10 (frame-wire-size frame)) (bytes=? #u8(255) (frame-ref frame 'data))+50
(bytes=? #u8(49 1 255) (encode-frame frame)))))))+51
(test "datagram-codec: missing truncated and overdeclared lengths fail"+52
(for-each+53
(lambda (wire) (assert-error (decode-frames wire 'application 'server)))+54
(list #u8(49) #u8(49 2 1) #u8(49 64) #u8(49 128 0 0)+55
(bytes-append #u8(49) (encode-varint quic-varint-maximum)))))+56
(test "datagram-codec: datagrams require application protection in both directions"+57
(for-each+58
(lambda (type)+59
(for-each+60
(lambda (sender)+61
(for-each+62
(lambda (level)+63
(assert-error (encode-frames (list (dg-frame type #u8(1))) level sender))+64
(assert-error (decode-frames (encode-frame (dg-frame type #u8(1))) level sender)))+65
'(initial handshake)))+66
'(client server)))+67
'(48 49)))+68
(test "datagram-codec: datagrams elicit ACKs without STREAM FIN semantics"+69
(assert-true+70
(every (lambda (type)+71
(let ((frame (dg-frame type #u8())))+72
(and (frame-ack-eliciting? frame) (not (frame-fin? frame)))))+73
'(48 49))))+74
(test "datagram-codec: byte field schema and total payload remain bounded"+75
(for-each+76
(lambda (type)+77
(assert-error (encode-frame (make-quic-frame type '())))+78
(assert-error (encode-frame (make-quic-frame type (list (cons 'data "text")))))+79
(assert-error (encode-frame (make-quic-frame type (list (cons 'data #u8()) (cons 'data #u8())))))+80
(assert-error (encode-frame (dg-frame type (make-bytevector frame-payload-limit 1)))))+81
'(48 49)))+82
(test "datagram-parameter: known zero recommended and full varint values round trip"+83
(for-each+84
(lambda (role)+85
(for-each+86
(lambda (maximum)+87
(let* ((parameters (dg-parameters role (encode-varint maximum)))+88
(decoded (decode-transport-parameters (encode-transport-parameters parameters role) role)))+89
(assert-equal maximum (transport-parameter-integer decoded 32 -1))))+90
(list 0 1 2 1200 65535 quic-varint-maximum)))+91
'(client server)))+92
(test "datagram-parameter: missing support defaults to zero"+93
(for-each+94
(lambda (role)+95
(let ((parameters (dg-parameters role #f)))+96
(assert-equal 0+97
(transport-parameter-integer+98
(decode-transport-parameters (encode-transport-parameters parameters role) role) 32 0))))+99
'(client server)))+100
(test "datagram-parameter: malformed integer values refuse encode and decode"+101
(for-each+102
(lambda (role)+103
(for-each+104
(lambda (value)+105
(assert-error (encode-transport-parameters (dg-parameters role value) role))+106
(let ((base (encode-transport-parameters (dg-parameters role #f) role)))+107
(assert-error+108
(decode-transport-parameters+109
(bytes-append base #u8(32) (encode-varint (bytevector-length value)) value) role))))+110
(list #u8() #u8(64) #u8(128 0 0) #u8(192 0 0 0 0 0 0) #u8(1 0))))+111
'(client server)))+112
(test "datagram-parameter: duplicate support advertisement refuses encode and decode"+113
(for-each+114
(lambda (role)+115
(assert-error+116
(encode-transport-parameters+117
(append (dg-parameters role #u8(1)) (list (cons 32 #u8(2)))) role))+118
(assert-error+119
(decode-transport-parameters+120
(bytes-append (encode-transport-parameters (dg-parameters role #u8(1)) role) #u8(32 1 2)) role)))+121
'(client server)))+122
(test "datagram-parameter: wider legal integer representations remain accepted"+123
(for-each+124
(lambda (role)+125
(let* ((wire (encode-transport-parameters (dg-parameters role (encode-varint 1200 8)) role))+126
(parameters (decode-transport-parameters wire role)))+127
(assert-equal 1200 (transport-parameter-integer parameters 32 0))))+128
'(client server))))test/test-datagram.sgladded
@@ -0,0 +1,497 @@
+1
(import (sigil test)+2
(sigil crypto)+3
(sigil quic bytes)+4
(sigil quic wire)+5
(sigil quic error)+6
(sigil quic frame)+7
(sigil quic packet)+8
(sigil quic reassembly)+9
(sigil quic connection)+10
(sigil quic stream)+11
(sigil quic tls))+12
+13
;; Public TLS peer: the target has no secret getters or injected hooks.+14
;; Fields: target/TLS, read/write keys, peer/target PNs, CRYPTO buffers/offsets,+15
;; observations, reserved, time, peer role, HANDSHAKE_DONE, target/peer CIDs.+16
(define dgc-original #u8(1 2 3 4 5 6 7 8))+17
(define dgc-client-id #u8(11 12 13 14 15 16 17 18))+18
(define dgc-server-id #u8(21 22 23 24 25 26 27 28))+19
+20
(define (dgc-index level)+21
(case level ((initial) 0) ((handshake) 1) ((application) 2)))+22
+23
(define (dgc-wipe! bytes)+24
(when (bytevector? bytes)+25
(do ((index 0 (+ index 1))) ((= index (bytevector-length bytes)))+26
(bytevector-u8-set! bytes index 0))))+27
+28
(define (dgc-parameters role maximum)+29
(append (stream-transport-parameters role)+30
(if maximum (list (cons 32 (encode-varint maximum))) '())))+31
+32
(define (dgc-build! peer level body)+33
(let* ((index (dgc-index level)) (numbers (vector-ref peer 4))+34
(number (vector-ref numbers index)) (role (vector-ref peer 11))+35
(destination+36
(if (and (eq? role 'client) (eq? level 'initial)+37
(= -1 (vector-ref (vector-ref peer 5) 0)))+38
dgc-original (vector-ref peer 13)))+39
(source (if (eq? level 'application) #u8() (vector-ref peer 14)))+40
(header (encode-packet-header level destination source #u8() number 4+41
(+ 16 (bytevector-length body))+42
length-width: (and (not (eq? level 'application)) 2)))+43
(payload+44
(if (eq? level 'initial)+45
(bytes-append body+46
(make-bytevector (- 1200 16 (bytevector-length header) (bytevector-length body)) 0))+47
body)))+48
(vector-set! numbers index (+ number 1))+49
(seal-quic-packet (vector-ref (vector-ref peer 3) index) level destination source number payload+50
length-width: (and (not (eq? level 'application)) 2))))+51
+52
(define (dgc-send! peer body)+53
(let ((packet (dgc-build! peer 'application body)))+54
(quic-receive! (vector-ref peer 0) packet (vector-ref peer 10))+55
packet))+56
+57
(define (dgc-events! peer)+58
(for-each+59
(lambda (event)+60
(let* ((level (tls-event-level event)) (index (dgc-index level))+61
(data (tls-event-data event)))+62
(case (tls-event-kind event)+63
((secrets)+64
(when (car data)+65
(vector-set! (vector-ref peer 2) index (traffic-keys (car data)))+66
(dgc-wipe! (car data)))+67
(when (cdr data)+68
(vector-set! (vector-ref peer 3) index (traffic-keys (cdr data)))+69
(dgc-wipe! (cdr data))))+70
((crypto)+71
(let* ((offsets (vector-ref peer 7)) (offset (vector-ref offsets index))+72
(frame (make-quic-frame 6 (list (cons 'offset offset) (cons 'data data))))+73
(packet (dgc-build! peer level (encode-frame frame))))+74
(quic-receive! (vector-ref peer 0) packet (vector-ref peer 10))+75
(vector-set! offsets index (+ offset (bytevector-length data))))))))+76
(tls-take-events! (vector-ref peer 1)))+77
(when (and (eq? (vector-ref peer 11) 'server) (tls-complete? (vector-ref peer 1))+78
(not (vector-ref peer 12)))+79
(vector-set! peer 12 #t)+80
(dgc-send! peer #u8(30))))+81
+82
(define (dgc-read! peer packet ack?)+83
(let* ((header (decode-packet-header packet 0 8)) (level (quic-header-kind header))+84
(index (dgc-index level)) (largest (vector-ref peer 5))+85
(opened (open-quic-packet packet 0 8 (vector-ref (vector-ref peer 2) index)+86
(vector-ref largest index))))+87
(unless opened (error "DATAGRAM fixture: target packet authentication failed"))+88
(let* ((number (opened-quic-packet-number opened))+89
(frames (decode-frames (opened-quic-packet-payload opened) level+90
(quic-role (vector-ref peer 0)))))+91
(vector-set! largest index (max number (vector-ref largest index)))+92
(vector-set! peer 8 (cons (list level number frames) (vector-ref peer 8)))+93
(for-each+94
(lambda (frame)+95
(when (= 6 (quic-frame-type frame))+96
(let ((receiver (vector-ref (vector-ref peer 6) index)))+97
(reassembler-insert! receiver (frame-ref frame 'offset) (frame-ref frame 'data))+98
(let ((bytes (reassembler-read! receiver)))+99
(when (> (bytevector-length bytes) 0)+100
(tls-input! (vector-ref peer 1) level bytes)+101
(dgc-events! peer)))))) frames)+102
(when (and ack? (any frame-ack-eliciting? frames))+103
(let ((frame (make-quic-frame 2+104
(list (cons 'ranges (list (cons number number))) (cons 'delay 0)))))+105
(quic-receive! (vector-ref peer 0) (dgc-build! peer level (encode-frame frame))+106
(vector-ref peer 10)))))))+107
+108
(define (dgc-output! peer now (keys: (ack? #t)))+109
(vector-set! peer 10 now)+110
(let ((packets (quic-take-datagrams! (vector-ref peer 0) now)))+111
(for-each+112
(lambda (packet)+113
(let ((index (dgc-index (quic-header-kind (decode-packet-header packet 0 8)))))+114
(when (vector-ref (vector-ref peer 2) index) (dgc-read! peer packet ack?))))+115
packets)+116
packets))+117
+118
(define (dgc-with-peer role procedure+119
(keys: (target-maximum 65535) (peer-maximum 65535) (start? #t) (before-ready #f)))+120
(let ((key (ecdsa-p256-generate-keypair)) (connection #f) (engine #f) (peer #f))+121
(dynamic-wind+122
(lambda () #t)+123
(lambda ()+124
(let* ((client? (eq? role 'client)) (peer-role (if client? 'server 'client))+125
(target-id (if client? dgc-client-id dgc-server-id))+126
(peer-id (if client? dgc-server-id dgc-client-id))+127
(parameters+128
(append (dgc-parameters peer-role peer-maximum)+129
(list (cons 1 (encode-varint 30000)) (cons 15 peer-id))+130
(if client? (list (cons 0 dgc-original)) '()))))+131
(set! connection+132
(if client?+133
(make-quic-client (list #u8(113 49)) 'pinned-key (dgc-parameters role target-maximum)+134
(make-tls-pin-verifier (cdr key)) local-id: target-id destination-id: dgc-original)+135
(make-quic-server (list #u8(113 49)) (dgc-parameters role target-maximum)+136
(list #u8(48 1 0)) (car key) dgc-original peer-id local-id: target-id)))+137
(set! engine+138
(if client?+139
(make-tls-server (list #u8(113 49)) parameters (list #u8(48 1 0)) (car key))+140
(make-tls-client (list #u8(113 49)) 'pinned-key parameters (make-tls-pin-verifier (cdr key)))))+141
(set! peer+142
(vector connection engine+143
(vector (initial-keys dgc-original role) #f #f)+144
(vector (initial-keys dgc-original peer-role) #f #f)+145
(vector 0 0 0) (vector -1 -1 -1)+146
(vector (make-byte-reassembler 65536) (make-byte-reassembler 65536)+147
(make-byte-reassembler 65536))+148
(vector 0 0 0) '() #f 0 peer-role #f target-id peer-id))+149
(tls-bind-peer! engine dgc-original target-id #f)+150
(when start?+151
(if client? (quic-start! connection 0) (begin (tls-start! engine) (dgc-events! peer)))+152
(do ((round 0 (+ round 1))) ((= round 12))+153
(dgc-output! peer 0)+154
(dgc-events! peer)+155
(when (and before-ready (= round 0)) (before-ready peer)))+156
(unless (and (quic-confirmed? connection) (not (quic-closed? connection))+157
(tls-complete? engine) (vector-ref (vector-ref peer 2) 2)+158
(vector-ref (vector-ref peer 3) 2))+159
(error "DATAGRAM fixture: protected handshake did not complete")))+160
(vector-set! peer 8 '())+161
(procedure peer)))+162
(lambda ()+163
(when connection (quic-abort! connection))+164
(when engine (tls-abort! engine))+165
(when peer+166
(for-each+167
(lambda (keys) (when keys (discard-packet-keys! keys)))+168
(append (vector->list (vector-ref peer 2)) (vector->list (vector-ref peer 3))))+169
(for-each reassembler-close! (vector->list (vector-ref peer 6))))+170
(dgc-wipe! (car key))))))+171
+172
(define (dgc-observed peer type)+173
(filter (lambda (frame) (= type (quic-frame-type frame)))+174
(apply append (map caddr (reverse (vector-ref peer 8))))))+175
+176
(define (dgc-wire type data)+177
(encode-frame (make-quic-frame type (list (cons 'data data)))))+178
+179
(define (dgc-drain! connection)+180
(let loop ((messages '()) (count 0))+181
(when (> count quic-datagram-queue-limit) (error "DATAGRAM fixture: receive count exceeded limit"))+182
(let ((data (quic-read-datagram! connection)))+183
(if data (loop (cons data messages) (+ count 1)) (reverse messages)))))+184
+185
(define (dgc-error? procedure)+186
(guard (exn (else #t)) (procedure) #f))+187
+188
(define (dgc-positive procedure)+189
(assert-true (guard (exn (else #f)) (procedure))))+190
+191
(define (dgc-protocol-close? peer trigger)+192
(let* ((connection (vector-ref peer 0)) (failure (quic-failure connection)))+193
(and (quic-closed? connection) (quic-error? failure) (= 10 (quic-error-code failure))+194
(= trigger (quic-error-frame-type failure)) (not (quic-read-datagram! connection))+195
(begin+196
(dgc-output! peer (vector-ref peer 10) ack?: #f)+197
(let ((frames (dgc-observed peer 28)))+198
(and (= 1 (length frames)) (= 10 (frame-ref (car frames) 'error))+199
(= trigger (frame-ref (car frames) 'frame-type))))))))+200
+201
(define (dgc-exchange? role length?)+202
(dgc-with-peer role+203
(lambda (peer)+204
(let* ((connection (vector-ref peer 0)) (type (if length? 49 48))+205
(data #u8(0 255 1 128)))+206
(and (quic-send-datagram! connection data length?: length?)+207
(begin+208
(dgc-output! peer 0)+209
(dgc-send! peer (dgc-wire type data))+210
(and (quic-confirmed? connection) (not (quic-closed? connection))+211
(= 1 (length (dgc-observed peer type)))+212
(bytes=? data (frame-ref (car (dgc-observed peer type)) 'data))+213
(bytes=? data (quic-read-datagram! connection))+214
(not (quic-read-datagram! connection)))))))))+215
+216
(test-group "RFC9221 protected connection DATAGRAM delivery"+217
(test "datagram: client exchanges binary messages without a stream handler"+218
(dgc-positive (lambda () (dgc-exchange? 'client #t))))+219
(test "datagram: server exchanges binary messages without a stream handler"+220
(dgc-positive (lambda () (dgc-exchange? 'server #t))))+221
(test "datagram: both directions exchange lengthless messages"+222
(dgc-positive (lambda () (every (lambda (role) (dgc-exchange? role #f)) '(client server)))))+223
(test "datagram: valid empty messages remain distinct from an empty queue"+224
(dgc-positive+225
(lambda ()+226
(every+227
(lambda (role)+228
(dgc-with-peer role+229
(lambda (peer)+230
(let ((connection (vector-ref peer 0)))+231
(and (not (quic-read-datagram! connection)) (quic-send-datagram! connection #u8())+232
(begin+233
(dgc-output! peer 0)+234
(dgc-send! peer #u8(48))+235
(and (bytes=? #u8() (quic-read-datagram! connection))+236
(not (quic-read-datagram! connection)))))))))+237
'(client server)))))+238
(test "datagram: send owns a copy before caller mutation"+239
(dgc-positive+240
(lambda ()+241
(dgc-with-peer 'client+242
(lambda (peer)+243
(let ((data (bytevector 0 255 7)))+244
(and (quic-send-datagram! (vector-ref peer 0) data)+245
(begin+246
(bytevector-u8-set! data 1 1)+247
(dgc-output! peer 0)+248
(bytes=? #u8(0 255 7) (frame-ref (car (dgc-observed peer 49)) 'data))))))))))+249
(test "datagram: absent or zero peer support refuses both send APIs without closing"+250
(dgc-positive+251
(lambda ()+252
(every+253
(lambda (maximum)+254
(dgc-with-peer 'client+255
(lambda (peer)+256
(let ((connection (vector-ref peer 0)))+257
(and (dgc-error? (lambda () (quic-send-datagram! connection #u8(1))))+258
(dgc-error?+259
(lambda () (quic-send-frame! connection (make-quic-frame 48 (list (cons 'data #u8(1)))))))+260
(not (quic-failure connection)) (quic-complete? connection)+261
(null? (dgc-output! peer 0))))) peer-maximum: maximum))+262
'(#f 0)))))+263
(test "datagram: peer-only advertisement permits unilateral sending"+264
(dgc-positive+265
(lambda ()+266
(dgc-with-peer 'server+267
(lambda (peer)+268
(and (quic-send-datagram! (vector-ref peer 0) #u8(1))+269
(begin (dgc-output! peer 0) (= 1 (length (dgc-observed peer 49))))))+270
target-maximum: #f))))+271
(test "datagram: missing local advertisement produces a protected protocol close"+272
(dgc-positive+273
(lambda ()+274
(every+275
(lambda (role)+276
(dgc-with-peer role+277
(lambda (peer) (dgc-send! peer #u8(48)) (dgc-protocol-close? peer 48))+278
target-maximum: #f)) '(client server)))))+279
(test "datagram: zero local advertisement produces a protected protocol close"+280
(dgc-positive+281
(lambda ()+282
(dgc-with-peer 'server+283
(lambda (peer) (dgc-send! peer #u8(49 0)) (dgc-protocol-close? peer 49))+284
target-maximum: 0))))+285
(test "datagram: receive limit counts type length and payload"+286
(dgc-positive+287
(lambda ()+288
(every+289
(lambda (role)+290
(dgc-with-peer role+291
(lambda (peer) (dgc-send! peer #u8(49 2 0 255)) (dgc-protocol-close? peer 49))+292
target-maximum: 3)) '(client server)))))+293
(test "datagram: exact receive limit accepts both encodings"+294
(dgc-positive+295
(lambda ()+296
(dgc-with-peer 'client+297
(lambda (peer)+298
(dgc-send! peer #u8(48 0 255))+299
(dgc-send! peer #u8(49 1 128))+300
(equal? (list #u8(0 255) #u8(128)) (dgc-drain! (vector-ref peer 0))))+301
target-maximum: 3))))+302
(test "datagram: nonminimal received length cannot evade the advertised limit"+303
(dgc-positive+304
(lambda ()+305
(dgc-with-peer 'server+306
(lambda (peer)+307
(dgc-send! peer (bytes-append #u8(49) (encode-varint 1 8) #u8(255)))+308
(dgc-protocol-close? peer 49)) target-maximum: 3))))+309
(test "datagram: exact wide-length receive limit remains legal"+310
(dgc-positive+311
(lambda ()+312
(dgc-with-peer 'client+313
(lambda (peer)+314
(dgc-send! peer (bytes-append #u8(49) (encode-varint 1 8) #u8(255)))+315
(and (bytes=? #u8(255) (quic-read-datagram! (vector-ref peer 0)))+316
(not (quic-failure (vector-ref peer 0))))) target-maximum: 10))))+317
(test "datagram: unowned STREAM cannot hide an invalid datagram or apply a prefix"+318
(dgc-positive+319
(lambda ()+320
(dgc-with-peer 'server+321
(lambda (peer)+322
(dgc-send! peer #u8(49 1 7 10 0 1 8 49 3 1 2 3))+323
(dgc-protocol-close? peer 49)) target-maximum: 3))))+324
(test "datagram: receive count limit refuses new arrivals and reads release credit"+325
(dgc-positive+326
(lambda ()+327
(dgc-with-peer 'client+328
(lambda (peer)+329
(let ((connection (vector-ref peer 0)))+330
(do ((index 0 (+ index 1))) ((= index 33))+331
(dgc-send! peer (dgc-wire 49 (bytevector index))))+332
(and (bytes=? #u8(0) (quic-read-datagram! connection))+333
(begin+334
(dgc-send! peer #u8(49 1 99))+335
(let ((messages (dgc-drain! connection)))+336
(and (= 32 (length messages)) (bytes=? #u8(1) (car messages))+337
(bytes=? #u8(31) (list-ref messages 30))+338
(bytes=? #u8(99) (list-ref messages 31))+339
(not (quic-failure connection))))))))))))+340
(test "datagram: receive byte limit refuses new arrivals independently of count"+341
(dgc-positive+342
(lambda ()+343
(dgc-with-peer 'server+344
(lambda (peer)+345
(let ((connection (vector-ref peer 0)))+346
(dgc-send! peer (dgc-wire 49 (make-bytevector 32768 1)))+347
(dgc-send! peer (dgc-wire 49 (make-bytevector 32768 2)))+348
(dgc-send! peer #u8(49 1 3))+349
(let ((first (quic-read-datagram! connection)))+350
(and (= 32768 (bytevector-length first)) (= 1 (bytevector-u8-ref first 0))+351
(begin+352
(dgc-send! peer #u8(49 1 4))+353
(let ((messages (dgc-drain! connection)))+354
(and (= 2 (length messages)) (= 32768 (bytevector-length (car messages)))+355
(= 2 (bytevector-u8-ref (car messages) 0))+356
(bytes=? #u8(4) (cadr messages)))))))))))))+357
(test "datagram: send count limit refuses without overwriting queued messages"+358
(dgc-positive+359
(lambda ()+360
(dgc-with-peer 'client+361
(lambda (peer)+362
(let ((connection (vector-ref peer 0)))+363
(do ((index 0 (+ index 1))) ((= index 32))+364
(unless (quic-send-datagram! connection (bytevector index)) (error "Unexpected send refusal")))+365
(and (not (quic-send-datagram! connection #u8(99)))+366
(dgc-error?+367
(lambda () (quic-send-frame! connection (make-quic-frame 49 (list (cons 'data #u8(99)))))))+368
(begin+369
(dgc-output! peer 0)+370
(let ((frames (dgc-observed peer 49)))+371
(and (= 32 (length frames))+372
(bytes=? #u8(0) (frame-ref (car frames) 'data))+373
(bytes=? #u8(31) (frame-ref (list-ref frames 31) 'data))+374
(quic-send-datagram! connection #u8(100))))))))))))+375
(test "datagram: peer limit includes encoding overhead for both send APIs"+376
(dgc-positive+377
(lambda ()+378
(dgc-with-peer 'server+379
(lambda (peer)+380
(let ((connection (vector-ref peer 0)) (data (make-bytevector 10 1)))+381
(and (dgc-error? (lambda () (quic-send-datagram! connection data)))+382
(dgc-error?+383
(lambda () (quic-send-frame! connection (make-quic-frame 49 (list (cons 'data data))))))+384
(null? (dgc-output! peer 0))+385
(quic-send-datagram! connection data length?: #f)+386
(begin (dgc-output! peer 0) (= 1 (length (dgc-observed peer 48)))))))+387
peer-maximum: 11))))+388
(test "datagram: packet geometry accepts exact 1200 and refuses one extra byte"+389
(dgc-positive+390
(lambda ()+391
(dgc-with-peer 'client+392
(lambda (peer)+393
(let ((connection (vector-ref peer 0)))+394
(and (dgc-error? (lambda () (quic-send-datagram! connection (make-bytevector 1169 1))))+395
(dgc-error? (lambda () (quic-send-datagram! connection (make-bytevector 1171 1) length?: #f)))+396
(quic-send-datagram! connection (make-bytevector 1168 1))+397
(quic-send-datagram! connection (make-bytevector 1170 2) length?: #f)+398
(let ((packets (dgc-output! peer 0)))+399
(and (= 2 (length packets)) (every (lambda (packet) (= 1200 (bytevector-length packet))) packets)+400
(not (quic-failure connection)))))))))))+401
(test "datagram: lost payload is not retransmitted and PTO sends only a fresh probe"+402
(dgc-positive+403
(lambda ()+404
(dgc-with-peer 'server+405
(lambda (peer)+406
(let ((connection (vector-ref peer 0)))+407
(and (quic-send-datagram! connection #u8(0 255 7))+408
(= 1 (length (quic-take-datagrams! connection 0)))+409
(begin+410
(quic-tick! connection 1000)+411
(dgc-output! peer 1000)+412
(and (= 1 (length (dgc-observed peer 1)))+413
(null? (dgc-observed peer 48)) (null? (dgc-observed peer 49))+414
(not (quic-failure connection)))))))))))+415
(test "datagram: duplicated protected packet delivers a message only once"+416
(dgc-positive+417
(lambda ()+418
(dgc-with-peer 'client+419
(lambda (peer)+420
(let ((packet (dgc-send! peer #u8(49 1 255))))+421
(quic-receive! (vector-ref peer 0) packet 0)+422
(equal? (list #u8(255)) (dgc-drain! (vector-ref peer 0)))))))))+423
(test "datagram: forged tag does not deliver or consume the later valid packet"+424
(dgc-positive+425
(lambda ()+426
(dgc-with-peer 'server+427
(lambda (peer)+428
(let* ((connection (vector-ref peer 0)) (packet (dgc-build! peer 'application #u8(49 1 255))))+429
(quic-receive! connection (flip-byte packet (- (bytevector-length packet) 1)) 0)+430
(and (not (quic-read-datagram! connection)) (null? (dgc-output! peer 0))+431
(begin+432
(quic-receive! connection packet 0)+433
(and (bytes=? #u8(255) (quic-read-datagram! connection))+434
(not (quic-failure connection)))))))))))+435
(test "datagram: ordinary congestion admission delays queued large messages"+436
(dgc-positive+437
(lambda ()+438
(dgc-with-peer 'client+439
(lambda (peer)+440
(let ((connection (vector-ref peer 0)))+441
(do ((index 0 (+ index 1))) ((= index 32))+442
(quic-send-datagram! connection (make-bytevector 1168 index)))+443
(let ((first (quic-take-datagrams! connection 0)))+444
(and (< 0 (length first) 32) (null? (quic-take-datagrams! connection 0))+445
(begin+446
(for-each (lambda (packet) (dgc-read! peer packet #t)) first)+447
(do ((round 0 (+ round 1))) ((= round 8)) (dgc-output! peer 0))+448
(and (= 32 (length (dgc-observed peer 49))) (not (quic-failure connection))))))))))))+449
(test "datagram: incomplete handshake refuses sends and exposes no messages"+450
(dgc-positive+451
(lambda ()+452
(dgc-with-peer 'client+453
(lambda (peer)+454
(let ((connection (vector-ref peer 0)))+455
(and (dgc-error? (lambda () (quic-send-datagram! connection #u8(1))))+456
(not (quic-read-datagram! connection)) (not (quic-closed? connection))))) start?: #f))))+457
(test "datagram: protected early message waits for client Finished commitment"+458
(dgc-positive+459
(lambda ()+460
(let ((held? #f))+461
(dgc-with-peer 'client+462
(lambda (peer)+463
(and held? (quic-complete? (vector-ref peer 0))+464
(bytes=? #u8(255) (quic-read-datagram! (vector-ref peer 0)))+465
(not (quic-read-datagram! (vector-ref peer 0)))))+466
before-ready:+467
(lambda (peer)+468
(dgc-send! peer #u8(49 1 255))+469
(set! held?+470
(and (not (quic-complete? (vector-ref peer 0)))+471
(not (quic-closed? (vector-ref peer 0)))+472
(not (quic-read-datagram! (vector-ref peer 0)))))))))))+473
(test "datagram: closing clears pending receive messages and refuses later sends"+474
(dgc-positive+475
(lambda ()+476
(dgc-with-peer 'server+477
(lambda (peer)+478
(let ((connection (vector-ref peer 0)))+479
(dgc-send! peer #u8(49 1 255))+480
(quic-abort! connection)+481
(and (quic-closed? connection) (not (quic-read-datagram! connection))+482
(dgc-error? (lambda () (quic-send-datagram! connection #u8(1)))))))))))+483
(test "datagram: stream delivery and datagram queue coexist"+484
(dgc-positive+485
(lambda ()+486
(dgc-with-peer 'client+487
(lambda (peer)+488
(let* ((connection (vector-ref peer 0)) (stream (make-quic-stream connection)))+489
(and (= 1 (quic-stream-write! stream #u8(7)))+490
(quic-send-datagram! connection #u8(9))+491
(begin+492
(dgc-output! peer 0)+493
(dgc-send! peer #u8(10 0 1 8 49 1 255))+494
(and (bytes=? #u8(8) (quic-stream-read! stream))+495
(bytes=? #u8(255) (quic-read-datagram! connection))+496
(= 1 (length (dgc-observed peer 49)))+497
(not (quic-failure connection))))))))))))test/test-frame.sglmodified
@@ -92,7 +92,8 @@
92
(frame-examples))) 93
(test "unknown and nonminimal frame types are rejected" 94
(do ((type 31 (+ type 1))) ((= type 256))−95
(assert-error (decode-frames (bytevector type) 'application 'server)))+95
(unless (memv type '(48 49))+96
(assert-error (decode-frames (bytevector type) 'application 'server)))) 97
(for-each reject-frame '("4001" "80000001" "c000000000000001"))) 98
(test "ordinary integer fields accept wider legal varints" 99
(let ((frame (one-frame "0640004001aa")))