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 an
scripts/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 the
src/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")))