AtlatestRepositorysigil-quic

sigil-quic / tree / testtest-datagram.sgl

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))
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))
20(define (dgc-index level)
21 (case level ((initial) 0) ((handshake) 1) ((application) 2)))
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))))
28(define (dgc-parameters role maximum)
29 (append (stream-transport-parameters role)
30 (if maximum (list (cons 32 (encode-varint maximum))) '())))
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))))
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))
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))))
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)))))))
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))
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))))))
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))))))
176(define (dgc-wire type data)
177 (encode-frame (make-quic-frame type (list (cons 'data data)))))
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)))))
185(define (dgc-error? procedure)
186 (guard (exn (else #t)) (procedure) #f))
188(define (dgc-positive procedure)
189 (assert-true (guard (exn (else #f)) (procedure))))
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))))))))
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)))))))))
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))))))))))))