@bitkyc08/opencodex 2.100.2 → 2.100.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/AGENTS_INSTALL.md +23 -1
- package/README.md +1 -1
- package/bin/ocx.mjs +40 -19
- package/gui/dist/assets/{App-COo8Yopd.css → App-BGP8I0V4.css} +1 -1
- package/gui/dist/assets/App-DcpyI78f.js +60 -0
- package/gui/dist/assets/{Tray-BcaI-VCr.js → Tray-CzjPJprT.js} +1 -1
- package/gui/dist/assets/brand-mark-BTIi7e69.js +1 -0
- package/gui/dist/assets/index-DJxM-imn.css +2 -0
- package/gui/dist/assets/index-DVgU6S3y.js +138 -0
- package/gui/dist/assets/{segment-thumb-features-e9A_FogJ.js → segment-thumb-features-Bn6Y-g3R.js} +1 -1
- package/gui/dist/classic/assets/App-eYJAyNHM.js +59 -0
- package/gui/dist/classic/assets/{Tray-DT146AhS.js → Tray-xHMYxLkV.js} +1 -1
- package/gui/dist/classic/assets/index-DSaVRW4F.js +138 -0
- package/gui/dist/classic/assets/quota-summary-DyzHlkFl.js +1 -0
- package/gui/dist/classic/index.html +1 -1
- package/gui/dist/index.html +2 -2
- package/native/ocx-child/Cargo.toml +9 -0
- package/native/ocx-child/src/cli.rs +404 -20
- package/native/ocx-child/src/codex_home.rs +99 -14
- package/native/ocx-child/src/daemon.rs +2 -1
- package/native/ocx-child/src/lib.rs +3 -0
- package/native/ocx-child/src/link_ws.rs +2598 -0
- package/native/ocx-child/src/link_ws_advert.rs +346 -0
- package/native/ocx-child/src/link_ws_frame.rs +749 -0
- package/native/ocx-child/src/parity.rs +5 -1
- package/native/ocx-child/src/platform.rs +152 -6
- package/native/ocx-child/src/relay.rs +150 -19
- package/package.json +3 -3
- package/src/adapters/anthropic/advisor-tool.ts +176 -0
- package/src/adapters/anthropic/beta-body-pairs.ts +6 -0
- package/src/adapters/anthropic/client-identity.ts +3 -1
- package/src/adapters/anthropic/passthrough.ts +9 -3
- package/src/adapters/anthropic/per-message-effort.ts +296 -0
- package/src/adapters/anthropic.ts +34 -14
- package/src/adapters/claude-cli/adapter.ts +1 -0
- package/src/adapters/client-fingerprint.ts +3 -3
- package/src/adapters/cursor/discovery.ts +17 -0
- package/src/adapters/cursor/native-exec-desktop.ts +2 -1
- package/src/adapters/cursor/native-exec-shell.ts +2 -1
- package/src/adapters/cursor/protobuf-request.ts +8 -8
- package/src/adapters/cursor.ts +7 -6
- package/src/adapters/devin/cloud-direct/chat.ts +71 -14
- package/src/adapters/google-antigravity-wire.ts +7 -5
- package/src/adapters/google-errors.ts +14 -2
- package/src/adapters/google-wire-compiler.ts +2 -2
- package/src/adapters/google.ts +9 -2
- package/src/adapters/kiro/payload.ts +7 -4
- package/src/adapters/kiro/reasoning.ts +44 -1
- package/src/adapters/kiro/structured-output.ts +10 -8
- package/src/adapters/kiro-tools.ts +61 -15
- package/src/adapters/openai-chat/destination-policy.ts +16 -0
- package/src/adapters/openai-chat/reasoning-replay.ts +4 -1
- package/src/adapters/qoder/adapter.ts +9 -1
- package/src/adapters/zed.ts +7 -2
- package/src/advisor/consult.ts +15 -4
- package/src/advisor/context.ts +12 -3
- package/src/advisor/runtime.ts +35 -5
- package/src/advisor/settings.ts +8 -0
- package/src/advisor/synthetic-tool.ts +21 -8
- package/src/bridge/response-json.ts +11 -2
- package/src/bridge/sse.ts +43 -8
- package/src/claude/auth-detect.ts +21 -33
- package/src/claude/desktop-3p.ts +11 -5
- package/src/claude/desktop-gateway-state.ts +2 -0
- package/src/claude/desktop-remote-store-artifact.ts +14 -3
- package/src/claude/desktop-remote-store.ts +82 -12
- package/src/claude/inbound-content-options.ts +31 -16
- package/src/claude/outbound.ts +13 -3
- package/src/cli/account-api.ts +21 -1
- package/src/cli/account-auth.ts +83 -22
- package/src/cli/account-extended.ts +33 -2
- package/src/cli/account-key-quota.ts +34 -5
- package/src/cli/account.ts +4 -2
- package/src/cli/advisor.ts +7 -4
- package/src/cli/alias.ts +38 -1
- package/src/cli/capabilities-access-remote.ts +128 -3
- package/src/cli/capabilities-accounts.ts +6 -6
- package/src/cli/capabilities-agents-routing.ts +17 -10
- package/src/cli/capabilities-base.ts +49 -19
- package/src/cli/capabilities-integrations.ts +2 -2
- package/src/cli/capabilities-observe-system.ts +2 -2
- package/src/cli/capabilities-provider-models.ts +18 -2
- package/src/cli/capabilities-route-to.ts +43 -0
- package/src/cli/capabilities.ts +2 -0
- package/src/cli/capability-contracts.ts +1 -1
- package/src/cli/claude-desktop.ts +30 -11
- package/src/cli/claude.ts +17 -3
- package/src/cli/codex-launcher.ts +3 -1
- package/src/cli/codex-shim-autorestore.ts +5 -42
- package/src/cli/config-command.ts +14 -1
- package/src/cli/config-root-startup.ts +34 -0
- package/src/cli/connect.ts +88 -16
- package/src/cli/desktop-runtime-guidance.ts +1 -1
- package/src/cli/disconnect-runtime.ts +178 -0
- package/src/cli/dispatch.ts +61 -13
- package/src/cli/export-command.ts +1 -1
- package/src/cli/gui-pair-client.ts +6 -3
- package/src/cli/gui.ts +10 -5
- package/src/cli/help-catalog.ts +11 -0
- package/src/cli/help.ts +4 -3
- package/src/cli/index.ts +85 -94
- package/src/cli/inspect.ts +11 -2
- package/src/cli/integrations.ts +26 -1
- package/src/cli/link-apply-restart.ts +4 -2
- package/src/cli/link-capture.ts +64 -0
- package/src/cli/link-child-ops.ts +218 -40
- package/src/cli/link-cleanup.ts +8 -5
- package/src/cli/link-diagnostics.ts +67 -0
- package/src/cli/link-enrollment.ts +158 -12
- package/src/cli/link-operations.ts +52 -0
- package/src/cli/link-recover.ts +152 -0
- package/src/cli/link-routes.ts +90 -0
- package/src/cli/link-status-child.ts +44 -1
- package/src/cli/link-status-traffic.ts +34 -0
- package/src/cli/link.ts +315 -37
- package/src/cli/message-command.ts +1 -1
- package/src/cli/message-mcp-command.ts +23 -10
- package/src/cli/models-runtime.ts +3 -3
- package/src/cli/opencode.ts +3 -1
- package/src/cli/pi-sync.ts +35 -0
- package/src/cli/preflight-exemptions.ts +49 -0
- package/src/cli/registry.ts +33 -14
- package/src/cli/resolve.ts +23 -8
- package/src/cli/restart-failure.ts +15 -2
- package/src/cli/root.ts +5 -1
- package/src/cli/route-to.ts +172 -0
- package/src/cli/runtime-api.ts +9 -8
- package/src/cli/status.ts +7 -2
- package/src/cli/stop-approval.ts +66 -19
- package/src/cli/stop-report.ts +23 -0
- package/src/cli/stop-windows-checked.ts +304 -0
- package/src/cli/sync-command.ts +70 -15
- package/src/cli/sync-fanout.ts +74 -19
- package/src/cli/sync-flags.ts +40 -3
- package/src/cli/sync-link-status.ts +18 -2
- package/src/cli/sync-update-guard.ts +7 -2
- package/src/cli/system-command.ts +1 -1
- package/src/cli/system-restart-client.ts +10 -3
- package/src/cli/system-settings-parity.ts +2 -1
- package/src/cli/uninstall-plan.ts +77 -5
- package/src/cli/uninstall-stop.ts +152 -0
- package/src/cli/v2-input.ts +10 -6
- package/src/cli/v2-local-output.ts +3 -2
- package/src/cli/v2-runtime.ts +10 -3
- package/src/cli/v2.ts +22 -7
- package/src/client/connect.ts +376 -35
- package/src/client/desktop-refusal.ts +38 -0
- package/src/client/lifecycle-lock.ts +29 -4
- package/src/client/link-home-features.ts +27 -0
- package/src/client/link-home.ts +92 -4
- package/src/client/link-ingress.ts +21 -3
- package/src/client/link-join.ts +12 -2
- package/src/client/link-parity-reporter.ts +60 -6
- package/src/client/link-relay-transport.ts +161 -36
- package/src/client/link-relay.ts +150 -6
- package/src/client/link-request-compression.ts +84 -0
- package/src/client/link-state.ts +11 -5
- package/src/client/link-status.ts +39 -1
- package/src/client/link-teardown.ts +1 -0
- package/src/client/link-tunnel.ts +56 -5
- package/src/client/link-websocket-limits.ts +89 -0
- package/src/client/link-websocket.ts +586 -0
- package/src/client/link-ws-advertisement.ts +100 -0
- package/src/client/link-ws-framer.ts +241 -0
- package/src/client/link-ws-transport.ts +177 -0
- package/src/client/machine-api.ts +13 -2
- package/src/client/machine-listener.ts +48 -7
- package/src/client/route-intent-apply.ts +293 -0
- package/src/client/route-intent-file-originals.ts +97 -0
- package/src/client/route-intent-native-originals.ts +201 -0
- package/src/client/route-intent-watch.ts +141 -0
- package/src/client/runtime-restart.ts +141 -7
- package/src/client/runtime.ts +63 -15
- package/src/client/state.ts +44 -0
- package/src/client/sync-expectation.ts +36 -2
- package/src/client/sync-runtime.ts +7 -0
- package/src/clients/config-export/alias-selectors.ts +63 -40
- package/src/clients/config-export/contracts.ts +2 -0
- package/src/clients/config-export/nested-selectors.ts +42 -0
- package/src/clients/config-export.ts +22 -3
- package/src/codex/account-pause.ts +4 -0
- package/src/codex/account-runtime-state.ts +4 -0
- package/src/codex/account-store.ts +12 -3
- package/src/codex/account-usability.ts +13 -0
- package/src/codex/auth-api/account-list.ts +29 -3
- package/src/codex/auth-api/main-account-probe.ts +3 -1
- package/src/codex/auth-api/main-hard-lock-refusal-read.ts +172 -0
- package/src/codex/auth-collision.ts +23 -22
- package/src/codex/auth-context.ts +61 -8
- package/src/codex/catalog/build-entries.ts +10 -0
- package/src/codex/catalog/derive-entry.ts +7 -0
- package/src/codex/catalog/gather-capture.ts +8 -2
- package/src/codex/catalog/parsing.ts +7 -3
- package/src/codex/catalog/provider-models.ts +54 -15
- package/src/codex/catalog/reserve-warn.ts +7 -5
- package/src/codex/catalog/reserve.ts +4 -3
- package/src/codex/catalog/retained-sync.ts +4 -1
- package/src/codex/catalog/routed-defaults.ts +35 -0
- package/src/codex/catalog/routed-gather.ts +1 -1
- package/src/codex/catalog-auto-refresh.ts +11 -0
- package/src/codex/cli-update-job.ts +35 -13
- package/src/codex/convergence.ts +4 -2
- package/src/codex/desktop-compatibility/native-identity.ts +4 -8
- package/src/codex/features.ts +2 -2
- package/src/codex/history-provider.ts +31 -0
- package/src/codex/inject/multi-agent-v2.ts +9 -3
- package/src/codex/inject/paginated-openai-compat.ts +54 -1
- package/src/codex/inject/plan.ts +20 -2
- package/src/codex/inject.ts +2 -0
- package/src/codex/journal-config-restore.ts +217 -0
- package/src/codex/journal.ts +75 -6
- package/src/codex/loopback-target.ts +22 -8
- package/src/codex/main-account.ts +109 -57
- package/src/codex/native-main-auth-file.ts +118 -0
- package/src/codex/native-main-credentials.ts +270 -0
- package/src/codex/native-main-owner.ts +3 -0
- package/src/codex/native-main-refresh-mode.ts +14 -1
- package/src/codex/native-profile-manager.ts +4 -3
- package/src/codex/native-profile-store.ts +3 -61
- package/src/codex/orca-import.ts +10 -1
- package/src/codex/quota-history.ts +13 -0
- package/src/codex/quota-window-conflict.ts +103 -0
- package/src/codex/quota.ts +86 -15
- package/src/codex/subagent-model-fallback.ts +3 -1
- package/src/codex/websocket-activity.ts +171 -16
- package/src/codex/websocket-registry.ts +11 -4
- package/src/combos/cooldown-store.ts +25 -5
- package/src/combos/failover.ts +342 -3
- package/src/combos/index.ts +5 -0
- package/src/combos/resolve.ts +115 -19
- package/src/config/dashboard-trusted-proxy.ts +83 -0
- package/src/config/diagnostics.ts +31 -0
- package/src/config/feature-flags.ts +9 -0
- package/src/config/live-reconcile.ts +16 -4
- package/src/config/load-degrade.ts +14 -1
- package/src/config/multi-agent-surface.ts +28 -5
- package/src/config/pending-teardown.ts +60 -3
- package/src/config/persisted-mutation.ts +2 -2
- package/src/config/persisted-projections.ts +18 -0
- package/src/config/process-state.ts +176 -4
- package/src/config/provider-validation.ts +4 -4
- package/src/config/reserve-capability.ts +96 -0
- package/src/config/schema/config-schema.ts +12 -0
- package/src/config/schema/leaf-validators.ts +11 -2
- package/src/config/schema/routed-catalog-defaults.ts +49 -0
- package/src/config/windows-process-command-line.ts +107 -0
- package/src/config.ts +7 -7
- package/src/desktop-update/acquire.ts +202 -0
- package/src/desktop-update/cli.ts +168 -0
- package/src/desktop-update/drain.ts +40 -0
- package/src/desktop-update/headless.ts +285 -0
- package/src/desktop-update/image.ts +85 -0
- package/src/desktop-update/install.ts +53 -0
- package/src/desktop-update/msi.ts +72 -0
- package/src/desktop-update/release.ts +128 -0
- package/src/desktop-update/runtime.ts +155 -0
- package/src/desktop-update/staging.ts +118 -0
- package/src/desktop-update/trust.ts +45 -0
- package/src/generated/compatibility-version.json +1114 -442
- package/src/generated/model-metadata.ts +1 -1
- package/src/images/fulfill-video.ts +3 -3
- package/src/images/loop.ts +9 -2
- package/src/images/plan.ts +147 -11
- package/src/images/types.ts +13 -4
- package/src/images/xai-video-client.ts +72 -10
- package/src/integrations/model-name-guard.ts +25 -0
- package/src/integrations/route-intent-catalog.ts +26 -0
- package/src/integrations/route-intent-connected.ts +262 -0
- package/src/integrations/route-intent-contract.ts +55 -0
- package/src/integrations/route-intent-disconnect.ts +109 -0
- package/src/integrations/route-intent-initial.ts +64 -0
- package/src/integrations/route-intent-state.ts +117 -0
- package/src/integrations/route-intent-tick.ts +65 -0
- package/src/integrations/route-intent.ts +212 -0
- package/src/integrations/writer.ts +44 -11
- package/src/lib/client-retry-after.ts +29 -0
- package/src/lib/config-ownership.ts +13 -0
- package/src/lib/desktop-gui-origin.ts +28 -0
- package/src/lib/errors.ts +1 -1
- package/src/lib/gcp-adc.ts +48 -4
- package/src/lib/gui-pair-capability.ts +2 -1
- package/src/lib/messages-error-body.ts +4 -1
- package/src/lib/offline-resend.ts +150 -0
- package/src/lib/outbound-credential-registry.ts +362 -4
- package/src/lib/paced-stream.ts +34 -0
- package/src/lib/passive-key-fetch-proof.ts +30 -0
- package/src/lib/passive-read.ts +5 -0
- package/src/lib/process-control.ts +76 -12
- package/src/lib/provider-outbound.ts +17 -6
- package/src/lib/redact.ts +84 -8
- package/src/lib/request-failure-model.ts +2 -0
- package/src/lib/response-body-inactivity.ts +23 -1
- package/src/lib/state-store-registrations.ts +11 -0
- package/src/lib/state-store-sweeper.ts +4 -0
- package/src/lib/supervisor-markers.ts +18 -0
- package/src/lib/terminal-safe-text.ts +58 -0
- package/src/lib/translator-budget.ts +3 -2
- package/src/lib/upstream-retry.ts +52 -9
- package/src/link/alias-lock.ts +119 -0
- package/src/link/child-activity.ts +28 -2
- package/src/link/child-binary-cache-fill.d.mts +50 -0
- package/src/link/child-binary-cache-fill.mjs +494 -0
- package/src/link/child-binary-cache-start.ts +73 -0
- package/src/link/child-binary-source.ts +12 -5
- package/src/link/child-gated-ocx.ts +29 -11
- package/src/link/child-observations.ts +2 -1
- package/src/link/child-observe.ts +2 -2
- package/src/link/child-ops-engine.ts +159 -91
- package/src/link/child-ops-host.ts +138 -0
- package/src/link/child-ops-runners.ts +319 -0
- package/src/link/child-ops-scheduler.ts +207 -0
- package/src/link/child-ops-types.ts +89 -0
- package/src/link/child-parity.ts +23 -4
- package/src/link/child-policy.ts +93 -0
- package/src/link/child-update-contract.ts +12 -3
- package/src/link/codex-settings.ts +1 -1
- package/src/link/compatibility.ts +18 -1
- package/src/link/diagnostics-read.ts +163 -0
- package/src/link/diagnostics.ts +20 -7
- package/src/link/explicit-route.ts +209 -0
- package/src/link/link-recover.ts +113 -0
- package/src/link/management-routes.ts +3 -1
- package/src/link/operation-recovery-slot.ts +44 -0
- package/src/link/operations-journal.ts +408 -0
- package/src/link/peer-report.ts +1 -1
- package/src/link/relay-auth.ts +14 -0
- package/src/link/remote-plant.ts +152 -14
- package/src/link/remote-platform.ts +21 -10
- package/src/link/remote-probe.ts +11 -3
- package/src/link/remote-windows.ts +124 -36
- package/src/link/request-compression.ts +30 -0
- package/src/link/residual-recovery.ts +66 -0
- package/src/link/retirement.ts +128 -0
- package/src/link/route-intent-watch.ts +41 -0
- package/src/link/route-intent.ts +209 -0
- package/src/link/route-proof.ts +82 -0
- package/src/link/route-rounds.ts +579 -0
- package/src/link/route-select.ts +95 -0
- package/src/link/route-trust.ts +96 -0
- package/src/link/ssh-argv.ts +172 -24
- package/src/link/ssh-capture-redact.ts +253 -0
- package/src/link/ssh-capture.ts +497 -0
- package/src/link/ssh-runner.ts +141 -14
- package/src/link/status-projection.ts +87 -0
- package/src/link/store.ts +54 -1
- package/src/link/supervisor.ts +543 -55
- package/src/link/sync-fanout-classify.ts +16 -0
- package/src/link/sync-then-restart.ts +65 -0
- package/src/link/tombstones.ts +209 -0
- package/src/link/traffic.ts +178 -0
- package/src/link/ws-activity-holds.ts +474 -0
- package/src/local-credentials/publication-fence.ts +20 -1
- package/src/messaging/budget.ts +23 -5
- package/src/messaging/mcp-queue-rpc.ts +1 -1
- package/src/messaging/mcp-queue-server.ts +16 -1
- package/src/messaging/mcp-resume-tools.ts +25 -0
- package/src/messaging/remote-enrollment.ts +3 -3
- package/src/messaging/remote-tunnels.ts +2 -2
- package/src/messaging/resume-permissions.ts +27 -0
- package/src/messaging/rpc.ts +50 -6
- package/src/oauth/anthropic-continuity.ts +23 -7
- package/src/oauth/anthropic-routing.ts +5 -2
- package/src/oauth/anthropic.ts +22 -2
- package/src/oauth/antigravity-risk.ts +126 -0
- package/src/oauth/claude-keychain-read.ts +78 -68
- package/src/oauth/generic-account-failover.ts +89 -18
- package/src/oauth/generic-session-affinity.ts +10 -3
- package/src/oauth/index.ts +24 -6
- package/src/oauth/local-token-detect.ts +8 -29
- package/src/oauth/login-cli-errors.ts +5 -1
- package/src/oauth/login-cli.ts +68 -19
- package/src/oauth/login-flow-state.ts +26 -3
- package/src/oauth/meta-muse.ts +1 -1
- package/src/oauth/pool-kernel.ts +3 -3
- package/src/oauth/store.ts +7 -0
- package/src/oauth/xai.ts +248 -14
- package/src/protocols/contract.ts +4 -0
- package/src/protocols/encoders/messages.ts +1 -0
- package/src/providers/alias-template.ts +48 -0
- package/src/providers/anthropic-billing-ownership.ts +2 -0
- package/src/providers/anthropic-billing-refusal.ts +27 -3
- package/src/providers/anthropic-output-caps.ts +46 -0
- package/src/providers/anthropic-reset-grant-ledger.ts +9 -3
- package/src/providers/antigravity-effort-families.ts +11 -3
- package/src/providers/antigravity-models.ts +32 -9
- package/src/providers/antigravity-wire-snapshot.ts +3 -2
- package/src/providers/api-key-pause.ts +3 -0
- package/src/providers/api-key-resolve.ts +49 -7
- package/src/providers/api-key-response-ownership.ts +2 -0
- package/src/providers/api-key-selection.ts +51 -9
- package/src/providers/api-keys.ts +6 -2
- package/src/providers/cache-affinity-identity.ts +73 -0
- package/src/providers/cache-affinity.ts +256 -0
- package/src/providers/default-aliases.ts +98 -20
- package/src/providers/google-vertex-model-discovery.ts +515 -0
- package/src/providers/key-failover.ts +123 -8
- package/src/providers/key-store.ts +3 -3
- package/src/providers/kiro-models.ts +3 -5
- package/src/providers/label.ts +31 -5
- package/src/providers/mistral-transport.ts +17 -4
- package/src/providers/model-rename-fields.ts +5 -0
- package/src/providers/muse-key-quota.ts +14 -6
- package/src/providers/new-model-policy-runtime.ts +17 -4
- package/src/providers/new-model-policy.ts +30 -4
- package/src/providers/passive-key-observation.ts +252 -0
- package/src/providers/quota/account-cache.ts +2 -1
- package/src/providers/quota/anthropic-cooldown-recovery-worker.ts +121 -0
- package/src/providers/quota/passive-key-limits.ts +272 -0
- package/src/providers/quota/passive-wire-model.ts +126 -0
- package/src/providers/quota/report-cache.ts +61 -2
- package/src/providers/quota/workbuddy.ts +6 -2
- package/src/providers/quota-key-accounts.ts +11 -6
- package/src/providers/quota-types.ts +18 -0
- package/src/providers/quota.ts +11 -12
- package/src/providers/registry/entries-core.ts +34 -16
- package/src/providers/registry/entries-extended.ts +32 -0
- package/src/providers/registry/model-seeds.ts +35 -0
- package/src/providers/resolved-model-policy.ts +7 -0
- package/src/providers/routed-config.ts +8 -3
- package/src/providers/workbuddy-credit-balance.ts +125 -16
- package/src/providers/xai-transport.ts +3 -0
- package/src/remote/features.ts +17 -0
- package/src/responses/anthropic-progress.ts +10 -4
- package/src/responses/citation-markers.ts +231 -0
- package/src/responses/effort-history.ts +732 -0
- package/src/responses/spill-store.ts +5 -1
- package/src/responses/state/replay-input.ts +50 -0
- package/src/responses/state/replay-owner.ts +24 -0
- package/src/responses/state/snapshot-codec.ts +9 -0
- package/src/responses/state/spill-queue.ts +1 -0
- package/src/responses/state.ts +42 -60
- package/src/router.ts +2 -2
- package/src/routing/history/integrity.ts +41 -4
- package/src/routing/home-route-capture.ts +123 -0
- package/src/routing/home-route-intent.ts +200 -0
- package/src/routing/route-intent-state.ts +178 -0
- package/src/routing/route-to-live-settings.ts +35 -0
- package/src/routing/route-to-local.ts +145 -0
- package/src/routing/route-to-status.ts +94 -0
- package/src/routing/route-to-sync-child.ts +32 -0
- package/src/server/adapter-resolve.ts +21 -1
- package/src/server/admitted-http-turn.ts +3 -0
- package/src/server/auth-cors.ts +111 -3
- package/src/server/bare-upstream-error.ts +220 -0
- package/src/server/chat-native.ts +14 -5
- package/src/server/claude-messages.ts +6 -4
- package/src/server/codex-model-list.ts +4 -2
- package/src/server/configured-credentials.ts +37 -5
- package/src/server/direct-local-http.ts +26 -3
- package/src/server/gui-desktop-authorization.ts +36 -0
- package/src/server/gui-pair-delivery.ts +6 -3
- package/src/server/gui-session.ts +10 -1
- package/src/server/inbound-body-admission.ts +17 -4
- package/src/server/index/link-listener.ts +196 -12
- package/src/server/index/link-management.ts +15 -1
- package/src/server/index/link-relay-sessions.ts +87 -8
- package/src/server/index/link-websocket-limits.ts +136 -0
- package/src/server/index/link-websocket.ts +692 -0
- package/src/server/index/optional-listeners.ts +97 -7
- package/src/server/index/route-intent-watch.ts +47 -0
- package/src/server/index/serve-contract.ts +86 -0
- package/src/server/index/serve-options.ts +36 -86
- package/src/server/index/startup-warnings.ts +8 -2
- package/src/server/index/websocket-handler.ts +26 -4
- package/src/server/index.ts +15 -4
- package/src/server/inference/client-encoder-delivery.ts +2 -0
- package/src/server/inspection-tee.ts +39 -2
- package/src/server/lifecycle.ts +2 -0
- package/src/server/link-turn.ts +149 -0
- package/src/server/management/advisor-routes.ts +10 -2
- package/src/server/management/agent-settings-routes.ts +50 -16
- package/src/server/management/anthropic-reset-grant-routes.ts +1 -1
- package/src/server/management/config-routes.ts +39 -3
- package/src/server/management/context.ts +9 -2
- package/src/server/management/desktop-authorization.ts +41 -0
- package/src/server/management/desktop-compatibility-routes.ts +9 -8
- package/src/server/management/desktop-compatibility-runtime-routes.ts +3 -2
- package/src/server/management/desktop-compatibility-settings-routes.ts +5 -3
- package/src/server/management/home-integration-decision.ts +89 -0
- package/src/server/management/integration-routes.ts +208 -81
- package/src/server/management/link-child-ops-routes.ts +145 -43
- package/src/server/management/link-child-preflight.ts +31 -0
- package/src/server/management/link-diagnostics-route.ts +29 -0
- package/src/server/management/link-enrollment.ts +199 -47
- package/src/server/management/link-operation.ts +609 -0
- package/src/server/management/link-recover-route.ts +103 -0
- package/src/server/management/link-route-edit.ts +192 -0
- package/src/server/management/link-route-request.ts +62 -0
- package/src/server/management/link-route-state.ts +83 -7
- package/src/server/management/link-routes.ts +553 -51
- package/src/server/management/link-traffic-status.ts +13 -0
- package/src/server/management/model-routes.ts +122 -36
- package/src/server/management/model-rows.ts +2 -1
- package/src/server/management/native-integration-routes.ts +176 -70
- package/src/server/management/oauth-account-routes.ts +58 -18
- package/src/server/management/protocol-routes.ts +7 -0
- package/src/server/management/provider-completion-test.ts +4 -4
- package/src/server/management/provider-overwrite-carry.ts +14 -0
- package/src/server/management/provider-routes.ts +68 -65
- package/src/server/management/provider-routing-quota.ts +45 -0
- package/src/server/management/route-registry.ts +22 -3
- package/src/server/management/route-to-routes.ts +257 -0
- package/src/server/management/static-catalog-probe.ts +33 -0
- package/src/server/management/system-restart.ts +4 -2
- package/src/server/management/usage-aggregate-cache.ts +101 -66
- package/src/server/management-api.ts +17 -3
- package/src/server/management-auth.ts +13 -1
- package/src/server/messages-native-preflight.ts +27 -4
- package/src/server/messages-native.ts +17 -5
- package/src/server/persistent-gui-session.ts +6 -3
- package/src/server/proxy-liveness.ts +87 -15
- package/src/server/relay-eager.ts +36 -12
- package/src/server/relay.ts +189 -117
- package/src/server/request-body-facts.ts +48 -0
- package/src/server/request-decompress.ts +65 -2
- package/src/server/request-log-account-rotation.ts +6 -0
- package/src/server/request-log-attempt-usage.ts +69 -0
- package/src/server/request-log-cache-affinity.ts +60 -0
- package/src/server/request-log-conversation.ts +45 -2
- package/src/server/request-log-terminal-status.ts +210 -24
- package/src/server/request-log.ts +76 -80
- package/src/server/reserve-capability-startup.ts +32 -0
- package/src/server/responses/adapter-continuation.ts +2 -1
- package/src/server/responses/adapter-delivery.ts +4 -0
- package/src/server/responses/adapter-dispatch.ts +36 -17
- package/src/server/responses/advisor-plan-slot.ts +33 -1
- package/src/server/responses/advisor-question.ts +21 -0
- package/src/server/responses/advisor-slot.ts +10 -3
- package/src/server/responses/antigravity-fault-rotation.ts +24 -0
- package/src/server/responses/antigravity-validation-refusal.ts +43 -6
- package/src/server/responses/bare-namespace-aliases.ts +18 -0
- package/src/server/responses/buffered-sse-json.ts +9 -3
- package/src/server/responses/code-mode-collab-surface.ts +11 -0
- package/src/server/responses/codex-tool-catalog.ts +156 -0
- package/src/server/responses/combo-required-tool-fulfillments.ts +4 -2
- package/src/server/responses/combo-selection-keepalive.ts +254 -0
- package/src/server/responses/combo-stream-preflight.ts +557 -54
- package/src/server/responses/compact.ts +32 -8
- package/src/server/responses/core-codex-account.ts +17 -3
- package/src/server/responses/core-combo-failure.ts +8 -0
- package/src/server/responses/core-combo.ts +55 -12
- package/src/server/responses/core-errors.ts +13 -7
- package/src/server/responses/core-lifetime.ts +3 -2
- package/src/server/responses/core-normalize.ts +3 -1
- package/src/server/responses/core-options.ts +14 -0
- package/src/server/responses/core.ts +23 -0
- package/src/server/responses/estimated-usage.ts +115 -0
- package/src/server/responses/fetch-helpers.ts +15 -10
- package/src/server/responses/jev-model-invoke.ts +7 -2
- package/src/server/responses/native-replay-guard.ts +57 -0
- package/src/server/responses/opengateway-completion-guard.ts +10 -4
- package/src/server/responses/outbound-request-body.ts +29 -0
- package/src/server/responses/passthrough-completion.ts +109 -9
- package/src/server/responses/passthrough-delivery.ts +77 -18
- package/src/server/responses/passthrough-dispatch.ts +77 -73
- package/src/server/responses/policy-fallback.ts +13 -1
- package/src/server/responses/request-prepare.ts +59 -11
- package/src/server/responses/request-transport.ts +10 -3
- package/src/server/responses/reset-replay.ts +46 -2
- package/src/server/responses/run-turn-execution.ts +2 -0
- package/src/server/responses/sidecar-execution.ts +19 -0
- package/src/server/responses/terminal-error-redaction.ts +222 -25
- package/src/server/responses/ws-upstream.ts +2 -2
- package/src/server/sse-payload-rewrite.ts +3 -2
- package/src/server/stop-service-route.ts +85 -0
- package/src/server/system-env-shell.ts +12 -1
- package/src/server/system-env.ts +5 -3
- package/src/server/windows-tcp-drop.ts +21 -4
- package/src/server/workflow-refusal.ts +8 -0
- package/src/server/ws-bridge.ts +191 -12
- package/src/service/cli-windows-stop.ts +189 -0
- package/src/service/cli.ts +41 -12
- package/src/service/desktop-supervision.d.mts +2 -0
- package/src/service/desktop-supervision.mjs +5 -0
- package/src/service/disconnected-client-restart.ts +60 -0
- package/src/service/guarded-manager-target.ts +18 -1
- package/src/service/health.ts +99 -6
- package/src/service/launchd.ts +84 -31
- package/src/service/orchestration.ts +418 -91
- package/src/service/repair.ts +223 -6
- package/src/service/restart-proxy-stop.ts +79 -0
- package/src/service/service-child-ownership.ts +6 -2
- package/src/service/windows-checked-stop-live.ts +467 -0
- package/src/service/windows-checked-stop.ts +435 -0
- package/src/service/windows-command-line-token.ts +23 -0
- package/src/service/windows-guarded-manager.ts +77 -34
- package/src/service/windows-ops.ts +38 -56
- package/src/service/windows-process-evidence.ts +292 -0
- package/src/service/windows-process-native.ts +262 -0
- package/src/service/windows-service-stop.ts +321 -0
- package/src/service/windows-stop-binding.ts +187 -0
- package/src/service/windows-stop-budget.ts +123 -0
- package/src/service/windows-stop-confirm.ts +158 -0
- package/src/service/windows-stop-deadline.ts +56 -0
- package/src/service.ts +2 -2
- package/src/stall-timeout.ts +11 -0
- package/src/types/config.ts +57 -110
- package/src/types/link.ts +20 -0
- package/src/types/multi-agent.ts +13 -0
- package/src/types/provider.ts +60 -2
- package/src/types/request.ts +23 -0
- package/src/types/routed-catalog-defaults.ts +17 -0
- package/src/types/routing-profile.ts +90 -0
- package/src/types.ts +4 -0
- package/src/update/guarded-runtime-ops.ts +5 -7
- package/src/update/index.ts +26 -11
- package/src/update/install-detection.mjs +3 -1
- package/src/update/job-pinned-start.ts +2 -0
- package/src/update/job-windows-restart.ts +19 -32
- package/src/update/job.ts +12 -5
- package/src/update/npm-install.d.mts +11 -0
- package/src/update/npm-install.mjs +44 -7
- package/src/update/orchestrated-entry.ts +1 -1
- package/src/update/orchestrated-node-driver.mjs +3 -2
- package/src/update/orchestrated-pnpm.d.mts +4 -0
- package/src/update/orchestrated-pnpm.mjs +50 -6
- package/src/update/orchestrated-session.d.mts +3 -1
- package/src/update/orchestrated-session.mjs +21 -6
- package/src/update/pnpm-global-install.d.mts +21 -3
- package/src/update/pnpm-global-install.mjs +322 -19
- package/src/update/pnpm-store-layout.mjs +46 -0
- package/src/update/sync-update-mutex.d.mts +3 -2
- package/src/update/sync-update-mutex.mjs +57 -8
- package/src/update/transactional-install.d.mts +3 -1
- package/src/update/transactional-install.mjs +545 -12
- package/src/update/windows-installer-marker.d.mts +1 -0
- package/src/update/windows-installer-marker.mjs +44 -0
- package/src/usage/expected-prices.ts +8 -0
- package/src/usage/filter-index.ts +326 -77
- package/src/usage/ledger-scanner.ts +15 -0
- package/src/usage/link-log-fields.ts +48 -0
- package/src/usage/log.ts +57 -6
- package/src/usage/request-body.ts +37 -0
- package/src/usage/telemetry-contract.ts +1 -0
- package/src/web-search/loop.ts +3 -0
- package/src/web-search/passthrough-bridge.ts +7 -0
- package/gui/dist/assets/App-BpJOzw4F.js +0 -59
- package/gui/dist/assets/brand-mark-DU-0Vdkr.js +0 -1
- package/gui/dist/assets/index-Bbor_y80.js +0 -94
- package/gui/dist/assets/index-DJEkIDAi.css +0 -2
- package/gui/dist/classic/assets/App-BrIlUiLc.js +0 -58
- package/gui/dist/classic/assets/index-DyJHagvT.js +0 -94
- package/gui/dist/classic/assets/quota-summary-CakPe9Ni.js +0 -1
- package/src/server/management/desktop-compatibility-authorization.ts +0 -12
|
@@ -0,0 +1,2598 @@
|
|
|
1
|
+
//! The Responses WebSocket over a Remote Link in ocx-child (design T4 3.2-3.3; what the gate-opening change
|
|
2
|
+
//! still owes: devlog/_plan/261113_link_websocket_gate_opening).
|
|
3
|
+
//!
|
|
4
|
+
//! Codex's upgrade on /v1/responses is tried only when ocx-child's release gate is open and the Home
|
|
5
|
+
//! advertised the feature on the last answer applied for the current link; otherwise today's 426 stays,
|
|
6
|
+
//! byte for byte, with no network I/O (relay.rs decides that before calling here). A tried upgrade:
|
|
7
|
+
//! no Origin; a valid Codex handshake; the caps (8 open or setting up, 4 setting up) and a 32 MiB
|
|
8
|
+
//! reservation from 256 MiB; one relay-auth preflight and the upgrade on one connection, inside one
|
|
9
|
+
//! 8 s deadline, proceeding only on that answer's own verified "on"; a complete 101 on that connection.
|
|
10
|
+
//! Every failure is today's 426. ocx-child has no tunnel supervisor, so there is no 503 of its own.
|
|
11
|
+
//!
|
|
12
|
+
//! After the upgrade each socket has two threads: the worker reads Codex and writes Codex's messages to
|
|
13
|
+
//! the Home; one spawned thread reads the Home and writes its messages to Codex. Every frame write is one
|
|
14
|
+
//! operation under that socket's write lock with an absolute deadline (data 600 s, control 30 s) that a
|
|
15
|
+
//! single reaper thread enforces by shutting both sockets down; the per-call write timeout is 300 s of no
|
|
16
|
+
//! progress. One idempotent terminal transition closes both legs with a 5 s bound. A stop aborts setups,
|
|
17
|
+
//! closes every socket with 1001 (best effort) and shuts everything down within 5 s.
|
|
18
|
+
|
|
19
|
+
use std::collections::HashMap;
|
|
20
|
+
use std::io::{BufReader, Cursor, Read, Write};
|
|
21
|
+
use std::net::{Shutdown, TcpStream};
|
|
22
|
+
use std::sync::atomic::{AtomicBool, Ordering};
|
|
23
|
+
use std::sync::{Arc, Condvar, Mutex, MutexGuard, OnceLock};
|
|
24
|
+
use std::thread;
|
|
25
|
+
use std::time::{Duration, Instant};
|
|
26
|
+
|
|
27
|
+
use base64::Engine as _;
|
|
28
|
+
use base64::engine::general_purpose::STANDARD as BASE64;
|
|
29
|
+
|
|
30
|
+
use crate::http_wire::{
|
|
31
|
+
CALLER_CREDENTIAL_HEADERS, HOP_BY_HOP_HEADERS, HttpRequestHead, HttpResponseHead,
|
|
32
|
+
read_response_head, write_json_response,
|
|
33
|
+
};
|
|
34
|
+
use crate::link_ws_frame::{
|
|
35
|
+
FrameEvent, FrameReader, Role, close_payload, control_frame, frame_header, is_wire_close_code,
|
|
36
|
+
mask_in_place,
|
|
37
|
+
};
|
|
38
|
+
use crate::platform::fill_random_bytes;
|
|
39
|
+
use crate::relay::{
|
|
40
|
+
CancelSlot, DeadlineStream, RelayCredentials, RequestLimits, open_link_ws_upstream,
|
|
41
|
+
token_request_head, write_all_before,
|
|
42
|
+
};
|
|
43
|
+
use crate::relay_auth::LINK_RELAY_SESSION_HEADER;
|
|
44
|
+
use crate::routes::RelayAuthKind;
|
|
45
|
+
|
|
46
|
+
const KIB: usize = 1024;
|
|
47
|
+
const MIB: usize = 1024 * KIB;
|
|
48
|
+
|
|
49
|
+
/// Every cap, budget and timeout, in one place (the TypeScript Child's link-websocket-limits.ts).
|
|
50
|
+
#[derive(Clone, Copy, Debug)]
|
|
51
|
+
pub struct Limits {
|
|
52
|
+
pub setup: Duration,
|
|
53
|
+
pub open_sockets: usize,
|
|
54
|
+
pub setting_up: usize,
|
|
55
|
+
pub socket_reservation: usize,
|
|
56
|
+
pub memory_budget: usize,
|
|
57
|
+
pub home_message: usize,
|
|
58
|
+
pub local_message: usize,
|
|
59
|
+
pub max_fragments: usize,
|
|
60
|
+
pub close_bound: Duration,
|
|
61
|
+
pub stall: Duration,
|
|
62
|
+
pub data_operation: Duration,
|
|
63
|
+
pub control_operation: Duration,
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
pub const LIMITS: Limits = Limits {
|
|
67
|
+
setup: Duration::from_secs(8),
|
|
68
|
+
open_sockets: 8,
|
|
69
|
+
setting_up: 4,
|
|
70
|
+
socket_reservation: 32 * MIB,
|
|
71
|
+
memory_budget: 256 * MIB,
|
|
72
|
+
home_message: 4 * MIB + 64 * KIB,
|
|
73
|
+
local_message: 8 * MIB,
|
|
74
|
+
max_fragments: 4_096,
|
|
75
|
+
close_bound: Duration::from_secs(5),
|
|
76
|
+
stall: Duration::from_secs(300),
|
|
77
|
+
data_operation: Duration::from_secs(600),
|
|
78
|
+
control_operation: Duration::from_secs(30),
|
|
79
|
+
};
|
|
80
|
+
|
|
81
|
+
const SPAWNED_STACK: usize = 256 * KIB;
|
|
82
|
+
/// A stop gives each socket's close at most this long: `stop_owned_daemon` (detach, restart, sync) waits 3 s
|
|
83
|
+
/// for the port to close, so the link WebSocket's share of a stop must leave room for the rest of it.
|
|
84
|
+
const STOP_CLOSE_BOUND: Duration = Duration::from_secs(1);
|
|
85
|
+
const MAX_MESSAGE_HEADER: &str = "x-codex-websocket-max-message-bytes";
|
|
86
|
+
const WEBSOCKET_GUID: &str = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
|
|
87
|
+
const UPGRADE_REQUIRED_BODY: &[u8] =
|
|
88
|
+
br#"{"error":{"message":"Responses WebSocket transport is disabled; use HTTP","type":"invalid_request_error","code":"upgrade_required"}}"#;
|
|
89
|
+
|
|
90
|
+
/// Today's answer to Codex's upgrade, which codex-rs turns into HTTP for the session.
|
|
91
|
+
pub fn write_upgrade_required<W: Write>(w: &mut W) -> std::io::Result<()> {
|
|
92
|
+
write_json_response(w, 426, "Upgrade Required", &[], UPGRADE_REQUIRED_BODY)
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
// ---------------------------------------------------------------------------------------------
|
|
96
|
+
// SHA-1, only for the Sec-WebSocket-Accept value of RFC 6455 (not a security primitive here).
|
|
97
|
+
|
|
98
|
+
fn sha1(data: &[u8]) -> [u8; 20] {
|
|
99
|
+
let mut h: [u32; 5] = [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0];
|
|
100
|
+
let mut message = data.to_vec();
|
|
101
|
+
let bit_len = (data.len() as u64).wrapping_mul(8);
|
|
102
|
+
message.push(0x80);
|
|
103
|
+
while message.len() % 64 != 56 {
|
|
104
|
+
message.push(0);
|
|
105
|
+
}
|
|
106
|
+
message.extend_from_slice(&bit_len.to_be_bytes());
|
|
107
|
+
for block in message.chunks(64) {
|
|
108
|
+
let mut w = [0u32; 80];
|
|
109
|
+
for (i, word) in w.iter_mut().take(16).enumerate() {
|
|
110
|
+
*word = u32::from_be_bytes([
|
|
111
|
+
block[i * 4],
|
|
112
|
+
block[i * 4 + 1],
|
|
113
|
+
block[i * 4 + 2],
|
|
114
|
+
block[i * 4 + 3],
|
|
115
|
+
]);
|
|
116
|
+
}
|
|
117
|
+
for i in 16..80 {
|
|
118
|
+
w[i] = (w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]).rotate_left(1);
|
|
119
|
+
}
|
|
120
|
+
let (mut a, mut b, mut c, mut d, mut e) = (h[0], h[1], h[2], h[3], h[4]);
|
|
121
|
+
for (i, word) in w.iter().enumerate() {
|
|
122
|
+
let (f, k) = match i {
|
|
123
|
+
0..=19 => ((b & c) | (!b & d), 0x5A827999),
|
|
124
|
+
20..=39 => (b ^ c ^ d, 0x6ED9EBA1),
|
|
125
|
+
40..=59 => ((b & c) | (b & d) | (c & d), 0x8F1BBCDC),
|
|
126
|
+
_ => (b ^ c ^ d, 0xCA62C1D6),
|
|
127
|
+
};
|
|
128
|
+
let t = a
|
|
129
|
+
.rotate_left(5)
|
|
130
|
+
.wrapping_add(f)
|
|
131
|
+
.wrapping_add(e)
|
|
132
|
+
.wrapping_add(k)
|
|
133
|
+
.wrapping_add(*word);
|
|
134
|
+
e = d;
|
|
135
|
+
d = c;
|
|
136
|
+
c = b.rotate_left(30);
|
|
137
|
+
b = a;
|
|
138
|
+
a = t;
|
|
139
|
+
}
|
|
140
|
+
h[0] = h[0].wrapping_add(a);
|
|
141
|
+
h[1] = h[1].wrapping_add(b);
|
|
142
|
+
h[2] = h[2].wrapping_add(c);
|
|
143
|
+
h[3] = h[3].wrapping_add(d);
|
|
144
|
+
h[4] = h[4].wrapping_add(e);
|
|
145
|
+
}
|
|
146
|
+
let mut out = [0u8; 20];
|
|
147
|
+
for (i, word) in h.iter().enumerate() {
|
|
148
|
+
out[i * 4..i * 4 + 4].copy_from_slice(&word.to_be_bytes());
|
|
149
|
+
}
|
|
150
|
+
out
|
|
151
|
+
}
|
|
152
|
+
|
|
153
|
+
pub fn websocket_accept(key: &str) -> String {
|
|
154
|
+
BASE64.encode(sha1(format!("{key}{WEBSOCKET_GUID}").as_bytes()))
|
|
155
|
+
}
|
|
156
|
+
|
|
157
|
+
// ---------------------------------------------------------------------------------------------
|
|
158
|
+
// Headers.
|
|
159
|
+
|
|
160
|
+
fn header_values<'a>(headers: &'a [(String, String)], name: &str) -> Vec<&'a str> {
|
|
161
|
+
headers
|
|
162
|
+
.iter()
|
|
163
|
+
.filter(|(k, _)| k.eq_ignore_ascii_case(name))
|
|
164
|
+
.map(|(_, v)| v.as_str())
|
|
165
|
+
.collect()
|
|
166
|
+
}
|
|
167
|
+
|
|
168
|
+
fn single<'a>(headers: &'a [(String, String)], name: &str) -> Option<&'a str> {
|
|
169
|
+
let values = header_values(headers, name);
|
|
170
|
+
if values.len() == 1 {
|
|
171
|
+
Some(values[0])
|
|
172
|
+
} else {
|
|
173
|
+
None
|
|
174
|
+
}
|
|
175
|
+
}
|
|
176
|
+
|
|
177
|
+
fn names_token(value: &str, token: &str) -> bool {
|
|
178
|
+
value
|
|
179
|
+
.split(',')
|
|
180
|
+
.any(|t| t.trim().eq_ignore_ascii_case(token))
|
|
181
|
+
}
|
|
182
|
+
|
|
183
|
+
/// Codex's handshake: GET /v1/responses without a query, Upgrade websocket, Connection upgrade,
|
|
184
|
+
/// version 13 and a 16-byte key, no body framing. Returns the key.
|
|
185
|
+
pub fn codex_handshake_key(req: &HttpRequestHead) -> Option<String> {
|
|
186
|
+
if req.method != "GET" || req.path != "/v1/responses" || !req.query.is_empty() {
|
|
187
|
+
return None;
|
|
188
|
+
}
|
|
189
|
+
let h = &req.headers;
|
|
190
|
+
if !single(h, "upgrade").is_some_and(|v| v.trim().eq_ignore_ascii_case("websocket")) {
|
|
191
|
+
return None;
|
|
192
|
+
}
|
|
193
|
+
if !header_values(h, "connection")
|
|
194
|
+
.iter()
|
|
195
|
+
.any(|v| names_token(v, "upgrade"))
|
|
196
|
+
{
|
|
197
|
+
return None;
|
|
198
|
+
}
|
|
199
|
+
if single(h, "sec-websocket-version") != Some("13") {
|
|
200
|
+
return None;
|
|
201
|
+
}
|
|
202
|
+
if !header_values(h, "content-length").is_empty()
|
|
203
|
+
|| !header_values(h, "transfer-encoding").is_empty()
|
|
204
|
+
{
|
|
205
|
+
return None;
|
|
206
|
+
}
|
|
207
|
+
let key = single(h, "sec-websocket-key")?.trim();
|
|
208
|
+
match BASE64.decode(key) {
|
|
209
|
+
Ok(bytes) if bytes.len() == 16 => Some(key.to_owned()),
|
|
210
|
+
_ => None,
|
|
211
|
+
}
|
|
212
|
+
}
|
|
213
|
+
|
|
214
|
+
const INTERNAL_HEADERS: &[&str] = &["x-opencodex-link-session", "x-opencodex-link-turn"];
|
|
215
|
+
|
|
216
|
+
/// Codex's headers for the Home leg: its handshake, the hop-by-hop set and every header Connection
|
|
217
|
+
/// nominates, Origin, Host, framing, caller credentials and the relay's internal headers dropped.
|
|
218
|
+
/// None when a value carries CR or LF or Host is repeated.
|
|
219
|
+
pub fn forward_upgrade_headers(headers: &[(String, String)]) -> Option<Vec<(String, String)>> {
|
|
220
|
+
if header_values(headers, "host").len() > 1 {
|
|
221
|
+
return None;
|
|
222
|
+
}
|
|
223
|
+
let nominated: Vec<String> = header_values(headers, "connection")
|
|
224
|
+
.iter()
|
|
225
|
+
.flat_map(|v| v.split(','))
|
|
226
|
+
.map(|t| t.trim().to_ascii_lowercase())
|
|
227
|
+
.filter(|t| !t.is_empty())
|
|
228
|
+
.collect();
|
|
229
|
+
let mut out = Vec::new();
|
|
230
|
+
for (name, value) in headers {
|
|
231
|
+
if name.contains(['\r', '\n', ':']) || value.contains(['\r', '\n']) || name.is_empty() {
|
|
232
|
+
return None;
|
|
233
|
+
}
|
|
234
|
+
let lower = name.to_ascii_lowercase();
|
|
235
|
+
if HOP_BY_HOP_HEADERS.contains(&lower.as_str())
|
|
236
|
+
|| CALLER_CREDENTIAL_HEADERS.contains(&lower.as_str())
|
|
237
|
+
|| INTERNAL_HEADERS.contains(&lower.as_str())
|
|
238
|
+
|| nominated.contains(&lower)
|
|
239
|
+
|| lower.starts_with("sec-websocket-")
|
|
240
|
+
|| matches!(
|
|
241
|
+
lower.as_str(),
|
|
242
|
+
"origin" | "host" | "content-length" | "accept-encoding" | "proxy-connection"
|
|
243
|
+
)
|
|
244
|
+
{
|
|
245
|
+
continue;
|
|
246
|
+
}
|
|
247
|
+
out.push((name.clone(), value.clone()));
|
|
248
|
+
}
|
|
249
|
+
Some(out)
|
|
250
|
+
}
|
|
251
|
+
|
|
252
|
+
/// A 101 that completes the Home-leg upgrade and nothing more.
|
|
253
|
+
pub fn valid_home_upgrade(resp: &HttpResponseHead, key: &str) -> bool {
|
|
254
|
+
resp.status == 101
|
|
255
|
+
&& single(&resp.headers, "upgrade")
|
|
256
|
+
.is_some_and(|v| v.trim().eq_ignore_ascii_case("websocket"))
|
|
257
|
+
&& header_values(&resp.headers, "connection")
|
|
258
|
+
.iter()
|
|
259
|
+
.any(|v| names_token(v, "upgrade"))
|
|
260
|
+
&& single(&resp.headers, "sec-websocket-accept") == Some(websocket_accept(key).as_str())
|
|
261
|
+
&& header_values(&resp.headers, "sec-websocket-extensions").is_empty()
|
|
262
|
+
&& header_values(&resp.headers, "sec-websocket-protocol").is_empty()
|
|
263
|
+
}
|
|
264
|
+
|
|
265
|
+
// ---------------------------------------------------------------------------------------------
|
|
266
|
+
// Admission, registry and the reaper.
|
|
267
|
+
|
|
268
|
+
struct Registry {
|
|
269
|
+
stopping: bool,
|
|
270
|
+
open: usize,
|
|
271
|
+
setting_up: usize,
|
|
272
|
+
reserved: usize,
|
|
273
|
+
next_id: u64,
|
|
274
|
+
sockets: HashMap<u64, Arc<SocketShared>>,
|
|
275
|
+
setups: HashMap<u64, Arc<CancelSlot>>,
|
|
276
|
+
}
|
|
277
|
+
|
|
278
|
+
fn registry() -> &'static (Mutex<Registry>, Condvar) {
|
|
279
|
+
static REGISTRY: OnceLock<(Mutex<Registry>, Condvar)> = OnceLock::new();
|
|
280
|
+
REGISTRY.get_or_init(|| {
|
|
281
|
+
(
|
|
282
|
+
Mutex::new(Registry {
|
|
283
|
+
stopping: false,
|
|
284
|
+
open: 0,
|
|
285
|
+
setting_up: 0,
|
|
286
|
+
reserved: 0,
|
|
287
|
+
next_id: 0,
|
|
288
|
+
sockets: HashMap::new(),
|
|
289
|
+
setups: HashMap::new(),
|
|
290
|
+
}),
|
|
291
|
+
Condvar::new(),
|
|
292
|
+
)
|
|
293
|
+
})
|
|
294
|
+
}
|
|
295
|
+
|
|
296
|
+
fn lock<T>(m: &Mutex<T>) -> MutexGuard<'_, T> {
|
|
297
|
+
m.lock().unwrap_or_else(|e| e.into_inner())
|
|
298
|
+
}
|
|
299
|
+
|
|
300
|
+
/// A setup slot: released on drop unless it became an open socket's lease.
|
|
301
|
+
struct SetupSlot {
|
|
302
|
+
id: u64,
|
|
303
|
+
reservation: usize,
|
|
304
|
+
converted: bool,
|
|
305
|
+
}
|
|
306
|
+
|
|
307
|
+
impl Drop for SetupSlot {
|
|
308
|
+
fn drop(&mut self) {
|
|
309
|
+
if self.converted {
|
|
310
|
+
return;
|
|
311
|
+
}
|
|
312
|
+
let (m, cv) = registry();
|
|
313
|
+
let mut r = lock(m);
|
|
314
|
+
r.setting_up -= 1;
|
|
315
|
+
r.reserved -= self.reservation;
|
|
316
|
+
r.setups.remove(&self.id);
|
|
317
|
+
cv.notify_all();
|
|
318
|
+
}
|
|
319
|
+
}
|
|
320
|
+
|
|
321
|
+
/// An open socket's slot and reservation: released when the last owner of its shared part drops it.
|
|
322
|
+
struct Lease {
|
|
323
|
+
id: u64,
|
|
324
|
+
reservation: usize,
|
|
325
|
+
}
|
|
326
|
+
|
|
327
|
+
impl Drop for Lease {
|
|
328
|
+
fn drop(&mut self) {
|
|
329
|
+
let (m, cv) = registry();
|
|
330
|
+
let mut r = lock(m);
|
|
331
|
+
r.open -= 1;
|
|
332
|
+
r.reserved -= self.reservation;
|
|
333
|
+
r.sockets.remove(&self.id);
|
|
334
|
+
cv.notify_all();
|
|
335
|
+
}
|
|
336
|
+
}
|
|
337
|
+
|
|
338
|
+
fn admit(l: &Limits) -> Option<(SetupSlot, Arc<CancelSlot>)> {
|
|
339
|
+
let (m, _) = registry();
|
|
340
|
+
let mut r = lock(m);
|
|
341
|
+
if r.stopping || r.open + r.setting_up >= l.open_sockets || r.setting_up >= l.setting_up {
|
|
342
|
+
return None;
|
|
343
|
+
}
|
|
344
|
+
if r.reserved + l.socket_reservation > l.memory_budget {
|
|
345
|
+
return None;
|
|
346
|
+
}
|
|
347
|
+
r.setting_up += 1;
|
|
348
|
+
r.reserved += l.socket_reservation;
|
|
349
|
+
r.next_id += 1;
|
|
350
|
+
let id = r.next_id;
|
|
351
|
+
let cancel = Arc::new(CancelSlot::default());
|
|
352
|
+
r.setups.insert(id, Arc::clone(&cancel));
|
|
353
|
+
Some((
|
|
354
|
+
SetupSlot {
|
|
355
|
+
id,
|
|
356
|
+
reservation: l.socket_reservation,
|
|
357
|
+
converted: false,
|
|
358
|
+
},
|
|
359
|
+
cancel,
|
|
360
|
+
))
|
|
361
|
+
}
|
|
362
|
+
|
|
363
|
+
struct Reaper {
|
|
364
|
+
inner: Mutex<ReaperInner>,
|
|
365
|
+
cv: Condvar,
|
|
366
|
+
}
|
|
367
|
+
|
|
368
|
+
struct ReaperInner {
|
|
369
|
+
entries: Vec<(u64, Instant, Arc<SocketShared>)>,
|
|
370
|
+
next: u64,
|
|
371
|
+
exit: bool,
|
|
372
|
+
started: bool,
|
|
373
|
+
}
|
|
374
|
+
|
|
375
|
+
static REAPER: OnceLock<Reaper> = OnceLock::new();
|
|
376
|
+
static REAPER_THREAD: Mutex<Option<thread::JoinHandle<()>>> = Mutex::new(None);
|
|
377
|
+
|
|
378
|
+
fn reaper() -> &'static Reaper {
|
|
379
|
+
REAPER.get_or_init(|| Reaper {
|
|
380
|
+
inner: Mutex::new(ReaperInner {
|
|
381
|
+
entries: Vec::new(),
|
|
382
|
+
next: 0,
|
|
383
|
+
exit: false,
|
|
384
|
+
started: false,
|
|
385
|
+
}),
|
|
386
|
+
cv: Condvar::new(),
|
|
387
|
+
})
|
|
388
|
+
}
|
|
389
|
+
|
|
390
|
+
/// Start the reaper thread if it is not running; false when it cannot be created.
|
|
391
|
+
fn ensure_reaper() -> bool {
|
|
392
|
+
let r = reaper();
|
|
393
|
+
let mut inner = lock(&r.inner);
|
|
394
|
+
if inner.started {
|
|
395
|
+
return true;
|
|
396
|
+
}
|
|
397
|
+
inner.exit = false;
|
|
398
|
+
let spawned = thread::Builder::new()
|
|
399
|
+
.name("ocx-link-ws-reaper".into())
|
|
400
|
+
.stack_size(SPAWNED_STACK)
|
|
401
|
+
.spawn(reaper_loop);
|
|
402
|
+
match spawned {
|
|
403
|
+
Ok(handle) => {
|
|
404
|
+
inner.started = true;
|
|
405
|
+
*lock(&REAPER_THREAD) = Some(handle);
|
|
406
|
+
true
|
|
407
|
+
}
|
|
408
|
+
Err(_) => false,
|
|
409
|
+
}
|
|
410
|
+
}
|
|
411
|
+
|
|
412
|
+
fn reaper_loop() {
|
|
413
|
+
let r = reaper();
|
|
414
|
+
loop {
|
|
415
|
+
let expired: Vec<Arc<SocketShared>> = {
|
|
416
|
+
let mut inner = lock(&r.inner);
|
|
417
|
+
loop {
|
|
418
|
+
if inner.exit {
|
|
419
|
+
return;
|
|
420
|
+
}
|
|
421
|
+
let now = Instant::now();
|
|
422
|
+
if inner.entries.iter().any(|(_, at, _)| *at <= now) {
|
|
423
|
+
break;
|
|
424
|
+
}
|
|
425
|
+
match inner.entries.iter().map(|(_, at, _)| *at).min() {
|
|
426
|
+
Some(next) => {
|
|
427
|
+
let (g, _) =
|
|
428
|
+
r.cv.wait_timeout(inner, next - now)
|
|
429
|
+
.unwrap_or_else(|e| e.into_inner());
|
|
430
|
+
inner = g;
|
|
431
|
+
}
|
|
432
|
+
None => inner = r.cv.wait(inner).unwrap_or_else(|e| e.into_inner()),
|
|
433
|
+
}
|
|
434
|
+
}
|
|
435
|
+
let now = Instant::now();
|
|
436
|
+
let mut fired = Vec::new();
|
|
437
|
+
inner.entries.retain(|(_, at, s)| {
|
|
438
|
+
if *at <= now {
|
|
439
|
+
fired.push(Arc::clone(s));
|
|
440
|
+
false
|
|
441
|
+
} else {
|
|
442
|
+
true
|
|
443
|
+
}
|
|
444
|
+
});
|
|
445
|
+
fired
|
|
446
|
+
};
|
|
447
|
+
// Outside the list lock: shut down, never taking a write lock.
|
|
448
|
+
for shared in expired {
|
|
449
|
+
shared.cut();
|
|
450
|
+
}
|
|
451
|
+
}
|
|
452
|
+
}
|
|
453
|
+
|
|
454
|
+
fn register_deadline(at: Instant, shared: &Arc<SocketShared>) -> u64 {
|
|
455
|
+
let r = reaper();
|
|
456
|
+
let mut inner = lock(&r.inner);
|
|
457
|
+
inner.next += 1;
|
|
458
|
+
let token = inner.next;
|
|
459
|
+
inner.entries.push((token, at, Arc::clone(shared)));
|
|
460
|
+
r.cv.notify_all();
|
|
461
|
+
token
|
|
462
|
+
}
|
|
463
|
+
|
|
464
|
+
fn clear_deadline(token: u64) {
|
|
465
|
+
let r = reaper();
|
|
466
|
+
let mut inner = lock(&r.inner);
|
|
467
|
+
inner.entries.retain(|(t, _, _)| *t != token);
|
|
468
|
+
r.cv.notify_all();
|
|
469
|
+
}
|
|
470
|
+
|
|
471
|
+
/// Fire every remaining entry at once (serve shutdown).
|
|
472
|
+
fn reaper_drain() {
|
|
473
|
+
let r = reaper();
|
|
474
|
+
let fired: Vec<Arc<SocketShared>> = {
|
|
475
|
+
let mut inner = lock(&r.inner);
|
|
476
|
+
let all = inner.entries.drain(..).map(|(_, _, s)| s).collect();
|
|
477
|
+
r.cv.notify_all();
|
|
478
|
+
all
|
|
479
|
+
};
|
|
480
|
+
for shared in fired {
|
|
481
|
+
shared.cut();
|
|
482
|
+
}
|
|
483
|
+
}
|
|
484
|
+
|
|
485
|
+
fn reaper_exit_and_join() {
|
|
486
|
+
{
|
|
487
|
+
let r = reaper();
|
|
488
|
+
let mut inner = lock(&r.inner);
|
|
489
|
+
inner.exit = true;
|
|
490
|
+
inner.started = false;
|
|
491
|
+
r.cv.notify_all();
|
|
492
|
+
}
|
|
493
|
+
if let Some(handle) = lock(&REAPER_THREAD).take() {
|
|
494
|
+
let _ = handle.join();
|
|
495
|
+
}
|
|
496
|
+
}
|
|
497
|
+
|
|
498
|
+
// ---------------------------------------------------------------------------------------------
|
|
499
|
+
// One open socket.
|
|
500
|
+
|
|
501
|
+
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
|
|
502
|
+
enum Lifecycle {
|
|
503
|
+
Registered,
|
|
504
|
+
Started,
|
|
505
|
+
Aborted,
|
|
506
|
+
}
|
|
507
|
+
|
|
508
|
+
struct SockState {
|
|
509
|
+
lifecycle: Lifecycle,
|
|
510
|
+
terminal_started: bool,
|
|
511
|
+
close_io: usize,
|
|
512
|
+
cleanup_done: bool,
|
|
513
|
+
close_token: Option<u64>,
|
|
514
|
+
spawned_done: bool,
|
|
515
|
+
}
|
|
516
|
+
|
|
517
|
+
#[derive(Clone, Copy, PartialEq, Eq)]
|
|
518
|
+
enum Leg {
|
|
519
|
+
Codex,
|
|
520
|
+
Home,
|
|
521
|
+
}
|
|
522
|
+
|
|
523
|
+
/// What the terminal transition writes to one leg.
|
|
524
|
+
#[derive(Clone, Debug)]
|
|
525
|
+
enum CloseAction {
|
|
526
|
+
/// A close frame with this code (and reason).
|
|
527
|
+
Frame(u16, String),
|
|
528
|
+
/// A close frame without a status code.
|
|
529
|
+
Empty,
|
|
530
|
+
/// No close frame: the connection ends at once.
|
|
531
|
+
Cut,
|
|
532
|
+
/// Nothing at all: the leg is not a WebSocket yet (before the local 101), its owner answers it.
|
|
533
|
+
Leave,
|
|
534
|
+
}
|
|
535
|
+
|
|
536
|
+
#[derive(Clone, Copy, PartialEq, Eq)]
|
|
537
|
+
enum Kind {
|
|
538
|
+
Data,
|
|
539
|
+
Control,
|
|
540
|
+
Close,
|
|
541
|
+
}
|
|
542
|
+
|
|
543
|
+
pub(crate) struct SocketShared {
|
|
544
|
+
codex: TcpStream,
|
|
545
|
+
home: TcpStream,
|
|
546
|
+
closing: AtomicBool,
|
|
547
|
+
/// Set under Codex's write lock once the local 101 is written: no frame reaches Codex before it.
|
|
548
|
+
upgraded: AtomicBool,
|
|
549
|
+
codex_write: Mutex<()>,
|
|
550
|
+
home_write: Mutex<()>,
|
|
551
|
+
state: Mutex<SockState>,
|
|
552
|
+
cv: Condvar,
|
|
553
|
+
limits: Limits,
|
|
554
|
+
_lease: Lease,
|
|
555
|
+
}
|
|
556
|
+
|
|
557
|
+
impl SocketShared {
|
|
558
|
+
/// Shut both connections down (the reaper's action); ends every blocked read or write.
|
|
559
|
+
fn cut(&self) {
|
|
560
|
+
self.closing.store(true, Ordering::SeqCst);
|
|
561
|
+
let _ = self.codex.shutdown(Shutdown::Both);
|
|
562
|
+
let _ = self.home.shutdown(Shutdown::Both);
|
|
563
|
+
}
|
|
564
|
+
}
|
|
565
|
+
|
|
566
|
+
fn random_mask() -> [u8; 4] {
|
|
567
|
+
let mut m = [0u8; 4];
|
|
568
|
+
if fill_random_bytes(&mut m).is_err() {
|
|
569
|
+
// A mask only has to be unpredictable to intermediaries; fall back to the clock.
|
|
570
|
+
let n = std::time::SystemTime::now()
|
|
571
|
+
.duration_since(std::time::UNIX_EPOCH)
|
|
572
|
+
.map_or(0, |d| d.subsec_nanos())
|
|
573
|
+
^ 0x9e37_79b9;
|
|
574
|
+
m = n.to_le_bytes();
|
|
575
|
+
}
|
|
576
|
+
m
|
|
577
|
+
}
|
|
578
|
+
|
|
579
|
+
/// One bounded frame write: the deadline is registered before the lock.
|
|
580
|
+
fn write_frame(
|
|
581
|
+
shared: &Arc<SocketShared>,
|
|
582
|
+
leg: Leg,
|
|
583
|
+
opcode: u8,
|
|
584
|
+
mut payload: Vec<u8>,
|
|
585
|
+
kind: Kind,
|
|
586
|
+
) -> std::io::Result<()> {
|
|
587
|
+
let bound = if kind == Kind::Data {
|
|
588
|
+
shared.limits.data_operation
|
|
589
|
+
} else {
|
|
590
|
+
shared.limits.control_operation
|
|
591
|
+
};
|
|
592
|
+
let token = register_deadline(Instant::now() + bound, shared);
|
|
593
|
+
let result = (|| {
|
|
594
|
+
let (lock_m, mut stream) = match leg {
|
|
595
|
+
Leg::Codex => (&shared.codex_write, &shared.codex),
|
|
596
|
+
Leg::Home => (&shared.home_write, &shared.home),
|
|
597
|
+
};
|
|
598
|
+
let _guard = lock(lock_m);
|
|
599
|
+
if leg == Leg::Codex && !shared.upgraded.load(Ordering::SeqCst) {
|
|
600
|
+
// Before the local 101 Codex's connection is still HTTP; its owner answers it.
|
|
601
|
+
return Err(std::io::Error::new(
|
|
602
|
+
std::io::ErrorKind::BrokenPipe,
|
|
603
|
+
"link websocket not upgraded",
|
|
604
|
+
));
|
|
605
|
+
}
|
|
606
|
+
if shared.closing.load(Ordering::SeqCst) && kind != Kind::Close {
|
|
607
|
+
return Err(std::io::Error::new(
|
|
608
|
+
std::io::ErrorKind::BrokenPipe,
|
|
609
|
+
"link websocket closing",
|
|
610
|
+
));
|
|
611
|
+
}
|
|
612
|
+
// Tests: the writer holds the lock and is past every early exit; its write starts now.
|
|
613
|
+
#[cfg(test)]
|
|
614
|
+
if kind == Kind::Data {
|
|
615
|
+
tests::data_locked();
|
|
616
|
+
}
|
|
617
|
+
let mask = if leg == Leg::Home {
|
|
618
|
+
Some(random_mask())
|
|
619
|
+
} else {
|
|
620
|
+
None
|
|
621
|
+
};
|
|
622
|
+
if opcode >= 8 {
|
|
623
|
+
stream.write_all(&control_frame(opcode, &payload, mask))?;
|
|
624
|
+
} else {
|
|
625
|
+
stream.write_all(&frame_header(opcode, payload.len(), mask))?;
|
|
626
|
+
if let Some(m) = mask {
|
|
627
|
+
mask_in_place(&mut payload, m);
|
|
628
|
+
}
|
|
629
|
+
stream.write_all(&payload)?;
|
|
630
|
+
}
|
|
631
|
+
stream.flush()
|
|
632
|
+
})();
|
|
633
|
+
clear_deadline(token);
|
|
634
|
+
result
|
|
635
|
+
}
|
|
636
|
+
|
|
637
|
+
fn close_bytes(action: &CloseAction) -> Option<Vec<u8>> {
|
|
638
|
+
match action {
|
|
639
|
+
CloseAction::Frame(code, reason) => Some(close_payload(Some(*code), reason)),
|
|
640
|
+
CloseAction::Empty => Some(Vec::new()),
|
|
641
|
+
CloseAction::Cut | CloseAction::Leave => None,
|
|
642
|
+
}
|
|
643
|
+
}
|
|
644
|
+
|
|
645
|
+
/// The local 101: written under Codex's write lock inside a control
|
|
646
|
+
/// operation deadline, so a close frame can only follow it. Ok(false) when closing began first (a stop
|
|
647
|
+
/// between registration and the 101): nothing is written and the caller answers today's 426.
|
|
648
|
+
fn write_101(shared: &Arc<SocketShared>, reply: &[u8], fail: bool) -> std::io::Result<bool> {
|
|
649
|
+
let token = register_deadline(Instant::now() + shared.limits.control_operation, shared);
|
|
650
|
+
let result = (|| {
|
|
651
|
+
let _guard = lock(&shared.codex_write);
|
|
652
|
+
if shared.closing.load(Ordering::SeqCst) {
|
|
653
|
+
return Ok(false);
|
|
654
|
+
}
|
|
655
|
+
if fail {
|
|
656
|
+
return Err(std::io::Error::other("101 write refused by test"));
|
|
657
|
+
}
|
|
658
|
+
let mut stream = &shared.codex;
|
|
659
|
+
stream.write_all(reply)?;
|
|
660
|
+
stream.flush()?;
|
|
661
|
+
shared.upgraded.store(true, Ordering::SeqCst);
|
|
662
|
+
Ok(true)
|
|
663
|
+
})();
|
|
664
|
+
clear_deadline(token);
|
|
665
|
+
result
|
|
666
|
+
}
|
|
667
|
+
|
|
668
|
+
/// The terminal transition. Idempotent; only the first caller writes close frames, and it claims its close
|
|
669
|
+
/// I/O and registers the close deadline in the same state-lock section that starts the transition.
|
|
670
|
+
fn terminate(shared: &Arc<SocketShared>, codex: CloseAction, home: CloseAction) {
|
|
671
|
+
let claimed = {
|
|
672
|
+
let mut st = lock(&shared.state);
|
|
673
|
+
if st.lifecycle == Lifecycle::Registered {
|
|
674
|
+
st.lifecycle = Lifecycle::Aborted;
|
|
675
|
+
shared.cv.notify_all();
|
|
676
|
+
}
|
|
677
|
+
if st.terminal_started {
|
|
678
|
+
false
|
|
679
|
+
} else {
|
|
680
|
+
st.terminal_started = true;
|
|
681
|
+
shared.closing.store(true, Ordering::SeqCst);
|
|
682
|
+
st.close_token = Some(register_deadline(
|
|
683
|
+
Instant::now() + shared.limits.close_bound,
|
|
684
|
+
shared,
|
|
685
|
+
));
|
|
686
|
+
st.close_io += 1;
|
|
687
|
+
true
|
|
688
|
+
}
|
|
689
|
+
};
|
|
690
|
+
if !claimed {
|
|
691
|
+
return;
|
|
692
|
+
}
|
|
693
|
+
#[cfg(test)]
|
|
694
|
+
tests::after_claim();
|
|
695
|
+
for (leg, action) in [(Leg::Codex, &codex), (Leg::Home, &home)] {
|
|
696
|
+
match close_bytes(action) {
|
|
697
|
+
Some(payload) => {
|
|
698
|
+
let _ = write_frame(shared, leg, 8, payload, Kind::Close);
|
|
699
|
+
}
|
|
700
|
+
None if matches!(action, CloseAction::Leave) => {}
|
|
701
|
+
None => {
|
|
702
|
+
let stream = if leg == Leg::Codex {
|
|
703
|
+
&shared.codex
|
|
704
|
+
} else {
|
|
705
|
+
&shared.home
|
|
706
|
+
};
|
|
707
|
+
let _ = stream.shutdown(Shutdown::Both);
|
|
708
|
+
}
|
|
709
|
+
}
|
|
710
|
+
}
|
|
711
|
+
let mut st = lock(&shared.state);
|
|
712
|
+
st.close_io -= 1;
|
|
713
|
+
retire_if_done(&mut st);
|
|
714
|
+
}
|
|
715
|
+
|
|
716
|
+
fn retire_if_done(st: &mut SockState) {
|
|
717
|
+
if st.cleanup_done
|
|
718
|
+
&& st.close_io == 0
|
|
719
|
+
&& let Some(token) = st.close_token.take()
|
|
720
|
+
{
|
|
721
|
+
clear_deadline(token);
|
|
722
|
+
}
|
|
723
|
+
}
|
|
724
|
+
|
|
725
|
+
/// A close code relayed to the other leg: absent, 1005, 1006, 1015 and anything that may not appear on
|
|
726
|
+
/// the wire become 1011.
|
|
727
|
+
fn relay_code(code: Option<u16>) -> u16 {
|
|
728
|
+
code.filter(|c| is_wire_close_code(*c)).unwrap_or(1011)
|
|
729
|
+
}
|
|
730
|
+
|
|
731
|
+
/// Reads one leg and writes its messages to the other leg until either ends.
|
|
732
|
+
fn pump<R: Read>(shared: &Arc<SocketShared>, from: Leg, mut source: R) {
|
|
733
|
+
let (role, limit, to) = match from {
|
|
734
|
+
Leg::Codex => (Role::FromClient, shared.limits.local_message, Leg::Home),
|
|
735
|
+
Leg::Home => (Role::FromServer, shared.limits.home_message, Leg::Codex),
|
|
736
|
+
};
|
|
737
|
+
let mut reader = FrameReader::new(role, limit, shared.limits.max_fragments);
|
|
738
|
+
let mut buf = vec![0u8; 8 * KIB];
|
|
739
|
+
loop {
|
|
740
|
+
let n = match source.read(&mut buf) {
|
|
741
|
+
Ok(0) | Err(_) => {
|
|
742
|
+
// The leg ended without a close frame.
|
|
743
|
+
match from {
|
|
744
|
+
// Codex dropped: the Home connection ends without a close frame (the Home's 1006).
|
|
745
|
+
Leg::Codex => terminate(shared, CloseAction::Cut, CloseAction::Cut),
|
|
746
|
+
// The Home dropped (a tunnel drop, a killed Home): 1011 to Codex.
|
|
747
|
+
Leg::Home => terminate(
|
|
748
|
+
shared,
|
|
749
|
+
CloseAction::Frame(1011, "home connection ended".into()),
|
|
750
|
+
CloseAction::Cut,
|
|
751
|
+
),
|
|
752
|
+
}
|
|
753
|
+
return;
|
|
754
|
+
}
|
|
755
|
+
Ok(n) => n,
|
|
756
|
+
};
|
|
757
|
+
let mut events = Vec::new();
|
|
758
|
+
let fault = reader.push(&buf[..n], &mut events).err();
|
|
759
|
+
for event in events {
|
|
760
|
+
match event {
|
|
761
|
+
FrameEvent::Text(text) => {
|
|
762
|
+
#[cfg(test)]
|
|
763
|
+
tests::maybe_panic(from);
|
|
764
|
+
if write_frame(shared, to, 1, text.into_bytes(), Kind::Data).is_err() {
|
|
765
|
+
terminate(
|
|
766
|
+
shared,
|
|
767
|
+
CloseAction::Frame(1011, String::new()),
|
|
768
|
+
CloseAction::Frame(1001, String::new()),
|
|
769
|
+
);
|
|
770
|
+
return;
|
|
771
|
+
}
|
|
772
|
+
}
|
|
773
|
+
FrameEvent::Binary(_) => {
|
|
774
|
+
let reason = "binary messages are not relayed".to_owned();
|
|
775
|
+
terminate(
|
|
776
|
+
shared,
|
|
777
|
+
CloseAction::Frame(1003, reason),
|
|
778
|
+
CloseAction::Frame(1003, String::new()),
|
|
779
|
+
);
|
|
780
|
+
return;
|
|
781
|
+
}
|
|
782
|
+
FrameEvent::Ping(payload) => {
|
|
783
|
+
if write_frame(shared, from, 10, payload, Kind::Control).is_err() {
|
|
784
|
+
terminate(shared, CloseAction::Cut, CloseAction::Cut);
|
|
785
|
+
return;
|
|
786
|
+
}
|
|
787
|
+
}
|
|
788
|
+
FrameEvent::Pong(_) => {}
|
|
789
|
+
FrameEvent::Close(code, reason) => {
|
|
790
|
+
match from {
|
|
791
|
+
// Codex closed: echo it to Codex and relay it to the Home (no status: an empty close).
|
|
792
|
+
Leg::Codex => {
|
|
793
|
+
let echo = match code {
|
|
794
|
+
Some(c) => CloseAction::Frame(c, String::new()),
|
|
795
|
+
None => CloseAction::Empty,
|
|
796
|
+
};
|
|
797
|
+
let to_home = match code {
|
|
798
|
+
Some(c) => CloseAction::Frame(relay_code(Some(c)), reason),
|
|
799
|
+
None => CloseAction::Empty,
|
|
800
|
+
};
|
|
801
|
+
terminate(shared, echo, to_home);
|
|
802
|
+
}
|
|
803
|
+
// The Home closed: echo it to the Home and relay it to Codex.
|
|
804
|
+
Leg::Home => {
|
|
805
|
+
let echo = match code {
|
|
806
|
+
Some(c) => CloseAction::Frame(c, String::new()),
|
|
807
|
+
None => CloseAction::Empty,
|
|
808
|
+
};
|
|
809
|
+
terminate(shared, CloseAction::Frame(relay_code(code), reason), echo);
|
|
810
|
+
}
|
|
811
|
+
}
|
|
812
|
+
return;
|
|
813
|
+
}
|
|
814
|
+
}
|
|
815
|
+
}
|
|
816
|
+
if let Some(fault) = fault {
|
|
817
|
+
let code = fault.close_code();
|
|
818
|
+
match from {
|
|
819
|
+
Leg::Codex => terminate(
|
|
820
|
+
shared,
|
|
821
|
+
CloseAction::Frame(code, String::new()),
|
|
822
|
+
CloseAction::Frame(1011, String::new()),
|
|
823
|
+
),
|
|
824
|
+
Leg::Home => terminate(
|
|
825
|
+
shared,
|
|
826
|
+
CloseAction::Frame(1011, "home message refused".into()),
|
|
827
|
+
CloseAction::Frame(code, String::new()),
|
|
828
|
+
),
|
|
829
|
+
}
|
|
830
|
+
return;
|
|
831
|
+
}
|
|
832
|
+
}
|
|
833
|
+
}
|
|
834
|
+
|
|
835
|
+
// ---------------------------------------------------------------------------------------------
|
|
836
|
+
// The upgrade.
|
|
837
|
+
|
|
838
|
+
/// Why an attempt fell back; kept for tests, never logged.
|
|
839
|
+
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
840
|
+
pub enum Fallback {
|
|
841
|
+
Origin,
|
|
842
|
+
Handshake,
|
|
843
|
+
Cap,
|
|
844
|
+
Unavailable,
|
|
845
|
+
Preflight,
|
|
846
|
+
NotAdvertised,
|
|
847
|
+
HomeRefused,
|
|
848
|
+
Stopping,
|
|
849
|
+
}
|
|
850
|
+
|
|
851
|
+
/// Serve one upgrade relay.rs decided to try. `codex_reader` is the worker's reader: bytes it already
|
|
852
|
+
/// buffered after Codex's head are read before anything else.
|
|
853
|
+
pub(crate) fn serve(
|
|
854
|
+
codex_reader: &mut BufReader<DeadlineStream>,
|
|
855
|
+
codex_writer: &mut TcpStream,
|
|
856
|
+
req: &HttpRequestHead,
|
|
857
|
+
tunnel_port: u16,
|
|
858
|
+
creds: RelayCredentials,
|
|
859
|
+
) -> std::io::Result<()> {
|
|
860
|
+
match open(codex_reader, codex_writer, req, tunnel_port, creds, LIMITS) {
|
|
861
|
+
Ok(()) => Ok(()),
|
|
862
|
+
Err(_) => write_upgrade_required(codex_writer),
|
|
863
|
+
}
|
|
864
|
+
}
|
|
865
|
+
|
|
866
|
+
fn open(
|
|
867
|
+
codex_reader: &mut BufReader<DeadlineStream>,
|
|
868
|
+
codex_writer: &mut TcpStream,
|
|
869
|
+
req: &HttpRequestHead,
|
|
870
|
+
tunnel_port: u16,
|
|
871
|
+
creds: RelayCredentials,
|
|
872
|
+
l: Limits,
|
|
873
|
+
) -> Result<(), Fallback> {
|
|
874
|
+
if !header_values(&req.headers, "origin").is_empty() {
|
|
875
|
+
return Err(Fallback::Origin);
|
|
876
|
+
}
|
|
877
|
+
let codex_key = codex_handshake_key(req).ok_or(Fallback::Handshake)?;
|
|
878
|
+
let forwarded = forward_upgrade_headers(&req.headers).ok_or(Fallback::Handshake)?;
|
|
879
|
+
let token_ok = std::str::from_utf8(creds.raw_token.as_slice()).is_ok();
|
|
880
|
+
if !token_ok {
|
|
881
|
+
return Err(Fallback::Unavailable);
|
|
882
|
+
}
|
|
883
|
+
let (mut slot, cancel) = admit(&l).ok_or(Fallback::Cap)?;
|
|
884
|
+
if !ensure_reaper() {
|
|
885
|
+
return Err(Fallback::Unavailable);
|
|
886
|
+
}
|
|
887
|
+
let deadline = Instant::now() + l.setup;
|
|
888
|
+
let limits_for_setup = RequestLimits {
|
|
889
|
+
deadline: Some(deadline),
|
|
890
|
+
cancel: Some(&cancel),
|
|
891
|
+
};
|
|
892
|
+
let mut upstream = open_link_ws_upstream(tunnel_port, &creds, limits_for_setup)
|
|
893
|
+
.map_err(|_| Fallback::Preflight)?;
|
|
894
|
+
if !upstream.link_ws_on {
|
|
895
|
+
return Err(Fallback::NotAdvertised);
|
|
896
|
+
}
|
|
897
|
+
let mut key_bytes = [0u8; 16];
|
|
898
|
+
fill_random_bytes(&mut key_bytes).map_err(|_| Fallback::Unavailable)?;
|
|
899
|
+
let home_key = BASE64.encode(key_bytes);
|
|
900
|
+
let before = format!(
|
|
901
|
+
"GET /v1/responses HTTP/1.1\r\nHost: 127.0.0.1:{tunnel_port}\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: {home_key}\r\n{LINK_RELAY_SESSION_HEADER}: {}\r\n",
|
|
902
|
+
upstream.nonce
|
|
903
|
+
);
|
|
904
|
+
let mut after = String::new();
|
|
905
|
+
for (k, v) in &forwarded {
|
|
906
|
+
after.push_str(&format!("{k}: {v}\r\n"));
|
|
907
|
+
}
|
|
908
|
+
after.push_str("\r\n");
|
|
909
|
+
let head = token_request_head(
|
|
910
|
+
&before,
|
|
911
|
+
RelayAuthKind::Bearer,
|
|
912
|
+
creds.raw_token.as_slice(),
|
|
913
|
+
&after,
|
|
914
|
+
);
|
|
915
|
+
// Each write call gets only the time left before the setup deadline.
|
|
916
|
+
write_all_before(
|
|
917
|
+
&mut upstream.writer,
|
|
918
|
+
head.as_slice(),
|
|
919
|
+
deadline,
|
|
920
|
+
l.setup,
|
|
921
|
+
&Instant::now,
|
|
922
|
+
)
|
|
923
|
+
.map_err(|_| Fallback::Preflight)?;
|
|
924
|
+
drop(head);
|
|
925
|
+
let resp = read_response_head(&mut upstream.reader).map_err(|_| Fallback::HomeRefused)?;
|
|
926
|
+
if !valid_home_upgrade(&resp, &home_key) {
|
|
927
|
+
return Err(Fallback::HomeRefused);
|
|
928
|
+
}
|
|
929
|
+
let home_buffered = upstream.reader.buffer().to_vec();
|
|
930
|
+
let home = upstream.writer;
|
|
931
|
+
// Registration: refused once a stop began; the setup slot becomes this socket's lease.
|
|
932
|
+
let (codex_clone, home_clone) = match (codex_writer.try_clone(), home.try_clone()) {
|
|
933
|
+
(Ok(a), Ok(b)) => (a, b),
|
|
934
|
+
_ => return Err(Fallback::Unavailable),
|
|
935
|
+
};
|
|
936
|
+
let shared = {
|
|
937
|
+
let (m, _) = registry();
|
|
938
|
+
let mut r = lock(m);
|
|
939
|
+
if r.stopping {
|
|
940
|
+
let _ = home.shutdown(Shutdown::Both);
|
|
941
|
+
return Err(Fallback::Stopping);
|
|
942
|
+
}
|
|
943
|
+
r.setting_up -= 1;
|
|
944
|
+
r.open += 1;
|
|
945
|
+
r.setups.remove(&slot.id);
|
|
946
|
+
slot.converted = true;
|
|
947
|
+
let shared = Arc::new(SocketShared {
|
|
948
|
+
codex: codex_clone,
|
|
949
|
+
home: home_clone,
|
|
950
|
+
closing: AtomicBool::new(false),
|
|
951
|
+
upgraded: AtomicBool::new(false),
|
|
952
|
+
codex_write: Mutex::new(()),
|
|
953
|
+
home_write: Mutex::new(()),
|
|
954
|
+
state: Mutex::new(SockState {
|
|
955
|
+
lifecycle: Lifecycle::Registered,
|
|
956
|
+
terminal_started: false,
|
|
957
|
+
close_io: 0,
|
|
958
|
+
cleanup_done: false,
|
|
959
|
+
close_token: None,
|
|
960
|
+
spawned_done: false,
|
|
961
|
+
}),
|
|
962
|
+
cv: Condvar::new(),
|
|
963
|
+
limits: l,
|
|
964
|
+
_lease: Lease {
|
|
965
|
+
id: slot.id,
|
|
966
|
+
reservation: slot.reservation,
|
|
967
|
+
},
|
|
968
|
+
});
|
|
969
|
+
r.sockets.insert(slot.id, Arc::clone(&shared));
|
|
970
|
+
shared
|
|
971
|
+
};
|
|
972
|
+
// A panic from here on still unregisters the socket and frees its slot (every normal return calls finish).
|
|
973
|
+
let _unwind = UnwindCleanup(Arc::clone(&shared));
|
|
974
|
+
// Open-socket timeouts: no read timeout, 300 s of no write progress.
|
|
975
|
+
for s in [&shared.codex, &shared.home] {
|
|
976
|
+
let _ = s.set_read_timeout(None);
|
|
977
|
+
let _ = s.set_write_timeout(Some(l.stall));
|
|
978
|
+
}
|
|
979
|
+
// The Home reader thread, created before the local 101; it waits for the start step.
|
|
980
|
+
let home_reader = match home.try_clone() {
|
|
981
|
+
Ok(h) => h,
|
|
982
|
+
Err(_) => {
|
|
983
|
+
terminate(&shared, CloseAction::Leave, CloseAction::Cut);
|
|
984
|
+
finish(&shared, None);
|
|
985
|
+
return Err(Fallback::Unavailable);
|
|
986
|
+
}
|
|
987
|
+
};
|
|
988
|
+
let spawned_shared = Arc::clone(&shared);
|
|
989
|
+
#[cfg(test)]
|
|
990
|
+
let fail_spawn = tests::FAIL_SPAWN.swap(false, Ordering::SeqCst);
|
|
991
|
+
#[cfg(not(test))]
|
|
992
|
+
let fail_spawn = false;
|
|
993
|
+
let spawned = if fail_spawn {
|
|
994
|
+
Err(std::io::Error::other("spawn refused by test"))
|
|
995
|
+
} else {
|
|
996
|
+
thread::Builder::new()
|
|
997
|
+
.name("ocx-link-ws-home".into())
|
|
998
|
+
.stack_size(SPAWNED_STACK)
|
|
999
|
+
.spawn(move || {
|
|
1000
|
+
let shared = spawned_shared;
|
|
1001
|
+
// Sets spawned_done however this thread ends, so the worker's finish never waits forever.
|
|
1002
|
+
let _done = SpawnedDone(Arc::clone(&shared));
|
|
1003
|
+
let started = {
|
|
1004
|
+
let mut st = lock(&shared.state);
|
|
1005
|
+
while st.lifecycle == Lifecycle::Registered {
|
|
1006
|
+
st = shared.cv.wait(st).unwrap_or_else(|e| e.into_inner());
|
|
1007
|
+
}
|
|
1008
|
+
st.lifecycle == Lifecycle::Started
|
|
1009
|
+
};
|
|
1010
|
+
if started {
|
|
1011
|
+
pump(
|
|
1012
|
+
&shared,
|
|
1013
|
+
Leg::Home,
|
|
1014
|
+
Cursor::new(home_buffered).chain(home_reader),
|
|
1015
|
+
);
|
|
1016
|
+
}
|
|
1017
|
+
})
|
|
1018
|
+
};
|
|
1019
|
+
let handle = match spawned {
|
|
1020
|
+
Ok(h) => h,
|
|
1021
|
+
Err(_) => {
|
|
1022
|
+
terminate(&shared, CloseAction::Leave, CloseAction::Cut);
|
|
1023
|
+
finish(&shared, None);
|
|
1024
|
+
return Err(Fallback::Unavailable);
|
|
1025
|
+
}
|
|
1026
|
+
};
|
|
1027
|
+
// The local 101, with the message limit Codex reads (x-codex-websocket-max-message-bytes).
|
|
1028
|
+
let accept = websocket_accept(&codex_key);
|
|
1029
|
+
let reply = format!(
|
|
1030
|
+
"HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: {accept}\r\n{MAX_MESSAGE_HEADER}: {}\r\n\r\n",
|
|
1031
|
+
l.local_message
|
|
1032
|
+
);
|
|
1033
|
+
#[cfg(test)]
|
|
1034
|
+
let fail_101 = tests::FAIL_101.swap(false, Ordering::SeqCst);
|
|
1035
|
+
#[cfg(not(test))]
|
|
1036
|
+
let fail_101 = false;
|
|
1037
|
+
#[cfg(test)]
|
|
1038
|
+
tests::before_101();
|
|
1039
|
+
match write_101(&shared, reply.as_bytes(), fail_101) {
|
|
1040
|
+
Ok(true) => {}
|
|
1041
|
+
Ok(false) => {
|
|
1042
|
+
// A stop claimed this socket first: no 101, today's 426 from the caller.
|
|
1043
|
+
finish(&shared, Some(handle));
|
|
1044
|
+
return Err(Fallback::Stopping);
|
|
1045
|
+
}
|
|
1046
|
+
Err(_) => {
|
|
1047
|
+
terminate(&shared, CloseAction::Cut, CloseAction::Cut);
|
|
1048
|
+
finish(&shared, Some(handle));
|
|
1049
|
+
return Ok(());
|
|
1050
|
+
}
|
|
1051
|
+
}
|
|
1052
|
+
test_barrier("link-ws-before-start");
|
|
1053
|
+
#[cfg(test)]
|
|
1054
|
+
tests::before_start();
|
|
1055
|
+
// The start step: registry lock, then the socket's state lock.
|
|
1056
|
+
let started = {
|
|
1057
|
+
let (m, _) = registry();
|
|
1058
|
+
let r = lock(m);
|
|
1059
|
+
let mut st = lock(&shared.state);
|
|
1060
|
+
if !r.stopping && st.lifecycle == Lifecycle::Registered {
|
|
1061
|
+
st.lifecycle = Lifecycle::Started;
|
|
1062
|
+
shared.cv.notify_all();
|
|
1063
|
+
true
|
|
1064
|
+
} else {
|
|
1065
|
+
false
|
|
1066
|
+
}
|
|
1067
|
+
};
|
|
1068
|
+
if !started {
|
|
1069
|
+
terminate(
|
|
1070
|
+
&shared,
|
|
1071
|
+
CloseAction::Frame(1001, "link websocket stopping".into()),
|
|
1072
|
+
CloseAction::Frame(1001, String::new()),
|
|
1073
|
+
);
|
|
1074
|
+
finish(&shared, Some(handle));
|
|
1075
|
+
return Ok(());
|
|
1076
|
+
}
|
|
1077
|
+
// The worker reads Codex; the bytes its reader already buffered come first.
|
|
1078
|
+
let _ = codex_reader.get_ref().get_ref().set_read_timeout(None);
|
|
1079
|
+
pump(&shared, Leg::Codex, &mut *codex_reader);
|
|
1080
|
+
finish(&shared, Some(handle));
|
|
1081
|
+
Ok(())
|
|
1082
|
+
}
|
|
1083
|
+
|
|
1084
|
+
/// Runs the worker's cleanup if the worker unwinds after registration (a panic): both connections end, the
|
|
1085
|
+
/// socket is unregistered, and its slot is freed once the spawned thread, which then reads EOF, has ended.
|
|
1086
|
+
struct UnwindCleanup(Arc<SocketShared>);
|
|
1087
|
+
|
|
1088
|
+
impl Drop for UnwindCleanup {
|
|
1089
|
+
fn drop(&mut self) {
|
|
1090
|
+
if thread::panicking() {
|
|
1091
|
+
finish(&self.0, None);
|
|
1092
|
+
}
|
|
1093
|
+
}
|
|
1094
|
+
}
|
|
1095
|
+
|
|
1096
|
+
/// The spawned Home reader's exit: on a panic both connections end first; spawned_done is always set.
|
|
1097
|
+
struct SpawnedDone(Arc<SocketShared>);
|
|
1098
|
+
|
|
1099
|
+
impl Drop for SpawnedDone {
|
|
1100
|
+
fn drop(&mut self) {
|
|
1101
|
+
if thread::panicking() {
|
|
1102
|
+
terminate(&self.0, CloseAction::Cut, CloseAction::Cut);
|
|
1103
|
+
}
|
|
1104
|
+
let mut st = lock(&self.0.state);
|
|
1105
|
+
st.spawned_done = true;
|
|
1106
|
+
self.0.cv.notify_all();
|
|
1107
|
+
}
|
|
1108
|
+
}
|
|
1109
|
+
|
|
1110
|
+
/// The worker's cleanup: the terminal transition (idempotent), wait for the spawned thread (the reaper's
|
|
1111
|
+
/// close deadline guarantees it ends), join it, then mark cleanup done so the close entry can retire.
|
|
1112
|
+
fn finish(shared: &Arc<SocketShared>, handle: Option<thread::JoinHandle<()>>) {
|
|
1113
|
+
terminate(shared, CloseAction::Cut, CloseAction::Cut);
|
|
1114
|
+
if handle.is_some() {
|
|
1115
|
+
let mut st = lock(&shared.state);
|
|
1116
|
+
while !st.spawned_done {
|
|
1117
|
+
st = shared.cv.wait(st).unwrap_or_else(|e| e.into_inner());
|
|
1118
|
+
}
|
|
1119
|
+
}
|
|
1120
|
+
if let Some(h) = handle {
|
|
1121
|
+
let _ = h.join();
|
|
1122
|
+
}
|
|
1123
|
+
{
|
|
1124
|
+
let mut st = lock(&shared.state);
|
|
1125
|
+
st.cleanup_done = true;
|
|
1126
|
+
retire_if_done(&mut st);
|
|
1127
|
+
}
|
|
1128
|
+
// Unregister: the registry's reference goes, so the lease drops with the last owner (a reaper close
|
|
1129
|
+
// entry still running keeps it until it fires).
|
|
1130
|
+
let (m, _) = registry();
|
|
1131
|
+
lock(m).sockets.remove(&shared._lease.id);
|
|
1132
|
+
}
|
|
1133
|
+
|
|
1134
|
+
#[cfg(feature = "link-ws-test-gate")]
|
|
1135
|
+
fn test_barrier(name: &str) {
|
|
1136
|
+
crate::test_hooks::barrier(name);
|
|
1137
|
+
}
|
|
1138
|
+
|
|
1139
|
+
#[cfg(not(feature = "link-ws-test-gate"))]
|
|
1140
|
+
fn test_barrier(_name: &str) {}
|
|
1141
|
+
|
|
1142
|
+
/// Serve shutdown: abort setups, close every socket (1001, best effort), wait until every slot is free,
|
|
1143
|
+
/// then stop the reaper. Bounded by the close deadline: the reaper shuts down whatever is still open.
|
|
1144
|
+
pub fn stop_all() {
|
|
1145
|
+
let (sockets, setups) = {
|
|
1146
|
+
let (m, _) = registry();
|
|
1147
|
+
let mut r = lock(m);
|
|
1148
|
+
r.stopping = true;
|
|
1149
|
+
(
|
|
1150
|
+
r.sockets.values().cloned().collect::<Vec<_>>(),
|
|
1151
|
+
r.setups.values().cloned().collect::<Vec<_>>(),
|
|
1152
|
+
)
|
|
1153
|
+
};
|
|
1154
|
+
for setup in &setups {
|
|
1155
|
+
setup.cancel();
|
|
1156
|
+
}
|
|
1157
|
+
// Every close deadline starts before any close frame is attempted, and is at most STOP_CLOSE_BOUND: a
|
|
1158
|
+
// peer that does not read cannot hold the stop past detach's wait.
|
|
1159
|
+
let mut claimed = Vec::new();
|
|
1160
|
+
for shared in &sockets {
|
|
1161
|
+
let mut st = lock(&shared.state);
|
|
1162
|
+
if st.lifecycle == Lifecycle::Registered {
|
|
1163
|
+
st.lifecycle = Lifecycle::Aborted;
|
|
1164
|
+
shared.cv.notify_all();
|
|
1165
|
+
}
|
|
1166
|
+
if !st.terminal_started {
|
|
1167
|
+
st.terminal_started = true;
|
|
1168
|
+
shared.closing.store(true, Ordering::SeqCst);
|
|
1169
|
+
st.close_token = Some(register_deadline(
|
|
1170
|
+
Instant::now() + shared.limits.close_bound.min(STOP_CLOSE_BOUND),
|
|
1171
|
+
shared,
|
|
1172
|
+
));
|
|
1173
|
+
st.close_io += 1;
|
|
1174
|
+
claimed.push(Arc::clone(shared));
|
|
1175
|
+
}
|
|
1176
|
+
}
|
|
1177
|
+
drop(sockets);
|
|
1178
|
+
for shared in &claimed {
|
|
1179
|
+
let _ = write_frame(
|
|
1180
|
+
shared,
|
|
1181
|
+
Leg::Codex,
|
|
1182
|
+
8,
|
|
1183
|
+
close_payload(Some(1001), "link websocket stopping"),
|
|
1184
|
+
Kind::Close,
|
|
1185
|
+
);
|
|
1186
|
+
let _ = write_frame(
|
|
1187
|
+
shared,
|
|
1188
|
+
Leg::Home,
|
|
1189
|
+
8,
|
|
1190
|
+
close_payload(Some(1001), ""),
|
|
1191
|
+
Kind::Close,
|
|
1192
|
+
);
|
|
1193
|
+
let mut st = lock(&shared.state);
|
|
1194
|
+
st.close_io -= 1;
|
|
1195
|
+
retire_if_done(&mut st);
|
|
1196
|
+
}
|
|
1197
|
+
drop(claimed);
|
|
1198
|
+
// Fire whatever is left so no blocked writer outlives the stop, then wait for every slot.
|
|
1199
|
+
let started = lock(&reaper().inner).started;
|
|
1200
|
+
if started {
|
|
1201
|
+
let (m, cv) = registry();
|
|
1202
|
+
let mut r = lock(m);
|
|
1203
|
+
loop {
|
|
1204
|
+
if r.open == 0 && r.setting_up == 0 {
|
|
1205
|
+
break;
|
|
1206
|
+
}
|
|
1207
|
+
drop(r);
|
|
1208
|
+
reaper_drain();
|
|
1209
|
+
r = lock(m);
|
|
1210
|
+
if r.open == 0 && r.setting_up == 0 {
|
|
1211
|
+
break;
|
|
1212
|
+
}
|
|
1213
|
+
let (g, _) = cv
|
|
1214
|
+
.wait_timeout(r, Duration::from_millis(50))
|
|
1215
|
+
.unwrap_or_else(|e| e.into_inner());
|
|
1216
|
+
r = g;
|
|
1217
|
+
}
|
|
1218
|
+
drop(r);
|
|
1219
|
+
reaper_exit_and_join();
|
|
1220
|
+
}
|
|
1221
|
+
}
|
|
1222
|
+
|
|
1223
|
+
#[cfg(test)]
|
|
1224
|
+
mod tests {
|
|
1225
|
+
use super::*;
|
|
1226
|
+
|
|
1227
|
+
#[test]
|
|
1228
|
+
fn sha1_and_accept_follow_rfc_6455() {
|
|
1229
|
+
assert_eq!(
|
|
1230
|
+
websocket_accept("dGhlIHNhbXBsZSBub25jZQ=="),
|
|
1231
|
+
"s3pPLMBiTxaQ9kYGzzhZRbK+xOo="
|
|
1232
|
+
);
|
|
1233
|
+
let empty = sha1(b"");
|
|
1234
|
+
assert_eq!(
|
|
1235
|
+
crate::platform::hex_encode(&empty),
|
|
1236
|
+
"da39a3ee5e6b4b0d3255bfef95601890afd80709"
|
|
1237
|
+
);
|
|
1238
|
+
let abc = sha1(b"abc");
|
|
1239
|
+
assert_eq!(
|
|
1240
|
+
crate::platform::hex_encode(&abc),
|
|
1241
|
+
"a9993e364706816aba3e25717850c26c9cd0d89d"
|
|
1242
|
+
);
|
|
1243
|
+
let long = sha1(&vec![b'a'; 1_000_000]);
|
|
1244
|
+
assert_eq!(
|
|
1245
|
+
crate::platform::hex_encode(&long),
|
|
1246
|
+
"34aa973cd4c4daa4f61eeb2bdbad27316534016f"
|
|
1247
|
+
);
|
|
1248
|
+
}
|
|
1249
|
+
|
|
1250
|
+
fn req(headers: &[(&str, &str)]) -> HttpRequestHead {
|
|
1251
|
+
HttpRequestHead {
|
|
1252
|
+
method: "GET".into(),
|
|
1253
|
+
target: "/v1/responses".into(),
|
|
1254
|
+
path: "/v1/responses".into(),
|
|
1255
|
+
query: String::new(),
|
|
1256
|
+
headers: headers
|
|
1257
|
+
.iter()
|
|
1258
|
+
.map(|(k, v)| (k.to_string(), v.to_string()))
|
|
1259
|
+
.collect(),
|
|
1260
|
+
}
|
|
1261
|
+
}
|
|
1262
|
+
|
|
1263
|
+
const KEY: &str = "dGhlIHNhbXBsZSBub25jZQ==";
|
|
1264
|
+
|
|
1265
|
+
#[test]
|
|
1266
|
+
fn codex_handshake_validation() {
|
|
1267
|
+
let good = req(&[
|
|
1268
|
+
("Host", "127.0.0.1"),
|
|
1269
|
+
("Upgrade", "websocket"),
|
|
1270
|
+
("Connection", "keep-alive, Upgrade"),
|
|
1271
|
+
("Sec-WebSocket-Version", "13"),
|
|
1272
|
+
("Sec-WebSocket-Key", KEY),
|
|
1273
|
+
]);
|
|
1274
|
+
assert_eq!(codex_handshake_key(&good).as_deref(), Some(KEY));
|
|
1275
|
+
let mut q = good.clone();
|
|
1276
|
+
q.query = "a=1".into();
|
|
1277
|
+
assert!(codex_handshake_key(&q).is_none());
|
|
1278
|
+
for drop in [
|
|
1279
|
+
"Upgrade",
|
|
1280
|
+
"Connection",
|
|
1281
|
+
"Sec-WebSocket-Version",
|
|
1282
|
+
"Sec-WebSocket-Key",
|
|
1283
|
+
] {
|
|
1284
|
+
let mut r = good.clone();
|
|
1285
|
+
r.headers.retain(|(k, _)| k != drop);
|
|
1286
|
+
assert!(codex_handshake_key(&r).is_none(), "{drop}");
|
|
1287
|
+
}
|
|
1288
|
+
let mut dup = good.clone();
|
|
1289
|
+
dup.headers.push(("Sec-WebSocket-Key".into(), KEY.into()));
|
|
1290
|
+
assert!(codex_handshake_key(&dup).is_none());
|
|
1291
|
+
let mut body = good.clone();
|
|
1292
|
+
body.headers.push(("Content-Length".into(), "0".into()));
|
|
1293
|
+
assert!(codex_handshake_key(&body).is_none());
|
|
1294
|
+
let mut short = good.clone();
|
|
1295
|
+
short.headers.retain(|(k, _)| k != "Sec-WebSocket-Key");
|
|
1296
|
+
short
|
|
1297
|
+
.headers
|
|
1298
|
+
.push(("Sec-WebSocket-Key".into(), "c2hvcnQ=".into()));
|
|
1299
|
+
assert!(codex_handshake_key(&short).is_none());
|
|
1300
|
+
}
|
|
1301
|
+
|
|
1302
|
+
#[test]
|
|
1303
|
+
fn forwarded_headers_drop_handshake_credentials_and_nominated() {
|
|
1304
|
+
let headers: Vec<(String, String)> = [
|
|
1305
|
+
("Host", "127.0.0.1:10100"),
|
|
1306
|
+
("Upgrade", "websocket"),
|
|
1307
|
+
("Connection", "Upgrade, x-private"),
|
|
1308
|
+
("x-private", "1"),
|
|
1309
|
+
("Sec-WebSocket-Key", KEY),
|
|
1310
|
+
("Sec-WebSocket-Version", "13"),
|
|
1311
|
+
("Sec-WebSocket-Extensions", "permessage-deflate"),
|
|
1312
|
+
("Origin", "http://127.0.0.1"),
|
|
1313
|
+
("Authorization", "Bearer codex"),
|
|
1314
|
+
("x-api-key", "k"),
|
|
1315
|
+
("Cookie", "c"),
|
|
1316
|
+
("x-opencodex-link-session", "n"),
|
|
1317
|
+
("x-opencodex-link-turn", "t"),
|
|
1318
|
+
("thread-id", "thread-1"),
|
|
1319
|
+
("Keep-Alive", "5"),
|
|
1320
|
+
("Accept-Encoding", "gzip"),
|
|
1321
|
+
("OpenAI-Beta", "responses_websockets=2026"),
|
|
1322
|
+
]
|
|
1323
|
+
.iter()
|
|
1324
|
+
.map(|(k, v)| (k.to_string(), v.to_string()))
|
|
1325
|
+
.collect();
|
|
1326
|
+
let out = forward_upgrade_headers(&headers).unwrap();
|
|
1327
|
+
let names: Vec<&str> = out.iter().map(|(k, _)| k.as_str()).collect();
|
|
1328
|
+
assert_eq!(names, vec!["thread-id", "OpenAI-Beta"]);
|
|
1329
|
+
let mut dup_host = headers.clone();
|
|
1330
|
+
dup_host.push(("Host".into(), "x".into()));
|
|
1331
|
+
assert!(forward_upgrade_headers(&dup_host).is_none());
|
|
1332
|
+
assert!(forward_upgrade_headers(&[("x".into(), "a\r\nb".into())]).is_none());
|
|
1333
|
+
}
|
|
1334
|
+
|
|
1335
|
+
#[test]
|
|
1336
|
+
fn home_101_validation() {
|
|
1337
|
+
let ok = |extra: &[(&str, &str)], omit: &str| {
|
|
1338
|
+
let mut headers: Vec<(String, String)> = vec![
|
|
1339
|
+
("Upgrade".into(), "websocket".into()),
|
|
1340
|
+
("Connection".into(), "Upgrade".into()),
|
|
1341
|
+
("Sec-WebSocket-Accept".into(), websocket_accept(KEY)),
|
|
1342
|
+
];
|
|
1343
|
+
headers.retain(|(k, _)| k != omit);
|
|
1344
|
+
headers.extend(extra.iter().map(|(k, v)| (k.to_string(), v.to_string())));
|
|
1345
|
+
valid_home_upgrade(
|
|
1346
|
+
&HttpResponseHead {
|
|
1347
|
+
status: 101,
|
|
1348
|
+
reason: "Switching Protocols".into(),
|
|
1349
|
+
headers,
|
|
1350
|
+
},
|
|
1351
|
+
KEY,
|
|
1352
|
+
)
|
|
1353
|
+
};
|
|
1354
|
+
assert!(ok(&[], ""));
|
|
1355
|
+
assert!(!ok(&[], "Upgrade"));
|
|
1356
|
+
assert!(!ok(&[], "Connection"));
|
|
1357
|
+
assert!(!ok(&[], "Sec-WebSocket-Accept"));
|
|
1358
|
+
assert!(!ok(
|
|
1359
|
+
&[("Sec-WebSocket-Extensions", "permessage-deflate")],
|
|
1360
|
+
""
|
|
1361
|
+
));
|
|
1362
|
+
assert!(!ok(&[("Sec-WebSocket-Protocol", "x")], ""));
|
|
1363
|
+
let wrong = HttpResponseHead {
|
|
1364
|
+
status: 101,
|
|
1365
|
+
reason: String::new(),
|
|
1366
|
+
headers: vec![
|
|
1367
|
+
("Upgrade".into(), "websocket".into()),
|
|
1368
|
+
("Connection".into(), "Upgrade".into()),
|
|
1369
|
+
("Sec-WebSocket-Accept".into(), websocket_accept("other")),
|
|
1370
|
+
],
|
|
1371
|
+
};
|
|
1372
|
+
assert!(!valid_home_upgrade(&wrong, KEY));
|
|
1373
|
+
let plain = HttpResponseHead {
|
|
1374
|
+
status: 200,
|
|
1375
|
+
reason: String::new(),
|
|
1376
|
+
headers: vec![],
|
|
1377
|
+
};
|
|
1378
|
+
assert!(!valid_home_upgrade(&plain, KEY));
|
|
1379
|
+
}
|
|
1380
|
+
|
|
1381
|
+
#[test]
|
|
1382
|
+
fn relayed_close_codes() {
|
|
1383
|
+
assert_eq!(relay_code(Some(4401)), 4401);
|
|
1384
|
+
assert_eq!(relay_code(Some(1012)), 1012);
|
|
1385
|
+
assert_eq!(relay_code(None), 1011);
|
|
1386
|
+
assert_eq!(relay_code(Some(1006)), 1011);
|
|
1387
|
+
}
|
|
1388
|
+
|
|
1389
|
+
/// A Home that takes one byte per write call while time passes.
|
|
1390
|
+
struct Trickle {
|
|
1391
|
+
clock: std::rc::Rc<std::cell::Cell<u64>>,
|
|
1392
|
+
timeouts: Vec<Duration>,
|
|
1393
|
+
written: usize,
|
|
1394
|
+
}
|
|
1395
|
+
|
|
1396
|
+
impl Write for Trickle {
|
|
1397
|
+
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
|
|
1398
|
+
self.clock.set(self.clock.get() + 1);
|
|
1399
|
+
self.written += 1;
|
|
1400
|
+
Ok(buf.len().min(1))
|
|
1401
|
+
}
|
|
1402
|
+
fn flush(&mut self) -> std::io::Result<()> {
|
|
1403
|
+
Ok(())
|
|
1404
|
+
}
|
|
1405
|
+
}
|
|
1406
|
+
|
|
1407
|
+
impl crate::relay::TimedWrite for Trickle {
|
|
1408
|
+
fn set_write_timeout_left(&mut self, left: Duration) -> std::io::Result<()> {
|
|
1409
|
+
self.timeouts.push(left);
|
|
1410
|
+
Ok(())
|
|
1411
|
+
}
|
|
1412
|
+
}
|
|
1413
|
+
|
|
1414
|
+
#[test]
|
|
1415
|
+
fn a_setup_write_ends_at_the_absolute_deadline_however_the_home_drains() {
|
|
1416
|
+
let base = Instant::now();
|
|
1417
|
+
let clock = std::rc::Rc::new(std::cell::Cell::new(0u64));
|
|
1418
|
+
let mut home = Trickle {
|
|
1419
|
+
clock: std::rc::Rc::clone(&clock),
|
|
1420
|
+
timeouts: Vec::new(),
|
|
1421
|
+
written: 0,
|
|
1422
|
+
};
|
|
1423
|
+
let now = || base + Duration::from_secs(clock.get());
|
|
1424
|
+
let err = crate::relay::write_all_before(
|
|
1425
|
+
&mut home,
|
|
1426
|
+
&[b'h'; 20],
|
|
1427
|
+
base + Duration::from_secs(8),
|
|
1428
|
+
Duration::from_secs(30),
|
|
1429
|
+
&now,
|
|
1430
|
+
)
|
|
1431
|
+
.unwrap_err();
|
|
1432
|
+
assert_eq!(err.kind(), std::io::ErrorKind::TimedOut);
|
|
1433
|
+
assert_eq!(home.written, 8, "no write starts after the deadline");
|
|
1434
|
+
let expected: Vec<Duration> = (1..=8).rev().map(Duration::from_secs).collect();
|
|
1435
|
+
assert_eq!(
|
|
1436
|
+
home.timeouts, expected,
|
|
1437
|
+
"each write gets only the time left"
|
|
1438
|
+
);
|
|
1439
|
+
// The per-call cap still applies when the deadline is far away.
|
|
1440
|
+
clock.set(0);
|
|
1441
|
+
home.timeouts.clear();
|
|
1442
|
+
crate::relay::write_all_before(
|
|
1443
|
+
&mut home,
|
|
1444
|
+
b"ok",
|
|
1445
|
+
base + Duration::from_secs(600),
|
|
1446
|
+
Duration::from_secs(10),
|
|
1447
|
+
&now,
|
|
1448
|
+
)
|
|
1449
|
+
.unwrap();
|
|
1450
|
+
assert_eq!(home.timeouts, vec![Duration::from_secs(10); 2]);
|
|
1451
|
+
}
|
|
1452
|
+
|
|
1453
|
+
// ---- relay tests: a mock Home and a Codex-shaped client on real loopback sockets, in process ----
|
|
1454
|
+
|
|
1455
|
+
use crate::http_wire::read_request_head;
|
|
1456
|
+
use crate::link_ws_advert::ws_state_proof;
|
|
1457
|
+
use crate::platform::SecretBytes;
|
|
1458
|
+
use crate::relay_auth::{compute_relay_proof, token_fingerprint_hex};
|
|
1459
|
+
use std::net::{SocketAddr, TcpListener};
|
|
1460
|
+
use std::sync::mpsc;
|
|
1461
|
+
|
|
1462
|
+
// One lock with the advertisement tests: both update the process-wide advertisement table.
|
|
1463
|
+
use crate::link_ws_advert::TEST_LOCK as SERIAL;
|
|
1464
|
+
pub(super) static FAIL_SPAWN: AtomicBool = AtomicBool::new(false);
|
|
1465
|
+
pub(super) static FAIL_101: AtomicBool = AtomicBool::new(false);
|
|
1466
|
+
static BEFORE_START: Mutex<Option<fn()>> = Mutex::new(None);
|
|
1467
|
+
static BEFORE_101: Mutex<Option<fn()>> = Mutex::new(None);
|
|
1468
|
+
/// Armed by a test: the next claiming terminal caller reports here, then waits for the release.
|
|
1469
|
+
static CLAIM_GATE: Mutex<Option<(mpsc::Sender<()>, mpsc::Receiver<()>)>> = Mutex::new(None);
|
|
1470
|
+
/// Armed by a test: the next data write reports here once it holds its leg's write lock and has passed its
|
|
1471
|
+
/// upgraded and closing checks, just before its bytes are written.
|
|
1472
|
+
static DATA_LOCKED: Mutex<Option<mpsc::Sender<()>>> = Mutex::new(None);
|
|
1473
|
+
|
|
1474
|
+
pub(super) fn before_start() {
|
|
1475
|
+
let hook = *lock(&BEFORE_START);
|
|
1476
|
+
if let Some(f) = hook {
|
|
1477
|
+
f();
|
|
1478
|
+
}
|
|
1479
|
+
}
|
|
1480
|
+
|
|
1481
|
+
pub(super) fn before_101() {
|
|
1482
|
+
let hook = *lock(&BEFORE_101);
|
|
1483
|
+
if let Some(f) = hook {
|
|
1484
|
+
f();
|
|
1485
|
+
}
|
|
1486
|
+
}
|
|
1487
|
+
|
|
1488
|
+
/// The claim a stop makes on each registered socket (without the reaper drain that follows it in
|
|
1489
|
+
/// stop_all), run on the worker just before its local 101.
|
|
1490
|
+
fn stop_claims_before_the_101() {
|
|
1491
|
+
let (m, _) = registry();
|
|
1492
|
+
lock(m).stopping = true;
|
|
1493
|
+
let shared = only_socket();
|
|
1494
|
+
terminate(
|
|
1495
|
+
&shared,
|
|
1496
|
+
CloseAction::Frame(1001, "link websocket stopping".into()),
|
|
1497
|
+
CloseAction::Frame(1001, String::new()),
|
|
1498
|
+
);
|
|
1499
|
+
}
|
|
1500
|
+
|
|
1501
|
+
#[test]
|
|
1502
|
+
fn a_stop_claim_before_the_local_101_leaves_it_unwritten_and_codex_gets_no_frame() {
|
|
1503
|
+
let _serial = lock(&SERIAL);
|
|
1504
|
+
reset_registry();
|
|
1505
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
1506
|
+
*lock(&BEFORE_101) = Some(stop_claims_before_the_101);
|
|
1507
|
+
let s = session(home_port, test_limits(), "", &[]);
|
|
1508
|
+
*lock(&BEFORE_101) = None;
|
|
1509
|
+
// No frame precedes the 101: with only the claim, Codex's connection is intact and gets the 426.
|
|
1510
|
+
assert_eq!(
|
|
1511
|
+
s.status, 426,
|
|
1512
|
+
"Codex gets an HTTP answer, never a close frame first"
|
|
1513
|
+
);
|
|
1514
|
+
assert_eq!(s.worker.join().unwrap(), Err(Fallback::Stopping));
|
|
1515
|
+
let mut home = homes.recv().unwrap();
|
|
1516
|
+
assert_eq!(
|
|
1517
|
+
read_events(&mut home.stream, Role::FromClient, &home.leftover, 1),
|
|
1518
|
+
vec![FrameEvent::Close(Some(1001), String::new())]
|
|
1519
|
+
);
|
|
1520
|
+
wait_all_released();
|
|
1521
|
+
reset_registry();
|
|
1522
|
+
}
|
|
1523
|
+
|
|
1524
|
+
static REAL_STOP: Mutex<Option<thread::JoinHandle<()>>> = Mutex::new(None);
|
|
1525
|
+
|
|
1526
|
+
/// The real stop_all, from another thread, once it has claimed this socket (before the worker's 101).
|
|
1527
|
+
fn real_stop_before_the_101() {
|
|
1528
|
+
let shared = only_socket();
|
|
1529
|
+
*lock(&REAL_STOP) = Some(thread::spawn(stop_all));
|
|
1530
|
+
let mut st = lock(&shared.state);
|
|
1531
|
+
while st.lifecycle == Lifecycle::Registered {
|
|
1532
|
+
st = shared.cv.wait(st).unwrap_or_else(|e| e.into_inner());
|
|
1533
|
+
}
|
|
1534
|
+
}
|
|
1535
|
+
|
|
1536
|
+
#[test]
|
|
1537
|
+
fn a_real_stop_before_the_local_101_gives_codex_the_426_at_best_and_never_a_frame_or_a_hang() {
|
|
1538
|
+
let _serial = lock(&SERIAL);
|
|
1539
|
+
reset_registry();
|
|
1540
|
+
let (home_port, _homes) = mock_home(HomeMode::Advertise);
|
|
1541
|
+
*lock(&BEFORE_101) = Some(real_stop_before_the_101);
|
|
1542
|
+
let s = session(home_port, test_limits(), "", &[]);
|
|
1543
|
+
*lock(&BEFORE_101) = None;
|
|
1544
|
+
// The stop also shuts Codex's connection down, so the 426 is best effort: an HTTP 426 or nothing.
|
|
1545
|
+
assert!(
|
|
1546
|
+
s.status == 426 || (s.status == 0 && s.response.is_empty()),
|
|
1547
|
+
"status {} {}",
|
|
1548
|
+
s.status,
|
|
1549
|
+
s.response
|
|
1550
|
+
);
|
|
1551
|
+
assert_eq!(s.worker.join().unwrap(), Err(Fallback::Stopping));
|
|
1552
|
+
lock(&REAL_STOP).take().unwrap().join().unwrap();
|
|
1553
|
+
wait_all_released();
|
|
1554
|
+
reset_registry();
|
|
1555
|
+
}
|
|
1556
|
+
|
|
1557
|
+
/// Armed by a test: the reader of this leg panics on its next text message.
|
|
1558
|
+
pub(super) static PANIC_IN: Mutex<Option<Leg>> = Mutex::new(None);
|
|
1559
|
+
|
|
1560
|
+
pub(super) fn maybe_panic(leg: Leg) {
|
|
1561
|
+
let armed = {
|
|
1562
|
+
let mut slot = lock(&PANIC_IN);
|
|
1563
|
+
if *slot == Some(leg) {
|
|
1564
|
+
slot.take()
|
|
1565
|
+
} else {
|
|
1566
|
+
None
|
|
1567
|
+
}
|
|
1568
|
+
};
|
|
1569
|
+
if armed.is_some() {
|
|
1570
|
+
panic!("panic injected by a test");
|
|
1571
|
+
}
|
|
1572
|
+
}
|
|
1573
|
+
|
|
1574
|
+
#[test]
|
|
1575
|
+
fn a_panic_in_the_worker_unregisters_the_socket_and_frees_its_slot() {
|
|
1576
|
+
let _serial = lock(&SERIAL);
|
|
1577
|
+
reset_registry();
|
|
1578
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
1579
|
+
let mut s = session(home_port, test_limits(), "", &[]);
|
|
1580
|
+
assert_eq!(s.status, 101);
|
|
1581
|
+
let mut home = homes.recv().unwrap();
|
|
1582
|
+
*lock(&PANIC_IN) = Some(Leg::Codex);
|
|
1583
|
+
s.codex.write_all(&client_frame(1, b"boom")).unwrap();
|
|
1584
|
+
assert!(s.worker.join().is_err(), "the worker panicked");
|
|
1585
|
+
assert!(
|
|
1586
|
+
lock(®istry().0).sockets.is_empty(),
|
|
1587
|
+
"the socket was unregistered on unwind"
|
|
1588
|
+
);
|
|
1589
|
+
assert_eq!(
|
|
1590
|
+
read_events(&mut home.stream, Role::FromClient, &home.leftover, 1),
|
|
1591
|
+
vec![]
|
|
1592
|
+
);
|
|
1593
|
+
wait_all_released();
|
|
1594
|
+
}
|
|
1595
|
+
|
|
1596
|
+
#[test]
|
|
1597
|
+
fn a_panic_in_the_home_reader_ends_the_socket_and_the_worker_returns() {
|
|
1598
|
+
let _serial = lock(&SERIAL);
|
|
1599
|
+
reset_registry();
|
|
1600
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
1601
|
+
let mut s = session(home_port, test_limits(), "", &[]);
|
|
1602
|
+
assert_eq!(s.status, 101);
|
|
1603
|
+
let mut home = homes.recv().unwrap();
|
|
1604
|
+
*lock(&PANIC_IN) = Some(Leg::Home);
|
|
1605
|
+
home.stream.write_all(&server_frame(1, b"boom")).unwrap();
|
|
1606
|
+
assert!(
|
|
1607
|
+
s.worker.join().unwrap().is_ok(),
|
|
1608
|
+
"the worker ended instead of waiting for the spawned thread"
|
|
1609
|
+
);
|
|
1610
|
+
assert_eq!(
|
|
1611
|
+
read_events(&mut s.codex, Role::FromServer, &s.codex_leftover, 1),
|
|
1612
|
+
vec![]
|
|
1613
|
+
);
|
|
1614
|
+
wait_all_released();
|
|
1615
|
+
}
|
|
1616
|
+
|
|
1617
|
+
pub(super) fn after_claim() {
|
|
1618
|
+
let gate = lock(&CLAIM_GATE).take();
|
|
1619
|
+
if let Some((reached, release)) = gate {
|
|
1620
|
+
let _ = reached.send(());
|
|
1621
|
+
let _ = release.recv();
|
|
1622
|
+
}
|
|
1623
|
+
}
|
|
1624
|
+
|
|
1625
|
+
pub(super) fn data_locked() {
|
|
1626
|
+
if let Some(tx) = lock(&DATA_LOCKED).take() {
|
|
1627
|
+
let _ = tx.send(());
|
|
1628
|
+
}
|
|
1629
|
+
}
|
|
1630
|
+
|
|
1631
|
+
/// The one registered socket (tests run one session at a time).
|
|
1632
|
+
fn only_socket() -> Arc<SocketShared> {
|
|
1633
|
+
let (m, _) = registry();
|
|
1634
|
+
let r = lock(m);
|
|
1635
|
+
assert_eq!(r.sockets.len(), 1);
|
|
1636
|
+
r.sockets.values().next().cloned().unwrap()
|
|
1637
|
+
}
|
|
1638
|
+
|
|
1639
|
+
fn reaper_holds(token: u64) -> bool {
|
|
1640
|
+
lock(&reaper().inner)
|
|
1641
|
+
.entries
|
|
1642
|
+
.iter()
|
|
1643
|
+
.any(|(t, _, _)| *t == token)
|
|
1644
|
+
}
|
|
1645
|
+
|
|
1646
|
+
const TOKEN: &str = "ocx-link-ws-test-token-0123456789";
|
|
1647
|
+
const KEY_ID: &str = "ws-key";
|
|
1648
|
+
const LINK_ID: &str = "lnk_0123456789abcdef";
|
|
1649
|
+
|
|
1650
|
+
fn reset_registry() {
|
|
1651
|
+
let (m, _) = registry();
|
|
1652
|
+
let mut r = lock(m);
|
|
1653
|
+
r.stopping = false;
|
|
1654
|
+
}
|
|
1655
|
+
|
|
1656
|
+
fn wait_all_released() {
|
|
1657
|
+
let (m, cv) = registry();
|
|
1658
|
+
let mut r = lock(m);
|
|
1659
|
+
while r.open != 0 || r.setting_up != 0 {
|
|
1660
|
+
r = cv.wait(r).unwrap_or_else(|e| e.into_inner());
|
|
1661
|
+
}
|
|
1662
|
+
}
|
|
1663
|
+
|
|
1664
|
+
fn test_limits() -> Limits {
|
|
1665
|
+
Limits {
|
|
1666
|
+
setup: Duration::from_secs(3),
|
|
1667
|
+
close_bound: Duration::from_millis(300),
|
|
1668
|
+
..LIMITS
|
|
1669
|
+
}
|
|
1670
|
+
}
|
|
1671
|
+
|
|
1672
|
+
#[derive(Clone, Copy, PartialEq)]
|
|
1673
|
+
enum HomeMode {
|
|
1674
|
+
Advertise,
|
|
1675
|
+
Silent,
|
|
1676
|
+
Refuse,
|
|
1677
|
+
WrongAccept,
|
|
1678
|
+
Hold,
|
|
1679
|
+
}
|
|
1680
|
+
|
|
1681
|
+
struct HomeSide {
|
|
1682
|
+
stream: TcpStream,
|
|
1683
|
+
request: HttpRequestHead,
|
|
1684
|
+
leftover: Vec<u8>,
|
|
1685
|
+
}
|
|
1686
|
+
|
|
1687
|
+
/// A mock Home: relay-auth v2 on each connection, then an upgrade on the same connection.
|
|
1688
|
+
fn mock_home(mode: HomeMode) -> (u16, mpsc::Receiver<HomeSide>) {
|
|
1689
|
+
let listener = TcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0))).unwrap();
|
|
1690
|
+
let port = listener.local_addr().unwrap().port();
|
|
1691
|
+
let (tx, rx) = mpsc::channel();
|
|
1692
|
+
thread::spawn(move || {
|
|
1693
|
+
for conn in listener.incoming() {
|
|
1694
|
+
let Ok(stream) = conn else { return };
|
|
1695
|
+
let tx = tx.clone();
|
|
1696
|
+
thread::spawn(move || home_connection(stream, mode, tx));
|
|
1697
|
+
}
|
|
1698
|
+
});
|
|
1699
|
+
(port, rx)
|
|
1700
|
+
}
|
|
1701
|
+
|
|
1702
|
+
fn home_connection(stream: TcpStream, mode: HomeMode, tx: mpsc::Sender<HomeSide>) {
|
|
1703
|
+
let fp = token_fingerprint_hex(TOKEN);
|
|
1704
|
+
let mut writer = stream.try_clone().unwrap();
|
|
1705
|
+
let mut reader = BufReader::new(stream);
|
|
1706
|
+
let Ok(pre) = read_request_head(&mut reader) else {
|
|
1707
|
+
return;
|
|
1708
|
+
};
|
|
1709
|
+
let param = |name: &str| {
|
|
1710
|
+
pre.query
|
|
1711
|
+
.split('&')
|
|
1712
|
+
.find_map(|kv| kv.strip_prefix(&format!("{name}=")))
|
|
1713
|
+
.unwrap_or("")
|
|
1714
|
+
.to_owned()
|
|
1715
|
+
};
|
|
1716
|
+
let nonce = param("nonce");
|
|
1717
|
+
if compute_relay_proof(&fp, "caller", KEY_ID, LINK_ID, &nonce).as_deref()
|
|
1718
|
+
!= Some(param("proof").as_str())
|
|
1719
|
+
{
|
|
1720
|
+
let _ = writer.write_all(b"HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\n\r\n");
|
|
1721
|
+
return;
|
|
1722
|
+
}
|
|
1723
|
+
let mut answer = format!(
|
|
1724
|
+
"HTTP/1.1 204 No Content\r\nx-opencodex-link-proof: {}\r\n",
|
|
1725
|
+
compute_relay_proof(&fp, "listener", KEY_ID, LINK_ID, &nonce).unwrap()
|
|
1726
|
+
);
|
|
1727
|
+
if mode != HomeMode::Silent {
|
|
1728
|
+
answer.push_str(&format!(
|
|
1729
|
+
"x-opencodex-link-ws-state: on\r\nx-opencodex-link-ws-proof: {}\r\n",
|
|
1730
|
+
ws_state_proof(&fp, KEY_ID, LINK_ID, &nonce).unwrap()
|
|
1731
|
+
));
|
|
1732
|
+
}
|
|
1733
|
+
answer.push_str("\r\n");
|
|
1734
|
+
writer.write_all(answer.as_bytes()).unwrap();
|
|
1735
|
+
let Ok(up) = read_request_head(&mut reader) else {
|
|
1736
|
+
return;
|
|
1737
|
+
};
|
|
1738
|
+
let key = up
|
|
1739
|
+
.headers
|
|
1740
|
+
.iter()
|
|
1741
|
+
.find(|(k, _)| k.eq_ignore_ascii_case("sec-websocket-key"))
|
|
1742
|
+
.map(|(_, v)| v.clone())
|
|
1743
|
+
.unwrap_or_default();
|
|
1744
|
+
match mode {
|
|
1745
|
+
HomeMode::Refuse => {
|
|
1746
|
+
let _ =
|
|
1747
|
+
writer.write_all(b"HTTP/1.1 426 Upgrade Required\r\nContent-Length: 0\r\n\r\n");
|
|
1748
|
+
return;
|
|
1749
|
+
}
|
|
1750
|
+
HomeMode::Hold => {
|
|
1751
|
+
let leftover = reader.buffer().to_vec();
|
|
1752
|
+
let _ = tx.send(HomeSide {
|
|
1753
|
+
stream: writer,
|
|
1754
|
+
request: up,
|
|
1755
|
+
leftover,
|
|
1756
|
+
});
|
|
1757
|
+
return;
|
|
1758
|
+
}
|
|
1759
|
+
_ => {}
|
|
1760
|
+
}
|
|
1761
|
+
let accept = if mode == HomeMode::WrongAccept {
|
|
1762
|
+
websocket_accept("other")
|
|
1763
|
+
} else {
|
|
1764
|
+
websocket_accept(&key)
|
|
1765
|
+
};
|
|
1766
|
+
writer.write_all(format!("HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: {accept}\r\n\r\n").as_bytes()).unwrap();
|
|
1767
|
+
let leftover = reader.buffer().to_vec();
|
|
1768
|
+
let _ = tx.send(HomeSide {
|
|
1769
|
+
stream: writer,
|
|
1770
|
+
request: up,
|
|
1771
|
+
leftover,
|
|
1772
|
+
});
|
|
1773
|
+
}
|
|
1774
|
+
|
|
1775
|
+
fn creds() -> RelayCredentials {
|
|
1776
|
+
RelayCredentials {
|
|
1777
|
+
api_key_id: KEY_ID.into(),
|
|
1778
|
+
link_id: LINK_ID.into(),
|
|
1779
|
+
token_fingerprint: token_fingerprint_hex(TOKEN),
|
|
1780
|
+
raw_token: SecretBytes::new(TOKEN.as_bytes().to_vec()),
|
|
1781
|
+
}
|
|
1782
|
+
}
|
|
1783
|
+
|
|
1784
|
+
/// Reads frames off a raw socket (either role) until `count` events arrived or the connection ended.
|
|
1785
|
+
fn read_events(
|
|
1786
|
+
stream: &mut TcpStream,
|
|
1787
|
+
role: Role,
|
|
1788
|
+
leftover: &[u8],
|
|
1789
|
+
count: usize,
|
|
1790
|
+
) -> Vec<FrameEvent> {
|
|
1791
|
+
let mut reader = FrameReader::new(role, 16 * MIB, 4096);
|
|
1792
|
+
let mut events = Vec::new();
|
|
1793
|
+
let _ = reader.push(leftover, &mut events);
|
|
1794
|
+
let mut buf = vec![0u8; 64 * KIB];
|
|
1795
|
+
while events.len() < count {
|
|
1796
|
+
match stream.read(&mut buf) {
|
|
1797
|
+
Ok(0) | Err(_) => break,
|
|
1798
|
+
Ok(n) => {
|
|
1799
|
+
if reader.push(&buf[..n], &mut events).is_err() {
|
|
1800
|
+
break;
|
|
1801
|
+
}
|
|
1802
|
+
}
|
|
1803
|
+
}
|
|
1804
|
+
}
|
|
1805
|
+
events
|
|
1806
|
+
}
|
|
1807
|
+
|
|
1808
|
+
fn client_frame(opcode: u8, payload: &[u8]) -> Vec<u8> {
|
|
1809
|
+
let mask = [9, 8, 7, 6];
|
|
1810
|
+
let mut body = payload.to_vec();
|
|
1811
|
+
mask_in_place(&mut body, mask);
|
|
1812
|
+
[frame_header(opcode, payload.len(), Some(mask)), body].concat()
|
|
1813
|
+
}
|
|
1814
|
+
|
|
1815
|
+
fn server_frame(opcode: u8, payload: &[u8]) -> Vec<u8> {
|
|
1816
|
+
[frame_header(opcode, payload.len(), None), payload.to_vec()].concat()
|
|
1817
|
+
}
|
|
1818
|
+
|
|
1819
|
+
struct Session {
|
|
1820
|
+
codex: TcpStream,
|
|
1821
|
+
codex_leftover: Vec<u8>,
|
|
1822
|
+
status: u16,
|
|
1823
|
+
response: String,
|
|
1824
|
+
worker: thread::JoinHandle<Result<(), Fallback>>,
|
|
1825
|
+
}
|
|
1826
|
+
|
|
1827
|
+
/// A Child worker serving one upgrade, and Codex's connection to it. `first` is sent with the head.
|
|
1828
|
+
fn session(home_port: u16, limits: Limits, extra: &str, first: &[u8]) -> Session {
|
|
1829
|
+
let listener = TcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0))).unwrap();
|
|
1830
|
+
let port = listener.local_addr().unwrap().port();
|
|
1831
|
+
let worker = thread::spawn(move || {
|
|
1832
|
+
let (stream, _) = listener.accept().unwrap();
|
|
1833
|
+
let mut writer = stream.try_clone().unwrap();
|
|
1834
|
+
let mut reader =
|
|
1835
|
+
BufReader::new(DeadlineStream::new(stream, None, Duration::from_secs(1)));
|
|
1836
|
+
let req = read_request_head(&mut reader).unwrap();
|
|
1837
|
+
let result = open(&mut reader, &mut writer, &req, home_port, creds(), limits);
|
|
1838
|
+
if result.is_err() {
|
|
1839
|
+
let _ = write_upgrade_required(&mut writer);
|
|
1840
|
+
}
|
|
1841
|
+
result
|
|
1842
|
+
});
|
|
1843
|
+
let mut codex = TcpStream::connect(SocketAddr::from(([127, 0, 0, 1], port))).unwrap();
|
|
1844
|
+
let head = format!(
|
|
1845
|
+
"GET /v1/responses HTTP/1.1\r\nHost: 127.0.0.1:{port}\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: {KEY}\r\nAuthorization: Bearer codex-own\r\nthread-id: thread-1\r\n{extra}\r\n"
|
|
1846
|
+
);
|
|
1847
|
+
codex.write_all(&[head.as_bytes(), first].concat()).unwrap();
|
|
1848
|
+
let mut reader = BufReader::new(codex.try_clone().unwrap());
|
|
1849
|
+
let Ok(resp) = read_response_head(&mut reader) else {
|
|
1850
|
+
// The Child ended the connection without an answer.
|
|
1851
|
+
return Session {
|
|
1852
|
+
codex,
|
|
1853
|
+
codex_leftover: Vec::new(),
|
|
1854
|
+
status: 0,
|
|
1855
|
+
response: String::new(),
|
|
1856
|
+
worker,
|
|
1857
|
+
};
|
|
1858
|
+
};
|
|
1859
|
+
let leftover = reader.buffer().to_vec();
|
|
1860
|
+
let response = resp
|
|
1861
|
+
.headers
|
|
1862
|
+
.iter()
|
|
1863
|
+
.map(|(k, v)| format!("{}: {v}", k.to_ascii_lowercase()))
|
|
1864
|
+
.collect::<Vec<_>>()
|
|
1865
|
+
.join("\n");
|
|
1866
|
+
Session {
|
|
1867
|
+
codex,
|
|
1868
|
+
codex_leftover: leftover,
|
|
1869
|
+
status: resp.status,
|
|
1870
|
+
response,
|
|
1871
|
+
worker,
|
|
1872
|
+
}
|
|
1873
|
+
}
|
|
1874
|
+
|
|
1875
|
+
#[test]
|
|
1876
|
+
fn relays_text_both_ways_with_the_link_key_and_the_coalesced_first_frame() {
|
|
1877
|
+
let _serial = lock(&SERIAL);
|
|
1878
|
+
reset_registry();
|
|
1879
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
1880
|
+
let first = client_frame(1, br#"{"type":"response.create"}"#);
|
|
1881
|
+
let mut s = session(home_port, test_limits(), "", &first);
|
|
1882
|
+
assert_eq!(s.status, 101);
|
|
1883
|
+
assert!(
|
|
1884
|
+
s.response
|
|
1885
|
+
.contains("x-codex-websocket-max-message-bytes: 8388608")
|
|
1886
|
+
);
|
|
1887
|
+
assert!(
|
|
1888
|
+
s.response
|
|
1889
|
+
.contains(&format!("sec-websocket-accept: {}", websocket_accept(KEY)))
|
|
1890
|
+
);
|
|
1891
|
+
let mut home = homes.recv().unwrap();
|
|
1892
|
+
let header = |n: &str| {
|
|
1893
|
+
home.request
|
|
1894
|
+
.headers
|
|
1895
|
+
.iter()
|
|
1896
|
+
.find(|(k, _)| k.eq_ignore_ascii_case(n))
|
|
1897
|
+
.map(|(_, v)| v.clone())
|
|
1898
|
+
};
|
|
1899
|
+
assert_eq!(
|
|
1900
|
+
header("authorization").as_deref(),
|
|
1901
|
+
Some(format!("Bearer {TOKEN}").as_str())
|
|
1902
|
+
);
|
|
1903
|
+
assert_eq!(header("thread-id").as_deref(), Some("thread-1"));
|
|
1904
|
+
assert!(header("x-opencodex-link-session").is_some());
|
|
1905
|
+
assert!(header("origin").is_none() && header("sec-websocket-extensions").is_none());
|
|
1906
|
+
let got = read_events(&mut home.stream, Role::FromClient, &home.leftover, 1);
|
|
1907
|
+
assert_eq!(
|
|
1908
|
+
got,
|
|
1909
|
+
vec![FrameEvent::Text(r#"{"type":"response.create"}"#.into())]
|
|
1910
|
+
);
|
|
1911
|
+
home.stream
|
|
1912
|
+
.write_all(&server_frame(1, b"from-home"))
|
|
1913
|
+
.unwrap();
|
|
1914
|
+
let back = read_events(&mut s.codex, Role::FromServer, &s.codex_leftover, 1);
|
|
1915
|
+
assert_eq!(back, vec![FrameEvent::Text("from-home".into())]);
|
|
1916
|
+
s.codex
|
|
1917
|
+
.write_all(&client_frame(8, &close_payload(Some(1000), "")))
|
|
1918
|
+
.unwrap();
|
|
1919
|
+
assert_eq!(
|
|
1920
|
+
read_events(&mut home.stream, Role::FromClient, &[], 1),
|
|
1921
|
+
vec![FrameEvent::Close(Some(1000), String::new())]
|
|
1922
|
+
);
|
|
1923
|
+
home.stream
|
|
1924
|
+
.write_all(&server_frame(8, &close_payload(Some(1000), "")))
|
|
1925
|
+
.unwrap();
|
|
1926
|
+
assert!(s.worker.join().unwrap().is_ok());
|
|
1927
|
+
wait_all_released();
|
|
1928
|
+
}
|
|
1929
|
+
|
|
1930
|
+
#[test]
|
|
1931
|
+
fn a_failed_local_101_aborts_the_home_thread_and_cuts_the_home_connection() {
|
|
1932
|
+
let _serial = lock(&SERIAL);
|
|
1933
|
+
reset_registry();
|
|
1934
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
1935
|
+
FAIL_101.store(true, Ordering::SeqCst);
|
|
1936
|
+
let s = session(home_port, test_limits(), "", &[]);
|
|
1937
|
+
assert_eq!(s.status, 0, "nothing is written after a failed 101");
|
|
1938
|
+
assert_eq!(s.worker.join().unwrap(), Ok(()));
|
|
1939
|
+
let mut home = homes.recv().unwrap();
|
|
1940
|
+
assert_eq!(
|
|
1941
|
+
read_events(&mut home.stream, Role::FromClient, &home.leftover, 1),
|
|
1942
|
+
vec![],
|
|
1943
|
+
"the Home connection ends without a close frame"
|
|
1944
|
+
);
|
|
1945
|
+
wait_all_released();
|
|
1946
|
+
}
|
|
1947
|
+
|
|
1948
|
+
#[test]
|
|
1949
|
+
fn a_close_claim_keeps_its_deadline_through_the_workers_cleanup() {
|
|
1950
|
+
let _serial = lock(&SERIAL);
|
|
1951
|
+
reset_registry();
|
|
1952
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
1953
|
+
// A close bound that cannot fire during the test: only retirement can remove the entry.
|
|
1954
|
+
let limits = Limits {
|
|
1955
|
+
close_bound: Duration::from_secs(120),
|
|
1956
|
+
..test_limits()
|
|
1957
|
+
};
|
|
1958
|
+
let s = session(home_port, limits, "", &[]);
|
|
1959
|
+
assert_eq!(s.status, 101);
|
|
1960
|
+
let home = homes.recv().unwrap();
|
|
1961
|
+
let shared = only_socket();
|
|
1962
|
+
let (reached_tx, reached) = mpsc::channel();
|
|
1963
|
+
let (release, release_rx) = mpsc::channel();
|
|
1964
|
+
*lock(&CLAIM_GATE) = Some((reached_tx, release_rx));
|
|
1965
|
+
let closer = {
|
|
1966
|
+
let shared = Arc::clone(&shared);
|
|
1967
|
+
thread::spawn(move || {
|
|
1968
|
+
terminate(
|
|
1969
|
+
&shared,
|
|
1970
|
+
CloseAction::Frame(1001, String::new()),
|
|
1971
|
+
CloseAction::Frame(1001, String::new()),
|
|
1972
|
+
);
|
|
1973
|
+
})
|
|
1974
|
+
};
|
|
1975
|
+
reached.recv().unwrap();
|
|
1976
|
+
// Between the claim and the first close write, both peers leave and the worker cleans up.
|
|
1977
|
+
home.stream.shutdown(Shutdown::Both).unwrap();
|
|
1978
|
+
s.codex.shutdown(Shutdown::Both).unwrap();
|
|
1979
|
+
assert!(s.worker.join().unwrap().is_ok());
|
|
1980
|
+
let token = {
|
|
1981
|
+
let st = lock(&shared.state);
|
|
1982
|
+
assert!(st.cleanup_done);
|
|
1983
|
+
assert_eq!(st.close_io, 1);
|
|
1984
|
+
st.close_token
|
|
1985
|
+
.expect("the claimed close keeps its deadline")
|
|
1986
|
+
};
|
|
1987
|
+
assert!(
|
|
1988
|
+
reaper_holds(token),
|
|
1989
|
+
"cleanup did not retire a claimed close entry"
|
|
1990
|
+
);
|
|
1991
|
+
release.send(()).unwrap();
|
|
1992
|
+
closer.join().unwrap();
|
|
1993
|
+
assert!(lock(&shared.state).close_token.is_none());
|
|
1994
|
+
assert!(
|
|
1995
|
+
!reaper_holds(token),
|
|
1996
|
+
"the last close caller retires the entry"
|
|
1997
|
+
);
|
|
1998
|
+
drop(shared);
|
|
1999
|
+
wait_all_released();
|
|
2000
|
+
}
|
|
2001
|
+
|
|
2002
|
+
#[test]
|
|
2003
|
+
fn a_close_behind_a_blocked_data_write_returns_at_the_close_deadline() {
|
|
2004
|
+
let _serial = lock(&SERIAL);
|
|
2005
|
+
reset_registry();
|
|
2006
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
2007
|
+
// Default stall (300 s) and data (600 s) bounds: only the 300 ms close deadline can end this.
|
|
2008
|
+
let s = session(home_port, test_limits(), "", &[]);
|
|
2009
|
+
let _home = homes.recv().unwrap();
|
|
2010
|
+
let shared = only_socket();
|
|
2011
|
+
let (locked_tx, locked) = mpsc::channel();
|
|
2012
|
+
*lock(&DATA_LOCKED) = Some(locked_tx);
|
|
2013
|
+
let writer = {
|
|
2014
|
+
let shared = Arc::clone(&shared);
|
|
2015
|
+
// Codex never reads: 64 MiB cannot fit in the loopback buffers, so this write blocks.
|
|
2016
|
+
thread::spawn(move || {
|
|
2017
|
+
write_frame(&shared, Leg::Codex, 1, vec![b'w'; 64 * MIB], Kind::Data)
|
|
2018
|
+
})
|
|
2019
|
+
};
|
|
2020
|
+
locked.recv().unwrap();
|
|
2021
|
+
let started = Instant::now();
|
|
2022
|
+
terminate(
|
|
2023
|
+
&shared,
|
|
2024
|
+
CloseAction::Frame(1001, String::new()),
|
|
2025
|
+
CloseAction::Frame(1001, String::new()),
|
|
2026
|
+
);
|
|
2027
|
+
let elapsed = started.elapsed();
|
|
2028
|
+
assert!(
|
|
2029
|
+
elapsed < Duration::from_secs(30),
|
|
2030
|
+
"the close waited {elapsed:?} behind the data write"
|
|
2031
|
+
);
|
|
2032
|
+
assert!(writer.join().unwrap().is_err());
|
|
2033
|
+
assert!(s.worker.join().unwrap().is_ok());
|
|
2034
|
+
drop(s.codex);
|
|
2035
|
+
drop(shared);
|
|
2036
|
+
wait_all_released();
|
|
2037
|
+
}
|
|
2038
|
+
|
|
2039
|
+
#[test]
|
|
2040
|
+
fn maximum_messages_cross_in_both_directions_at_once() {
|
|
2041
|
+
let _serial = lock(&SERIAL);
|
|
2042
|
+
reset_registry();
|
|
2043
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
2044
|
+
let l = test_limits();
|
|
2045
|
+
let mut s = session(home_port, l, "", &[]);
|
|
2046
|
+
let mut home = homes.recv().unwrap();
|
|
2047
|
+
let up = "u".repeat(l.local_message);
|
|
2048
|
+
let down = "d".repeat(l.home_message);
|
|
2049
|
+
let mut codex_writer = s.codex.try_clone().unwrap();
|
|
2050
|
+
let up_frame = client_frame(1, up.as_bytes());
|
|
2051
|
+
let codex_send = thread::spawn(move || codex_writer.write_all(&up_frame).is_ok());
|
|
2052
|
+
let mut home_writer = home.stream.try_clone().unwrap();
|
|
2053
|
+
let down_frame = server_frame(1, down.as_bytes());
|
|
2054
|
+
let home_send = thread::spawn(move || home_writer.write_all(&down_frame).is_ok());
|
|
2055
|
+
let mut home_stream = home.stream.try_clone().unwrap();
|
|
2056
|
+
let leftover = std::mem::take(&mut home.leftover);
|
|
2057
|
+
let home_read =
|
|
2058
|
+
thread::spawn(move || read_events(&mut home_stream, Role::FromClient, &leftover, 1));
|
|
2059
|
+
let at_codex = read_events(&mut s.codex, Role::FromServer, &s.codex_leftover, 1);
|
|
2060
|
+
let at_home = home_read.join().unwrap();
|
|
2061
|
+
assert!(codex_send.join().unwrap() && home_send.join().unwrap());
|
|
2062
|
+
assert_eq!(at_codex, vec![FrameEvent::Text(down)]);
|
|
2063
|
+
assert_eq!(at_home, vec![FrameEvent::Text(up)]);
|
|
2064
|
+
s.codex.shutdown(Shutdown::Both).unwrap();
|
|
2065
|
+
assert!(s.worker.join().unwrap().is_ok());
|
|
2066
|
+
wait_all_released();
|
|
2067
|
+
}
|
|
2068
|
+
|
|
2069
|
+
#[test]
|
|
2070
|
+
fn pings_during_large_messages_get_whole_pongs_between_frames() {
|
|
2071
|
+
let _serial = lock(&SERIAL);
|
|
2072
|
+
reset_registry();
|
|
2073
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
2074
|
+
let mut s = session(home_port, test_limits(), "", &[]);
|
|
2075
|
+
let home = homes.recv().unwrap();
|
|
2076
|
+
// Codex holds off reading while the Home sends large messages and Codex pings repeatedly.
|
|
2077
|
+
let mut home_writer = home.stream.try_clone().unwrap();
|
|
2078
|
+
let big = server_frame(1, &vec![b'm'; MIB]);
|
|
2079
|
+
let home_send = thread::spawn(move || {
|
|
2080
|
+
for _ in 0..3 {
|
|
2081
|
+
home_writer.write_all(&big).unwrap();
|
|
2082
|
+
}
|
|
2083
|
+
});
|
|
2084
|
+
let pings: Vec<u8> = (0..100u8).flat_map(|i| client_frame(9, &[i])).collect();
|
|
2085
|
+
s.codex.write_all(&pings).unwrap();
|
|
2086
|
+
let events = read_events(&mut s.codex, Role::FromServer, &s.codex_leftover, 103);
|
|
2087
|
+
home_send.join().unwrap();
|
|
2088
|
+
let texts: Vec<usize> = events
|
|
2089
|
+
.iter()
|
|
2090
|
+
.filter_map(|e| match e {
|
|
2091
|
+
FrameEvent::Text(t) => Some(t.len()),
|
|
2092
|
+
_ => None,
|
|
2093
|
+
})
|
|
2094
|
+
.collect();
|
|
2095
|
+
let pongs: Vec<Vec<u8>> = events
|
|
2096
|
+
.iter()
|
|
2097
|
+
.filter_map(|e| match e {
|
|
2098
|
+
FrameEvent::Pong(p) => Some(p.clone()),
|
|
2099
|
+
_ => None,
|
|
2100
|
+
})
|
|
2101
|
+
.collect();
|
|
2102
|
+
assert_eq!(texts, vec![MIB; 3]);
|
|
2103
|
+
assert_eq!(pongs, (0..100u8).map(|i| vec![i]).collect::<Vec<_>>());
|
|
2104
|
+
s.codex.shutdown(Shutdown::Both).unwrap();
|
|
2105
|
+
assert!(s.worker.join().unwrap().is_ok());
|
|
2106
|
+
wait_all_released();
|
|
2107
|
+
}
|
|
2108
|
+
|
|
2109
|
+
#[test]
|
|
2110
|
+
fn codex_lost_while_a_write_to_it_is_blocked_ends_both_legs() {
|
|
2111
|
+
let _serial = lock(&SERIAL);
|
|
2112
|
+
reset_registry();
|
|
2113
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
2114
|
+
// Default write bounds: only Codex's departure can end this promptly.
|
|
2115
|
+
let s = session(home_port, test_limits(), "", &[]);
|
|
2116
|
+
let mut home = homes.recv().unwrap();
|
|
2117
|
+
let (locked_tx, locked) = mpsc::channel();
|
|
2118
|
+
*lock(&DATA_LOCKED) = Some(locked_tx);
|
|
2119
|
+
let mut home_writer = home.stream.try_clone().unwrap();
|
|
2120
|
+
let flood = thread::spawn(move || {
|
|
2121
|
+
let message = server_frame(1, &vec![b'f'; MIB]);
|
|
2122
|
+
for _ in 0..64 {
|
|
2123
|
+
if home_writer.write_all(&message).is_err() {
|
|
2124
|
+
return;
|
|
2125
|
+
}
|
|
2126
|
+
}
|
|
2127
|
+
});
|
|
2128
|
+
locked.recv().unwrap();
|
|
2129
|
+
s.codex.shutdown(Shutdown::Both).unwrap();
|
|
2130
|
+
assert!(s.worker.join().unwrap().is_ok());
|
|
2131
|
+
let mut rest = vec![0u8; 64 * KIB];
|
|
2132
|
+
loop {
|
|
2133
|
+
match home.stream.read(&mut rest) {
|
|
2134
|
+
Ok(0) | Err(_) => break,
|
|
2135
|
+
Ok(_) => {}
|
|
2136
|
+
}
|
|
2137
|
+
}
|
|
2138
|
+
// The flood is this test's own writer and may be blocked on a socket the Child has already shut down;
|
|
2139
|
+
// shutting our end wakes it at once (otherwise it waits for the kernel to drop the orphaned connection).
|
|
2140
|
+
let _ = home.stream.shutdown(Shutdown::Both);
|
|
2141
|
+
let _ = flood.join();
|
|
2142
|
+
wait_all_released();
|
|
2143
|
+
}
|
|
2144
|
+
|
|
2145
|
+
#[test]
|
|
2146
|
+
fn stop_with_writes_blocked_both_ways_on_several_sockets_ends() {
|
|
2147
|
+
let _serial = lock(&SERIAL);
|
|
2148
|
+
reset_registry();
|
|
2149
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
2150
|
+
let mut sessions = Vec::new();
|
|
2151
|
+
let mut floods = Vec::new();
|
|
2152
|
+
for _ in 0..3 {
|
|
2153
|
+
// Default write bounds; neither peer reads, both send.
|
|
2154
|
+
let s = session(home_port, test_limits(), "", &[]);
|
|
2155
|
+
assert_eq!(s.status, 101);
|
|
2156
|
+
let home = homes.recv().unwrap();
|
|
2157
|
+
let mut codex_writer = s.codex.try_clone().unwrap();
|
|
2158
|
+
floods.push(thread::spawn(move || {
|
|
2159
|
+
let message = client_frame(1, &vec![b'c'; MIB]);
|
|
2160
|
+
for _ in 0..64 {
|
|
2161
|
+
if codex_writer.write_all(&message).is_err() {
|
|
2162
|
+
return;
|
|
2163
|
+
}
|
|
2164
|
+
}
|
|
2165
|
+
}));
|
|
2166
|
+
let mut home_writer = home.stream.try_clone().unwrap();
|
|
2167
|
+
floods.push(thread::spawn(move || {
|
|
2168
|
+
let message = server_frame(1, &vec![b'h'; MIB]);
|
|
2169
|
+
for _ in 0..64 {
|
|
2170
|
+
if home_writer.write_all(&message).is_err() {
|
|
2171
|
+
return;
|
|
2172
|
+
}
|
|
2173
|
+
}
|
|
2174
|
+
}));
|
|
2175
|
+
sessions.push((s, home));
|
|
2176
|
+
}
|
|
2177
|
+
let started = Instant::now();
|
|
2178
|
+
stop_all();
|
|
2179
|
+
let elapsed = started.elapsed();
|
|
2180
|
+
assert!(
|
|
2181
|
+
elapsed < Duration::from_secs(30),
|
|
2182
|
+
"stop took {elapsed:?} with writes blocked"
|
|
2183
|
+
);
|
|
2184
|
+
for (s, home) in sessions {
|
|
2185
|
+
assert!(s.worker.join().unwrap().is_ok());
|
|
2186
|
+
// The floods are this test's own writers: shutting our ends wakes them at once.
|
|
2187
|
+
let _ = home.stream.shutdown(Shutdown::Both);
|
|
2188
|
+
let _ = s.codex.shutdown(Shutdown::Both);
|
|
2189
|
+
}
|
|
2190
|
+
for f in floods {
|
|
2191
|
+
let _ = f.join();
|
|
2192
|
+
}
|
|
2193
|
+
wait_all_released();
|
|
2194
|
+
reset_registry();
|
|
2195
|
+
}
|
|
2196
|
+
|
|
2197
|
+
#[test]
|
|
2198
|
+
fn a_home_that_does_not_advertise_refuses_or_answers_a_broken_101_gets_426() {
|
|
2199
|
+
let _serial = lock(&SERIAL);
|
|
2200
|
+
reset_registry();
|
|
2201
|
+
for (mode, why) in [
|
|
2202
|
+
(HomeMode::Silent, Fallback::NotAdvertised),
|
|
2203
|
+
(HomeMode::Refuse, Fallback::HomeRefused),
|
|
2204
|
+
(HomeMode::WrongAccept, Fallback::HomeRefused),
|
|
2205
|
+
] {
|
|
2206
|
+
let (home_port, _homes) = mock_home(mode);
|
|
2207
|
+
let s = session(home_port, test_limits(), "", &[]);
|
|
2208
|
+
assert_eq!(s.status, 426);
|
|
2209
|
+
assert_eq!(s.worker.join().unwrap(), Err(why));
|
|
2210
|
+
}
|
|
2211
|
+
let s = session(1, test_limits(), "", &[]);
|
|
2212
|
+
assert_eq!(s.status, 426);
|
|
2213
|
+
assert_eq!(s.worker.join().unwrap(), Err(Fallback::Preflight));
|
|
2214
|
+
let (home_port, _homes) = mock_home(HomeMode::Advertise);
|
|
2215
|
+
let s = session(
|
|
2216
|
+
home_port,
|
|
2217
|
+
test_limits(),
|
|
2218
|
+
"Origin: http://127.0.0.1\r\n",
|
|
2219
|
+
&[],
|
|
2220
|
+
);
|
|
2221
|
+
assert_eq!(s.status, 426);
|
|
2222
|
+
assert_eq!(s.worker.join().unwrap(), Err(Fallback::Origin));
|
|
2223
|
+
wait_all_released();
|
|
2224
|
+
}
|
|
2225
|
+
|
|
2226
|
+
#[test]
|
|
2227
|
+
fn binary_closes_both_legs_with_1003() {
|
|
2228
|
+
let _serial = lock(&SERIAL);
|
|
2229
|
+
reset_registry();
|
|
2230
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
2231
|
+
let mut s = session(home_port, test_limits(), "", &[]);
|
|
2232
|
+
let mut home = homes.recv().unwrap();
|
|
2233
|
+
s.codex.write_all(&client_frame(2, &[1, 2, 3])).unwrap();
|
|
2234
|
+
assert_eq!(
|
|
2235
|
+
read_events(&mut s.codex, Role::FromServer, &s.codex_leftover, 1),
|
|
2236
|
+
vec![FrameEvent::Close(
|
|
2237
|
+
Some(1003),
|
|
2238
|
+
"binary messages are not relayed".into()
|
|
2239
|
+
)]
|
|
2240
|
+
);
|
|
2241
|
+
assert_eq!(
|
|
2242
|
+
read_events(&mut home.stream, Role::FromClient, &home.leftover, 1),
|
|
2243
|
+
vec![FrameEvent::Close(Some(1003), String::new())]
|
|
2244
|
+
);
|
|
2245
|
+
assert!(s.worker.join().unwrap().is_ok());
|
|
2246
|
+
wait_all_released();
|
|
2247
|
+
}
|
|
2248
|
+
|
|
2249
|
+
#[test]
|
|
2250
|
+
fn codex_close_without_status_and_codex_drop_reach_the_home_as_such() {
|
|
2251
|
+
let _serial = lock(&SERIAL);
|
|
2252
|
+
reset_registry();
|
|
2253
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
2254
|
+
let mut s = session(home_port, test_limits(), "", &[]);
|
|
2255
|
+
let mut home = homes.recv().unwrap();
|
|
2256
|
+
s.codex.write_all(&client_frame(8, &[])).unwrap();
|
|
2257
|
+
assert_eq!(
|
|
2258
|
+
read_events(&mut home.stream, Role::FromClient, &home.leftover, 1),
|
|
2259
|
+
vec![FrameEvent::Close(None, String::new())]
|
|
2260
|
+
);
|
|
2261
|
+
assert!(s.worker.join().unwrap().is_ok());
|
|
2262
|
+
// Codex gone without a close frame: the Home connection ends without one.
|
|
2263
|
+
let s = session(home_port, test_limits(), "", &[]);
|
|
2264
|
+
let mut home = homes.recv().unwrap();
|
|
2265
|
+
s.codex.shutdown(Shutdown::Both).unwrap();
|
|
2266
|
+
assert_eq!(
|
|
2267
|
+
read_events(&mut home.stream, Role::FromClient, &home.leftover, 1),
|
|
2268
|
+
vec![]
|
|
2269
|
+
);
|
|
2270
|
+
assert!(s.worker.join().unwrap().is_ok());
|
|
2271
|
+
wait_all_released();
|
|
2272
|
+
}
|
|
2273
|
+
|
|
2274
|
+
#[test]
|
|
2275
|
+
fn home_close_codes_are_relayed_and_a_dropped_home_is_1011() {
|
|
2276
|
+
let _serial = lock(&SERIAL);
|
|
2277
|
+
reset_registry();
|
|
2278
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
2279
|
+
for code in [4401u16, 1012, 1013, 1014] {
|
|
2280
|
+
let mut s = session(home_port, test_limits(), "", &[]);
|
|
2281
|
+
let mut home = homes.recv().unwrap();
|
|
2282
|
+
home.stream
|
|
2283
|
+
.write_all(&server_frame(8, &close_payload(Some(code), "bye")))
|
|
2284
|
+
.unwrap();
|
|
2285
|
+
assert_eq!(
|
|
2286
|
+
read_events(&mut s.codex, Role::FromServer, &s.codex_leftover, 1),
|
|
2287
|
+
vec![FrameEvent::Close(Some(code), "bye".into())]
|
|
2288
|
+
);
|
|
2289
|
+
assert_eq!(
|
|
2290
|
+
read_events(&mut home.stream, Role::FromClient, &[], 1),
|
|
2291
|
+
vec![FrameEvent::Close(Some(code), String::new())]
|
|
2292
|
+
);
|
|
2293
|
+
assert!(s.worker.join().unwrap().is_ok());
|
|
2294
|
+
}
|
|
2295
|
+
let mut s = session(home_port, test_limits(), "", &[]);
|
|
2296
|
+
let home = homes.recv().unwrap();
|
|
2297
|
+
home.stream.shutdown(Shutdown::Both).unwrap();
|
|
2298
|
+
assert_eq!(
|
|
2299
|
+
read_events(&mut s.codex, Role::FromServer, &s.codex_leftover, 1),
|
|
2300
|
+
vec![FrameEvent::Close(
|
|
2301
|
+
Some(1011),
|
|
2302
|
+
"home connection ended".into()
|
|
2303
|
+
)]
|
|
2304
|
+
);
|
|
2305
|
+
assert!(s.worker.join().unwrap().is_ok());
|
|
2306
|
+
wait_all_released();
|
|
2307
|
+
}
|
|
2308
|
+
|
|
2309
|
+
#[test]
|
|
2310
|
+
fn a_home_message_over_the_limit_closes_codex_1011_and_the_home_1009() {
|
|
2311
|
+
let _serial = lock(&SERIAL);
|
|
2312
|
+
reset_registry();
|
|
2313
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
2314
|
+
let mut s = session(
|
|
2315
|
+
home_port,
|
|
2316
|
+
Limits {
|
|
2317
|
+
home_message: 1024,
|
|
2318
|
+
..test_limits()
|
|
2319
|
+
},
|
|
2320
|
+
"",
|
|
2321
|
+
&[],
|
|
2322
|
+
);
|
|
2323
|
+
let mut home = homes.recv().unwrap();
|
|
2324
|
+
home.stream
|
|
2325
|
+
.write_all(&server_frame(1, &[b'y'; 2048]))
|
|
2326
|
+
.unwrap();
|
|
2327
|
+
assert_eq!(
|
|
2328
|
+
read_events(&mut s.codex, Role::FromServer, &s.codex_leftover, 1),
|
|
2329
|
+
vec![FrameEvent::Close(Some(1011), "home message refused".into())]
|
|
2330
|
+
);
|
|
2331
|
+
assert_eq!(
|
|
2332
|
+
read_events(&mut home.stream, Role::FromClient, &home.leftover, 1),
|
|
2333
|
+
vec![FrameEvent::Close(Some(1009), String::new())]
|
|
2334
|
+
);
|
|
2335
|
+
assert!(s.worker.join().unwrap().is_ok());
|
|
2336
|
+
wait_all_released();
|
|
2337
|
+
}
|
|
2338
|
+
|
|
2339
|
+
#[test]
|
|
2340
|
+
fn caps_refuse_and_a_slot_returns_only_after_the_home_connection_closed() {
|
|
2341
|
+
let _serial = lock(&SERIAL);
|
|
2342
|
+
reset_registry();
|
|
2343
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
2344
|
+
let one = Limits {
|
|
2345
|
+
open_sockets: 1,
|
|
2346
|
+
..test_limits()
|
|
2347
|
+
};
|
|
2348
|
+
let mut first = session(home_port, one, "", &[]);
|
|
2349
|
+
let mut home = homes.recv().unwrap();
|
|
2350
|
+
let second = session(home_port, one, "", &[]);
|
|
2351
|
+
assert_eq!(second.status, 426);
|
|
2352
|
+
assert_eq!(second.worker.join().unwrap(), Err(Fallback::Cap));
|
|
2353
|
+
// Codex closes; the Home never answers: the slot is held until the close bound shuts it down.
|
|
2354
|
+
first
|
|
2355
|
+
.codex
|
|
2356
|
+
.write_all(&client_frame(8, &close_payload(Some(1000), "")))
|
|
2357
|
+
.unwrap();
|
|
2358
|
+
assert_eq!(
|
|
2359
|
+
read_events(&mut home.stream, Role::FromClient, &home.leftover, 1),
|
|
2360
|
+
vec![FrameEvent::Close(Some(1000), String::new())]
|
|
2361
|
+
);
|
|
2362
|
+
let mut rest = [0u8; 16];
|
|
2363
|
+
assert_eq!(
|
|
2364
|
+
home.stream.read(&mut rest).unwrap_or(0),
|
|
2365
|
+
0,
|
|
2366
|
+
"the Child ends the Home connection at the close bound"
|
|
2367
|
+
);
|
|
2368
|
+
assert!(first.worker.join().unwrap().is_ok());
|
|
2369
|
+
wait_all_released();
|
|
2370
|
+
let mem = Limits {
|
|
2371
|
+
memory_budget: 0,
|
|
2372
|
+
..test_limits()
|
|
2373
|
+
};
|
|
2374
|
+
let refused = session(home_port, mem, "", &[]);
|
|
2375
|
+
assert_eq!(refused.worker.join().unwrap(), Err(Fallback::Cap));
|
|
2376
|
+
}
|
|
2377
|
+
|
|
2378
|
+
#[test]
|
|
2379
|
+
fn the_setup_deadline_ends_a_held_upgrade() {
|
|
2380
|
+
let _serial = lock(&SERIAL);
|
|
2381
|
+
reset_registry();
|
|
2382
|
+
let (home_port, homes) = mock_home(HomeMode::Hold);
|
|
2383
|
+
let s = session(
|
|
2384
|
+
home_port,
|
|
2385
|
+
Limits {
|
|
2386
|
+
setup: Duration::from_millis(300),
|
|
2387
|
+
..test_limits()
|
|
2388
|
+
},
|
|
2389
|
+
"",
|
|
2390
|
+
&[],
|
|
2391
|
+
);
|
|
2392
|
+
assert_eq!(s.status, 426);
|
|
2393
|
+
assert_eq!(s.worker.join().unwrap(), Err(Fallback::HomeRefused));
|
|
2394
|
+
drop(homes);
|
|
2395
|
+
wait_all_released();
|
|
2396
|
+
}
|
|
2397
|
+
|
|
2398
|
+
#[test]
|
|
2399
|
+
fn stop_closes_open_sockets_with_1001_and_refuses_new_ones() {
|
|
2400
|
+
let _serial = lock(&SERIAL);
|
|
2401
|
+
reset_registry();
|
|
2402
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
2403
|
+
let mut s = session(home_port, test_limits(), "", &[]);
|
|
2404
|
+
let mut home = homes.recv().unwrap();
|
|
2405
|
+
stop_all();
|
|
2406
|
+
assert_eq!(
|
|
2407
|
+
read_events(&mut s.codex, Role::FromServer, &s.codex_leftover, 1),
|
|
2408
|
+
vec![FrameEvent::Close(
|
|
2409
|
+
Some(1001),
|
|
2410
|
+
"link websocket stopping".into()
|
|
2411
|
+
)]
|
|
2412
|
+
);
|
|
2413
|
+
assert_eq!(
|
|
2414
|
+
read_events(&mut home.stream, Role::FromClient, &home.leftover, 1),
|
|
2415
|
+
vec![FrameEvent::Close(Some(1001), String::new())]
|
|
2416
|
+
);
|
|
2417
|
+
assert!(s.worker.join().unwrap().is_ok());
|
|
2418
|
+
let after = session(home_port, test_limits(), "", &[]);
|
|
2419
|
+
assert_eq!(after.worker.join().unwrap(), Err(Fallback::Cap));
|
|
2420
|
+
reset_registry();
|
|
2421
|
+
}
|
|
2422
|
+
|
|
2423
|
+
#[test]
|
|
2424
|
+
fn pings_are_answered_per_hop() {
|
|
2425
|
+
let _serial = lock(&SERIAL);
|
|
2426
|
+
reset_registry();
|
|
2427
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
2428
|
+
let mut s = session(home_port, test_limits(), "", &[]);
|
|
2429
|
+
let mut home = homes.recv().unwrap();
|
|
2430
|
+
home.stream.write_all(&server_frame(9, b"hp")).unwrap();
|
|
2431
|
+
assert_eq!(
|
|
2432
|
+
read_events(&mut home.stream, Role::FromClient, &home.leftover, 1),
|
|
2433
|
+
vec![FrameEvent::Pong(b"hp".to_vec())]
|
|
2434
|
+
);
|
|
2435
|
+
s.codex.write_all(&client_frame(9, b"cp")).unwrap();
|
|
2436
|
+
assert_eq!(
|
|
2437
|
+
read_events(&mut s.codex, Role::FromServer, &s.codex_leftover, 1),
|
|
2438
|
+
vec![FrameEvent::Pong(b"cp".to_vec())]
|
|
2439
|
+
);
|
|
2440
|
+
home.stream.write_all(&server_frame(1, b"after")).unwrap();
|
|
2441
|
+
assert_eq!(
|
|
2442
|
+
read_events(&mut s.codex, Role::FromServer, &[], 1),
|
|
2443
|
+
vec![FrameEvent::Text("after".into())]
|
|
2444
|
+
);
|
|
2445
|
+
s.codex.shutdown(Shutdown::Both).unwrap();
|
|
2446
|
+
assert!(s.worker.join().unwrap().is_ok());
|
|
2447
|
+
wait_all_released();
|
|
2448
|
+
}
|
|
2449
|
+
|
|
2450
|
+
#[test]
|
|
2451
|
+
fn a_codex_that_stops_reading_is_disconnected_by_the_write_bounds() {
|
|
2452
|
+
let _serial = lock(&SERIAL);
|
|
2453
|
+
reset_registry();
|
|
2454
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
2455
|
+
let limits = Limits {
|
|
2456
|
+
stall: Duration::from_millis(200),
|
|
2457
|
+
data_operation: Duration::from_millis(400),
|
|
2458
|
+
..test_limits()
|
|
2459
|
+
};
|
|
2460
|
+
let s = session(home_port, limits, "", &[]);
|
|
2461
|
+
let home = homes.recv().unwrap();
|
|
2462
|
+
let mut writer = home.stream.try_clone().unwrap();
|
|
2463
|
+
let flood = thread::spawn(move || {
|
|
2464
|
+
let message = server_frame(1, &vec![b'z'; MIB]);
|
|
2465
|
+
for _ in 0..64 {
|
|
2466
|
+
if writer.write_all(&message).is_err() {
|
|
2467
|
+
return;
|
|
2468
|
+
}
|
|
2469
|
+
}
|
|
2470
|
+
});
|
|
2471
|
+
// Codex never reads: the write toward it stalls, the operation bound shuts both legs down.
|
|
2472
|
+
assert!(s.worker.join().unwrap().is_ok());
|
|
2473
|
+
// The flood is this test's own writer and may be blocked on a socket the Child has already shut down;
|
|
2474
|
+
// shutting our end wakes it at once (otherwise it waits for the kernel to drop the orphaned connection).
|
|
2475
|
+
let _ = home.stream.shutdown(Shutdown::Both);
|
|
2476
|
+
let _ = flood.join();
|
|
2477
|
+
drop(s.codex);
|
|
2478
|
+
wait_all_released();
|
|
2479
|
+
}
|
|
2480
|
+
|
|
2481
|
+
#[test]
|
|
2482
|
+
fn a_home_close_while_the_worker_is_blocked_writing_ends_within_the_close_bound() {
|
|
2483
|
+
let _serial = lock(&SERIAL);
|
|
2484
|
+
reset_registry();
|
|
2485
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
2486
|
+
let mut s = session(home_port, test_limits(), "", &[]);
|
|
2487
|
+
let mut home = homes.recv().unwrap();
|
|
2488
|
+
// The Home stops reading; Codex floods until the worker blocks writing to the Home.
|
|
2489
|
+
let mut codex_writer = s.codex.try_clone().unwrap();
|
|
2490
|
+
let flood = thread::spawn(move || {
|
|
2491
|
+
let message = client_frame(1, &vec![b'q'; MIB]);
|
|
2492
|
+
for _ in 0..64 {
|
|
2493
|
+
if codex_writer.write_all(&message).is_err() {
|
|
2494
|
+
return;
|
|
2495
|
+
}
|
|
2496
|
+
}
|
|
2497
|
+
});
|
|
2498
|
+
home.stream
|
|
2499
|
+
.write_all(&server_frame(8, &close_payload(Some(4000), "home")))
|
|
2500
|
+
.unwrap();
|
|
2501
|
+
let events = read_events(&mut s.codex, Role::FromServer, &s.codex_leftover, 1);
|
|
2502
|
+
assert_eq!(events, vec![FrameEvent::Close(Some(4000), "home".into())]);
|
|
2503
|
+
assert!(s.worker.join().unwrap().is_ok());
|
|
2504
|
+
// The flood is this test's own writer and may be blocked on a socket the Child has already shut down;
|
|
2505
|
+
// shutting our end wakes it at once (otherwise it waits for the kernel to drop the orphaned connection).
|
|
2506
|
+
let _ = s.codex.shutdown(Shutdown::Both);
|
|
2507
|
+
let _ = flood.join();
|
|
2508
|
+
wait_all_released();
|
|
2509
|
+
}
|
|
2510
|
+
|
|
2511
|
+
#[test]
|
|
2512
|
+
fn a_stop_between_the_101_and_the_start_aborts_and_releases_the_home_thread() {
|
|
2513
|
+
let _serial = lock(&SERIAL);
|
|
2514
|
+
reset_registry();
|
|
2515
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
2516
|
+
*lock(&BEFORE_START) = Some(stop_all_without_join);
|
|
2517
|
+
let mut s = session(home_port, test_limits(), "", &[]);
|
|
2518
|
+
let mut home = homes.recv().unwrap();
|
|
2519
|
+
assert_eq!(s.status, 101);
|
|
2520
|
+
assert_eq!(
|
|
2521
|
+
read_events(&mut s.codex, Role::FromServer, &s.codex_leftover, 1),
|
|
2522
|
+
vec![FrameEvent::Close(
|
|
2523
|
+
Some(1001),
|
|
2524
|
+
"link websocket stopping".into()
|
|
2525
|
+
)]
|
|
2526
|
+
);
|
|
2527
|
+
assert_eq!(
|
|
2528
|
+
read_events(&mut home.stream, Role::FromClient, &home.leftover, 1),
|
|
2529
|
+
vec![FrameEvent::Close(Some(1001), String::new())]
|
|
2530
|
+
);
|
|
2531
|
+
assert!(s.worker.join().unwrap().is_ok());
|
|
2532
|
+
*lock(&BEFORE_START) = None;
|
|
2533
|
+
wait_all_released();
|
|
2534
|
+
reset_registry();
|
|
2535
|
+
}
|
|
2536
|
+
|
|
2537
|
+
/// The registry half of stop_all (used inside the start hook, where joining the reaper would wait on this socket).
|
|
2538
|
+
fn stop_all_without_join() {
|
|
2539
|
+
let (m, _) = registry();
|
|
2540
|
+
lock(m).stopping = true;
|
|
2541
|
+
}
|
|
2542
|
+
|
|
2543
|
+
/// `stop_owned_daemon` (detach, restart, sync) waits 3 s for the port to close; the link WebSocket's share
|
|
2544
|
+
/// of a stop must leave room for the listener to close and the process to exit.
|
|
2545
|
+
const DETACH_WAIT: Duration = Duration::from_secs(3);
|
|
2546
|
+
|
|
2547
|
+
#[test]
|
|
2548
|
+
fn a_stop_with_a_codex_that_does_not_read_ends_well_inside_detachs_wait() {
|
|
2549
|
+
let _serial = lock(&SERIAL);
|
|
2550
|
+
reset_registry();
|
|
2551
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
2552
|
+
// The default limits: a 5 s close bound, 300 s stall, 600 s data operations.
|
|
2553
|
+
let s = session(home_port, LIMITS, "", &[]);
|
|
2554
|
+
assert_eq!(s.status, 101);
|
|
2555
|
+
let _home = homes.recv().unwrap();
|
|
2556
|
+
let shared = only_socket();
|
|
2557
|
+
let (locked_tx, locked) = mpsc::channel();
|
|
2558
|
+
*lock(&DATA_LOCKED) = Some(locked_tx);
|
|
2559
|
+
// Codex never reads; a large message holds Codex's write lock, so the stop's 1001 cannot be written.
|
|
2560
|
+
let writer = {
|
|
2561
|
+
let shared = Arc::clone(&shared);
|
|
2562
|
+
thread::spawn(move || {
|
|
2563
|
+
write_frame(&shared, Leg::Codex, 1, vec![b's'; 64 * MIB], Kind::Data)
|
|
2564
|
+
})
|
|
2565
|
+
};
|
|
2566
|
+
locked.recv().unwrap();
|
|
2567
|
+
drop(shared);
|
|
2568
|
+
let started = Instant::now();
|
|
2569
|
+
stop_all();
|
|
2570
|
+
let elapsed = started.elapsed();
|
|
2571
|
+
assert!(
|
|
2572
|
+
elapsed < DETACH_WAIT - Duration::from_secs(1),
|
|
2573
|
+
"stop took {elapsed:?}; detach gives up after {DETACH_WAIT:?}"
|
|
2574
|
+
);
|
|
2575
|
+
assert!(writer.join().unwrap().is_err());
|
|
2576
|
+
assert!(s.worker.join().unwrap().is_ok());
|
|
2577
|
+
drop(s.codex);
|
|
2578
|
+
wait_all_released();
|
|
2579
|
+
reset_registry();
|
|
2580
|
+
}
|
|
2581
|
+
|
|
2582
|
+
#[test]
|
|
2583
|
+
fn a_failed_thread_spawn_answers_426_and_closes_the_home_connection() {
|
|
2584
|
+
let _serial = lock(&SERIAL);
|
|
2585
|
+
reset_registry();
|
|
2586
|
+
let (home_port, homes) = mock_home(HomeMode::Advertise);
|
|
2587
|
+
FAIL_SPAWN.store(true, Ordering::SeqCst);
|
|
2588
|
+
let s = session(home_port, test_limits(), "", &[]);
|
|
2589
|
+
assert_eq!(s.status, 426);
|
|
2590
|
+
assert_eq!(s.worker.join().unwrap(), Err(Fallback::Unavailable));
|
|
2591
|
+
let mut home = homes.recv().unwrap();
|
|
2592
|
+
assert_eq!(
|
|
2593
|
+
read_events(&mut home.stream, Role::FromClient, &home.leftover, 1),
|
|
2594
|
+
vec![]
|
|
2595
|
+
);
|
|
2596
|
+
wait_all_released();
|
|
2597
|
+
}
|
|
2598
|
+
}
|