AtlatestRepositorysigil-quic

sigil-quic / tree / testtest-frame.sgl

1(import (sigil test)
2 (sigil process)
3 (sigil quic bytes)
4 (sigil quic wire)
5 (sigil quic frame)
6 (sigil quic vectors))
7
8;; Independent examples written from RFC 9000 section 19 layouts. Values
9;; deliberately differ across fields, so parser ordering is observable.
10(define (frame-examples)
11 (map hex->bytes
12 '("000000" "01" "02140301020304" "03140301020304070809"
13 "04010203" "050102" "060403aabbcc" "0702abcd"
14 "0801aabbcc" "0901aabbcc" "0a0103aabbcc" "0b0103aabbcc"
15 "0c0104aabbcc" "0d0104aabbcc" "0e010403aabbcc" "0f010403aabbcc"
16 "104123" "11014123" "1204" "1304" "1404" "150104" "1604" "1704"
17 "18020102aabb000102030405060708090a0b0c0d0e0f" "1902"
18 "1a0001020304050607" "1b0001020304050607"
19 "1c010603666f6f" "1d0103666f6f" "1e")))
21(define (one-frame hex)
22 (car (decode-frames (hex->bytes hex) 'application 'server)))
24(define (check-frame-wire expected actual)
25 (assert-equal
26 (if (equal? (getenv "QUIC_FRAME_RED") "1") (flip-byte expected 0) expected) actual))
28(define (frame-round-trip-control hex)
29 (let ((wire (hex->bytes hex)))
30 (check-frame-wire wire (encode-frame (car (decode-frames wire 'application 'server))))))
32(define (reject-frame hex)
33 (assert-error (decode-frames (hex->bytes hex) 'application 'server)))
35(test-group "QUIC v1 frame codec"
36 (test "frame-control: ACK ranges wire"
37 (check-frame-wire #u8(2 20 3 1 2 3 4)
38 (encode-frame (make-quic-frame 2 (list (cons 'ranges '((18 . 20) (9 . 13))) (cons 'delay 3))))))
39 (test "frame-control: ACK ECN wire"
40 (check-frame-wire #u8(3 20 3 1 2 3 4 7 8 9)
41 (encode-frame (make-quic-frame 3
42 (list (cons 'ranges '((18 . 20) (9 . 13))) (cons 'delay 3) (cons 'ecn '(7 8 9)))))))
43 (test "frame-control: CRYPTO wire"
44 (check-frame-wire #u8(6 4 3 170 187 204)
45 (encode-frame (make-quic-frame 6 (list (cons 'offset 4) (cons 'data #u8(170 187 204)))))))
46 (test "frame-control: STREAM offset length FIN wire"
47 (check-frame-wire #u8(15 1 4 3 170 187 204)
48 (encode-frame (make-quic-frame 15
49 (list (cons 'stream-id 1) (cons 'offset 4) (cons 'data #u8(170 187 204)))))))
50 (test "frame-control: NEW_CONNECTION_ID wire"
51 (frame-round-trip-control "18020102aabb000102030405060708090a0b0c0d0e0f"))
52 (test "frame-control: CONNECTION_CLOSE wire"
53 (frame-round-trip-control "1c010603666f6f"))
54 (test "frame-control: RFC9001 client CRYPTO payload"
55 (let* ((wire (fixture 'quic-client-payload)) (frame (car (decode-frames wire 'initial 'client))))
56 (assert-equal 6 (quic-frame-type frame))
57 (assert-equal 0 (frame-ref frame 'offset))
58 (assert-equal 241 (bytevector-length (frame-ref frame 'data)))
59 (assert-equal #u8(1 0 0 237) (bytevector-copy (frame-ref frame 'data) 0 4))
60 (check-frame-wire wire (encode-frame frame))))
61 (test "frame-control: RFC9001 server ACK and CRYPTO payload"
62 (let* ((wire (fixture 'quic-server-payload)) (frames (decode-frames wire 'initial 'server)))
63 (assert-equal '(2 6) (map quic-frame-type frames))
64 (assert-equal '((0 . 0)) (frame-ref (car frames) 'ranges))
65 (assert-equal 90 (bytevector-length (frame-ref (cadr frames) 'data)))
66 (check-frame-wire wire (encode-frames frames 'initial 'server))))
67 (test "all RFC9000 frame types retain independent example bytes"
68 (for-each
69 (lambda (wire)
70 (let ((frames (decode-frames wire 'application 'server)))
71 (assert-equal 1 (length frames))
72 (assert-equal wire (encode-frame (car frames))))) (frame-examples)))
73 (test "ACK range and ECN values decode independently"
74 (let ((frame (one-frame "03140301020304070809")))
75 (assert-equal '((18 . 20) (9 . 13)) (frame-ref frame 'ranges))
76 (assert-equal 3 (frame-ref frame 'delay))
77 (assert-equal '(7 8 9) (frame-ref frame 'ecn))))
78 (test "all STREAM flag combinations preserve offsets length and FIN"
79 (do ((type 8 (+ type 1))) ((= type 16))
80 (let* ((wire (list-ref (frame-examples) type)) (frame (car (decode-frames wire 'application 'client))))
81 (assert-equal type (quic-frame-type frame))
82 (assert-equal 1 (frame-ref frame 'stream-id))
83 (assert-equal (if (>= type 12) 4 0) (frame-ref frame 'offset))
84 (assert-equal #u8(170 187 204) (frame-ref frame 'data))
85 (assert-equal (odd? type) (frame-fin? frame)))))
86 (test "all fixed or length-bearing frames reject every proper prefix"
87 (for-each
88 (lambda (wire)
89 (unless (memv (bytevector-u8-ref wire 0) '(0 8 9 12 13))
90 (do ((n 0 (+ n 1))) ((= n (bytevector-length wire)))
91 (assert-error (decode-frames (bytevector-copy wire 0 n) 'application 'server)))))
92 (frame-examples)))
93 (test "unknown and nonminimal frame types are rejected"
94 (do ((type 31 (+ type 1))) ((= type 256))
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")))
100 (assert-equal 0 (frame-ref frame 'offset))
101 (assert-equal #u8(170) (frame-ref frame 'data))
102 (assert-equal #u8(6 0 1 170) (encode-frame frame))))
103 (test "ACK first range gap and subsequent range cannot underflow"
104 (for-each reject-frame '("0200000001" "02010001000000" "02050001010004")))
105 (test "ACK range count is capped before looping"
106 (reject-frame "020000410000")
107 (assert-error
108 (encode-frame (make-quic-frame 2 (list (cons 'ranges '()) (cons 'delay 0)))))
109 (assert-error
110 (encode-frame (make-quic-frame 2
111 (list (cons 'ranges '((4 . 8) (3 . 4))) (cons 'delay 0))))))
112 (test "ACK encoder rejects reversed ascending and adjacent ranges"
113 (for-each
114 (lambda (ranges)
115 (assert-error (encode-frame (make-quic-frame 2 (list (cons 'ranges ranges) (cons 'delay 0))))))
116 '(((8 . 4)) ((4 . 8) (9 . 10)) ((4 . 8) (2 . 3)) ((-1 . 1)))))
117 (test "frame count is bounded and contiguous padding uses one record"
118 (assert-equal frame-count-limit
119 (length (decode-frames (make-bytevector frame-count-limit 1) 'application 'client)))
120 (assert-error (decode-frames (make-bytevector (+ frame-count-limit 1) 1) 'application 'client))
121 (let ((frames (decode-frames (make-bytevector frame-payload-limit 0) 'initial 'client)))
122 (assert-equal 1 (length frames))
123 (assert-equal frame-payload-limit (frame-ref (car frames) 'length))))
124 (test "empty and oversized payloads or encoded lists are rejected"
125 (assert-error (decode-frames #u8() 'initial 'client))
126 (assert-error (decode-frames (make-bytevector (+ frame-payload-limit 1) 0) 'initial 'client))
127 (assert-error (encode-frames '() 'initial 'client))
128 (assert-error
129 (encode-frames
130 (list (make-quic-frame 0 (list (cons 'length frame-payload-limit))) (make-quic-frame 1 '()))
131 'initial 'client)))
132 (test "encryption-level and sender restrictions match frame table"
133 (for-each
134 (lambda (wire)
135 (let ((type (bytevector-u8-ref wire 0)))
136 (for-each
137 (lambda (level)
138 (if (memv type '(0 1 2 3 6 28))
139 (assert-true (pair? (decode-frames wire level 'client)))
140 (assert-error (decode-frames wire level 'server)))) '(initial handshake))
141 (if (memv type '(7 30))
142 (assert-error (decode-frames wire 'application 'client))
143 (assert-true (pair? (decode-frames wire 'application 'client)))))) (frame-examples))
144 (assert-error (decode-frames #u8(1) 'early 'client))
145 (assert-error (decode-frames #u8(1) 'initial 'peer))
146 (assert-error (encode-frames (list (make-quic-frame 30 '())) 'application 'client))
147 (assert-error (encode-frames (list (make-quic-frame 16 '((maximum . 1)))) 'initial 'server)))
148 (test "CRYPTO and STREAM end offsets use full 62-bit arithmetic"
149 (let ((crypto (one-frame "06ffffffffffffffff00")))
150 (assert-equal quic-varint-maximum (frame-ref crypto 'offset))
151 (assert-equal #u8() (frame-ref crypto 'data)))
152 (reject-frame "06ffffffffffffffff01aa")
153 (reject-frame "0e00ffffffffffffffff01aa")
154 (assert-error
155 (encode-frame (make-quic-frame 6
156 (list (cons 'offset quic-varint-maximum) (cons 'data #u8(1)))))))
157 (test "stream count control frames enforce 2^60 limit"
158 (for-each
159 (lambda (type)
160 (let ((wire (bytes-append (bytevector type) (hex->bytes "d000000000000000"))))
161 (assert-equal 1152921504606846976
162 (frame-ref (car (decode-frames wire 'application 'server)) 'maximum)))
163 (assert-error
164 (decode-frames (bytes-append (bytevector type) (hex->bytes "d000000000000001")) 'application 'server))
165 (assert-error
166 (encode-frame (make-quic-frame type '((maximum . 1152921504606846977)))))) '(18 19 22 23)))
167 (test "NEW_CONNECTION_ID validates length retire sequence and token"
168 (for-each reject-frame '("18000000" "18000101aa00000000000000000000000000000000"
169 "18000015" "18000001aa000000000000000000000000000000"))
170 (let ((frame (one-frame "18020102aabb000102030405060708090a0b0c0d0e0f")))
171 (assert-equal 2 (frame-ref frame 'sequence))
172 (assert-equal 1 (frame-ref frame 'retire-prior-to))
173 (assert-equal #u8(170 187) (frame-ref frame 'connection-id))))
174 (test "empty NEW_TOKEN and wrong path data length are rejected"
175 (reject-frame "0700")
176 (assert-error (encode-frame (make-quic-frame 7 '((token . #u8())))))
177 (assert-error (encode-frame (make-quic-frame 26 '((data . #u8(1 2))))))
178 (assert-error
179 (encode-frame (make-quic-frame 27 (list (cons 'data (make-bytevector 9 0)))))))
180 (test "encoder rejects duplicate unknown missing and mistyped fields"
181 (for-each
182 (lambda (fields) (assert-error (encode-frame (make-quic-frame 6 fields))))
183 '(((offset . 0) (offset . 1)) ((offset . 0) (unknown . #u8())) ((offset . 0))
184 ((offset . 0) (data . 7)) ((offset . -1) (data . #u8()))))
185 (assert-error (encode-frame (make-quic-frame 31 '())))
186 (assert-error (encode-frame (make-quic-frame 0 '((length . 0)))))
187 (assert-error (encode-frame #f)))
188 (test "lengthless STREAM is last and consumes all remaining bytes"
189 (let* ((stream (make-quic-frame 9 '((stream-id . 0) (offset . 0) (data . #u8(170)))))
190 (ping (make-quic-frame 1 '())))
191 (assert-error (encode-frames (list stream ping) 'application 'client))
192 (assert-error
193 (encode-frame (make-quic-frame 9 '((stream-id . 0) (offset . 1) (data . #u8(170))))))
194 (let ((frames (decode-frames #u8(9 0 170 1) 'application 'client)))
195 (assert-equal 1 (length frames))
196 (assert-equal #u8(170 1) (frame-ref (car frames) 'data)))))
197 (test "zero CONNECTION_CLOSE triggering type and opaque reason are preserved"
198 (let ((frame (one-frame "1c000002fffe")))
199 (assert-equal 0 (frame-ref frame 'error))
200 (assert-equal 0 (frame-ref frame 'frame-type))
201 (assert-equal #u8(255 254) (frame-ref frame 'reason))
202 (assert-equal (hex->bytes "1c000002fffe") (encode-frame frame))))
203 (test "ACK-eliciting classification excludes padding ACK and close"
204 (for-each
205 (lambda (wire)
206 (let ((frame (car (decode-frames wire 'application 'server))))
207 (assert-equal (not (memv (quic-frame-type frame) '(0 2 3 28 29)))
208 (frame-ack-eliciting? frame)))) (frame-examples)))
209 (test "decoded frame data does not alias packet storage"
210 (let* ((wire (bytevector 6 0 1 42)) (frame (car (decode-frames wire 'initial 'client))))
211 (bytevector-u8-set! wire 3 99)
212 (assert-equal #u8(42) (frame-ref frame 'data)))))