AtlatestRepositorysigil-quic
1;;; Bounded ownership of authenticated peer connection IDs. Callers assign
2;;; acquired IDs to paths and reliably send/acknowledge pending retirements.
3(define-library (sigil quic connection peer ids)
4 (import (sigil struct)
5 (sigil quic bytes)
6 (sigil quic error)
7 (sigil quic frame)
8 (sigil quic wire))
9 (export make-peer-id-pool peer-id-pool? peer-id-pool-count
10 peer-id-pool-receive! peer-id-pool-acquire! peer-id-pool-id
11 peer-id-pool-sequences peer-id-pool-retire! peer-id-pool-retirements
12 peer-id-pool-ack! peer-id-pool-close!)
13 (begin
14 (define-struct peer-id-pool
15 (entries mutable: #t)
16 (limit)
17 (zero?)
18 (peer-floor default: 0 mutable: #t)
19 (retired-floor default: 0 mutable: #t)
20 (closed? default: #f mutable: #t))
22 ;; Entry: sequence, owned CID, owned reset token/#f, acquired?, retiring?.
23 ;; At most limit active plus twice limit awaiting RETIRE acknowledgment.
24 (define (new-entry sequence cid token acquired?)
25 (vector sequence (bytevector-copy cid) (and token (bytevector-copy token)) acquired? #f))
27 (define (uint? value)
28 (and (integer? value) (exact? value) (<= 0 value quic-varint-maximum)))
30 (define (id? cid minimum)
31 (and (bytevector? cid) (<= minimum (bytevector-length cid) 20)))
33 (define (token? token)
34 (and (bytevector? token) (= 16 (bytevector-length token))))
36 (define (make-peer-id-pool initial
37 (keys: (limit 2) (token #f) (preferred #f)))
38 (unless (and (id? initial 0) (uint? limit) (<= 2 limit 8)
39 (or (not token) (and (> (bytevector-length initial) 0) (token? token)))
40 (or (not preferred)
41 (and (> (bytevector-length initial) 0) (pair? preferred)
42 (id? (car preferred) 1) (token? (cdr preferred))
43 (not (bytes=? initial (car preferred))))))
44 (error "QUIC peer IDs: invalid initial ID, limits or authenticated metadata"))
45 ;; Construct only after source-ID / preferred-address / token metadata
46 ;; has been authenticated. The original path already uses sequence zero.
47 (peer-id-pool entries:
48 (cons (new-entry 0 initial token #t)
49 (if preferred (list (new-entry 1 (car preferred) (cdr preferred) #f)) '()))
50 limit: limit zero?: (= (bytevector-length initial) 0)))
52 (define (require-open! pool)
53 (when (peer-id-pool-closed? pool) (error "QUIC peer IDs: pool is closed")))
55 (define (find-entry entries sequence)
56 (and (pair? entries)
57 (if (= sequence (vector-ref (car entries) 0))
58 (car entries)
59 (find-entry (cdr entries) sequence))))
61 (define (count-state entries retiring?)
62 (let loop ((rest entries) (count 0))
63 (if (null? rest)
64 count
65 (loop (cdr rest)
66 (+ count (if (eq? (vector-ref (car rest) 4) retiring?) 1 0))))))
68 (define (peer-id-pool-count pool)
69 (count-state (peer-id-pool-entries pool) #f))
71 (define (capacity! pool entries)
72 (when (or (> (count-state entries #f) (peer-id-pool-limit pool))
73 (> (count-state entries #t) (* 2 (peer-id-pool-limit pool))))
74 (raise-quic-error 9 24 "QUIC peer connection ID inventory limit exceeded")))
76 (define (peer-id-pool-receive! pool frame)
77 (require-open! pool)
78 (unless (and (quic-frame? frame) (= 24 (quic-frame-type frame)))
79 (error "QUIC peer IDs: expected NEW_CONNECTION_ID"))
80 (when (peer-id-pool-zero? pool)
81 (raise-quic-error 10 24 "QUIC peer IDs: NEW_CONNECTION_ID after zero-length source ID"))
82 (let ((sequence (frame-ref frame 'sequence))
83 (retire (frame-ref frame 'retire-prior-to))
84 (cid (frame-ref frame 'connection-id))
85 (token (frame-ref frame 'token)))
86 (unless (and (uint? sequence) (uint? retire) (<= retire sequence)
87 (id? cid 1) (token? token))
88 (raise-quic-error 7 24 "QUIC peer IDs: invalid NEW_CONNECTION_ID fields"))
89 (let* ((entries (peer-id-pool-entries pool))
90 (known (find-entry entries sequence))
91 (floor (max retire (peer-id-pool-peer-floor pool))))
92 (when (and known
93 (or (not (bytes=? cid (vector-ref known 1)))
94 (and (vector-ref known 2)
95 (not (bytes-timing-safe=? token (vector-ref known 2))))))
96 (raise-quic-error 10 24 "QUIC peer IDs: conflicting sequence metadata"))
97 (for-each
98 (lambda (value)
99 (when (and (not (= sequence (vector-ref value 0)))
100 (bytes=? cid (vector-ref value 1)))
101 (raise-quic-error 10 24 "QUIC peer IDs: connection ID reused with another sequence")))
102 entries)
103 ;; Plan changes without touching owned entries, so limit errors leave
104 ;; the original path and its inventory intact. RetirePriorTo applies
105 ;; before counting the newly supplied active ID.
106 (let* ((planned
107 (map
108 (lambda (value)
109 (vector (vector-ref value 0) (vector-ref value 1)
110 (if (and known (= sequence (vector-ref value 0)) (not (vector-ref value 2)))
111 (bytevector-copy token)
112 (vector-ref value 2))
113 (vector-ref value 3)
114 (or (vector-ref value 4) (< (vector-ref value 0) floor))))
115 entries))
116 (incoming (or (find-entry planned sequence) (new-entry sequence cid token #f))))
117 (unless known
118 (vector-set! incoming 4 (< sequence (max floor (peer-id-pool-retired-floor pool))))
119 (set! planned (append planned (list incoming))))
120 (capacity! pool planned)
121 (set-peer-id-pool-entries! pool planned)
122 (set-peer-id-pool-peer-floor! pool floor)
123 (for-each
124 (lambda (value)
125 (when (vector-ref value 4)
126 (set-peer-id-pool-retired-floor! pool
127 (max (peer-id-pool-retired-floor pool) (+ 1 (vector-ref value 0))))))
128 planned)
129 (not (vector-ref incoming 4))))))
131 ;; A CID is assigned to at most one path. A failed candidate retires it;
132 ;; releasing it for another address would permit cross-path correlation.
133 (define (peer-id-pool-acquire! pool)
134 (require-open! pool)
135 (let loop ((rest (peer-id-pool-entries pool)))
136 (and (pair? rest)
137 (let ((value (car rest)))
138 (if (or (vector-ref value 3) (vector-ref value 4))
139 (loop (cdr rest))
140 (begin
141 (vector-set! value 3 #t)
142 (vector-ref value 0)))))))
144 (define (peer-id-pool-id pool sequence)
145 (unless (uint? sequence) (error "QUIC peer IDs: invalid sequence"))
146 (let ((value (find-entry (peer-id-pool-entries pool) sequence)))
147 (and value (not (vector-ref value 4)) (bytevector-copy (vector-ref value 1)))))
149 (define (peer-id-pool-sequences pool)
150 (let loop ((rest (peer-id-pool-entries pool)) (out '()))
151 (if (null? rest)
152 (reverse out)
153 (let ((value (car rest)))
154 (loop (cdr rest)
155 (if (vector-ref value 4) out (cons (vector-ref value 0) out)))))))
157 (define (peer-id-pool-retire! pool sequence)
158 (require-open! pool)
159 (unless (uint? sequence) (error "QUIC peer IDs: invalid sequence"))
160 (let ((value (find-entry (peer-id-pool-entries pool) sequence)))
161 (unless value (error "QUIC peer IDs: cannot retire an unknown ID"))
162 (when (peer-id-pool-zero? pool) (error "QUIC peer IDs: cannot retire a zero-length ID"))
163 (and (not (vector-ref value 4))
164 (begin
165 (when (>= (count-state (peer-id-pool-entries pool) #t) (* 2 (peer-id-pool-limit pool)))
166 (raise-quic-error 9 24 "QUIC peer IDs: too many pending retirements"))
167 (vector-set! value 4 #t)
168 (set-peer-id-pool-retired-floor! pool
169 (max (peer-id-pool-retired-floor pool) (+ sequence 1)))
170 #t))))
172 ;; Keep all pending retirements until a carrying packet is acknowledged.
173 ;; The connection deduplicates/retransmits these reliable control frames.
174 (define (peer-id-pool-retirements pool)
175 (let loop ((rest (peer-id-pool-entries pool)) (out '()))
176 (if (null? rest)
177 (reverse out)
178 (let ((value (car rest)))
179 (loop (cdr rest)
180 (if (vector-ref value 4)
181 (cons (make-quic-frame 25 (list (cons 'sequence (vector-ref value 0)))) out)
182 out))))))
184 (define (wipe-token! value)
185 (let ((token (vector-ref value 2)))
186 (when token
187 (do ((index 0 (+ index 1))) ((= index (bytevector-length token)))
188 (bytevector-u8-set! token index 0)))
189 (vector-set! value 2 #f)))
191 ;; Only call after validating an ACK for a packet actually carrying RETIRE.
192 ;; A compact local retirement floor prevents forgotten IDs resurrecting.
193 ;; Existing live IDs below that floor are explicit exceptions; previously
194 ;; unseen older IDs are immediately retired instead of assigned to a path.
195 (define (peer-id-pool-ack! pool sequence)
196 (require-open! pool)
197 (unless (uint? sequence) (error "QUIC peer IDs: invalid retirement acknowledgment"))
198 (let ((value (find-entry (peer-id-pool-entries pool) sequence)))
199 (and value (vector-ref value 4)
200 (begin
201 (wipe-token! value)
202 (set-peer-id-pool-entries! pool
203 (let loop ((rest (peer-id-pool-entries pool)) (out '()))
204 (cond
205 ((null? rest) (reverse out))
206 ((= sequence (vector-ref (car rest) 0)) (loop (cdr rest) out))
207 (else (loop (cdr rest) (cons (car rest) out))))))
208 #t))))
210 (define (peer-id-pool-close! pool)
211 (unless (peer-id-pool-closed? pool)
212 (for-each wipe-token! (peer-id-pool-entries pool))
213 (set-peer-id-pool-entries! pool '())
214 (set-peer-id-pool-closed?! pool #t))
215 #t)))