Commitdfb94889Recorded18 Oct 2026Repositorysigil-quic
Qualify Retry token key lifetime and failure cleanup
Changed
scripts/inject-retry-spy.mjs | 63 +++++++++++++++++++++++++++++++++++++
scripts/native-tls-tests.mjs | 12 ++++---
scripts/retry-cleanup-tests.sgl | 277 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
scripts/retry-spy.sgl | 79 ++++++++++++++++++++++++++++++++++++++++++++++
4 files changed, 427 insertions(+), 4 deletions(-)Diff
scripts/inject-retry-spy.mjsadded
@@ -0,0 +1,63 @@
+1
// Remote-only ownership observations. Never execute on the development laptop.+2
// Inputs and outputs must differ; shipping modules are restored by the gate.+3
import {readFileSync,writeFileSync} from 'node:fs';+4
const [kind,input,output]=process.argv.slice(2);+5
if(!['token','endpoint','fixture'].includes(kind)||!input||!output||input===output){+6
throw Error('Usage: inject-retry-spy.mjs token|endpoint|fixture INPUT OUTPUT');+7
}+8
let source=readFileSync(input,'utf8');+9
function once(from,to){+10
if(source.split(from).length!==2)throw Error('Retry observation site changed: '+from);+11
source=source.replace(from,()=>to);+12
}+13
if(kind==='fixture'){+14
const boundary=source.indexOf('\n\n'),end=source.indexOf('\n(test-group ');+15
if(!source.startsWith('(import ')||boundary<0||end<boundary||!source.includes('(define (er-with-pair ')){+16
throw Error('Expected public endpoint Retry fixture');+17
}+18
const imports=source.slice(0,boundary),helpers=source.slice(boundary+2,end);+19
const names=[...helpers.matchAll(/^\(define (?:\(([^\s()]+)|([^\s()]+))/gm)].map(m=>m[1]||m[2]);+20
if(names.length!==16||new Set(names).size!==16)throw Error('Public fixture definitions changed');+21
writeFileSync(output,';;; TEST ONLY: shared public UDP fixture, no named tests.\n'++22
'(define-library (sigil quic tests retry fixture)\n '+imports+'\n'++23
' (export '+names.join(' ')+')\n (begin\n'++24
helpers.split('\n').map(line=>' '+line).join('\n')+'\n ))\n');+25
}else{+26
if(source.includes('retry-spy'))throw Error('Already instrumented');+27
if(kind==='token'){+28
if(!source.includes('(define-library (sigil quic retry token)'))throw Error('Expected token manager');+29
once(' (set! owned (if key (bytevector-copy key) (random-bytes 32)))',+30
' (set! owned (if key (bytevector-copy key) (random-bytes 32)))\n'++31
' (retry-spy-owned! owned)');+32
once(' (let ((manager (retry-token-manager key: owned lifetime: lifetime)))',+33
' (let ((manager (retry-token-manager key: owned lifetime: lifetime)))\n'++34
' (retry-spy-manager! manager)');+35
once(' (wipe! key)))',+36
" (wipe! key)\n (retry-spy-checkpoint! 'close-after)))");+37
once('(hmac-sha256-bytes (retry-token-manager-key manager)',+38
'(retry-spy-mac hmac-sha256-bytes (retry-token-manager-key manager)');+39
if(source.split('(random-bytes ').length!==3)throw Error('Token random sites changed');+40
source=source.replaceAll('(random-bytes ','(retry-spy-random random-bytes ');+41
}else{+42
if(!source.includes('(define-library (sigil quic endpoint)'))throw Error('Expected endpoint');+43
once(' (set-quic-endpoint-retry-manager! endpoint manager)',+44
' (set-quic-endpoint-retry-manager! endpoint manager)\n'++45
" (retry-spy-checkpoint! 'accept-after-manager)");+46
once('(random-bytes 8)','(retry-spy-random random-bytes 8)');+47
once('(encode-retry-packet original client retry token)',+48
'(retry-spy-packet encode-retry-packet original client retry token)');+49
once('\n (unless (and (quic-connection? connection) (eq? (quic-role connection) \'server)',+50
'\n (retry-spy-candidate! connection)\n'++51
' (unless (and (quic-connection? connection) (eq? (quic-role connection) \'server)');+52
const start=source.indexOf(' (define (send-retry!'),end=source.indexOf(' (define (admit-retry-connection!',start);+53
if(start<0||end<start)throw Error('Retry send boundary changed');+54
let body=source.slice(start,end);+55
const send='(udp-send (quic-endpoint-socket endpoint) packet "127.0.0.1" peer-port)';+56
if(body.split(send).length!==2)throw Error('Retry send operation changed');+57
body=body.replace(send,()=>'(retry-spy-send udp-send (quic-endpoint-socket endpoint) packet "127.0.0.1" peer-port)');+58
source=source.slice(0,start)+body+source.slice(end);+59
}+60
once('(import (sigil crypto)',+61
'(import (sigil quic tests retry spy)\n (sigil crypto)');+62
writeFileSync(output,';;; TEST ONLY: actual Retry key ownership/fault observations; never ship.\n'+source);+63
}scripts/native-tls-tests.mjsmodified
@@ -76,7 +76,8 @@ const clientRetry = process.argv.includes('--client-retry');
76
const retryToken = process.argv.includes('--retry-token'); 77
const serverRetry = process.argv.includes('--server-retry'); 78
const endpointRetry = process.argv.includes('--endpoint-retry');−79
if ([cleanupFaults, secretCleanup, secretRetention, handshakeCleanup, packetRetention, factoryCleanup, eventCleanup, constructionCleanup, pathResponse, cidZero, cidSequence, handlerReadiness, seenBudget, ticketValidation, negotiation, certificatePolicy, retryPolicy, earlyPackets, retryPacket, clientRetry, retryToken, serverRetry, endpointRetry].filter(Boolean).length > 1) {+79
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) { 81
throw new Error('Select one focused test suite'); 82
} 83
if (cleanupFaults) {@@ -148,6 +149,9 @@ if (serverRetry) {
149
if (endpointRetry) { 150
files.splice(0, files.length, 'test-endpoint-retry.sgl'); 151
}+152
if (retryCleanup) {+153
files.splice(0, files.length, '../scripts/retry-cleanup-tests.sgl');+154
} 155
const bodies = files.map(file => { 156
const text = readFileSync(join(root, 'test', file), 'utf8'); 157
const boundary = text.indexOf('\n\n');@@ -161,14 +165,14 @@ writeFileSync(join(source, 'native.sgl'), `(define-library (sigil quic tests nat
165
(sigil math) 166
(sigil io) 167
(sigil socket)−164
(sigil process)${files.includes('test-endpoint-retry.sgl') ? '\n (sigil time)' : ''}+168
(sigil process)${files.includes('test-endpoint-retry.sgl') || retryCleanup ? '\n (sigil time)' : ''} 169
(sigil crypto) 170
(sigil quic bytes) 171
(sigil quic vectors) 172
(sigil quic wire) 173
(sigil quic frame) 174
(sigil quic reassembly)−171
(sigil quic packet)${files.includes('test-retry-token.sgl') ? '\n (sigil quic retry token)' : ''}+175
(sigil quic packet)${files.includes('test-retry-token.sgl') || retryCleanup ? '\n (sigil quic retry token)' : ''} 176
(sigil quic error) 177
(sigil quic connection space) 178
(sigil quic connection)@@ -184,7 +188,7 @@ writeFileSync(join(source, 'native.sgl'), `(define-library (sigil quic tests nat
188
(sigil quic tls extensions) 189
(sigil quic tls authentication) 190
(sigil quic tls transcript)−187
(sigil quic tls vectors)${secretCleanup || secretRetention ? '\n (sigil quic tests secret spy)' : ''}${handshakeCleanup ? '\n (sigil quic tests handshake spy)' : ''}${packetRetention ? '\n (sigil quic tests packet spy)' : ''}${factoryCleanup ? '\n (sigil quic tests factory spy)' : ''}${eventCleanup ? '\n (sigil quic tests event spy)' : ''}${constructionCleanup ? '\n (sigil quic tests construction spy)' : ''}${seenBudget ? '\n (sigil quic tests seen spy)' : ''})+191
(sigil quic tls vectors)${secretCleanup || secretRetention ? '\n (sigil quic tests secret spy)' : ''}${handshakeCleanup ? '\n (sigil quic tests handshake spy)' : ''}${packetRetention ? '\n (sigil quic tests packet spy)' : ''}${factoryCleanup ? '\n (sigil quic tests factory spy)' : ''}${eventCleanup ? '\n (sigil quic tests event spy)' : ''}${constructionCleanup ? '\n (sigil quic tests construction spy)' : ''}${seenBudget ? '\n (sigil quic tests seen spy)' : ''}${retryCleanup ? '\n (sigil quic tests retry spy)\n (sigil quic tests retry fixture)' : ''}) 192
(export main) 193
(begin 194
${bodies.map(body => body.split('\n').map(line => ' ' + line).join('\n')).join('\n\n')}scripts/retry-cleanup-tests.sgladded
@@ -0,0 +1,277 @@
+1
(import (sigil test)+2
(sigil io)+3
(sigil crypto)+4
(sigil quic bytes)+5
(sigil quic packet)+6
(sigil quic connection)+7
(sigil quic stream)+8
(sigil quic endpoint)+9
(sigil quic retry token)+10
(sigil quic tests retry spy)+11
(sigil quic tests retry fixture))+12
+13
;; Explicit remote-only observations of actual owned buffers. Predicates run+14
;; before teardown; negative variants' stranded references are wiped afterward.+15
(define (rc-wipe! bytes)+16
(do ((index 0 (+ index 1))) ((= index (bytevector-length bytes)))+17
(bytevector-u8-set! bytes index 0)))+18
+19
(define (rc-zero? bytes)+20
(let loop ((index 0))+21
(or (= index (bytevector-length bytes))+22
(and (= 0 (bytevector-u8-ref bytes index)) (loop (+ index 1))))))+23
+24
(define (rc-with-spy procedure)+25
(dynamic-wind+26
retry-spy-reset!+27
procedure+28
(lambda ()+29
(retry-spy-fail! #f)+30
(retry-spy-send-mode! #f)+31
(for-each+32
(lambda (entry)+33
(let ((manager (vector-ref entry 2)))+34
(when manager+35
(guard (exn (else #f)) (close-retry-token-manager! manager)))))+36
(retry-spy-owned))+37
(for-each+38
(lambda (candidate)+39
(when (quic-connection? candidate)+40
(guard (exn (else #f)) (quic-abort! candidate))))+41
(retry-spy-candidates))+42
(for-each (lambda (entry) (rc-wipe! (vector-ref entry 0))) (retry-spy-owned))+43
(retry-spy-reset!))))+44
+45
(define (rc-record)+46
(let ((entries (retry-spy-owned)))+47
(unless (= 1 (length entries)) (error "Retry lifetime fixture: expected one owned key"))+48
(car entries)))+49
+50
(define (rc-captured? entry)+51
(and (= 32 (bytevector-length (vector-ref entry 0))) (vector-ref entry 1)))+52
+53
(define (rc-live? entry)+54
(and (rc-captured? entry) (retry-token-manager? (vector-ref entry 2))+55
(not (rc-zero? (vector-ref entry 0)))))+56
+57
(define (rc-erased? entry)+58
(and (rc-captured? entry) (rc-zero? (vector-ref entry 0))))+59
+60
(define (rc-failure? stage procedure)+61
(let ((failure (guard (exn (else exn)) (procedure) #f)))+62
(and (error-object? failure)+63
(equal? "QL12 injected Retry failure" (error-object-message failure))+64
(equal? (list stage) (error-object-irritants failure)))))+65
+66
(define (rc-message? message procedure)+67
(let ((failure (guard (exn (else exn)) (procedure) #f)))+68
(and (error-object? failure) (equal? message (error-object-message failure)))))+69
+70
(define (rc-rebind? endpoint)+71
(let ((replacement (open-quic-endpoint port: (quic-endpoint-port endpoint))))+72
(quic-endpoint-close! replacement)+73
#t))+74
+75
(define (rc-closed? endpoint entry)+76
(and (quic-endpoint-closed? endpoint) (rc-erased? entry) (rc-rebind? endpoint)))+77
+78
(define (rc-candidate-closed? pair)+79
(let ((candidate (vector-ref pair 5)) (stream (vector-ref pair 6)))+80
(and candidate stream (quic-closed? candidate)+81
(memq candidate (retry-spy-candidates))+82
(guard (exn (else #t)) (quic-stream-read! stream) #f))))+83
+84
(define (rc-step! pair)+85
(quic-endpoint-step! (vector-ref pair 1) wait-ms: 1))+86
+87
(define (rc-positive procedure)+88
(assert-true (guard (exn (else #f)) (rc-with-spy procedure))))+89
+90
;; The operation is armed only after fixture setup, while its key is live.+91
(define (rc-challenge-failure? stage)+92
(er-with-pair+93
(lambda (pair)+94
(let ((entry (rc-record)))+95
(and (rc-live? entry)+96
(begin+97
(retry-spy-fail! stage)+98
(and (rc-failure? stage (lambda () (er-challenge! pair)))+99
(= 0 (vector-ref pair 7))+100
(rc-closed? (vector-ref pair 1) entry))))))))+101
+102
(test-group "Private Retry key lifetime and ordinary unwind failures"+103
(test "ql12-retry-lifetime: unconfirmed endpoint close erases owned key and releases socket"+104
(rc-positive+105
(lambda ()+106
(er-with-pair+107
(lambda (pair)+108
(let ((entry (rc-record)) (endpoint (vector-ref pair 1)))+109
(and (rc-live? entry)+110
(begin+111
(quic-endpoint-close! endpoint)+112
(quic-endpoint-close! endpoint)+113
(and (= 0 (vector-ref pair 7)) (rc-closed? endpoint entry))))))))))+114
(test "ql12-retry-lifetime: manager close erases owned copy and preserves caller key"+115
(rc-positive+116
(lambda ()+117
(let ((borrowed (make-bytevector 32 90)))+118
(dynamic-wind+119
(lambda () #t)+120
(lambda ()+121
(let* ((manager (make-retry-token-manager key: borrowed)) (entry (rc-record)))+122
(and (rc-live? entry) (eq? manager (vector-ref entry 2))+123
(not (eq? borrowed (vector-ref entry 0)))+124
(begin+125
(close-retry-token-manager! manager)+126
(close-retry-token-manager! manager)+127
(and (rc-erased? entry) (bytes=? borrowed (make-bytevector 32 90)))))))+128
(lambda () (rc-wipe! borrowed)))))))+129
(test "ql12-retry-lifetime: next constructor operation failure wipes untransferred key"+130
(rc-positive+131
(lambda ()+132
(retry-spy-fail! 'manager-next)+133
(and (rc-failure? 'manager-next (lambda () (make-retry-token-manager)))+134
(let ((entry (rc-record)))+135
(and (not (vector-ref entry 2)) (rc-erased? entry)))))))+136
(test "ql12-retry-lifetime: setup failure after endpoint takes manager releases key and socket"+137
(rc-positive+138
(lambda ()+139
(let ((endpoint (open-quic-endpoint)))+140
(dynamic-wind+141
(lambda () #t)+142
(lambda ()+143
(retry-spy-fail! 'accept-after-manager)+144
(and (rc-failure? 'accept-after-manager+145
(lambda () (quic-endpoint-accept-retry! endpoint (lambda args #f))))+146
(rc-closed? endpoint (rc-record))))+147
(lambda () (quic-endpoint-close! endpoint)))))))+148
(test "ql12-retry-lifetime: confirmation retires key before explicit endpoint close"+149
(rc-positive+150
(lambda ()+151
(er-with-pair+152
(lambda (pair)+153
(let ((entry (rc-record)))+154
(and (rc-live? entry)+155
(begin+156
(er-ready! pair)+157
(and (not (quic-endpoint-closed? (vector-ref pair 1)))+158
(quic-confirmed? (vector-ref pair 0))+159
(quic-confirmed? (vector-ref pair 5)) (rc-erased? entry))))))))))+160
(test "ql12-retry-lifetime: tentative TLS failure retains key until replacement confirms"+161
(rc-positive+162
(lambda ()+163
(er-with-pair+164
(lambda (pair)+165
(let* ((entry (rc-record)) (challenge (er-challenge! pair))+166
(header (decode-packet-header challenge 0 0)) (packet (er-retried! pair challenge)))+167
(er-send! pair (er-forged header))+168
(rc-step! pair)+169
(and (= 1 (vector-ref pair 7)) (rc-candidate-closed? pair)+170
(not (quic-endpoint-connection (vector-ref pair 1))) (rc-live? entry)+171
(begin+172
(let drain ((count 0))+173
(when (and (< count 64) (er-read pair)) (drain (+ count 1))))+174
(er-send! pair packet)+175
(er-ready! pair)+176
(and (= 2 (vector-ref pair 7)) (rc-erased? entry))))))))))+177
(test "ql12-retry-lifetime: invalid token and Initial tag retain key until valid confirmation"+178
(rc-positive+179
(lambda ()+180
(er-with-pair+181
(lambda (pair)+182
(let* ((entry (rc-record)) (challenge (er-challenge! pair))+183
(header (decode-packet-header challenge 0 0)) (packet (er-retried! pair challenge))+184
(token (quic-header-token header)))+185
(and (er-drop? pair (er-forged header token: (flip-byte token (- (bytevector-length token) 1))))+186
(rc-live? entry)+187
(er-drop? pair (flip-byte packet (- (bytevector-length packet) 1)))+188
(rc-live? entry)+189
(begin+190
(er-send! pair packet)+191
(er-ready! pair)+192
(and (= 1 (vector-ref pair 7)) (rc-erased? entry))))))))))+193
(test "ql12-retry-lifetime: Retry ID random failure retires key and socket"+194
(rc-positive (lambda () (rc-challenge-failure? 'retry-id))))+195
(test "ql12-retry-lifetime: token nonce random failure retires key and socket"+196
(rc-positive (lambda () (rc-challenge-failure? 'token-nonce))))+197
(test "ql12-retry-lifetime: token mint MAC failure retires key and socket"+198
(rc-positive (lambda () (rc-challenge-failure? 'token-mac))))+199
(test "ql12-retry-lifetime: token validation MAC failure retires key before factory"+200
(rc-positive+201
(lambda ()+202
(er-with-pair+203
(lambda (pair)+204
(let ((entry (rc-record)) (packet (er-retried! pair (er-challenge! pair))))+205
(and (rc-live? entry)+206
(begin+207
(retry-spy-fail! 'token-mac)+208
(er-send! pair packet)+209
(and (rc-failure? 'token-mac (lambda () (rc-step! pair)))+210
(= 0 (vector-ref pair 7))+211
(rc-closed? (vector-ref pair 1) entry))))))))))+212
(test "ql12-retry-lifetime: Retry encoding failure retires key and socket"+213
(rc-positive (lambda () (rc-challenge-failure? 'retry-packet))))+214
(test "ql12-retry-lifetime: blocked send retains key and duplicate challenge later confirms"+215
(rc-positive+216
(lambda ()+217
(er-with-pair+218
(lambda (pair)+219
(let ((entry (rc-record))+220
(packet (car (quic-take-datagrams! (vector-ref pair 0) (er-now pair)))))+221
(retry-spy-send-mode! 'blocked)+222
(er-send! pair packet)+223
(rc-step! pair)+224
(and (er-empty? pair) (not (er-read pair)) (rc-live? entry)+225
(begin+226
(retry-spy-send-mode! #f)+227
(er-send! pair packet)+228
(rc-step! pair)+229
(let ((challenge (er-read pair)))+230
(and challenge (valid-retry-packet? er-original challenge)+231
(begin+232
(er-send! pair (er-retried! pair challenge))+233
(er-ready! pair)+234
(and (= 1 (vector-ref pair 7)) (rc-erased? entry)))))))))))))+235
(test "ql12-retry-lifetime: partial Retry send raises and retires key and socket"+236
(rc-positive+237
(lambda ()+238
(er-with-pair+239
(lambda (pair)+240
(let ((entry (rc-record)))+241
(and (rc-live? entry)+242
(begin+243
(retry-spy-send-mode! 'partial)+244
(and (rc-message? "QUIC endpoint: partial Retry datagram send"+245
(lambda () (er-challenge! pair)))+246
(= 0 (vector-ref pair 7))+247
(rc-closed? (vector-ref pair 1) entry))))))))))+248
(test "ql12-retry-lifetime: returned candidate failure aborts connection and retires key"+249
(rc-positive+250
(lambda ()+251
(er-with-pair+252
(lambda (pair)+253
(let ((entry (rc-record)) (packet (er-retried! pair (er-challenge! pair))))+254
(and (rc-live? entry)+255
(begin+256
(retry-spy-fail! 'candidate-after)+257
(er-send! pair packet)+258
(and (rc-failure? 'candidate-after (lambda () (rc-step! pair)))+259
(= 1 (vector-ref pair 7)) (rc-candidate-closed? pair)+260
(not (quic-endpoint-connection (vector-ref pair 1)))+261
(rc-closed? (vector-ref pair 1) entry))))))))))+262
(test "ql12-retry-lifetime: post-wipe close failure still releases socket and tentative connection"+263
(rc-positive+264
(lambda ()+265
(er-with-pair+266
(lambda (pair)+267
(let ((entry (rc-record)) (packet (er-retried! pair (er-challenge! pair)))+268
(endpoint (vector-ref pair 1)))+269
(er-send! pair packet)+270
(rc-step! pair)+271
(and (= 1 (vector-ref pair 7)) (vector-ref pair 5)+272
(eq? (vector-ref pair 5) (quic-endpoint-connection endpoint))+273
(not (quic-confirmed? (vector-ref pair 5))) (rc-live? entry)+274
(begin+275
(retry-spy-fail! 'close-after)+276
(and (rc-failure? 'close-after (lambda () (quic-endpoint-close! endpoint)))+277
(rc-candidate-closed? pair) (rc-closed? endpoint entry)))))))))))scripts/retry-spy.sgladded
@@ -0,0 +1,79 @@
+1
;;; Remote test-only actual owned-buffer references and ordinary unwind faults.+2
;;; No dependency on token/endpoint modules: they pass operations and identities.+3
(define-library (sigil quic tests retry spy)+4
(export retry-spy-reset! retry-spy-fail! retry-spy-send-mode!+5
retry-spy-owned retry-spy-candidates retry-spy-owned!+6
retry-spy-manager! retry-spy-candidate! retry-spy-checkpoint!+7
retry-spy-random retry-spy-mac retry-spy-packet retry-spy-send)+8
(begin+9
(define owned '())+10
(define candidates '())+11
(define failure #f)+12
(define send-mode #f)+13
+14
;; Tests wipe stranded references after assertions before clearing records.+15
(define (retry-spy-reset!)+16
(set! owned '())+17
(set! candidates '())+18
(set! failure #f)+19
(set! send-mode #f))+20
+21
(define (retry-spy-owned) (reverse owned))+22
(define (retry-spy-candidates) (reverse candidates))+23
(define (retry-spy-fail! stage) (set! failure stage))+24
+25
(define (retry-spy-send-mode! mode)+26
(unless (memq mode '(#f blocked partial)) (error "Retry spy: invalid send mode"))+27
(set! send-mode mode))+28
+29
;; One-shot exceptions let production cleanup run without a second fault.+30
(define (retry-spy-checkpoint! stage)+31
(when (eq? failure stage)+32
(set! failure #f)+33
(error "QL12 injected Retry failure" stage)))+34
+35
(define (nonzero? bytes)+36
(let loop ((index 0))+37
(and (< index (bytevector-length bytes))+38
(or (not (= 0 (bytevector-u8-ref bytes index)))+39
(loop (+ index 1))))))+40
+41
;; Entry fields: actual owned key, nonzero at capture, opaque manager.+42
;; Capture occurs after the real ownership assignment, before the next op.+43
(define (retry-spy-owned! bytes)+44
(set! owned (cons (vector bytes (nonzero? bytes) #f) owned))+45
(retry-spy-checkpoint! 'manager-next))+46
+47
(define (retry-spy-manager! manager)+48
(unless (pair? owned) (error "Retry spy: manager without owned key"))+49
(vector-set! (car owned) 2 manager)+50
manager)+51
+52
(define (retry-spy-candidate! candidate)+53
(set! candidates (cons candidate candidates))+54
(retry-spy-checkpoint! 'candidate-after)+55
candidate)+56
+57
(define (retry-spy-random procedure size)+58
(retry-spy-checkpoint!+59
(case size+60
((32) 'manager-random)+61
((16) 'token-nonce)+62
((8) 'retry-id)+63
(else (error "Retry spy: unexpected random request" size))))+64
(procedure size))+65
+66
(define (retry-spy-mac procedure key bytes)+67
(retry-spy-checkpoint! 'token-mac)+68
(procedure key bytes))+69
+70
(define (retry-spy-packet procedure original client retry token)+71
(retry-spy-checkpoint! 'retry-packet)+72
(procedure original client retry token))+73
+74
(define (retry-spy-send procedure socket bytes host port)+75
(retry-spy-checkpoint! 'retry-send)+76
(case send-mode+77
((blocked) #f)+78
((partial) (- (bytevector-length bytes) 1))+79
(else (procedure socket bytes host port))))))