Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
0873d2c79d | ||
|
|
12a11edfd7 | ||
|
|
71ab5a957c | ||
|
|
f6c740bc24 | ||
|
|
968173095e | ||
|
|
63c603d919 | ||
|
|
fdb9bedb03 | ||
|
|
4be4750aae | ||
|
|
165b11bda3 | ||
|
|
e83bb8d2f1 | ||
|
|
c0a647237a | ||
|
|
9c49fa91af | ||
|
|
fbeb6dc328 | ||
|
|
8180f4ff80 | ||
|
|
9155c55d4c | ||
|
|
be2eab6262 | ||
|
|
15df9086c1 | ||
|
|
d2d4c085ae | ||
|
|
6e785275da | ||
|
|
9d49c4b070 | ||
|
|
dd3cff19cb | ||
|
|
25047a603a | ||
|
|
69dcedbd9c | ||
|
|
bccfaae2fa | ||
|
|
7cd26aff56 | ||
|
|
4f59233064 | ||
|
|
7e0174fda1 | ||
|
|
7d5f250254 | ||
|
|
fbf44889ea | ||
|
|
f9cd12b374 | ||
|
|
aab9b63350 | ||
|
|
224b3b37e8 | ||
|
|
1fa4aa5532 | ||
|
|
315c595714 | ||
|
|
50102800a3 | ||
|
|
a998d7a3e3 | ||
|
|
cd02ff47a5 | ||
|
|
836a531e93 | ||
|
|
8d72f07cf0 | ||
|
|
bdea96229b | ||
|
|
d318b734fa | ||
|
|
4305da5e57 | ||
|
|
dc787f1f3b | ||
|
|
f63127d633 | ||
|
|
b02a14bcfc | ||
|
|
20dff12c05 | ||
|
|
ac6bc20c68 | ||
|
|
8f0accf21d | ||
|
|
69c5023f1e | ||
|
|
b242e34ca0 | ||
|
|
82492231bc | ||
|
|
27e1dc15e8 | ||
|
|
684be52d5a | ||
|
|
76de56fef5 | ||
|
|
ae9e2c67cc | ||
|
|
400edbe913 | ||
|
|
462ced01a6 | ||
|
|
c79ee1315d | ||
|
|
cce24b6880 | ||
|
|
b1316b2bd9 | ||
|
|
9f6eccc5ac | ||
|
|
4d1adeb05e | ||
|
|
628c0630a5 | ||
|
|
086c883c4a | ||
|
|
4324d3046e | ||
|
|
de5c1a5a15 | ||
|
|
d22ee79159 | ||
|
|
3d1fd36811 | ||
|
|
7f2ea8a8dc | ||
|
|
b26f389460 | ||
|
|
b46f15b340 | ||
|
|
c9d32f9793 | ||
|
|
5cf9d44d7e | ||
|
|
d9dc60918c | ||
|
|
bb31a7befc | ||
|
|
b1b7a3dbc0 | ||
|
|
8275f893dd | ||
|
|
36f12d6d4e | ||
|
|
a4d82bf45b | ||
|
|
d925414bc8 | ||
|
|
9f9fe18926 | ||
|
|
d8d044f439 | ||
|
|
517bee9b9e | ||
|
|
10d7fd6d95 | ||
|
|
9b440a46e3 | ||
|
|
c3b0dc6c8a | ||
|
|
bfda29a845 | ||
|
|
2c58cbac48 | ||
|
|
174b162dfd | ||
|
|
75b7424a0d | ||
|
|
8d4fe502be | ||
|
|
038c1b1c2b | ||
|
|
20d7f49c9d | ||
|
|
74cee50d35 | ||
|
|
32a75c92ef | ||
|
|
f4d9c12bb6 | ||
|
|
b610ce3d7f | ||
|
|
1a5dcd17a9 | ||
|
|
3b1b1fa63e | ||
|
|
7880b14e47 | ||
|
|
5bbf5b71b7 | ||
|
|
cfec9606a4 | ||
|
|
e8d7cdc77a | ||
|
|
8ba585679a | ||
|
|
ea102130ac | ||
|
|
e656402ec8 | ||
|
|
80f3c22582 | ||
|
|
a79ac3e09e | ||
|
|
6580005e77 | ||
|
|
2734c8e356 | ||
|
|
0c2897ce37 | ||
|
|
fbc903fa6a | ||
|
|
fe9617ab56 | ||
|
|
1e9e4f16b5 | ||
|
|
6a6a5e7ded | ||
|
|
e20b6890d3 | ||
|
|
17bee91248 | ||
|
|
63d0de8ae3 | ||
|
|
9a8efc807a | ||
|
|
9879a0eb25 | ||
|
|
03c19ef7c6 | ||
|
|
2540801140 | ||
|
|
dd28fa233c | ||
|
|
e5ca519df0 | ||
|
|
06c8e01eb5 | ||
|
|
990439985d | ||
|
|
54136b71ef | ||
|
|
5d18304f0f | ||
|
|
8bbf844bb6 | ||
|
|
97607a0a91 |
@@ -1,9 +1,8 @@
|
||||
name: public-benchmark-pages
|
||||
|
||||
on:
|
||||
workflow_run:
|
||||
workflows: [build-test-release]
|
||||
types: [completed]
|
||||
schedule:
|
||||
- cron: '*/15 * * * *'
|
||||
workflow_dispatch:
|
||||
|
||||
concurrency:
|
||||
@@ -12,15 +11,17 @@ concurrency:
|
||||
|
||||
jobs:
|
||||
publish:
|
||||
runs-on: alkane-verify
|
||||
runs-on: alkane-ci
|
||||
container:
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:8f20439b38ae1c070b1a692a89c084f69134f4fa16a755d02783f621cd9ac041
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
|
||||
permissions:
|
||||
contents: read
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Install SSH client
|
||||
run: bash ci/ensure-build-deps.sh ssh
|
||||
run: |
|
||||
apt-get update -qq
|
||||
apt-get install -y -qq --no-install-recommends openssh-client
|
||||
- name: Render measured benchmark history
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
|
||||
|
||||
@@ -7,9 +7,9 @@ on:
|
||||
|
||||
jobs:
|
||||
publish:
|
||||
runs-on: alkane-verify
|
||||
runs-on: alkane-ci
|
||||
container:
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:8f20439b38ae1c070b1a692a89c084f69134f4fa16a755d02783f621cd9ac041
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
|
||||
permissions:
|
||||
actions: read
|
||||
contents: write
|
||||
|
||||
@@ -17,11 +17,12 @@ jobs:
|
||||
windows:
|
||||
runs-on: alkane-ci
|
||||
container:
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:8f20439b38ae1c070b1a692a89c084f69134f4fa16a755d02783f621cd9ac041
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
|
||||
env:
|
||||
CARGO_TARGET_DIR: target
|
||||
CARGO_BUILD_JOBS: 2
|
||||
WX_WINDOWS_PREFIX: /root/.cache/wx-3.3.3-mingw
|
||||
ALKANE_EMBEDDED_TOKEN: ${{ secrets.ALKANE_EMBEDDED_TOKEN }}
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
with:
|
||||
@@ -64,6 +65,14 @@ jobs:
|
||||
- name: Build Windows candidate
|
||||
if: steps.version.outputs.release == 'true'
|
||||
run: bash ci/windows-ci.sh build
|
||||
- name: Sign Windows candidate (Azure Artifact Signing)
|
||||
if: steps.version.outputs.release == 'true'
|
||||
env:
|
||||
AZURE_SIGNING_PROFILE: ${{ vars.AZURE_SIGNING_PROFILE }}
|
||||
AZURE_SIGNING_TENANT_ID: ${{ secrets.AZURE_SIGNING_TENANT_ID }}
|
||||
AZURE_SIGNING_CLIENT_ID: ${{ secrets.AZURE_SIGNING_CLIENT_ID }}
|
||||
AZURE_SIGNING_CLIENT_SECRET: ${{ secrets.AZURE_SIGNING_CLIENT_SECRET }}
|
||||
run: bash ci/windows-ci.sh sign
|
||||
- name: Package Windows candidate
|
||||
if: steps.version.outputs.release == 'true'
|
||||
run: bash ci/windows-ci.sh package "${{ steps.version.outputs.version }}"
|
||||
@@ -80,12 +89,13 @@ jobs:
|
||||
needs: windows
|
||||
runs-on: alkane-ci
|
||||
container:
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:8f20439b38ae1c070b1a692a89c084f69134f4fa16a755d02783f621cd9ac041
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
|
||||
env:
|
||||
CARGO_TARGET_DIR: target
|
||||
CARGO_BUILD_JOBS: 2
|
||||
WX_PREFIX: /root/.cache/wx-3.3.3-linux
|
||||
WX_RS_WXCONFIG: /root/.cache/wx-3.3.3-linux/bin/wx-config
|
||||
ALKANE_EMBEDDED_TOKEN: ${{ secrets.ALKANE_EMBEDDED_TOKEN }}
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
with:
|
||||
|
||||
@@ -0,0 +1,47 @@
|
||||
name: pages
|
||||
|
||||
# The project site, https://blueflare.gitea.bluefla.re/alkane-toolkit/ :
|
||||
# overview, user manual (docs/manual), code-quality dashboard (from the
|
||||
# quality record main CI publishes with the badges) and benchmark history.
|
||||
# Rebuilt after every main build-test-release run and published to this
|
||||
# repository's gh-pages branch.
|
||||
on:
|
||||
workflow_run:
|
||||
workflows: [build-test-release]
|
||||
types: [completed]
|
||||
workflow_dispatch:
|
||||
|
||||
concurrency:
|
||||
group: alkane-toolkit-pages
|
||||
cancel-in-progress: false
|
||||
|
||||
jobs:
|
||||
publish:
|
||||
runs-on: alkane-verify
|
||||
container:
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
|
||||
permissions:
|
||||
contents: write
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Install page tools
|
||||
run: bash ci/ensure-build-deps.sh pages
|
||||
- name: Render measured benchmark history
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
|
||||
run: python3 ci/bench_history.py render
|
||||
- name: Fetch measured quality record
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
|
||||
run: python3 ci/fetch-quality.py quality.json
|
||||
- name: Build site
|
||||
run: |
|
||||
python3 ci/build-pages.py --out site --quality quality.json \
|
||||
--bench bench-site/index.html --sha "$GITHUB_SHA"
|
||||
- name: Publish site
|
||||
env:
|
||||
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
|
||||
run: python3 ci/publish-pages.py site
|
||||
- name: Clean generated site
|
||||
if: always()
|
||||
run: python3 ci/cleanup-generated.py
|
||||
@@ -23,11 +23,14 @@ jobs:
|
||||
windows:
|
||||
runs-on: alkane-ci
|
||||
container:
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:8f20439b38ae1c070b1a692a89c084f69134f4fa16a755d02783f621cd9ac041
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
|
||||
env:
|
||||
CARGO_TARGET_DIR: target
|
||||
CARGO_BUILD_JOBS: 2
|
||||
WX_WINDOWS_PREFIX: /root/.cache/wx-3.3.3-mingw
|
||||
# Read-only token baked into the GUI so the release picker can list the
|
||||
# private alkane-os releases with no user setup (option_env!).
|
||||
ALKANE_EMBEDDED_TOKEN: ${{ secrets.ALKANE_EMBEDDED_TOKEN }}
|
||||
steps:
|
||||
- name: Checkout (full history for tags)
|
||||
uses: actions/checkout@v4
|
||||
@@ -91,6 +94,14 @@ jobs:
|
||||
- name: Headless UI self-test (Windows build, under Wine)
|
||||
run: bash ci/windows-ci.sh selftest
|
||||
|
||||
- name: Sign Windows executable (Azure Artifact Signing)
|
||||
env:
|
||||
AZURE_SIGNING_PROFILE: ${{ vars.AZURE_SIGNING_PROFILE }}
|
||||
AZURE_SIGNING_TENANT_ID: ${{ secrets.AZURE_SIGNING_TENANT_ID }}
|
||||
AZURE_SIGNING_CLIENT_ID: ${{ secrets.AZURE_SIGNING_CLIENT_ID }}
|
||||
AZURE_SIGNING_CLIENT_SECRET: ${{ secrets.AZURE_SIGNING_CLIENT_SECRET }}
|
||||
run: bash ci/windows-ci.sh sign
|
||||
|
||||
- name: Package Windows artifact
|
||||
if: steps.ver.outputs.release == 'true'
|
||||
run: bash ci/windows-ci.sh package "${{ steps.ver.outputs.version }}"
|
||||
@@ -120,7 +131,7 @@ jobs:
|
||||
needs: windows
|
||||
runs-on: alkane-ci
|
||||
container:
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:8f20439b38ae1c070b1a692a89c084f69134f4fa16a755d02783f621cd9ac041
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
|
||||
env:
|
||||
CARGO_TARGET_DIR: target
|
||||
CARGO_BUILD_JOBS: 2
|
||||
@@ -128,6 +139,9 @@ jobs:
|
||||
# Set once for the whole job so build/clippy/test/bench steps don't each
|
||||
# re-export it (round 18 #12).
|
||||
WX_RS_WXCONFIG: /root/.cache/wx-3.3.3-linux/bin/wx-config
|
||||
# Read-only token baked into the GUI so the release picker can list the
|
||||
# private alkane-os releases with no user setup (option_env!).
|
||||
ALKANE_EMBEDDED_TOKEN: ${{ secrets.ALKANE_EMBEDDED_TOKEN }}
|
||||
steps:
|
||||
- name: Checkout (full history for tags)
|
||||
uses: actions/checkout@v4
|
||||
@@ -263,8 +277,10 @@ jobs:
|
||||
set -euo pipefail
|
||||
rustup component add llvm-tools-preview >/dev/null 2>&1 || true
|
||||
[ "$(cargo llvm-cov --version)" = 'cargo-llvm-cov 0.8.7' ]
|
||||
PCT=$(bash ci/coverage.sh --summary-only \
|
||||
| awk '/^TOTAL/{gsub(/%/,"",$10); print $10}')
|
||||
# Keep the whole table: gen-badges turns it into the per-crate and
|
||||
# per-file breakdown on the Pages quality dashboard.
|
||||
bash ci/coverage.sh --summary-only | tee coverage-summary.txt
|
||||
PCT=$(awk '/^TOTAL/{gsub(/%/,"",$10); print $10}' coverage-summary.txt)
|
||||
[ -n "$PCT" ] || { echo "coverage report produced no TOTAL line" >&2; exit 1; }
|
||||
echo "pct=${PCT}" >> "$GITHUB_OUTPUT"
|
||||
echo "line coverage (tests + self-test): ${PCT}%"
|
||||
@@ -292,7 +308,8 @@ jobs:
|
||||
python3 ci/gen-badges.py --tests "$PASS" \
|
||||
--coverage "${{ steps.cov.outputs.pct }}" \
|
||||
--bench-coverage "${{ steps.benchcov.outputs.pct }}" \
|
||||
--bench-delta "$BENCH_DELTA" --clippy clean
|
||||
--bench-delta "$BENCH_DELTA" --clippy clean \
|
||||
--coverage-summary coverage-summary.txt
|
||||
|
||||
- name: Publish measured badges
|
||||
env:
|
||||
|
||||
@@ -11,9 +11,9 @@ concurrency:
|
||||
|
||||
jobs:
|
||||
check:
|
||||
runs-on: alkane-fast
|
||||
runs-on: alkane-ci
|
||||
container:
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:8f20439b38ae1c070b1a692a89c084f69134f4fa16a755d02783f621cd9ac041
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
|
||||
env:
|
||||
CARGO_BUILD_JOBS: 2
|
||||
steps:
|
||||
|
||||
@@ -11,9 +11,9 @@ concurrency:
|
||||
|
||||
jobs:
|
||||
verify:
|
||||
runs-on: alkane-verify
|
||||
runs-on: alkane-ci
|
||||
container:
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:8f20439b38ae1c070b1a692a89c084f69134f4fa16a755d02783f621cd9ac041
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
|
||||
outputs:
|
||||
surface: ${{ steps.surface.outputs.surface }}
|
||||
env:
|
||||
@@ -159,6 +159,7 @@ jobs:
|
||||
run: |
|
||||
cargo test -p alkane-gui --offline
|
||||
cargo test --workspace --exclude alkane-gui --exclude wx-rs --offline
|
||||
python3 tools/report-relay/test_relay.py
|
||||
|
||||
- name: Microbenchmarks
|
||||
if: steps.surface.outputs.surface == 'full'
|
||||
@@ -201,9 +202,9 @@ jobs:
|
||||
verify-windows:
|
||||
needs: verify
|
||||
if: needs.verify.outputs.surface == 'full'
|
||||
runs-on: alkane-verify
|
||||
runs-on: alkane-ci
|
||||
container:
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:8f20439b38ae1c070b1a692a89c084f69134f4fa16a755d02783f621cd9ac041
|
||||
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
|
||||
env:
|
||||
CARGO_TARGET_DIR: target
|
||||
CARGO_BUILD_JOBS: 2
|
||||
|
||||
@@ -63,6 +63,18 @@ jobs:
|
||||
$os = Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion'
|
||||
"Testing run $env:RUN_ID on Windows $($os.DisplayVersion) build $($os.CurrentBuild)"
|
||||
|
||||
- name: Authenticode signature (native Windows)
|
||||
env:
|
||||
SIGNING_ENABLED: ${{ vars.AZURE_SIGNING_PROFILE }}
|
||||
run: |
|
||||
# Windows itself judges the signature: chain to a trusted root,
|
||||
# intact file hash, valid timestamp. Required once signing is on.
|
||||
$sig = Get-AuthenticodeSignature "$env:ALKANE_NATIVE\alkane-toolkit.exe"
|
||||
Write-Host "Signature: $($sig.Status) $($sig.StatusMessage)"
|
||||
if ($sig.SignerCertificate) { Write-Host "Signer: $($sig.SignerCertificate.Subject)" }
|
||||
if ($sig.TimeStamperCertificate) { Write-Host "Timestamp: $($sig.TimeStamperCertificate.Subject)" }
|
||||
if ($env:SIGNING_ENABLED -and $sig.Status -ne 'Valid') { exit 1 }
|
||||
|
||||
- name: Unit tests (native Windows)
|
||||
run: |
|
||||
$failed = @()
|
||||
|
||||
@@ -2,3 +2,8 @@
|
||||
**/target
|
||||
.claude/
|
||||
__pycache__/
|
||||
# Internal working notes live outside this public repository.
|
||||
/AGENTS.md
|
||||
/HANDOFF.md
|
||||
/CLAUDE.md
|
||||
code-review-report*.md
|
||||
|
||||
Generated
+7
@@ -40,6 +40,8 @@ name = "alkane-artifacts"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"alkane-core",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"sha2",
|
||||
"thiserror",
|
||||
]
|
||||
@@ -50,6 +52,8 @@ version = "0.1.0"
|
||||
dependencies = [
|
||||
"alkane-artifacts",
|
||||
"alkane-core",
|
||||
"alkane-flash",
|
||||
"serde_json",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -74,6 +78,7 @@ version = "0.1.0"
|
||||
dependencies = [
|
||||
"alkane-artifacts",
|
||||
"alkane-core",
|
||||
"serde_json",
|
||||
"sha2",
|
||||
"tempfile",
|
||||
"thiserror",
|
||||
@@ -84,8 +89,10 @@ name = "alkane-gui"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"aes",
|
||||
"alkane-artifacts",
|
||||
"alkane-core",
|
||||
"alkane-discovery",
|
||||
"alkane-flash",
|
||||
"asic-rs",
|
||||
"base64 0.21.7",
|
||||
"ecb",
|
||||
|
||||
@@ -19,6 +19,7 @@ license = "MIT"
|
||||
thiserror = "2"
|
||||
serde = { version = "1", features = ["derive"] }
|
||||
sha2 = "0.10"
|
||||
serde_json = "1"
|
||||
|
||||
# Release binary: small, self-contained, and fast enough for a fleet GUI whose
|
||||
# hot path is network I/O, not CPU (round 18 #12). opt-level "s" + fat LTO +
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2026 Blueflare
|
||||
Copyright (c) 2026 BlueFlare Energy Solutions Inc.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
|
||||
@@ -1,17 +1,18 @@
|
||||
# Alkane Toolkit
|
||||
|
||||
[](https://gitea.bluefla.re/blueflare/alkane-toolkit/actions)
|
||||

|
||||

|
||||

|
||||

|
||||

|
||||

|
||||

|
||||

|
||||
[](https://blueflare.gitea.bluefla.re/alkane-toolkit/quality/)
|
||||
[](https://blueflare.gitea.bluefla.re/alkane-toolkit/quality/#coverage)
|
||||
[](https://blueflare.gitea.bluefla.re/alkane-toolkit/bench/)
|
||||
[](https://blueflare.gitea.bluefla.re/alkane-toolkit/quality/)
|
||||
[](https://blueflare.gitea.bluefla.re/alkane-toolkit/quality/#coverage)
|
||||
[](https://blueflare.gitea.bluefla.re/alkane-toolkit/quality/)
|
||||
[](https://blueflare.gitea.bluefla.re/alkane-toolkit/quality/)
|
||||
[](LICENSE)
|
||||
|
||||
The code quality grade reports GUI Clippy and first-party Rust formatting checks
|
||||
from the last successful main build. Test coverage has a separate badge.
|
||||
The badges link to the [project site](https://blueflare.gitea.bluefla.re/alkane-toolkit/): the [manual](https://blueflare.gitea.bluefla.re/alkane-toolkit/manual/),
|
||||
the [code-quality dashboard](https://blueflare.gitea.bluefla.re/alkane-toolkit/quality/) (how the grade is set, coverage by
|
||||
crate and file) and the [benchmark history](https://blueflare.gitea.bluefla.re/alkane-toolkit/bench/).
|
||||
|
||||
Desktop miner discovery and monitoring. The Rust GUI uses wxWidgets through
|
||||
a patched [wx-rs bridge](thirdparty/wx-rs). In-app image flashing is disabled
|
||||
@@ -31,7 +32,9 @@ uses offline fixtures and does not contact hardware.
|
||||
Windows 10/11 builds are cross-compiled on Linux (`scripts/build-wx-windows.sh`,
|
||||
then `scripts/build-gui-windows.sh`) and attached to every release as a
|
||||
self-contained `alkane-toolkit.exe`; see [docs/windows.md](docs/windows.md).
|
||||
macOS is not built.
|
||||
macOS builds run on a Mac (`scripts/build-wx-macos.sh`, then
|
||||
`scripts/build-gui-macos.sh`) and produce one universal app for Apple Silicon
|
||||
and Intel, macOS 11 or later; see [docs/macos.md](docs/macos.md).
|
||||
|
||||
## Current scope
|
||||
|
||||
@@ -42,8 +45,51 @@ macOS is not built.
|
||||
aftermarket firmware to stock.
|
||||
|
||||
Discovery is read-only. Control and restore actions change miners. Check the
|
||||
selected devices before applying them. See the [implementation plan](docs/IMPLEMENTATION-PLAN.md)
|
||||
and [firmware matrix](docs/aftermarket-parity-roadmap.md) for planned coverage.
|
||||
selected devices before applying them.
|
||||
|
||||
## Headless .afw install (CV1835 and AM335x)
|
||||
|
||||
`alkane-cli` is the headless engine; the GUI uses the same engine. A verified
|
||||
`.afw` is a full OS bundle for exactly one board. The CV1835 installer writes
|
||||
only `/dev/mmcblk0p1` over SSH, holds the current p1 first, reads the whole
|
||||
partition back, and reboots only after the read-back matches.
|
||||
|
||||
The AM335x installer writes mtd8 (type-3 ramdisk), mtd6 (dtb) and mtd7
|
||||
(legacy kernel uImage) with `flash_erase` + `nandwrite`. It never touches
|
||||
mtd0-5 (SPL/U-Boot/bootenv), holds a backup of each target before writing it,
|
||||
and reads every target back before reboot. Its `verify-live` checks SSH
|
||||
(kernel string), the HTTP marker on port 80, the API on port 4028, and the
|
||||
eth0 DHCP lease.
|
||||
|
||||
```sh
|
||||
alkane-cli afw verify BUNDLE.afw --allow-unsigned
|
||||
alkane-cli afw plan BUNDLE.afw --host 10.255.1.167
|
||||
alkane-cli afw preflight BUNDLE.afw --host 10.255.1.167
|
||||
alkane-cli afw install BUNDLE.afw --host 10.255.1.167 --dry-run
|
||||
alkane-cli afw install BUNDLE.afw --host 10.255.1.167 --confirm FLASH
|
||||
alkane-cli afw verify-live BUNDLE.afw --host 10.255.1.167
|
||||
alkane-cli afw restore --host 10.255.1.167 --held-backup p1.img --confirm FLASH
|
||||
```
|
||||
|
||||
For AM335x the same subcommands infer the board from the bundle; restore names
|
||||
the three held copies explicitly:
|
||||
|
||||
```sh
|
||||
alkane-cli afw plan BUNDLE.afw --host 10.255.1.64
|
||||
alkane-cli afw preflight BUNDLE.afw --host 10.255.1.64
|
||||
alkane-cli afw install BUNDLE.afw --host 10.255.1.64 --dry-run
|
||||
alkane-cli afw install BUNDLE.afw --host 10.255.1.64 --confirm FLASH
|
||||
alkane-cli afw verify-live BUNDLE.afw --host 10.255.1.64 --timeout 300
|
||||
alkane-cli afw restore --board am335x --host 10.255.1.64 \
|
||||
--held-backup mtd8.img --held-kernel mtd7.img --held-dtb mtd6.img --confirm FLASH
|
||||
```
|
||||
|
||||
On stock Bitmain CV1835 the SSH login is the unprivileged `miner` account; the
|
||||
toolkit obtains root through the stock update-daemon loopback channel, not a
|
||||
serial console. Credentials come only from `ALKANE_BOARD_PASSWORD` or
|
||||
`ALKANE_BOARD_PASSWORD_FILE`, or from `--password-file` / `--identity-file`.
|
||||
No credential value is printed. `--allow-unsigned` is bench-only; site use
|
||||
needs an Ed25519-signed bundle.
|
||||
|
||||
## Development
|
||||
|
||||
@@ -55,8 +101,8 @@ WX_RS_WXCONFIG="$HOME/.cache/wx-3.3.3-linux/bin/wx-config" \
|
||||
|
||||
Keep build output off the source share. `main` runs full CI and publishes
|
||||
qualifying releases; `next` builds `-rc` candidates. Badges measure host
|
||||
code, not installation support. See the public
|
||||
[benchmark history](https://blueflare.gitea.bluefla.re/alkane-benchmarks/toolkit/).
|
||||
code, not installation support. See the
|
||||
[benchmark history](https://blueflare.gitea.bluefla.re/alkane-toolkit/bench/).
|
||||
|
||||
## Firmware safety
|
||||
|
||||
|
||||
Executable
+293
@@ -0,0 +1,293 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Build the Alkane Toolkit Pages site (served from this repo's gh-pages).
|
||||
|
||||
build-pages.py --out site [--manual docs/manual] [--quality quality.json]
|
||||
[--bench bench-site/index.html] [--sha SHA]
|
||||
|
||||
Pages:
|
||||
/ overview and downloads
|
||||
/manual/ the user manual, one page per docs/manual/NN-name.md chapter
|
||||
/quality/ code-quality dashboard from the measured quality.json that main
|
||||
CI publishes next to the badges (ci/gen-badges.py)
|
||||
/bench/ the measured benchmark history (ci/bench_history.py render)
|
||||
|
||||
Every value taken from CI data is HTML-escaped; the manual is Markdown written
|
||||
in this repository.
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import html
|
||||
import json
|
||||
import re
|
||||
import shutil
|
||||
from pathlib import Path
|
||||
|
||||
import markdown
|
||||
|
||||
REPO = "https://gitea.bluefla.re/blueflare/alkane-toolkit"
|
||||
RELEASES = REPO + "/releases"
|
||||
SECTIONS = (("", "Overview"), ("manual/", "Manual"), ("quality/", "Code quality"),
|
||||
("bench/", "Benchmarks"))
|
||||
|
||||
CSS = """
|
||||
:root { --bg:#ffffff; --fg:#1f2328; --muted:#59636e; --line:#d1d9e0; --card:#f6f8fa;
|
||||
--accent:#d9822b; --link:#0969da; --good:#1a7f37; --warn:#9a6700; --bad:#cf222e; }
|
||||
@media (prefers-color-scheme: dark) { :root { --bg:#0d1117; --fg:#e6edf3; --muted:#9198a1;
|
||||
--line:#30363d; --card:#151b23; --link:#4493f8; --good:#3fb950; --warn:#d29922; --bad:#f85149; } }
|
||||
* { box-sizing: border-box; }
|
||||
body { margin:0; background:var(--bg); color:var(--fg);
|
||||
font:16px/1.55 system-ui,-apple-system,"Segoe UI",Roboto,Ubuntu,sans-serif; }
|
||||
a { color:var(--link); text-decoration:none; } a:hover { text-decoration:underline; }
|
||||
header { border-bottom:1px solid var(--line); }
|
||||
header .bar, main { max-width:1040px; margin:0 auto; padding:0 16px; }
|
||||
header .bar { display:flex; align-items:center; gap:24px; height:56px; flex-wrap:wrap; }
|
||||
header .brand { font-weight:700; color:var(--fg); display:flex; gap:8px; align-items:center; }
|
||||
header .brand i { width:20px; height:20px; border-radius:5px; background:var(--accent); display:inline-block; }
|
||||
header nav { display:flex; gap:18px; flex-wrap:wrap; }
|
||||
header nav a { color:var(--muted); } header nav a.on { color:var(--fg); font-weight:600; }
|
||||
main { padding:28px 16px 64px; }
|
||||
h1 { font-size:1.9rem; margin:.2em 0 .4em; } h2 { margin-top:1.8em; border-bottom:1px solid var(--line); padding-bottom:.25em; }
|
||||
code { background:var(--card); border:1px solid var(--line); border-radius:5px; padding:.1em .35em; font-size:.92em; }
|
||||
pre { background:var(--card); border:1px solid var(--line); border-radius:8px; padding:12px; overflow:auto; }
|
||||
pre code { border:0; padding:0; }
|
||||
table { border-collapse:collapse; width:100%; margin:1em 0; display:block; overflow-x:auto; }
|
||||
th, td { border:1px solid var(--line); padding:6px 10px; text-align:left; vertical-align:top; }
|
||||
th { background:var(--card); }
|
||||
td.num, th.num { text-align:right; font-variant-numeric:tabular-nums; white-space:nowrap; }
|
||||
.cards { display:grid; grid-template-columns:repeat(auto-fill,minmax(180px,1fr)); gap:12px; margin:1.2em 0; }
|
||||
.card { background:var(--card); border:1px solid var(--line); border-radius:10px; padding:14px; }
|
||||
.card b { display:block; font-size:1.6rem; } .card span { color:var(--muted); font-size:.9rem; }
|
||||
.good { color:var(--good); } .warn { color:var(--warn); } .bad { color:var(--bad); }
|
||||
.bar-cell { min-width:120px; } .meter { height:8px; background:var(--line); border-radius:4px; overflow:hidden; }
|
||||
.meter i { display:block; height:100%; }
|
||||
.layout { display:grid; grid-template-columns:220px 1fr; gap:32px; }
|
||||
.layout aside ol { padding-left:1.2em; margin:0; } .layout aside li { margin:.3em 0; }
|
||||
.layout aside a.on { font-weight:600; color:var(--fg); }
|
||||
@media (max-width:760px) { .layout { grid-template-columns:1fr; } }
|
||||
.buttons a { display:inline-block; margin:4px 8px 4px 0; padding:8px 14px; border-radius:8px;
|
||||
border:1px solid var(--line); background:var(--card); color:var(--fg); }
|
||||
.buttons a.primary { background:var(--accent); border-color:var(--accent); color:#fff; }
|
||||
footer { color:var(--muted); font-size:.85rem; margin-top:48px; }
|
||||
"""
|
||||
|
||||
|
||||
def page(title: str, body: str, depth: int, current: str, sha: str) -> str:
|
||||
up = "../" * depth
|
||||
nav = "".join(
|
||||
f'<a href="{up}{path}"{" class=on" if path == current else ""}>{label}</a>'
|
||||
for path, label in SECTIONS)
|
||||
built = f"Built from {html.escape(sha[:10])}. " if sha else ""
|
||||
return f"""<!doctype html>
|
||||
<html lang="en"><head><meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<title>{html.escape(title)} - Alkane Toolkit</title>
|
||||
<link rel="stylesheet" href="{up}style.css"></head>
|
||||
<body><header><div class="bar"><a class="brand" href="{up}"><i></i>Alkane Toolkit</a>
|
||||
<nav>{nav}<a href="{RELEASES}">Downloads</a><a href="{REPO}">Source</a></nav></div></header>
|
||||
<main>{body}
|
||||
<footer>{built}Alkane Toolkit is MIT licensed.</footer></main></body></html>
|
||||
"""
|
||||
|
||||
|
||||
def write(out: Path, rel: str, text: str) -> None:
|
||||
path = out / rel
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
path.write_text(text, encoding="utf-8")
|
||||
|
||||
|
||||
# ---- manual -----------------------------------------------------------------
|
||||
|
||||
def chapters(manual: Path) -> list[tuple[str, str, str]]:
|
||||
"""(slug, title, markdown) for docs/manual/NN-slug.md, in file-name order."""
|
||||
out = []
|
||||
for path in sorted(manual.glob("[0-9][0-9]-*.md")):
|
||||
text = path.read_text(encoding="utf-8")
|
||||
m = re.search(r"^# (.+)$", text, re.M)
|
||||
title = m.group(1).strip() if m else path.stem
|
||||
out.append((path.stem[3:], title, text))
|
||||
return out
|
||||
|
||||
|
||||
def build_manual(out: Path, manual: Path, sha: str) -> None:
|
||||
items = chapters(manual)
|
||||
if not items:
|
||||
raise SystemExit(f"no manual chapters in {manual}")
|
||||
|
||||
def toc(current: str) -> str:
|
||||
links = "".join(
|
||||
f'<li><a href="{slug}.html"{" class=on" if slug == current else ""}>'
|
||||
f"{html.escape(title)}</a></li>" for slug, title, _ in items)
|
||||
return f"<aside><ol>{links}</ol></aside>"
|
||||
|
||||
for slug, title, text in items:
|
||||
# Chapters link to each other as NN-name.md in the repo; on the site
|
||||
# they are name.html.
|
||||
text = re.sub(r"\]\((?:\./)?[0-9][0-9]-([a-z0-9-]+)\.md(#[^)]*)?\)", r"](\1.html\2)", text)
|
||||
body_html = markdown.markdown(text, extensions=["tables", "fenced_code", "toc"])
|
||||
write(out, f"manual/{slug}.html",
|
||||
page(title, f'<div class="layout">{toc(slug)}<article>{body_html}</article></div>',
|
||||
1, "manual/", sha))
|
||||
first = items[0][0]
|
||||
listing = "".join(f'<li><a href="{s}.html">{html.escape(t)}</a></li>' for s, t, _ in items)
|
||||
write(out, "manual/index.html",
|
||||
page("Manual", f"<h1>Manual</h1><p>Start with "
|
||||
f'<a href="{first}.html">{html.escape(items[0][1])}</a>.</p><ol>{listing}</ol>',
|
||||
1, "manual/", sha))
|
||||
|
||||
|
||||
# ---- quality dashboard ---------------------------------------------------------
|
||||
|
||||
def pct_class(pct: float | None) -> str:
|
||||
if pct is None:
|
||||
return ""
|
||||
return "good" if pct >= 80 else "warn" if pct >= 40 else "bad"
|
||||
|
||||
|
||||
def meter(pct: float) -> str:
|
||||
colour = {"good": "var(--good)", "warn": "var(--warn)", "bad": "var(--bad)"}[pct_class(pct)]
|
||||
return f'<div class="meter"><i style="width:{max(0.0, min(pct, 100.0)):.1f}%;background:{colour}"></i></div>'
|
||||
|
||||
|
||||
def build_quality(out: Path, quality: dict | None, sha: str) -> None:
|
||||
e = html.escape
|
||||
if not quality:
|
||||
write(out, "quality/index.html", page(
|
||||
"Code quality", "<h1>Code quality</h1><p>No measurement has been published yet; "
|
||||
"the next main build will fill this page.</p>", 1, "quality/", sha))
|
||||
return
|
||||
grade = str(quality.get("grade", "pending"))
|
||||
cov = quality.get("coverage_pct")
|
||||
bench_cov = quality.get("bench_coverage_pct")
|
||||
delta = quality.get("bench_delta_pct")
|
||||
|
||||
def card(value: str, label: str, cls: str = "") -> str:
|
||||
return f'<div class="card"><b class="{cls}">{value}</b><span>{label}</span></div>'
|
||||
|
||||
cards = "".join([
|
||||
card(e(grade), "Quality grade", {"A": "good", "B": "good", "C": "warn"}.get(grade, "bad")),
|
||||
card(e(str(quality.get("tests_passed", "-"))), "Tests passing", "good"),
|
||||
card(f"{cov:.1f}%" if cov is not None else "-", "Line coverage", pct_class(cov)),
|
||||
card(f"{bench_cov:.1f}%" if bench_cov is not None else "-", "Benchmark coverage", pct_class(bench_cov)),
|
||||
card(e(str(quality.get("clippy") or "-")), "Clippy (warnings are errors)",
|
||||
"good" if quality.get("clippy") == "clean" else "bad"),
|
||||
card(e(str(quality.get("rustfmt") or "-")), "rustfmt", "good" if quality.get("rustfmt") == "clean" else ""),
|
||||
card(f"{quality.get('loc', 0):,}", "Lines of Rust"),
|
||||
card(e(str(quality.get("dependencies", "-"))), "Crates in Cargo.lock"),
|
||||
card((f"{'+' if delta > 0 else ''}{delta:.1f}%" if delta is not None else "-"),
|
||||
"Benchmarks vs previous" + (" (same inputs)" if quality.get("bench_same_inputs") else ""),
|
||||
"" if delta is None else "good" if delta >= 2 else "" if delta > -2 else "warn"),
|
||||
])
|
||||
bands = ", ".join(f"{e(str(letter))} at {floor:.0f}% or more"
|
||||
for floor, letter in quality.get("grade_bands", []))
|
||||
grade_rule = (f"<p>The grade is F if Clippy or rustfmt fails on main. Otherwise it is the "
|
||||
f"line-coverage band: {bands}, and F below that. The coverage badge uses the "
|
||||
f"same bands for its colour, so the two never disagree.</p>")
|
||||
|
||||
crates = quality.get("coverage_by_crate", {})
|
||||
loc = quality.get("loc_by_crate", {})
|
||||
rows = []
|
||||
for name in sorted(set(crates) | set(loc)):
|
||||
c = crates.get(name)
|
||||
if c and c["lines"]:
|
||||
pct = 100.0 * (c["lines"] - c["missed"]) / c["lines"]
|
||||
cov_cells = (f'<td class="num {pct_class(pct)}">{pct:.1f}%</td>'
|
||||
f'<td class="bar-cell">{meter(pct)}</td>'
|
||||
f'<td class="num">{c["lines"] - c["missed"]:,} / {c["lines"]:,}</td>')
|
||||
else:
|
||||
cov_cells = '<td class="num">-</td><td></td><td class="num">-</td>'
|
||||
rows.append(f"<tr><td>{e(name)}</td>{cov_cells}<td class='num'>{loc.get(name, 0):,}</td></tr>")
|
||||
crate_table = ("<table><tr><th>Crate</th><th class=num>Line coverage</th><th></th>"
|
||||
"<th class=num>Covered lines</th><th class=num>Lines of Rust</th></tr>"
|
||||
+ "".join(rows) + "</table>")
|
||||
|
||||
files = sorted(quality.get("coverage_by_file", []),
|
||||
key=lambda r: (r["lines"] - r["missed"]) / r["lines"] if r["lines"] else 1)
|
||||
file_rows = "".join(
|
||||
f"<tr><td><code>{e(r['file'])}</code></td>"
|
||||
f"<td class='num {pct_class(100.0 * (r['lines'] - r['missed']) / r['lines'])}'>"
|
||||
f"{100.0 * (r['lines'] - r['missed']) / r['lines']:.1f}%</td>"
|
||||
f"<td class='num'>{r['missed']:,}</td><td class='num'>{r['lines']:,}</td></tr>"
|
||||
for r in files if r["lines"])
|
||||
file_table = ("<table><tr><th>File (least covered first)</th><th class=num>Coverage</th>"
|
||||
"<th class=num>Uncovered lines</th><th class=num>Lines</th></tr>"
|
||||
+ file_rows + "</table>") if file_rows else ""
|
||||
|
||||
measured = str(quality.get("sha", ""))[:10]
|
||||
of_build = f" (this page: <code>{e(measured)}</code>)" if measured else ""
|
||||
body = f"""<h1>Code quality</h1>
|
||||
<p>Measured by main CI on every build{of_build}:
|
||||
unit tests, line coverage (unit tests plus the headless UI self-test), Clippy with
|
||||
warnings as errors, and rustfmt. Windows builds run the same tests under Wine and
|
||||
on real Windows 11.</p>
|
||||
<div class="cards">{cards}</div>
|
||||
<h2 id="grade">How the grade is set</h2>{grade_rule}
|
||||
<h2 id="coverage">Coverage by crate</h2>{crate_table}
|
||||
<h2 id="files">Coverage by file</h2>{file_table}
|
||||
<p>The dependency count is every package in <code>Cargo.lock</code>, direct and
|
||||
transitive. Lines of Rust count every <code>.rs</code> line under <code>crates/</code>,
|
||||
tests included.</p>"""
|
||||
write(out, "quality/index.html", page("Code quality", body, 1, "quality/", sha))
|
||||
|
||||
|
||||
# ---- benchmarks + overview -------------------------------------------------------
|
||||
|
||||
def build_bench(out: Path, bench: Path | None, sha: str) -> None:
|
||||
if bench is None or not bench.is_file():
|
||||
write(out, "bench/index.html", page(
|
||||
"Benchmarks", "<h1>Benchmarks</h1><p>No benchmark history yet.</p>", 1, "bench/", sha))
|
||||
return
|
||||
rendered = bench.read_text(encoding="utf-8")
|
||||
# The history renderer emits a complete document; keep its body (and its
|
||||
# own styles) under the site's header.
|
||||
styles = "".join(re.findall(r"<style[^>]*>.*?</style>", rendered, re.S | re.I))
|
||||
m = re.search(r"<body[^>]*>(.*)</body>", rendered, re.S | re.I)
|
||||
inner = m.group(1) if m else rendered
|
||||
text = page("Benchmarks", inner, 1, "bench/", sha)
|
||||
write(out, "bench/index.html", text.replace("</head>", styles + "</head>", 1))
|
||||
|
||||
|
||||
def build_index(out: Path, quality: dict | None, sha: str) -> None:
|
||||
grade = html.escape(str((quality or {}).get("grade", "pending")))
|
||||
body = f"""<h1>Alkane Toolkit</h1>
|
||||
<p>Desktop discovery and monitoring for ASIC miners on your network: find every
|
||||
miner in your IP ranges, see hashrate, power, temperatures, fans and hashboard
|
||||
health at a glance, and run the controls each firmware supports.</p>
|
||||
<div class="buttons"><a class="primary" href="{RELEASES}">Download for Windows or Linux</a>
|
||||
<a href="manual/">Read the manual</a><a href="quality/">Code quality: {grade}</a>
|
||||
<a href="bench/">Benchmarks</a></div>
|
||||
<h2>Platforms</h2>
|
||||
<ul><li><b>Windows 10 and 11</b> (x86_64): one signed, self-contained <code>alkane-toolkit.exe</code>.</li>
|
||||
<li><b>Linux</b> (x86_64, GTK 3): one binary.</li></ul>
|
||||
<p>Every release is built, tested and signed by CI from the public source.</p>"""
|
||||
write(out, "index.html", page("Overview", body, 0, "", sha))
|
||||
|
||||
|
||||
def main() -> None:
|
||||
ap = argparse.ArgumentParser(description=__doc__,
|
||||
formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
ap.add_argument("--out", required=True)
|
||||
ap.add_argument("--manual", default="docs/manual")
|
||||
ap.add_argument("--quality", default=None)
|
||||
ap.add_argument("--bench", default=None)
|
||||
ap.add_argument("--sha", default="")
|
||||
args = ap.parse_args()
|
||||
out = Path(args.out)
|
||||
if out.exists():
|
||||
shutil.rmtree(out)
|
||||
out.mkdir(parents=True)
|
||||
quality = None
|
||||
if args.quality and Path(args.quality).is_file():
|
||||
quality = json.loads(Path(args.quality).read_text())
|
||||
if not isinstance(quality, dict) or quality.get("schema") != 1:
|
||||
raise SystemExit("unsupported quality.json")
|
||||
(out / "style.css").write_text(CSS.strip() + "\n", encoding="utf-8")
|
||||
build_index(out, quality, args.sha)
|
||||
build_manual(out, Path(args.manual), args.sha)
|
||||
build_quality(out, quality, args.sha)
|
||||
build_bench(out, Path(args.bench) if args.bench else None, args.sha)
|
||||
print(f"built {sum(1 for _ in out.rglob('*.html'))} pages in {out}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -32,12 +32,12 @@ def main() -> int:
|
||||
print(f"{path.name}: {name} has a different runner image", file=sys.stderr)
|
||||
return 1
|
||||
pages = yaml.load(
|
||||
(ROOT / ".gitea/workflows/bench-pages.yml").read_text(),
|
||||
(ROOT / ".gitea/workflows/pages.yml").read_text(),
|
||||
Loader=yaml.BaseLoader,
|
||||
)
|
||||
if (pages["on"]["workflow_run"]["workflows"] != ["build-test-release"]
|
||||
or pages["jobs"]["publish"].get("runs-on") != "alkane-verify"):
|
||||
print("Benchmark Pages must follow main CI on the trusted verifier", file=sys.stderr)
|
||||
print("Pages must follow main CI on the trusted verifier", file=sys.stderr)
|
||||
return 1
|
||||
release = yaml.load(
|
||||
(ROOT / ".gitea/workflows/release.yml").read_text(),
|
||||
@@ -46,7 +46,7 @@ def main() -> int:
|
||||
if release["jobs"]["release"].get("runs-on") != "alkane-ci":
|
||||
print("Main release must use the dedicated Alkane build pool", file=sys.stderr)
|
||||
return 1
|
||||
if any("ci/publish-bench-pages.py" in step.get("run", "")
|
||||
if any("ci/publish-pages.py" in step.get("run", "")
|
||||
for step in release["jobs"]["release"]["steps"]):
|
||||
print("Main release must not publish Pages from GARM", file=sys.stderr)
|
||||
return 1
|
||||
|
||||
@@ -9,9 +9,9 @@ import sys
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
DIRECTORIES = ("target", "dist", "coverage", "bench-site")
|
||||
FILES = ("bench-current.txt",)
|
||||
BADGE_FILES = ("bench-baseline.json", "bench-context.json")
|
||||
DIRECTORIES = ("target", "dist", "coverage", "bench-site", "site")
|
||||
FILES = ("bench-current.txt", "coverage-summary.txt", "quality.json")
|
||||
BADGE_FILES = ("bench-baseline.json", "bench-context.json", "quality.json")
|
||||
|
||||
|
||||
def cleanup() -> None:
|
||||
|
||||
@@ -46,7 +46,7 @@ vendor/*|thirdparty/asic-rs/*)
|
||||
# resources, embedded assets). ui.rs/fixtures.rs/bin
|
||||
# match the UI arm above first, so they still bump Z, not Y.
|
||||
backend=true ;;
|
||||
*) : ;; # docs, HANDOFF, README, thirdparty/wxwidgets tree: no bump
|
||||
*) : ;; # docs, README, thirdparty/wxwidgets tree: no bump
|
||||
esac
|
||||
done <<< "$changed"
|
||||
|
||||
|
||||
@@ -3,17 +3,19 @@
|
||||
# Use the preinstalled CI image or install missing packages on older runners.
|
||||
set -euo pipefail
|
||||
|
||||
mode="${1:?usage: ensure-build-deps.sh base|ui|all|ssh|windows}"
|
||||
mode="${1:?usage: ensure-build-deps.sh base|ui|all|ssh|windows|pages}"
|
||||
case "$mode" in
|
||||
base) packages=(libssl-dev pkg-config ca-certificates) ;;
|
||||
ui) packages=(xvfb xauth dbus-x11 fonts-dejavu-core) ;;
|
||||
ssh) packages=(openssh-client) ;;
|
||||
pages) packages=(python3-markdown) ;;
|
||||
all) packages=(libssl-dev pkg-config ca-certificates openssh-client
|
||||
xvfb xauth dbus-x11 fonts-dejavu-core) ;;
|
||||
# Windows cross build (mingw-w64, posix threads) + Wine for its tests.
|
||||
windows) packages=(libssl-dev pkg-config ca-certificates
|
||||
gcc-mingw-w64-x86-64-posix g++-mingw-w64-x86-64-posix
|
||||
binutils-mingw-w64-x86-64 mingw-w64-x86-64-dev wine wine64 xvfb xauth) ;;
|
||||
binutils-mingw-w64-x86-64 mingw-w64-x86-64-dev wine wine64 xvfb xauth
|
||||
openjdk-21-jre-headless) ;;
|
||||
*) echo "unknown dependency set: $mode" >&2; exit 2 ;;
|
||||
esac
|
||||
|
||||
|
||||
Executable
+41
@@ -0,0 +1,41 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Download the measured quality record (badges/quality.json on ci-badges).
|
||||
|
||||
fetch-quality.py OUT.json
|
||||
|
||||
Writes nothing (and exits 0) when main CI has not published one yet, so the
|
||||
Pages build shows a "not measured yet" dashboard instead of failing.
|
||||
"""
|
||||
|
||||
import base64
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import sys
|
||||
from urllib.error import HTTPError
|
||||
from urllib.request import Request, urlopen
|
||||
|
||||
|
||||
def main() -> None:
|
||||
out = Path(sys.argv[1])
|
||||
api = os.environ["GITHUB_API_URL"].rstrip("/")
|
||||
repo = os.environ["GITHUB_REPOSITORY"]
|
||||
url = f"{api}/repos/{repo}/contents/badges/quality.json?ref=ci-badges"
|
||||
request = Request(url, headers={"Authorization": f"token {os.environ['GITEA_TOKEN']}"})
|
||||
try:
|
||||
with urlopen(request, timeout=20) as response:
|
||||
content = base64.b64decode(json.load(response)["content"])
|
||||
except HTTPError as error:
|
||||
if error.code == 404:
|
||||
print("No quality record published yet")
|
||||
return
|
||||
raise
|
||||
if not isinstance(json.loads(content), dict):
|
||||
sys.exit("invalid quality record")
|
||||
out.write_bytes(content)
|
||||
print(f"Fetched quality record ({len(content)} bytes)")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
+103
-8
@@ -135,10 +135,72 @@ def cov_color(pct: float) -> str:
|
||||
return "red"
|
||||
|
||||
|
||||
def quality_grade(clippy: str | None) -> str:
|
||||
if clippy is None:
|
||||
# Code-quality grade (shown on the badge and explained on the Pages quality
|
||||
# dashboard). Lint failures fail the grade outright; otherwise the grade is the
|
||||
# measured line-coverage band, using the same bands as the coverage badge
|
||||
# colour, so the two badges can never disagree.
|
||||
GRADE_BANDS = ((80.0, "A"), (60.0, "B"), (40.0, "C"), (20.0, "D"))
|
||||
GRADE_COLORS = {"A": "brightgreen", "B": "yellowgreen", "C": "yellow",
|
||||
"D": "orange", "F": "red", "pending": "lightgrey"}
|
||||
|
||||
|
||||
def quality_grade(clippy: str | None, coverage: float | None = None) -> str:
|
||||
if clippy is None or (clippy == "clean" and coverage is None):
|
||||
return "pending"
|
||||
return "A" if clippy == "clean" else "F"
|
||||
if clippy != "clean":
|
||||
return "F"
|
||||
for floor, grade in GRADE_BANDS:
|
||||
if coverage >= floor:
|
||||
return grade
|
||||
return "F"
|
||||
|
||||
|
||||
def coverage_by_file(summary_path: str | None, root: str) -> list[dict]:
|
||||
"""Per-file line coverage from a `cargo llvm-cov --summary-only` table.
|
||||
|
||||
Columns: Filename, Regions, Missed Regions, Cover, Functions, Missed
|
||||
Functions, Executed, Lines, Missed Lines, Cover, ...
|
||||
"""
|
||||
if not summary_path:
|
||||
return []
|
||||
rows = []
|
||||
root_abs = os.path.abspath(root).rstrip("/") + "/"
|
||||
for line in Path(summary_path).read_text(errors="replace").splitlines():
|
||||
cols = line.split()
|
||||
if len(cols) < 10 or cols[0] in ("Filename", "TOTAL") or not cols[0].endswith(".rs"):
|
||||
continue
|
||||
try:
|
||||
lines, missed = int(cols[7]), int(cols[8])
|
||||
except ValueError:
|
||||
continue
|
||||
name = cols[0][len(root_abs):] if cols[0].startswith(root_abs) else cols[0]
|
||||
# llvm-cov drops the prefix every file shares, so when only workspace
|
||||
# crates are measured "crates/alkane-gui/src/x.rs" is printed as
|
||||
# "alkane-gui/src/x.rs". Put the prefix back.
|
||||
first = Path(name).parts[0] if Path(name).parts else ""
|
||||
if not name.startswith("crates/") and (Path(root) / "crates" / first).is_dir():
|
||||
name = f"crates/{name}"
|
||||
rows.append({"file": name, "lines": lines, "missed": missed})
|
||||
return rows
|
||||
|
||||
|
||||
def crate_of(path: str) -> str:
|
||||
parts = Path(path).parts
|
||||
if "crates" in parts and parts.index("crates") + 1 < len(parts):
|
||||
return parts[parts.index("crates") + 1]
|
||||
if "wx-rs-0.2.0-patched" in parts:
|
||||
return "wx-rs (bridge)"
|
||||
return "other"
|
||||
|
||||
|
||||
def loc_by_crate(root: str) -> dict[str, int]:
|
||||
out: dict[str, int] = {}
|
||||
crates = Path(root) / "crates"
|
||||
for path in sorted(crates.glob("*/**/*.rs")):
|
||||
crate = path.relative_to(crates).parts[0]
|
||||
with open(path, encoding="utf-8", errors="ignore") as fh:
|
||||
out[crate] = out.get(crate, 0) + sum(1 for _ in fh)
|
||||
return out
|
||||
|
||||
|
||||
def human(n: int) -> str:
|
||||
@@ -169,6 +231,9 @@ def main() -> int:
|
||||
# percentage string, or "NEW" when there is no baseline.
|
||||
ap.add_argument("--bench-delta", default=None)
|
||||
ap.add_argument("--clippy", choices=("clean", "failed"))
|
||||
# The full `cargo llvm-cov --summary-only` table, for the per-crate and
|
||||
# per-file breakdown in quality.json (the Pages quality dashboard).
|
||||
ap.add_argument("--coverage-summary", default=None)
|
||||
args = ap.parse_args()
|
||||
for value in (args.coverage, args.bench_coverage):
|
||||
if value is not None and (not math.isfinite(value) or not 0 <= value <= 100):
|
||||
@@ -189,11 +254,9 @@ def main() -> int:
|
||||
write("loc", "lines of code", human(loc), loc_color(loc))
|
||||
write("license", "license", lic, "blue")
|
||||
write("dependencies", "dependencies", str(deps), "blue")
|
||||
grade = quality_grade(args.clippy)
|
||||
write("quality", "code quality", grade,
|
||||
{"A": "brightgreen", "B": "yellowgreen", "C": "yellow",
|
||||
"D": "orange", "F": "red", "pending": "lightgrey"}[grade],
|
||||
f"code quality: {grade} (GUI Clippy and first-party rustfmt)")
|
||||
grade = quality_grade(args.clippy, args.coverage)
|
||||
write("quality", "code quality", grade, GRADE_COLORS[grade],
|
||||
f"code quality: {grade} (Clippy, rustfmt and line coverage)")
|
||||
if args.tests is not None:
|
||||
write("tests", "tests", f"{args.tests} passing", "brightgreen")
|
||||
if args.coverage is not None:
|
||||
@@ -228,6 +291,38 @@ def main() -> int:
|
||||
write("bench", "bench", "baseline set", "blue")
|
||||
elif args.bench is not None:
|
||||
write("bench", "bench", args.bench, "blue")
|
||||
|
||||
# Everything above, plus the per-crate breakdowns, for the Pages quality
|
||||
# dashboard (ci/build-pages.py).
|
||||
files = coverage_by_file(args.coverage_summary, args.root)
|
||||
crates: dict[str, dict] = {}
|
||||
for row in files:
|
||||
c = crates.setdefault(crate_of(row["file"]), {"lines": 0, "missed": 0})
|
||||
c["lines"] += row["lines"]
|
||||
c["missed"] += row["missed"]
|
||||
quality = {
|
||||
"schema": 1,
|
||||
"sha": os.environ.get("GITHUB_SHA", ""),
|
||||
"grade": grade,
|
||||
"grade_bands": [[floor, letter] for floor, letter in GRADE_BANDS],
|
||||
"clippy": args.clippy,
|
||||
"rustfmt": "clean" if args.clippy is not None else None,
|
||||
"tests_passed": args.tests,
|
||||
"coverage_pct": args.coverage,
|
||||
"bench_coverage_pct": args.bench_coverage,
|
||||
"bench_delta_pct": delta,
|
||||
"bench_same_inputs": same_inputs,
|
||||
"loc": loc,
|
||||
"loc_by_crate": loc_by_crate(args.root),
|
||||
"dependencies": deps,
|
||||
"license": lic,
|
||||
"coverage_by_crate": crates,
|
||||
"coverage_by_file": files,
|
||||
}
|
||||
path = os.path.join(args.root, args.out, "quality.json")
|
||||
with open(path, "w", encoding="utf-8") as fh:
|
||||
json.dump(quality, fh, indent=1, sort_keys=True)
|
||||
print(f"wrote {path}")
|
||||
return 0
|
||||
|
||||
|
||||
|
||||
@@ -9,6 +9,8 @@
|
||||
# scripts/build-wx-windows.sh and stamped with the source digest the same
|
||||
# way as the wxGTK prefix (ci/ensure-wx-prefix.sh rebuilds on a mismatch)
|
||||
# - Wine with an initialised prefix, to run the Windows tests and self-test
|
||||
# - a Java runtime and jsign (checksum-pinned), to Authenticode-sign the .exe
|
||||
# through Azure Artifact Signing (ci/sign-windows.sh)
|
||||
#
|
||||
# Build and push from the workstation with ci/images/build-image.sh.
|
||||
ARG BASE=gitea.bluefla.re/blueflare/alkane-ci@sha256:9d2a992bbcb91014af3c85d2e1ec8c5990701cecf83fd06c8d46f9ef13dbd948
|
||||
@@ -18,9 +20,18 @@ RUN DEBIAN_FRONTEND=noninteractive apt-get update -qq \
|
||||
&& DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends \
|
||||
gcc-mingw-w64-x86-64-posix g++-mingw-w64-x86-64-posix \
|
||||
binutils-mingw-w64-x86-64 mingw-w64-x86-64-dev \
|
||||
wine wine64 xvfb xauth \
|
||||
wine wine64 xvfb xauth openjdk-21-jre-headless \
|
||||
&& rm -rf /var/lib/apt/lists/*
|
||||
|
||||
# jsign (Maven Central net.jsign:jsign; keep in step with ci/windows-ci.sh).
|
||||
ARG JSIGN_VERSION=7.6
|
||||
ARG JSIGN_SHA256=6cf58aa080e7ff82656f320cff8d4a3bff30408df8766806dcba3740dd839fa5
|
||||
RUN mkdir -p /opt/jsign \
|
||||
&& curl -sSfL -o /opt/jsign/jsign.jar \
|
||||
"https://repo1.maven.org/maven2/net/jsign/jsign/${JSIGN_VERSION}/jsign-${JSIGN_VERSION}.jar" \
|
||||
&& echo "${JSIGN_SHA256} /opt/jsign/jsign.jar" | sha256sum -c - \
|
||||
&& java -jar /opt/jsign/jsign.jar --help >/dev/null
|
||||
|
||||
RUN rustup target add x86_64-pc-windows-gnu
|
||||
|
||||
# The build context is the repository root, filtered by
|
||||
@@ -44,4 +55,5 @@ RUN test -s /root/.cache/wx-3.3.3-mingw/lib/libwx_mswu-3.3-x86_64-w64-mingw32.a
|
||||
&& test -s /root/.cache/wx-3.3.3-linux/lib/libwx_gtk3u-3.3.a \
|
||||
&& x86_64-w64-mingw32-g++-posix --version >/dev/null \
|
||||
&& wine --version \
|
||||
&& test -s /opt/jsign/jsign.jar \
|
||||
&& rustup target list --installed | grep -qx x86_64-pc-windows-gnu
|
||||
|
||||
Executable
+109
@@ -0,0 +1,109 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Package the universal macOS build as an app bundle, for release.
|
||||
|
||||
package-macos.py VERSION BINARY OUT_DIR
|
||||
|
||||
BINARY is the universal (arm64 + x86_64) alkane-toolkit executable made by
|
||||
scripts/build-gui-macos.sh. Writes
|
||||
dist/alkane-toolkit-vVERSION-macos-universal.zip holding "Alkane Toolkit.app",
|
||||
LICENSE and README.txt, and prints its path. Runs on macOS (lipo, codesign,
|
||||
ditto).
|
||||
|
||||
The bundle is ad-hoc signed only (Apple Silicon refuses to run unsigned
|
||||
code); it is not signed with a Developer ID or notarized, so Gatekeeper asks
|
||||
the user to confirm the first launch. README.txt says how.
|
||||
"""
|
||||
|
||||
import pathlib
|
||||
import plistlib
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
|
||||
ROOT = pathlib.Path(__file__).resolve().parents[1]
|
||||
APP = "Alkane Toolkit.app"
|
||||
BUNDLE_ID = "re.bluefla.alkane-toolkit"
|
||||
MIN_MACOS = "11.0"
|
||||
|
||||
|
||||
def run(*args: str) -> str:
|
||||
return subprocess.run(args, check=True, capture_output=True, text=True).stdout
|
||||
|
||||
|
||||
def build_app(version: str, binary: pathlib.Path, dest: pathlib.Path) -> pathlib.Path:
|
||||
archs = run("lipo", "-archs", str(binary)).split()
|
||||
if sorted(archs) != ["arm64", "x86_64"]:
|
||||
sys.exit(f"{binary} is not a universal arm64 + x86_64 binary: {archs}")
|
||||
app = dest / APP
|
||||
macos = app / "Contents" / "MacOS"
|
||||
resources = app / "Contents" / "Resources"
|
||||
macos.mkdir(parents=True)
|
||||
resources.mkdir()
|
||||
shutil.copy2(binary, macos / "alkane-toolkit")
|
||||
shutil.copy2(ROOT / "crates/alkane-gui/macos/alkane-toolkit.icns", resources)
|
||||
info = {
|
||||
"CFBundleName": "Alkane Toolkit",
|
||||
"CFBundleDisplayName": "Alkane Toolkit",
|
||||
"CFBundleIdentifier": BUNDLE_ID,
|
||||
"CFBundleExecutable": "alkane-toolkit",
|
||||
"CFBundleIconFile": "alkane-toolkit",
|
||||
"CFBundlePackageType": "APPL",
|
||||
"CFBundleShortVersionString": version,
|
||||
"CFBundleVersion": version,
|
||||
"CFBundleInfoDictionaryVersion": "6.0",
|
||||
"LSMinimumSystemVersion": MIN_MACOS,
|
||||
"NSHighResolutionCapable": True,
|
||||
"NSPrincipalClass": "NSApplication",
|
||||
# The scanner talks to miners on the local network.
|
||||
"NSLocalNetworkUsageDescription":
|
||||
"Alkane Toolkit scans your local network to find and manage miners.",
|
||||
"NSHumanReadableCopyright":
|
||||
"Copyright (c) 2026 BlueFlare Energy Solutions Inc. (MIT License)",
|
||||
}
|
||||
with open(app / "Contents" / "Info.plist", "wb") as fh:
|
||||
plistlib.dump(info, fh)
|
||||
(app / "Contents" / "PkgInfo").write_text("APPL????")
|
||||
# Ad-hoc signature over the whole bundle (the linker's per-slice
|
||||
# signatures do not cover Info.plist or the resources).
|
||||
run("codesign", "--force", "--sign", "-", "--timestamp=none", str(app))
|
||||
run("codesign", "--verify", "--strict", str(app))
|
||||
return app
|
||||
|
||||
|
||||
def release(version: str, binary: str, out_dir: str) -> None:
|
||||
name = f"alkane-toolkit-v{version}-macos-universal"
|
||||
out = pathlib.Path(out_dir).resolve() / f"{name}.zip"
|
||||
out.parent.mkdir(parents=True, exist_ok=True)
|
||||
readme = (
|
||||
f"alkane-toolkit v{version} (macOS, Apple Silicon and Intel)\n"
|
||||
"\n"
|
||||
f"Runs on macOS {MIN_MACOS} (Big Sur) or later. Drag \"Alkane Toolkit\"\n"
|
||||
"to Applications, then open it.\n"
|
||||
"\n"
|
||||
"The app is not notarized by Apple, so the first launch is blocked\n"
|
||||
"with a warning. To allow it once:\n"
|
||||
" - macOS 15 or later: try to open it, then System Settings >\n"
|
||||
" Privacy & Security > \"Open Anyway\" for Alkane Toolkit.\n"
|
||||
" - macOS 11 to 14: Control-click the app, choose Open, then Open.\n"
|
||||
"Or, in Terminal: xattr -dr com.apple.quarantine \"/Applications/Alkane Toolkit.app\"\n"
|
||||
"\n"
|
||||
"Settings are stored in ~/.config/alkane-toolkit/.\n"
|
||||
"Manual: https://blueflare.gitea.bluefla.re/alkane-toolkit/manual/\n"
|
||||
)
|
||||
with tempfile.TemporaryDirectory(prefix="alkane-macos-") as tmp:
|
||||
folder = pathlib.Path(tmp) / name
|
||||
folder.mkdir()
|
||||
build_app(version, pathlib.Path(binary), folder)
|
||||
shutil.copy2(ROOT / "LICENSE", folder / "LICENSE")
|
||||
(folder / "README.txt").write_text(readme)
|
||||
out.unlink(missing_ok=True)
|
||||
run("ditto", "-c", "-k", "--keepParent", str(folder), str(out))
|
||||
print(out)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
if len(sys.argv) != 4:
|
||||
sys.exit(__doc__)
|
||||
release(*sys.argv[1:])
|
||||
@@ -15,6 +15,7 @@
|
||||
|
||||
import json
|
||||
import pathlib
|
||||
import struct
|
||||
import sys
|
||||
import zipfile
|
||||
|
||||
@@ -26,6 +27,7 @@ def release(version: str, exe: str, out_dir: str) -> None:
|
||||
exe_path = pathlib.Path(exe)
|
||||
if exe_path.suffix != ".exe" or not exe_path.is_file():
|
||||
sys.exit(f"not a Windows executable: {exe}")
|
||||
signed = _has_authenticode_signature(exe_path)
|
||||
name = f"alkane-toolkit-v{version}-windows-x86_64"
|
||||
out = pathlib.Path(out_dir) / f"{name}.zip"
|
||||
out.parent.mkdir(parents=True, exist_ok=True)
|
||||
@@ -35,6 +37,14 @@ def release(version: str, exe: str, out_dir: str) -> None:
|
||||
"Run alkane-toolkit.exe. No installer and no extra runtime are needed:\r\n"
|
||||
"the executable is self-contained and runs on Windows 10 and 11.\r\n"
|
||||
"\r\n"
|
||||
+ (
|
||||
"The executable is signed by BlueFlare Energy Solutions Inc. (Azure Artifact Signing). To check:\r\n"
|
||||
"right-click alkane-toolkit.exe > Properties > Digital Signatures.\r\n"
|
||||
if signed else
|
||||
"This build is not code-signed, so Windows SmartScreen may warn on first\r\n"
|
||||
"run: choose More info > Run anyway.\r\n"
|
||||
)
|
||||
+ "\r\n"
|
||||
"Settings are kept in %APPDATA%\\alkane-toolkit.\r\n"
|
||||
"SSH-based actions use the OpenSSH client built into Windows (ssh.exe);\r\n"
|
||||
"HTTP actions use curl.exe, also built in.\r\n"
|
||||
@@ -49,6 +59,15 @@ def release(version: str, exe: str, out_dir: str) -> None:
|
||||
print(out)
|
||||
|
||||
|
||||
def _has_authenticode_signature(exe: pathlib.Path) -> bool:
|
||||
"""True if the PE file carries a certificate table (an Authenticode signature)."""
|
||||
data = exe.read_bytes()
|
||||
pe = struct.unpack_from("<I", data, 0x3C)[0]
|
||||
magic = struct.unpack_from("<H", data, pe + 24)[0]
|
||||
dirs = pe + 24 + (96 if magic == 0x10B else 112)
|
||||
return struct.unpack_from("<II", data, dirs + 4 * 8)[1] > 0
|
||||
|
||||
|
||||
def tests(cargo_json: str, out_zip: str) -> None:
|
||||
executables = []
|
||||
for line in pathlib.Path(cargo_json).read_text().splitlines():
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Publish measured toolkit badges to the private Gitea badge branch."""
|
||||
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
@@ -22,7 +23,14 @@ def main() -> None:
|
||||
raise ValueError(f"invalid {name} SVG")
|
||||
publish_file(api, repo, f"badges/{name}.svg", data, token,
|
||||
f"Update measured {name} badge")
|
||||
print(f"Published {len(NAMES)} measured badge SVGs")
|
||||
# The full measurement record behind the badges, read by the Pages
|
||||
# quality dashboard (ci/build-pages.py).
|
||||
data = (ROOT / "badges" / "quality.json").read_bytes()
|
||||
if not isinstance(json.loads(data), dict):
|
||||
raise ValueError("invalid quality.json")
|
||||
publish_file(api, repo, "badges/quality.json", data, token,
|
||||
"Update measured quality record", max_bytes=262_144)
|
||||
print(f"Published {len(NAMES)} measured badge SVGs and quality.json")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
Executable
+79
@@ -0,0 +1,79 @@
|
||||
#!/usr/bin/env python3
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Publish the built Pages site to this repository's gh-pages branch.
|
||||
|
||||
publish-pages.py SITE_DIR
|
||||
|
||||
Served at https://blueflare.gitea.bluefla.re/alkane-toolkit/ by the Pages
|
||||
server, which serves the gh-pages branch of public repositories. Each publish
|
||||
is one orphan commit (force-pushed), so the branch never accumulates history.
|
||||
Only main may publish, and a run for a superseded main commit skips.
|
||||
"""
|
||||
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
from urllib.request import Request, urlopen
|
||||
|
||||
BRANCH = "gh-pages"
|
||||
MAX_BYTES = 20 * 1024 * 1024
|
||||
|
||||
|
||||
def current_main_sha(api: str, repo: str, token: str) -> str:
|
||||
request = Request(f"{api}/repos/{repo}/branches/main",
|
||||
headers={"Authorization": f"token {token}"})
|
||||
with urlopen(request, timeout=20) as response:
|
||||
return json.load(response)["commit"]["id"]
|
||||
|
||||
|
||||
def git(*args: str, cwd: Path, env: dict | None = None) -> None:
|
||||
subprocess.run(("git", *args), cwd=cwd, env=env, check=True)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
if len(sys.argv) != 2:
|
||||
sys.exit(__doc__)
|
||||
site = Path(sys.argv[1])
|
||||
if not (site / "index.html").is_file():
|
||||
sys.exit(f"{site} has no index.html")
|
||||
size = sum(p.stat().st_size for p in site.rglob("*") if p.is_file())
|
||||
if size > MAX_BYTES:
|
||||
sys.exit(f"site is {size} bytes, over the {MAX_BYTES} byte limit")
|
||||
for path in site.rglob("*"):
|
||||
if path.is_file() and path.suffix not in {".html", ".css", ".svg", ".png", ".json"}:
|
||||
sys.exit(f"unexpected file type on the site: {path}")
|
||||
|
||||
api = os.environ["GITHUB_API_URL"].rstrip("/")
|
||||
repo = os.environ["GITHUB_REPOSITORY"]
|
||||
sha = os.environ["GITHUB_SHA"]
|
||||
token = os.environ["GITEA_TOKEN"]
|
||||
if os.environ.get("GITHUB_REF") != "refs/heads/main":
|
||||
sys.exit("Pages publication requires main")
|
||||
if current_main_sha(api, repo, token) != sha:
|
||||
print("Skipping Pages for a superseded main commit")
|
||||
return
|
||||
|
||||
server = api.removesuffix("/api/v1")
|
||||
with tempfile.TemporaryDirectory(prefix="alkane-pages-") as directory:
|
||||
work = Path(directory)
|
||||
shutil.copytree(site, work, dirs_exist_ok=True)
|
||||
env = dict(os.environ, GIT_TERMINAL_PROMPT="0")
|
||||
git("init", "-q", "-b", BRANCH, cwd=work)
|
||||
git("-c", "user.name=Alkane CI", "-c", "user.email=ci@noreply.gitea.bluefla.re",
|
||||
"add", "-A", cwd=work)
|
||||
git("-c", "user.name=Alkane CI", "-c", "user.email=ci@noreply.gitea.bluefla.re",
|
||||
"commit", "-q", "-m", f"Publish site for {sha[:10]} [skip ci]", cwd=work)
|
||||
# The token is read from the environment by the credential helper at
|
||||
# push time; it never appears on a command line or in the remote URL.
|
||||
helper = '!f() { echo username=alkane-ci; echo "password=$GITEA_TOKEN"; }; f'
|
||||
git("-c", f"credential.helper={helper}", "push", "-q", "--force",
|
||||
f"{server}/{repo}.git", f"HEAD:refs/heads/{BRANCH}", cwd=work, env=env)
|
||||
print(f"Published Pages for {sha[:10]} to {BRANCH}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
+1
-1
@@ -1 +1 @@
|
||||
gitea.bluefla.re/blueflare/alkane-ci@sha256:8f20439b38ae1c070b1a692a89c084f69134f4fa16a755d02783f621cd9ac041
|
||||
gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
|
||||
|
||||
Executable
+88
@@ -0,0 +1,88 @@
|
||||
#!/usr/bin/env bash
|
||||
# SPDX-License-Identifier: MIT
|
||||
# Authenticode-sign Windows executables with Azure Artifact Signing (formerly
|
||||
# Trusted Signing), from Linux, with jsign. Every signature is RFC 3161
|
||||
# timestamped: the signing certificates live only a few days, the timestamp is
|
||||
# what keeps a signature valid after that.
|
||||
#
|
||||
# ci/sign-windows.sh FILE.exe [FILE.exe ...]
|
||||
#
|
||||
# Configuration (environment):
|
||||
# AZURE_SIGNING_PROFILE certificate profile name; EMPTY = signing not set
|
||||
# up yet: the files are left unsigned (exit 0)
|
||||
# AZURE_SIGNING_ACCOUNT signing account (default blueflaresigning)
|
||||
# AZURE_SIGNING_ENDPOINT account endpoint (default https://wus2.codesigning.azure.net)
|
||||
# Credentials, one of:
|
||||
# AZURE_SIGNING_TENANT_ID + AZURE_SIGNING_CLIENT_ID + AZURE_SIGNING_CLIENT_SECRET
|
||||
# (the CI service principal alkane-toolkit-ci-signer, role
|
||||
# "Artifact Signing Certificate Profile Signer" on the account only)
|
||||
# AZURE_SIGNING_TOKEN an access token for https://codesigning.azure.net,
|
||||
# e.g. from `az account get-access-token --resource https://codesigning.azure.net`
|
||||
# ALKANE_JSIGN_JAR jsign jar (default /opt/jsign/jsign.jar, from the CI image)
|
||||
#
|
||||
# Once a profile is configured, any failure fails the job: a release is never
|
||||
# shipped half-signed or silently unsigned.
|
||||
set -euo pipefail
|
||||
|
||||
[ "$#" -gt 0 ] || { sed -n '3,25p' "$0" >&2; exit 2; }
|
||||
profile="${AZURE_SIGNING_PROFILE:-}"
|
||||
if [ -z "$profile" ]; then
|
||||
echo "Windows code signing is not enabled (AZURE_SIGNING_PROFILE unset); leaving $* unsigned"
|
||||
exit 0
|
||||
fi
|
||||
account="${AZURE_SIGNING_ACCOUNT:-blueflaresigning}"
|
||||
endpoint="${AZURE_SIGNING_ENDPOINT:-https://wus2.codesigning.azure.net}"
|
||||
jar="${ALKANE_JSIGN_JAR:-/opt/jsign/jsign.jar}"
|
||||
[ -f "$jar" ] || { echo "jsign not found at $jar" >&2; exit 1; }
|
||||
|
||||
if [ -z "${AZURE_SIGNING_TOKEN:-}" ]; then
|
||||
: "${AZURE_SIGNING_TENANT_ID:?signing credentials missing}"
|
||||
: "${AZURE_SIGNING_CLIENT_ID:?signing credentials missing}"
|
||||
: "${AZURE_SIGNING_CLIENT_SECRET:?signing credentials missing}"
|
||||
# Client-credentials token for the signing service. The secret and token
|
||||
# stay in this process's environment, never on a command line.
|
||||
AZURE_SIGNING_TOKEN="$(python3 - <<'PY'
|
||||
import json, os, sys, urllib.parse, urllib.request
|
||||
body = urllib.parse.urlencode({
|
||||
"grant_type": "client_credentials",
|
||||
"client_id": os.environ["AZURE_SIGNING_CLIENT_ID"],
|
||||
"client_secret": os.environ["AZURE_SIGNING_CLIENT_SECRET"],
|
||||
"scope": "https://codesigning.azure.net/.default",
|
||||
}).encode()
|
||||
url = f"https://login.microsoftonline.com/{os.environ['AZURE_SIGNING_TENANT_ID']}/oauth2/v2.0/token"
|
||||
try:
|
||||
with urllib.request.urlopen(url, body, timeout=60) as r:
|
||||
print(json.load(r)["access_token"])
|
||||
except Exception as e:
|
||||
sys.exit(f"could not get a signing token: {e}")
|
||||
PY
|
||||
)"
|
||||
fi
|
||||
export AZURE_SIGNING_TOKEN
|
||||
|
||||
for file in "$@"; do
|
||||
java -jar "$jar" \
|
||||
--storetype TRUSTEDSIGNING \
|
||||
--keystore "${endpoint#https://}" \
|
||||
--storepass env:AZURE_SIGNING_TOKEN \
|
||||
--alias "$account/$profile" \
|
||||
--alg SHA-256 \
|
||||
--tsaurl http://timestamp.acs.microsoft.com --tsmode RFC3161 \
|
||||
--tsretries 3 --tsretrywait 10 \
|
||||
--name "Alkane Toolkit" \
|
||||
--url https://gitea.bluefla.re/blueflare/alkane-toolkit \
|
||||
"$file"
|
||||
# jsign fails on any error; also make sure a signature actually landed in
|
||||
# the PE certificate table before the file goes anywhere.
|
||||
python3 - "$file" <<'PY'
|
||||
import struct, sys
|
||||
data = open(sys.argv[1], "rb").read()
|
||||
pe = struct.unpack_from("<I", data, 0x3C)[0]
|
||||
magic = struct.unpack_from("<H", data, pe + 24)[0]
|
||||
dirs = pe + 24 + (96 if magic == 0x10B else 112)
|
||||
offset, size = struct.unpack_from("<II", data, dirs + 4 * 8) # IMAGE_DIRECTORY_ENTRY_SECURITY
|
||||
if size == 0:
|
||||
sys.exit(f"{sys.argv[1]}: no Authenticode signature after signing")
|
||||
print(f"{sys.argv[1]}: signed ({size} byte certificate table)")
|
||||
PY
|
||||
done
|
||||
+41
-10
@@ -5,6 +5,7 @@
|
||||
import importlib.util
|
||||
import re
|
||||
from pathlib import Path
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
|
||||
@@ -50,16 +51,46 @@ class BenchBadgeTests(unittest.TestCase):
|
||||
self.assertEqual(gen_badges.bench_color(30.0), "brightgreen")
|
||||
self.assertEqual(gen_badges.bench_color(-55.5555556), "orange")
|
||||
|
||||
def test_quality_grade_is_only_the_clippy_result(self):
|
||||
self.assertEqual(gen_badges.quality_grade("clean"), "A")
|
||||
self.assertEqual(gen_badges.quality_grade("failed"), "F")
|
||||
self.assertEqual(gen_badges.quality_grade(None), "pending")
|
||||
svg = gen_badges.badge_svg(
|
||||
"code quality", "A", "brightgreen",
|
||||
"code quality: A (GUI Clippy and first-party rustfmt)",
|
||||
)
|
||||
self.assertIn('aria-label="code quality: A (GUI Clippy and first-party rustfmt)"', svg)
|
||||
self.assertIn('>A</text>', svg)
|
||||
def test_quality_grade_follows_lint_and_coverage(self):
|
||||
# A lint failure fails the grade; otherwise it is the coverage band,
|
||||
# with the same floors as the coverage badge colour.
|
||||
self.assertEqual(gen_badges.quality_grade("failed", 95.0), "F")
|
||||
self.assertEqual(gen_badges.quality_grade("clean", 85.0), "A")
|
||||
self.assertEqual(gen_badges.quality_grade("clean", 65.6), "B")
|
||||
self.assertEqual(gen_badges.quality_grade("clean", 48.0), "C")
|
||||
self.assertEqual(gen_badges.quality_grade("clean", 25.0), "D")
|
||||
self.assertEqual(gen_badges.quality_grade("clean", 5.0), "F")
|
||||
self.assertEqual(gen_badges.quality_grade("clean"), "pending")
|
||||
self.assertEqual(gen_badges.quality_grade(None, 90.0), "pending")
|
||||
for pct in (85.0, 65.6, 48.0, 25.0):
|
||||
grade = gen_badges.quality_grade("clean", pct)
|
||||
self.assertEqual(gen_badges.GRADE_COLORS[grade], gen_badges.cov_color(pct))
|
||||
|
||||
def test_coverage_table_is_split_by_crate(self):
|
||||
with tempfile.TemporaryDirectory(prefix="alkane-cov-") as directory:
|
||||
summary = Path(directory) / "summary.txt"
|
||||
summary.write_text(
|
||||
"Filename Regions Missed Regions Cover Functions Missed Functions "
|
||||
"Executed Lines Missed Lines Cover\n"
|
||||
"crates/alkane-gui/src/ui.rs 10 5 50.00% 4 2 50.00% 100 60 40.00%\n"
|
||||
"crates/alkane-core/src/platform.rs 4 0 100.00% 2 0 100.00% 50 5 90.00%\n"
|
||||
"TOTAL 14 5 64.29% 6 2 66.67% 150 65 56.67%\n")
|
||||
rows = gen_badges.coverage_by_file(str(summary), directory)
|
||||
self.assertEqual([r["file"] for r in rows],
|
||||
["crates/alkane-gui/src/ui.rs", "crates/alkane-core/src/platform.rs"])
|
||||
self.assertEqual(rows[0]["missed"], 60)
|
||||
self.assertEqual(gen_badges.crate_of(rows[1]["file"]), "alkane-core")
|
||||
|
||||
def test_coverage_table_restores_the_stripped_crates_prefix(self):
|
||||
with tempfile.TemporaryDirectory(prefix="alkane-cov-") as directory:
|
||||
(Path(directory) / "crates" / "alkane-cli").mkdir(parents=True)
|
||||
summary = Path(directory) / "summary.txt"
|
||||
summary.write_text(
|
||||
"alkane-cli/src/main.rs 4 4 0.00% 1 1 0.00% 23 23 0.00%\n")
|
||||
rows = gen_badges.coverage_by_file(str(summary), directory)
|
||||
self.assertEqual(rows[0], {"file": "crates/alkane-cli/src/main.rs",
|
||||
"lines": 23, "missed": 23})
|
||||
self.assertEqual(gen_badges.crate_of(rows[0]["file"]), "alkane-cli")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
+14
-6
@@ -43,6 +43,7 @@ def check_workflow_contract() -> None:
|
||||
"Clippy (Windows target, warnings are errors)", "Build release (Windows)",
|
||||
"Unit tests (Windows build, under Wine)",
|
||||
"Headless UI self-test (Windows build, under Wine)",
|
||||
"Sign Windows executable (Azure Artifact Signing)",
|
||||
"Package Windows artifact", "Clean generated Toolkit build",
|
||||
)),
|
||||
("next.yml", "next", "candidate", (
|
||||
@@ -50,7 +51,8 @@ def check_workflow_contract() -> None:
|
||||
"Create private prerelease", "Clean generated Toolkit build",
|
||||
)),
|
||||
("next.yml", "next", "windows", (
|
||||
"Build Windows candidate", "Package Windows candidate",
|
||||
"Build Windows candidate", "Sign Windows candidate (Azure Artifact Signing)",
|
||||
"Package Windows candidate",
|
||||
"Clean generated Toolkit build",
|
||||
)),
|
||||
("verify.yml", "main", "verify", (
|
||||
@@ -83,7 +85,8 @@ def check_workflow_contract() -> None:
|
||||
condition = steps[position].get("if")
|
||||
if gate in {"Create Gitea release + upload artifact",
|
||||
"Create private prerelease", "Package Windows artifact",
|
||||
"Build Windows candidate", "Package Windows candidate"}:
|
||||
"Build Windows candidate", "Package Windows candidate",
|
||||
"Sign Windows candidate (Azure Artifact Signing)"}:
|
||||
assert condition is not None and "release == 'true'" in condition, path
|
||||
elif filename == "verify.yml" and gate in {
|
||||
"Build", "Unit tests", "Microbenchmarks",
|
||||
@@ -133,12 +136,17 @@ def main() -> None:
|
||||
["README.md", "ci/pr-surface.py"]):
|
||||
assert not pr_surface.documentation_only(paths), paths
|
||||
assert pr_surface.headless_packages(["crates/alkane-cli/src/main.rs"]) == ["alkane-cli"]
|
||||
assert pr_surface.headless_packages(["crates/alkane-artifacts/src/lib.rs"]) == [
|
||||
"alkane-artifacts", "alkane-cli", "alkane-flash",
|
||||
]
|
||||
# alkane-gui depends on alkane-flash and alkane-artifacts (right-click
|
||||
# install/uninstall and the release picker), so a change in either reaches
|
||||
# the GUI graph and needs the full build: not a headless-only change.
|
||||
assert pr_surface.headless_packages(["crates/alkane-artifacts/src/lib.rs"]) == []
|
||||
assert pr_surface.headless_packages(["crates/alkane-flash/src/lib.rs"]) == []
|
||||
assert pr_surface.headless_packages([
|
||||
"crates/alkane-access/src/lib.rs", "crates/alkane-flash/tests/update.rs",
|
||||
]) == ["alkane-access", "alkane-flash"]
|
||||
]) == []
|
||||
assert pr_surface.headless_packages([
|
||||
"crates/alkane-access/src/lib.rs", "crates/alkane-cli/src/main.rs",
|
||||
]) == ["alkane-access", "alkane-cli"]
|
||||
for paths in ([], ["crates/alkane-core/src/lib.rs"],
|
||||
["crates/alkane-discovery/src/lib.rs"],
|
||||
["crates/alkane-gui/src/main.rs"],
|
||||
|
||||
+16
-1
@@ -8,6 +8,9 @@
|
||||
# windows-ci.sh build release alkane-toolkit.exe
|
||||
# windows-ci.sh test all unit tests, run under Wine
|
||||
# windows-ci.sh selftest headless UI self-test under Wine + Xvfb
|
||||
# windows-ci.sh sign Authenticode-sign alkane-toolkit.exe through
|
||||
# Azure Artifact Signing (ci/sign-windows.sh;
|
||||
# a no-op until AZURE_SIGNING_PROFILE is set)
|
||||
# windows-ci.sh package VERSION dist/alkane-toolkit-vVERSION-windows-x86_64.zip
|
||||
# windows-ci.sh test-bundle dist/alkane-toolkit-windows-tests.zip (for
|
||||
# the native Windows job)
|
||||
@@ -30,6 +33,15 @@ case "${1:-}" in
|
||||
toolchain)
|
||||
bash ci/ensure-build-deps.sh windows
|
||||
rustup target list --installed | grep -qx "$target" || rustup target add "$target"
|
||||
# jsign ships in the CI image; fetch the same pinned jar on older images.
|
||||
jsign_version=7.6
|
||||
jsign_sha256=6cf58aa080e7ff82656f320cff8d4a3bff30408df8766806dcba3740dd839fa5
|
||||
if [ ! -s /opt/jsign/jsign.jar ]; then
|
||||
mkdir -p /opt/jsign
|
||||
curl -sSfL -o /opt/jsign/jsign.jar \
|
||||
"https://repo1.maven.org/maven2/net/jsign/jsign/$jsign_version/jsign-$jsign_version.jar"
|
||||
echo "$jsign_sha256 /opt/jsign/jsign.jar" | sha256sum -c -
|
||||
fi
|
||||
;;
|
||||
clippy)
|
||||
rustup component add clippy >/dev/null 2>&1 || true
|
||||
@@ -53,6 +65,9 @@ case "${1:-}" in
|
||||
selftest)
|
||||
bash scripts/ui-selftest-windows.sh "$exe"
|
||||
;;
|
||||
sign)
|
||||
bash ci/sign-windows.sh "$exe"
|
||||
;;
|
||||
package)
|
||||
python3 ci/package-windows.py release "${2:?usage: windows-ci.sh package VERSION}" "$exe" dist
|
||||
;;
|
||||
@@ -64,7 +79,7 @@ case "${1:-}" in
|
||||
dist/alkane-toolkit-windows-tests.zip
|
||||
;;
|
||||
*)
|
||||
sed -n '3,16p' "$0" >&2
|
||||
sed -n '3,19p' "$0" >&2
|
||||
exit 2
|
||||
;;
|
||||
esac
|
||||
|
||||
@@ -6,5 +6,7 @@ license.workspace = true
|
||||
|
||||
[dependencies]
|
||||
alkane-core = { path = "../alkane-core" }
|
||||
serde.workspace = true
|
||||
serde_json.workspace = true
|
||||
sha2.workspace = true
|
||||
thiserror.workspace = true
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,528 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Fetch the latest alkane-os `.afw` release from a Gitea repository.
|
||||
//!
|
||||
//! GitHub is retired for this project; releases live on the self-hosted Gitea.
|
||||
//! This resolves `releases/latest`, picks the `.afw` asset for a board, and
|
||||
//! downloads it so the normal verify -> plan -> preflight -> install flow runs on
|
||||
//! it exactly as it would on a local file. TLS is required, so this shells out to
|
||||
//! `curl` (as the GUI already does) rather than the plaintext TCP path used for
|
||||
//! liveness checks.
|
||||
//!
|
||||
//! A private repo needs a token; it is read from the environment at run time
|
||||
//! (`ALKANE_RELEASE_TOKEN`, else `GITEA_TOKEN`) and passed to curl through a
|
||||
//! 0600 config file, never on the command line.
|
||||
//!
|
||||
//! As a convenience for the GUI, a read-only token can be baked into the binary
|
||||
//! at build time by compiling with `ALKANE_EMBEDDED_TOKEN=<token>` set (see
|
||||
//! `EMBEDDED_TOKEN`). The source tree carries no secret - the value lives only in
|
||||
//! a binary built with that variable set - and the environment variables above
|
||||
//! always take precedence, so a user can override it. When no such token is baked
|
||||
//! in and none is in the environment, the token is simply absent (fine for public
|
||||
//! repos; a private repo then returns 401/404).
|
||||
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Command;
|
||||
|
||||
use serde_json::Value;
|
||||
use thiserror::Error;
|
||||
|
||||
/// A read-only Gitea token baked in at build time when the crate is compiled
|
||||
/// with `ALKANE_EMBEDDED_TOKEN` set. `None` in an ordinary build (no secret in
|
||||
/// the source tree). The environment variables win over this, so it is only a
|
||||
/// fallback for a distributed binary (the GUI) that ships without asking the user
|
||||
/// to configure a token. Scope it read-only on the server side; anyone with the
|
||||
/// binary can extract it.
|
||||
const EMBEDDED_TOKEN: Option<&str> = option_env!("ALKANE_EMBEDDED_TOKEN");
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum FetchError {
|
||||
#[error("curl failed: {0}")]
|
||||
Curl(String),
|
||||
#[error("release metadata did not parse: {0}")]
|
||||
Parse(String),
|
||||
#[error("no .afw asset for board {0} in the latest release")]
|
||||
NoAsset(String),
|
||||
#[error("io: {0}")]
|
||||
Io(String),
|
||||
}
|
||||
|
||||
/// Where releases come from. Defaults to the alkane-os repo on the self-hosted
|
||||
/// Gitea; the base URL and token are read from the environment.
|
||||
pub struct ReleaseSource {
|
||||
pub base_url: String,
|
||||
pub owner: String,
|
||||
pub repo: String,
|
||||
pub token: Option<String>,
|
||||
}
|
||||
|
||||
impl ReleaseSource {
|
||||
/// The alkane-os release source, honoring `ALKANE_RELEASE_BASE` and a token
|
||||
/// from `ALKANE_RELEASE_TOKEN` or `GITEA_TOKEN`.
|
||||
pub fn alkane_os() -> Self {
|
||||
Self::for_repo("blueflare", "alkane-os")
|
||||
}
|
||||
|
||||
/// A release source for an arbitrary Gitea `owner`/`repo`. The base URL
|
||||
/// (`ALKANE_RELEASE_BASE`, else the self-hosted Gitea) and the token
|
||||
/// (`ALKANE_RELEASE_TOKEN`, else `GITEA_TOKEN`, else the build-time embedded
|
||||
/// token) are resolved exactly as for `alkane_os`.
|
||||
pub fn for_repo(owner: &str, repo: &str) -> Self {
|
||||
let base_url = std::env::var("ALKANE_RELEASE_BASE")
|
||||
.ok()
|
||||
.filter(|s| !s.is_empty())
|
||||
.unwrap_or_else(|| "https://gitea.bluefla.re".to_string());
|
||||
let token = std::env::var("ALKANE_RELEASE_TOKEN")
|
||||
.ok()
|
||||
.or_else(|| std::env::var("GITEA_TOKEN").ok())
|
||||
.filter(|t| !t.is_empty())
|
||||
.or_else(|| EMBEDDED_TOKEN.map(str::to_string).filter(|t| !t.is_empty()));
|
||||
Self {
|
||||
base_url,
|
||||
owner: owner.to_string(),
|
||||
repo: repo.to_string(),
|
||||
token,
|
||||
}
|
||||
}
|
||||
|
||||
/// The releases list (newest first). Unlike `releases/latest`, this includes
|
||||
/// pre-releases, so an early/bench channel is still found by `--latest`.
|
||||
fn api_list(&self) -> String {
|
||||
format!(
|
||||
"{}/api/v1/repos/{}/{}/releases?limit=50",
|
||||
self.base_url.trim_end_matches('/'),
|
||||
self.owner,
|
||||
self.repo
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/// Find the first `.afw` asset for `board` across a newest-first list of
|
||||
/// releases. Returns (name, url).
|
||||
fn pick_asset(releases: &Value, board: &str) -> Option<(String, String)> {
|
||||
let needle = format!("-{board}-");
|
||||
for release in releases.as_array()? {
|
||||
let Some(assets) = release.get("assets").and_then(Value::as_array) else {
|
||||
continue;
|
||||
};
|
||||
for asset in assets {
|
||||
let name = asset.get("name").and_then(Value::as_str).unwrap_or("");
|
||||
if name.ends_with(".afw") && name.contains(&needle) {
|
||||
if let Some(url) = asset.get("browser_download_url").and_then(Value::as_str) {
|
||||
return Some((name.to_string(), url.to_string()));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// A temp curl `--config` file carrying the auth header, removed on drop so the
|
||||
/// token never lands in a process argument or a lingering file.
|
||||
struct TokenConfig {
|
||||
path: Option<PathBuf>,
|
||||
}
|
||||
|
||||
impl TokenConfig {
|
||||
fn new(token: &Option<String>) -> Result<Self, FetchError> {
|
||||
let Some(token) = token else {
|
||||
return Ok(Self { path: None });
|
||||
};
|
||||
let path = std::env::temp_dir().join(format!("alkane-fetch-{}.cfg", std::process::id()));
|
||||
write_private(
|
||||
&path,
|
||||
&format!("header = \"Authorization: token {token}\"\n"),
|
||||
)?;
|
||||
Ok(Self { path: Some(path) })
|
||||
}
|
||||
|
||||
fn apply(&self, cmd: &mut Command) {
|
||||
if let Some(path) = &self.path {
|
||||
cmd.arg("--config").arg(path);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for TokenConfig {
|
||||
fn drop(&mut self) {
|
||||
if let Some(path) = &self.path {
|
||||
let _ = fs::remove_file(path);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
fn write_private(path: &Path, contents: &str) -> Result<(), FetchError> {
|
||||
use std::io::Write;
|
||||
use std::os::unix::fs::OpenOptionsExt;
|
||||
let mut file = fs::OpenOptions::new()
|
||||
.write(true)
|
||||
.create(true)
|
||||
.truncate(true)
|
||||
.mode(0o600)
|
||||
.open(path)
|
||||
.map_err(|e| FetchError::Io(e.to_string()))?;
|
||||
file.write_all(contents.as_bytes())
|
||||
.map_err(|e| FetchError::Io(e.to_string()))
|
||||
}
|
||||
|
||||
#[cfg(not(unix))]
|
||||
fn write_private(path: &Path, contents: &str) -> Result<(), FetchError> {
|
||||
fs::write(path, contents).map_err(|e| FetchError::Io(e.to_string()))
|
||||
}
|
||||
|
||||
fn curl_bytes(src: &ReleaseSource, url: &str) -> Result<Vec<u8>, FetchError> {
|
||||
let config = TokenConfig::new(&src.token)?;
|
||||
let mut cmd = Command::new("curl");
|
||||
cmd.arg("-fsSL").arg("--max-time").arg("120");
|
||||
config.apply(&mut cmd);
|
||||
cmd.arg(url);
|
||||
let out = cmd.output().map_err(|e| FetchError::Curl(e.to_string()))?;
|
||||
if !out.status.success() {
|
||||
return Err(FetchError::Curl(format!(
|
||||
"{} ({})",
|
||||
String::from_utf8_lossy(&out.stderr).trim(),
|
||||
out.status
|
||||
)));
|
||||
}
|
||||
Ok(out.stdout)
|
||||
}
|
||||
|
||||
fn curl_download(src: &ReleaseSource, url: &str, dest: &Path) -> Result<(), FetchError> {
|
||||
let config = TokenConfig::new(&src.token)?;
|
||||
let mut cmd = Command::new("curl");
|
||||
cmd.arg("-fsSL")
|
||||
.arg("--max-time")
|
||||
.arg("600")
|
||||
.arg("-o")
|
||||
.arg(dest);
|
||||
config.apply(&mut cmd);
|
||||
cmd.arg(url);
|
||||
let out = cmd.output().map_err(|e| FetchError::Curl(e.to_string()))?;
|
||||
if !out.status.success() {
|
||||
return Err(FetchError::Curl(format!(
|
||||
"{} ({})",
|
||||
String::from_utf8_lossy(&out.stderr).trim(),
|
||||
out.status
|
||||
)));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Resolve the latest release's `.afw` asset for `board`: returns (name, url).
|
||||
/// Scans the newest-first releases list (so a pre-release counts as latest).
|
||||
pub fn latest_afw_asset(src: &ReleaseSource, board: &str) -> Result<(String, String), FetchError> {
|
||||
let body = curl_bytes(src, &src.api_list())?;
|
||||
let releases: Value =
|
||||
serde_json::from_slice(&body).map_err(|e| FetchError::Parse(e.to_string()))?;
|
||||
pick_asset(&releases, board).ok_or_else(|| FetchError::NoAsset(board.to_string()))
|
||||
}
|
||||
|
||||
/// Download the latest `.afw` for `board` into `dest_dir`; returns its path.
|
||||
pub fn fetch_latest_afw(
|
||||
src: &ReleaseSource,
|
||||
board: &str,
|
||||
dest_dir: &Path,
|
||||
) -> Result<PathBuf, FetchError> {
|
||||
let (name, url) = latest_afw_asset(src, board)?;
|
||||
fs::create_dir_all(dest_dir).map_err(|e| FetchError::Io(e.to_string()))?;
|
||||
let dest = dest_dir.join(&name);
|
||||
curl_download(src, &url, &dest)?;
|
||||
Ok(dest)
|
||||
}
|
||||
|
||||
/// Board tokens recognised in `.afw` asset names (the `-<board>-` filename
|
||||
/// segment). Used by `ReleaseInfo::compatible_boards`.
|
||||
pub const KNOWN_BOARDS: &[&str] = &[
|
||||
"zynq-7010",
|
||||
"am335x",
|
||||
"cv1835",
|
||||
"a113d",
|
||||
"allwinner-h3",
|
||||
"allwinner-h6",
|
||||
"allwinner-h616",
|
||||
];
|
||||
|
||||
/// One `.afw` asset in a release.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct AfwAsset {
|
||||
pub name: String,
|
||||
pub url: String,
|
||||
}
|
||||
|
||||
/// A release as listed for the GUI's release picker: its tag/name, whether it is
|
||||
/// a pre-release or draft, when it was published, and the `.afw` assets it holds.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct ReleaseInfo {
|
||||
pub tag: String,
|
||||
pub name: String,
|
||||
pub prerelease: bool,
|
||||
pub draft: bool,
|
||||
pub published_at: String,
|
||||
pub afw_assets: Vec<AfwAsset>,
|
||||
}
|
||||
|
||||
impl ReleaseInfo {
|
||||
/// The `.afw` asset for `board` in this release, if any (matched by the
|
||||
/// `-<board>-` segment of the filename, as `pick_asset` does).
|
||||
pub fn asset_for_board(&self, board: &str) -> Option<&AfwAsset> {
|
||||
let needle = format!("-{board}-");
|
||||
self.afw_assets.iter().find(|a| a.name.contains(&needle))
|
||||
}
|
||||
|
||||
/// The distinct board tokens (from `KNOWN_BOARDS`) this release carries an
|
||||
/// `.afw` for, detected from the asset filenames (`-<board>-` segment, e.g.
|
||||
/// `alkane-os-0.1.2-zynq-7010-armv7.afw` -> `zynq-7010`). Ordered by first
|
||||
/// appearance across the assets; a release with no recognised board yields an
|
||||
/// empty list.
|
||||
pub fn compatible_boards(&self) -> Vec<String> {
|
||||
let mut boards: Vec<String> = Vec::new();
|
||||
for asset in &self.afw_assets {
|
||||
for board in KNOWN_BOARDS {
|
||||
let needle = format!("-{board}-");
|
||||
if asset.name.contains(&needle) && !boards.iter().any(|b| b == board) {
|
||||
boards.push((*board).to_string());
|
||||
}
|
||||
}
|
||||
}
|
||||
boards
|
||||
}
|
||||
|
||||
/// Whether this release has an `.afw` for `board` (same match as
|
||||
/// `asset_for_board`).
|
||||
pub fn is_compatible_with(&self, board: &str) -> bool {
|
||||
self.asset_for_board(board).is_some()
|
||||
}
|
||||
}
|
||||
|
||||
/// Parse a Gitea releases array (newest first) into `ReleaseInfo`s, keeping only
|
||||
/// the `.afw` assets of each. Drafts are included so the caller can decide.
|
||||
fn parse_releases(releases: &Value) -> Vec<ReleaseInfo> {
|
||||
let mut out = Vec::new();
|
||||
let Some(arr) = releases.as_array() else {
|
||||
return out;
|
||||
};
|
||||
for release in arr {
|
||||
let tag = release
|
||||
.get("tag_name")
|
||||
.and_then(Value::as_str)
|
||||
.unwrap_or("")
|
||||
.to_string();
|
||||
let name = release
|
||||
.get("name")
|
||||
.and_then(Value::as_str)
|
||||
.unwrap_or("")
|
||||
.to_string();
|
||||
let prerelease = release
|
||||
.get("prerelease")
|
||||
.and_then(Value::as_bool)
|
||||
.unwrap_or(false);
|
||||
let draft = release
|
||||
.get("draft")
|
||||
.and_then(Value::as_bool)
|
||||
.unwrap_or(false);
|
||||
let published_at = release
|
||||
.get("published_at")
|
||||
.or_else(|| release.get("created_at"))
|
||||
.and_then(Value::as_str)
|
||||
.unwrap_or("")
|
||||
.to_string();
|
||||
let mut afw_assets = Vec::new();
|
||||
if let Some(assets) = release.get("assets").and_then(Value::as_array) {
|
||||
for asset in assets {
|
||||
let aname = asset.get("name").and_then(Value::as_str).unwrap_or("");
|
||||
if aname.ends_with(".afw") {
|
||||
if let Some(url) = asset.get("browser_download_url").and_then(Value::as_str) {
|
||||
afw_assets.push(AfwAsset {
|
||||
name: aname.to_string(),
|
||||
url: url.to_string(),
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
out.push(ReleaseInfo {
|
||||
tag,
|
||||
name,
|
||||
prerelease,
|
||||
draft,
|
||||
published_at,
|
||||
afw_assets,
|
||||
});
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// List the releases (newest first) of the source repo, each with its `.afw`
|
||||
/// assets. Used by the GUI to scan alkane-os releases and pick one to install.
|
||||
pub fn list_releases(src: &ReleaseSource) -> Result<Vec<ReleaseInfo>, FetchError> {
|
||||
let body = curl_bytes(src, &src.api_list())?;
|
||||
let releases: Value =
|
||||
serde_json::from_slice(&body).map_err(|e| FetchError::Parse(e.to_string()))?;
|
||||
Ok(parse_releases(&releases))
|
||||
}
|
||||
|
||||
/// Download a specific release asset (by its `browser_download_url`) into
|
||||
/// `dest_dir`, saving it under `name`; returns the written path.
|
||||
pub fn fetch_afw_url(
|
||||
src: &ReleaseSource,
|
||||
name: &str,
|
||||
url: &str,
|
||||
dest_dir: &Path,
|
||||
) -> Result<PathBuf, FetchError> {
|
||||
fs::create_dir_all(dest_dir).map_err(|e| FetchError::Io(e.to_string()))?;
|
||||
let dest = dest_dir.join(name);
|
||||
curl_download(src, url, &dest)?;
|
||||
Ok(dest)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn source_defaults_to_alkane_os_on_gitea() {
|
||||
std::env::remove_var("ALKANE_RELEASE_BASE");
|
||||
let src = ReleaseSource::alkane_os();
|
||||
assert_eq!(src.owner, "blueflare");
|
||||
assert_eq!(src.repo, "alkane-os");
|
||||
assert!(src
|
||||
.api_list()
|
||||
.contains("/api/v1/repos/blueflare/alkane-os/releases"));
|
||||
assert!(src.api_list().starts_with("https://gitea.bluefla.re"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pick_asset_takes_the_newest_matching_afw() {
|
||||
// Newest-first list of releases; the board's .afw in the first release wins.
|
||||
let releases = serde_json::json!([
|
||||
{"tag_name": "v0.1.0-bench1", "assets": [
|
||||
{"name": "SHA256SUMS", "browser_download_url": "u0"},
|
||||
{"name": "alkane-os-0.1.0-am335x-arm.afw", "browser_download_url": "u1"},
|
||||
{"name": "alkane-os-0.1.0-zynq-7010-armv7.afw", "browser_download_url": "u2"},
|
||||
]},
|
||||
{"tag_name": "v0.0.9", "assets": [
|
||||
{"name": "alkane-os-0.0.9-zynq-7010-armv7.afw", "browser_download_url": "old"},
|
||||
]},
|
||||
]);
|
||||
assert_eq!(
|
||||
pick_asset(&releases, "zynq-7010"),
|
||||
Some(("alkane-os-0.1.0-zynq-7010-armv7.afw".into(), "u2".into()))
|
||||
);
|
||||
assert_eq!(pick_asset(&releases, "cv1835"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn list_parses_releases_and_filters_afw_assets() {
|
||||
let releases = serde_json::json!([
|
||||
{"tag_name": "v0.2.0-bench1", "name": "bench", "prerelease": true, "draft": false,
|
||||
"published_at": "2026-11-11T10:00:00Z", "assets": [
|
||||
{"name": "SHA256SUMS", "browser_download_url": "s"},
|
||||
{"name": "alkane-os-0.2.0-zynq-7010-armv7.afw", "browser_download_url": "z"},
|
||||
]},
|
||||
{"tag_name": "v0.1.0", "name": "", "prerelease": false, "draft": false,
|
||||
"published_at": "2026-10-01T00:00:00Z", "assets": [
|
||||
{"name": "alkane-os-0.1.0-am335x-arm.afw", "browser_download_url": "a"},
|
||||
]},
|
||||
]);
|
||||
let parsed = parse_releases(&releases);
|
||||
assert_eq!(parsed.len(), 2);
|
||||
// Newest first; only .afw assets kept; SHA256SUMS dropped.
|
||||
assert_eq!(parsed[0].tag, "v0.2.0-bench1");
|
||||
assert!(parsed[0].prerelease);
|
||||
assert_eq!(parsed[0].afw_assets.len(), 1);
|
||||
// The board filter matches the -<board>- segment.
|
||||
assert_eq!(
|
||||
parsed[0]
|
||||
.asset_for_board("zynq-7010")
|
||||
.map(|a| a.url.as_str()),
|
||||
Some("z")
|
||||
);
|
||||
assert!(parsed[0].asset_for_board("am335x").is_none());
|
||||
assert_eq!(
|
||||
parsed[1].asset_for_board("am335x").map(|a| a.name.as_str()),
|
||||
Some("alkane-os-0.1.0-am335x-arm.afw")
|
||||
);
|
||||
assert!(parsed[1].asset_for_board("zynq-7010").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn for_repo_builds_the_api_url_for_a_custom_repo() {
|
||||
std::env::remove_var("ALKANE_RELEASE_BASE");
|
||||
let src = ReleaseSource::for_repo("someorg", "some-firmware");
|
||||
assert_eq!(src.owner, "someorg");
|
||||
assert_eq!(src.repo, "some-firmware");
|
||||
assert_eq!(
|
||||
src.api_list(),
|
||||
"https://gitea.bluefla.re/api/v1/repos/someorg/some-firmware/releases?limit=50"
|
||||
);
|
||||
// alkane_os() is for_repo("blueflare", "alkane-os").
|
||||
let os = ReleaseSource::alkane_os();
|
||||
assert_eq!(
|
||||
(os.owner.as_str(), os.repo.as_str()),
|
||||
("blueflare", "alkane-os")
|
||||
);
|
||||
}
|
||||
|
||||
fn release_with(names: &[&str]) -> ReleaseInfo {
|
||||
ReleaseInfo {
|
||||
tag: "v0.1.2".into(),
|
||||
name: String::new(),
|
||||
prerelease: false,
|
||||
draft: false,
|
||||
published_at: String::new(),
|
||||
afw_assets: names
|
||||
.iter()
|
||||
.map(|n| AfwAsset {
|
||||
name: (*n).to_string(),
|
||||
url: format!("https://example.invalid/{n}"),
|
||||
})
|
||||
.collect(),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn compatible_boards_extracts_board_tokens_from_asset_names() {
|
||||
let single = release_with(&["alkane-os-0.1.2-zynq-7010-armv7.afw"]);
|
||||
assert_eq!(single.compatible_boards(), vec!["zynq-7010"]);
|
||||
|
||||
// Multi-board release: distinct boards in first-appearance order,
|
||||
// duplicates (a second arch build of one board) collapse.
|
||||
let multi = release_with(&[
|
||||
"alkane-os-0.1.2-am335x-armv7.afw",
|
||||
"alkane-os-0.1.2-zynq-7010-armv7.afw",
|
||||
"alkane-os-0.1.2-allwinner-h616-aarch64.afw",
|
||||
"alkane-os-0.1.2-am335x-arm.afw",
|
||||
"alkane-os-0.1.2-cv1835-riscv64.afw",
|
||||
]);
|
||||
assert_eq!(
|
||||
multi.compatible_boards(),
|
||||
vec!["am335x", "zynq-7010", "allwinner-h616", "cv1835"]
|
||||
);
|
||||
|
||||
// allwinner-h6 must not match an allwinner-h616 asset (and vice versa).
|
||||
let h616 = release_with(&["alkane-os-0.1.2-allwinner-h616-aarch64.afw"]);
|
||||
assert_eq!(h616.compatible_boards(), vec!["allwinner-h616"]);
|
||||
let h6 = release_with(&["alkane-os-0.1.2-allwinner-h6-aarch64.afw"]);
|
||||
assert_eq!(h6.compatible_boards(), vec!["allwinner-h6"]);
|
||||
|
||||
// No .afw assets, or an unrecognised board, yields nothing.
|
||||
assert!(release_with(&[]).compatible_boards().is_empty());
|
||||
assert!(release_with(&["alkane-os-0.1.2-mystery-board-arm.afw"])
|
||||
.compatible_boards()
|
||||
.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn is_compatible_with_matches_asset_for_board() {
|
||||
let rel = release_with(&[
|
||||
"alkane-os-0.1.2-zynq-7010-armv7.afw",
|
||||
"alkane-os-0.1.2-a113d-aarch64.afw",
|
||||
]);
|
||||
assert!(rel.is_compatible_with("zynq-7010"));
|
||||
assert!(rel.is_compatible_with("a113d"));
|
||||
assert!(!rel.is_compatible_with("am335x"));
|
||||
assert!(!rel.is_compatible_with("allwinner-h6"));
|
||||
assert!(!release_with(&[]).is_compatible_with("zynq-7010"));
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,9 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Verify local firmware artifacts before an install path consumes them.
|
||||
|
||||
pub mod afw;
|
||||
pub mod fetch;
|
||||
|
||||
use sha2::{Digest, Sha256};
|
||||
use std::collections::HashSet;
|
||||
use std::fs::File;
|
||||
|
||||
@@ -7,3 +7,5 @@ license.workspace = true
|
||||
[dependencies]
|
||||
alkane-core = { path = "../alkane-core" }
|
||||
alkane-artifacts = { path = "../alkane-artifacts" }
|
||||
alkane-flash = { path = "../alkane-flash" }
|
||||
serde_json.workspace = true
|
||||
|
||||
+1461
-16
File diff suppressed because it is too large
Load Diff
@@ -7,6 +7,7 @@ license.workspace = true
|
||||
[dependencies]
|
||||
alkane-core = { path = "../alkane-core" }
|
||||
alkane-artifacts = { path = "../alkane-artifacts" }
|
||||
serde_json.workspace = true
|
||||
sha2.workspace = true
|
||||
thiserror.workspace = true
|
||||
tempfile = "3"
|
||||
|
||||
@@ -0,0 +1,660 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Readable Amlogic A113D (Amlogic AXG, Antminer BHB42XXX) install/restore over
|
||||
//! the FLAG-BASED boot chain. This is the Claude-domain counterpart of
|
||||
//! `zynq_nand`: it drives the DSH root-on-stock primitive (`stock::root_exec` /
|
||||
//! `stock::root_put`) for the from-stock install, and the alkane SSH transport
|
||||
//! for the in-band restore, with the stock-access method never read here.
|
||||
//!
|
||||
//! Mechanism (CONFIRMED live 2026-11-13, see alkane-sdk-construction
|
||||
//! alkane-a113d-image-bringup):
|
||||
//!
|
||||
//! - The OS files `alkane/{vmlinux.bin,devicetree.dtb,uramdisk.image.gz}` are
|
||||
//! staged into the nvdata UBI volume (UBIFS), exactly as the alkane boot chain
|
||||
//! reads them (`ubifsload`). Zero raw writes to the brick-sensitive regions.
|
||||
//! - A one-byte-magic FLAG lives in the `misc` partition (the Android BCB block,
|
||||
//! abs NAND 0x1000000) at erase-block 1 (offset 0x20000, abs 0x1020000). Block
|
||||
//! 0 (the BCB) is never touched. The flag is the four bytes "ALAN".
|
||||
//! - Stock U-Boot's `bootcmd` is set (once, in-band via /dev/nand_env from stock)
|
||||
//! to `run checkalk; run storeboot`, where `checkalk` RAW-reads the flag page
|
||||
//! (`nand read`, NO UBI) and, only if the magic matches, runs `alkboot` (which
|
||||
//! mounts the nvdata UBIFS and boots alkane). When the flag is absent the stock
|
||||
//! path is a pure raw read + `storeboot`, which boots genuine stock STABLY (a
|
||||
//! ubi/ubifs op in the stock boot path instead makes stock's firstboot
|
||||
//! supervisor reboot-loop - that is why the flag read must be raw).
|
||||
//! - INSTALL (stock -> alkane): stage the files, write the env, set flag=ALAN.
|
||||
//! - RESTORE (alkane -> stock): erase the flag block in-band from the running
|
||||
//! alkane OS (which exposes `misc` as an MTD). One raw NAND erase, `reboot -f`,
|
||||
//! and stock boots via `storeboot`. Fully network-only; the alkane payload and
|
||||
//! the env are left in place, so re-install is just re-writing the flag.
|
||||
//!
|
||||
//! itest note: this vendor U-Boot's `itest.l *<mem>` does NOT compare correctly,
|
||||
//! but `itest.b *<mem>` does, so `checkalk` tests the four magic bytes with
|
||||
//! nested `itest.b`. CONFIRMED live 2026-11-13.
|
||||
|
||||
use crate::stock::StockError;
|
||||
use crate::transport::{Remote, SshOptions, SshTransport};
|
||||
use crate::uimage::crc32;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::time::Duration;
|
||||
|
||||
pub const BOARD: &str = "a113d";
|
||||
|
||||
/// U-Boot env blob size on this board (CONFIRMED: `/dev/nand_env` is 64 KiB, a
|
||||
/// standard U-Boot env = 4-byte little-endian CRC32 + NUL-separated key=value,
|
||||
/// double-NUL terminated, 0x00-padded).
|
||||
const ENV_SIZE: usize = 65536;
|
||||
|
||||
/// Flag: four magic bytes "ALAN" at misc (abs 0x1000000) erase-block 1.
|
||||
const FLAG_ABS_OFFSET: u64 = 0x1020000; // misc base 0x1000000 + block 1 (0x20000)
|
||||
const FLAG_BLOCK_IN_MISC: u64 = 0x20000; // offset of the flag block within the misc MTD
|
||||
const FLAG_MAGIC: [u8; 4] = *b"ALAN";
|
||||
|
||||
/// Boot load addresses (CONFIRMED live) and the alkane console bootargs.
|
||||
const KRNADDR: &str = "0x1200000";
|
||||
const FDTADDR: &str = "0x8000000";
|
||||
const RDADDR: &str = "0x8100000";
|
||||
const ALK_BOOTARGS: &str = "console=ttyAML0,115200 earlycon=meson,0xff803000 no_console_suspend";
|
||||
|
||||
/// The on-board basenames inside the nvdata UBI volume's `alkane/` directory.
|
||||
const ALKANE_DIR: &str = "alkane";
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Shell abstraction: StockShell drives the DSH root primitive; AlkaneShell the
|
||||
// alkane SSH transport. (Mirrors zynq_nand.)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
trait Shell {
|
||||
fn exec(&mut self, cmd: &str) -> Result<String, StockError>;
|
||||
fn exec_long(&mut self, cmd: &str) -> Result<String, StockError>;
|
||||
fn put(&mut self, data: &[u8], remote_path: &str) -> Result<(), StockError>;
|
||||
}
|
||||
|
||||
struct StockShell {
|
||||
host: String,
|
||||
password: Option<String>,
|
||||
}
|
||||
|
||||
impl Shell for StockShell {
|
||||
fn exec(&mut self, cmd: &str) -> Result<String, StockError> {
|
||||
crate::stock::root_exec(&self.host, self.password.as_deref(), cmd)
|
||||
}
|
||||
fn exec_long(&mut self, cmd: &str) -> Result<String, StockError> {
|
||||
// root_exec already carries a generous timeout in the method.
|
||||
crate::stock::root_exec(&self.host, self.password.as_deref(), cmd)
|
||||
}
|
||||
fn put(&mut self, data: &[u8], remote_path: &str) -> Result<(), StockError> {
|
||||
crate::stock::root_put(&self.host, self.password.as_deref(), data, remote_path)
|
||||
}
|
||||
}
|
||||
|
||||
struct AlkaneShell {
|
||||
transport: SshTransport,
|
||||
_secret: TempFile,
|
||||
}
|
||||
|
||||
impl AlkaneShell {
|
||||
fn connect(host: &str, password: Option<&str>) -> Result<Self, StockError> {
|
||||
// Password in a 0600 temp file; a throwaway empty known_hosts (the host
|
||||
// key legitimately changes across stock<->alkane). Same stance as zynq.
|
||||
let secret = TempFile::with(password.unwrap_or("alkane").as_bytes(), "pw")?;
|
||||
let known = temp_path("kh");
|
||||
let _ = std::fs::File::create(&known);
|
||||
let options = SshOptions {
|
||||
host: host.to_owned(),
|
||||
port: 22,
|
||||
user: "root".to_owned(),
|
||||
identity_file: None,
|
||||
password_file: Some(secret.0.clone()),
|
||||
known_hosts: Some(known),
|
||||
root_method: crate::transport::RootMethod::Auto,
|
||||
update_daemon_port: None,
|
||||
};
|
||||
let transport =
|
||||
SshTransport::connect(options, true).map_err(|e| StockError::Network(e.to_string()))?;
|
||||
Ok(AlkaneShell {
|
||||
transport,
|
||||
_secret: secret,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl Shell for AlkaneShell {
|
||||
fn exec(&mut self, cmd: &str) -> Result<String, StockError> {
|
||||
self.transport
|
||||
.root_command(cmd, Duration::from_secs(120))
|
||||
.map(|o| String::from_utf8_lossy(&o).into_owned())
|
||||
.map_err(|e| StockError::Method(e.to_string()))
|
||||
}
|
||||
fn exec_long(&mut self, cmd: &str) -> Result<String, StockError> {
|
||||
self.transport
|
||||
.root_command(cmd, Duration::from_secs(900))
|
||||
.map(|o| String::from_utf8_lossy(&o).into_owned())
|
||||
.map_err(|e| StockError::Method(e.to_string()))
|
||||
}
|
||||
fn put(&mut self, data: &[u8], remote_path: &str) -> Result<(), StockError> {
|
||||
let tmp = TempFile::with(data, "put")?;
|
||||
self.transport
|
||||
.push(&tmp.0, remote_path, Duration::from_secs(900))
|
||||
.map_err(|e| StockError::Method(e.to_string()))
|
||||
}
|
||||
}
|
||||
|
||||
static TEMP_SEQ: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
|
||||
|
||||
fn temp_path(tag: &str) -> PathBuf {
|
||||
let n = TEMP_SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
|
||||
std::env::temp_dir().join(format!("alkane-aml-{}-{}-{}", std::process::id(), tag, n))
|
||||
}
|
||||
|
||||
/// A 0600 temp file removed on drop.
|
||||
struct TempFile(PathBuf);
|
||||
impl TempFile {
|
||||
fn with(contents: &[u8], tag: &str) -> Result<Self, StockError> {
|
||||
let path = temp_path(tag);
|
||||
write_private(&path, contents).map_err(|e| StockError::Io(e.to_string()))?;
|
||||
Ok(TempFile(path))
|
||||
}
|
||||
}
|
||||
impl Drop for TempFile {
|
||||
fn drop(&mut self) {
|
||||
let _ = std::fs::remove_file(&self.0);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
fn write_private(path: &Path, contents: &[u8]) -> std::io::Result<()> {
|
||||
use std::io::Write as _;
|
||||
use std::os::unix::fs::OpenOptionsExt;
|
||||
let mut f = std::fs::OpenOptions::new()
|
||||
.create(true)
|
||||
.truncate(true)
|
||||
.write(true)
|
||||
.mode(0o600)
|
||||
.open(path)?;
|
||||
f.write_all(contents)?;
|
||||
f.flush()
|
||||
}
|
||||
|
||||
#[cfg(not(unix))]
|
||||
fn write_private(path: &Path, contents: &[u8]) -> std::io::Result<()> {
|
||||
std::fs::write(path, contents)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// base64 (busybox-safe: decode a possibly line-wrapped stream).
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
fn b64_decode(s: &str) -> Option<Vec<u8>> {
|
||||
const INV: u8 = 0xFF;
|
||||
fn val(c: u8) -> u8 {
|
||||
match c {
|
||||
b'A'..=b'Z' => c - b'A',
|
||||
b'a'..=b'z' => c - b'a' + 26,
|
||||
b'0'..=b'9' => c - b'0' + 52,
|
||||
b'+' => 62,
|
||||
b'/' => 63,
|
||||
_ => INV,
|
||||
}
|
||||
}
|
||||
let mut out = Vec::new();
|
||||
let mut acc = 0u32;
|
||||
let mut bits = 0u32;
|
||||
for &c in s.as_bytes() {
|
||||
if c == b'=' {
|
||||
break;
|
||||
}
|
||||
let v = val(c);
|
||||
if v == INV {
|
||||
continue; // skip whitespace / newlines
|
||||
}
|
||||
acc = (acc << 6) | v as u32;
|
||||
bits += 6;
|
||||
if bits >= 8 {
|
||||
bits -= 8;
|
||||
out.push((acc >> bits) as u8);
|
||||
}
|
||||
}
|
||||
Some(out)
|
||||
}
|
||||
|
||||
fn b64_encode(data: &[u8]) -> String {
|
||||
const T: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||||
let mut out = String::with_capacity(data.len().div_ceil(3) * 4);
|
||||
for chunk in data.chunks(3) {
|
||||
let b = [
|
||||
chunk[0],
|
||||
*chunk.get(1).unwrap_or(&0),
|
||||
*chunk.get(2).unwrap_or(&0),
|
||||
];
|
||||
let n = ((b[0] as u32) << 16) | ((b[1] as u32) << 8) | b[2] as u32;
|
||||
out.push(T[((n >> 18) & 63) as usize] as char);
|
||||
out.push(T[((n >> 12) & 63) as usize] as char);
|
||||
out.push(if chunk.len() > 1 {
|
||||
T[((n >> 6) & 63) as usize] as char
|
||||
} else {
|
||||
'='
|
||||
});
|
||||
out.push(if chunk.len() > 2 {
|
||||
T[(n & 63) as usize] as char
|
||||
} else {
|
||||
'='
|
||||
});
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// U-Boot environment (standard format) read / parse / build / write.
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Read the 64 KiB U-Boot env blob from /dev/nand_env (stock only).
|
||||
fn read_env(sh: &mut dyn Shell) -> Result<Vec<u8>, StockError> {
|
||||
let out = sh.exec(
|
||||
"echo B64START; dd if=/dev/nand_env bs=65536 count=1 2>/dev/null | base64; echo B64END",
|
||||
)?;
|
||||
let start = out
|
||||
.find("B64START")
|
||||
.ok_or_else(|| StockError::Method("env read: no marker".into()))?;
|
||||
let end = out
|
||||
.find("B64END")
|
||||
.ok_or_else(|| StockError::Method("env read: no end marker".into()))?;
|
||||
let b64 = &out[start + "B64START".len()..end];
|
||||
let blob = b64_decode(b64).ok_or_else(|| StockError::Method("env read: bad base64".into()))?;
|
||||
if blob.len() != ENV_SIZE {
|
||||
return Err(StockError::Method(format!(
|
||||
"env read: {} bytes (expected {ENV_SIZE})",
|
||||
blob.len()
|
||||
)));
|
||||
}
|
||||
let stored = u32::from_le_bytes([blob[0], blob[1], blob[2], blob[3]]);
|
||||
if crc32(&blob[4..]) != stored {
|
||||
return Err(StockError::Method("env read: CRC mismatch".into()));
|
||||
}
|
||||
Ok(blob)
|
||||
}
|
||||
|
||||
/// Parse the env body into ordered (key, value) pairs (up to the double-NUL).
|
||||
fn parse_env(blob: &[u8]) -> Vec<(String, String)> {
|
||||
let body = &blob[4..];
|
||||
let end = body
|
||||
.windows(2)
|
||||
.position(|w| w == [0, 0])
|
||||
.unwrap_or(body.len());
|
||||
let mut vars = Vec::new();
|
||||
for kv in body[..end].split(|&b| b == 0) {
|
||||
if kv.is_empty() {
|
||||
continue;
|
||||
}
|
||||
if let Some(eq) = kv.iter().position(|&b| b == b'=') {
|
||||
let k = String::from_utf8_lossy(&kv[..eq]).into_owned();
|
||||
let v = String::from_utf8_lossy(&kv[eq + 1..]).into_owned();
|
||||
vars.push((k, v));
|
||||
}
|
||||
}
|
||||
vars
|
||||
}
|
||||
|
||||
/// Build a 64 KiB env blob from ordered (key,value) pairs: CRC32 + body +
|
||||
/// double-NUL + 0x00 padding (what a clean `saveenv` produces).
|
||||
fn build_env(vars: &[(String, String)]) -> Result<Vec<u8>, StockError> {
|
||||
let mut body = Vec::with_capacity(ENV_SIZE);
|
||||
for (k, v) in vars {
|
||||
body.extend_from_slice(k.as_bytes());
|
||||
body.push(b'=');
|
||||
body.extend_from_slice(v.as_bytes());
|
||||
body.push(0);
|
||||
}
|
||||
body.push(0); // terminating double-NUL (last var's NUL + this one)
|
||||
if body.len() > ENV_SIZE - 4 {
|
||||
return Err(StockError::Method("env too large".into()));
|
||||
}
|
||||
body.resize(ENV_SIZE - 4, 0);
|
||||
let crc = crc32(&body);
|
||||
let mut blob = Vec::with_capacity(ENV_SIZE);
|
||||
blob.extend_from_slice(&crc.to_le_bytes());
|
||||
blob.extend_from_slice(&body);
|
||||
Ok(blob)
|
||||
}
|
||||
|
||||
/// Set (or insert, preserving order) a variable.
|
||||
fn set_var(vars: &mut Vec<(String, String)>, key: &str, value: &str) {
|
||||
if let Some(slot) = vars.iter_mut().find(|(k, _)| k == key) {
|
||||
slot.1 = value.to_owned();
|
||||
} else {
|
||||
vars.push((key.to_owned(), value.to_owned()));
|
||||
}
|
||||
}
|
||||
|
||||
/// Write the env blob to /dev/nand_env and read it back byte-exact BEFORE any
|
||||
/// reboot (the env is only consumed at next boot, so a verified read-back cannot
|
||||
/// brick). On a read-back mismatch the caller must restore the previous env.
|
||||
fn write_env(sh: &mut dyn Shell, blob: &[u8]) -> Result<(), StockError> {
|
||||
let b64 = b64_encode(blob);
|
||||
// Stream the blob to a temp file, then dd it to /dev/nand_env in one write.
|
||||
sh.put(b64.as_bytes(), "/tmp/.alkenv.b64")?;
|
||||
let out = sh.exec(
|
||||
"base64 -d /tmp/.alkenv.b64 > /tmp/.alkenv.bin 2>/dev/null; \
|
||||
dd if=/tmp/.alkenv.bin of=/dev/nand_env bs=65536 count=1 2>/dev/null; sync; \
|
||||
echo RB=$(dd if=/dev/nand_env bs=65536 count=1 2>/dev/null | md5sum | cut -d' ' -f1); \
|
||||
rm -f /tmp/.alkenv.b64 /tmp/.alkenv.bin",
|
||||
)?;
|
||||
let want = md5_hex(blob);
|
||||
let got = out
|
||||
.split("RB=")
|
||||
.nth(1)
|
||||
.map(|s| s.trim().to_owned())
|
||||
.unwrap_or_default();
|
||||
if got != want {
|
||||
return Err(StockError::Method(format!(
|
||||
"env write read-back mismatch: wrote {want}, read {got}"
|
||||
)));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn md5_hex(data: &[u8]) -> String {
|
||||
crate::md5::md5_hex(data)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// MTD / flag helpers.
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Find the /dev/mtdN whose /proc/mtd label matches `name`.
|
||||
fn find_mtd(sh: &mut dyn Shell, name: &str) -> Result<String, StockError> {
|
||||
let out = sh.exec("cat /proc/mtd")?;
|
||||
for line in out.lines() {
|
||||
if line.contains(&format!("\"{name}\"")) {
|
||||
if let Some((dev, _)) = line.split_once(':') {
|
||||
return Ok(format!("/dev/{}", dev.trim()));
|
||||
}
|
||||
}
|
||||
}
|
||||
Err(StockError::Method(format!("no '{name}' MTD on this board")))
|
||||
}
|
||||
|
||||
/// Discover the nvdata UBI volume's name (never assumed: vendor histories leave
|
||||
/// different names). Looks for an already-attached ubi volume on the nvdata MTD.
|
||||
fn discover_nvdata_volume(sh: &mut dyn Shell) -> Result<(String, String), StockError> {
|
||||
// Returns (mountpoint, volume_name). On stock the vendor mounts nvdata (e.g.
|
||||
// at /tmp/miner); find the ubifs mount whose volume sits on the nvdata MTD.
|
||||
let mounts = sh.exec("cat /proc/mounts")?;
|
||||
for line in mounts.lines() {
|
||||
// e.g. "/dev/ubi2_0 /tmp/miner ubifs rw,..."
|
||||
let mut it = line.split_whitespace();
|
||||
let dev = it.next().unwrap_or("");
|
||||
let mnt = it.next().unwrap_or("");
|
||||
let fs = it.next().unwrap_or("");
|
||||
if fs == "ubifs" && dev.contains("ubi") {
|
||||
// read the volume name from sysfs: /sys/class/ubi/<ubiX_0>/name
|
||||
let base = dev.trim_start_matches("/dev/");
|
||||
let name = sh
|
||||
.exec(&format!("cat /sys/class/ubi/{base}/name 2>/dev/null"))?
|
||||
.trim()
|
||||
.to_owned();
|
||||
// Only accept the nvdata volume (skip the small config_data volume).
|
||||
// nvdata is the large one; confirm by its mount not being /config.
|
||||
if !name.is_empty() && mnt != "/config" {
|
||||
return Ok((mnt.to_owned(), name));
|
||||
}
|
||||
}
|
||||
}
|
||||
Err(StockError::Method(
|
||||
"could not find the mounted nvdata UBI volume".into(),
|
||||
))
|
||||
}
|
||||
|
||||
/// Write the ALAN flag into misc block 1 (flag=alkane). `misc_dev` is the misc
|
||||
/// MTD device on the running OS (stock: /dev/mtd2; alkane: whatever /proc/mtd
|
||||
/// shows for "misc").
|
||||
fn set_flag_alkane(sh: &mut dyn Shell, misc_dev: &str) -> Result<(), StockError> {
|
||||
// one page: magic + 0xFF pad
|
||||
let mut page = FLAG_MAGIC.to_vec();
|
||||
page.resize(2048, 0xFF);
|
||||
sh.put(&page, "/tmp/.alkflag")?;
|
||||
let out = sh.exec(&format!(
|
||||
"flash_erase {misc_dev} 0x{FLAG_BLOCK_IN_MISC:x} 1 >/dev/null 2>&1; \
|
||||
nandwrite -s 0x{FLAG_BLOCK_IN_MISC:x} -p {misc_dev} /tmp/.alkflag >/dev/null 2>&1; sync; \
|
||||
echo RB=$(dd if={misc_dev} bs=2048 skip={blk} count=1 2>/dev/null | md5sum | cut -d' ' -f1); \
|
||||
rm -f /tmp/.alkflag",
|
||||
blk = FLAG_BLOCK_IN_MISC / 2048
|
||||
))?;
|
||||
let want = md5_hex(&page);
|
||||
let got = out
|
||||
.split("RB=")
|
||||
.nth(1)
|
||||
.map(|s| s.trim().to_owned())
|
||||
.unwrap_or_default();
|
||||
if got != want {
|
||||
return Err(StockError::Method("flag write read-back mismatch".into()));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Erase the flag block (flag=stock).
|
||||
fn clear_flag(sh: &mut dyn Shell, misc_dev: &str) -> Result<(), StockError> {
|
||||
sh.exec(&format!(
|
||||
"flash_erase {misc_dev} 0x{FLAG_BLOCK_IN_MISC:x} 1 >/dev/null 2>&1; sync; echo CLEARED"
|
||||
))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// The flag-based boot-chain env vars.
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// checkalk raw-reads the flag page and tests the four magic bytes with nested
|
||||
/// `itest.b` (this vendor U-Boot mis-compares `itest.l *<mem>`); only on a match
|
||||
/// does it run alkboot. No ubi/ubifs here - that keeps the stock path raw.
|
||||
fn checkalk_value() -> String {
|
||||
format!(
|
||||
"nand read 0x08000000 0x{FLAG_ABS_OFFSET:x} 0x800; \
|
||||
if itest.b *0x08000000 == 0x{a:02x}; then \
|
||||
if itest.b *0x08000001 == 0x{l:02x}; then \
|
||||
if itest.b *0x08000002 == 0x{a2:02x}; then \
|
||||
if itest.b *0x08000003 == 0x{n:02x}; then run alkboot; fi; fi; fi; fi",
|
||||
a = FLAG_MAGIC[0],
|
||||
l = FLAG_MAGIC[1],
|
||||
a2 = FLAG_MAGIC[2],
|
||||
n = FLAG_MAGIC[3],
|
||||
)
|
||||
}
|
||||
|
||||
/// alkboot mounts the nvdata UBIFS and boots alkane from `alkane/`.
|
||||
fn alkboot_value(volume: &str) -> String {
|
||||
format!(
|
||||
"setenv bootargs ${{alkbootargs}}; ubi part nvdata; ubifsmount ubi0:{volume}; \
|
||||
ubifsload ${{krnaddr}} {ALKANE_DIR}/vmlinux.bin; \
|
||||
ubifsload ${{fdtaddr}} {ALKANE_DIR}/devicetree.dtb; \
|
||||
ubifsload ${{rdaddr}} {ALKANE_DIR}/uramdisk.image.gz; \
|
||||
booti ${{krnaddr}} ${{rdaddr}} ${{fdtaddr}}"
|
||||
)
|
||||
}
|
||||
|
||||
/// Install the flag-based boot env (preserving all existing stock vars). Leaves
|
||||
/// bootcmd = "run checkalk; run storeboot".
|
||||
fn install_boot_env(sh: &mut dyn Shell, volume: &str) -> Result<(), StockError> {
|
||||
let blob = read_env(sh)?;
|
||||
let mut vars = parse_env(&blob);
|
||||
set_var(&mut vars, "krnaddr", KRNADDR);
|
||||
set_var(&mut vars, "fdtaddr", FDTADDR);
|
||||
set_var(&mut vars, "rdaddr", RDADDR);
|
||||
set_var(&mut vars, "alkbootargs", ALK_BOOTARGS);
|
||||
set_var(&mut vars, "alkboot", &alkboot_value(volume));
|
||||
set_var(&mut vars, "checkalk", &checkalk_value());
|
||||
set_var(&mut vars, "bootcmd", "run checkalk; run storeboot");
|
||||
let new_blob = build_env(&vars)?;
|
||||
write_env(sh, &new_blob)
|
||||
}
|
||||
|
||||
fn reboot_stock(sh: &mut dyn Shell) {
|
||||
let _ = sh.exec("sync; reboot");
|
||||
}
|
||||
|
||||
fn reboot_alkane(sh: &mut dyn Shell) {
|
||||
// plain `reboot` no-ops on the minimal init; `reboot -f` triggers PSCI reset.
|
||||
let _ = sh.exec("sync; reboot -f");
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Public API (dispatched from stock.rs for board == a113d).
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Install alkane onto an A113D running genuine stock, network-only, over the
|
||||
/// DSH root-on-stock primitive. Stages the OS files into the nvdata UBI volume,
|
||||
/// installs the flag-based boot env, and sets flag=alkane; the next boot runs
|
||||
/// alkane. Zero raw writes outside the flag block in `misc`.
|
||||
pub fn install_from_stock(
|
||||
host: &str,
|
||||
kernel_image: &[u8],
|
||||
dtb: &[u8],
|
||||
uramdisk: &[u8],
|
||||
password: Option<&str>,
|
||||
) -> Result<(), StockError> {
|
||||
let mut sh = StockShell {
|
||||
host: host.to_owned(),
|
||||
password: password.map(|s| s.to_owned()),
|
||||
};
|
||||
|
||||
// Guard: this board must be A113D stock (has a 'misc' MTD and a mounted
|
||||
// nvdata UBI). If not, defer to the compiled-in method.
|
||||
let proc_mtd = sh.exec("cat /proc/mtd 2>/dev/null").unwrap_or_default();
|
||||
if !proc_mtd.contains("\"nvdata\"") || !proc_mtd.contains("\"misc\"") {
|
||||
return Err(StockError::NotApplicable);
|
||||
}
|
||||
|
||||
let misc = find_mtd(&mut sh, "misc")?;
|
||||
let (mount, volume) = discover_nvdata_volume(&mut sh)?;
|
||||
|
||||
// Stage the three files into <mount>/alkane/ and read-back verify.
|
||||
let dir = format!("{mount}/{ALKANE_DIR}");
|
||||
sh.exec(&format!("mkdir -p {dir}"))?;
|
||||
// rootfs -> dtb -> kernel (kernel lands last).
|
||||
stage_file(&mut sh, uramdisk, &format!("{dir}/uramdisk.image.gz"))?;
|
||||
stage_file(&mut sh, dtb, &format!("{dir}/devicetree.dtb"))?;
|
||||
stage_file(&mut sh, kernel_image, &format!("{dir}/vmlinux.bin"))?;
|
||||
sh.exec("sync")?;
|
||||
|
||||
// Install the flag-based boot env (read-back verified before reboot).
|
||||
install_boot_env(&mut sh, &volume)?;
|
||||
|
||||
// Set flag=alkane, then reboot into alkane.
|
||||
set_flag_alkane(&mut sh, &misc)?;
|
||||
reboot_stock(&mut sh);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Stage one file to a UBIFS path and prove its read-back md5 before continuing.
|
||||
fn stage_file(sh: &mut dyn Shell, data: &[u8], dest: &str) -> Result<(), StockError> {
|
||||
let tmp = "/tmp/.alkstage";
|
||||
sh.put(data, tmp)?;
|
||||
let out = sh.exec_long(&format!(
|
||||
"cp -f {tmp} {dest} && sync; echo RB=$(md5sum {dest} | cut -d' ' -f1); rm -f {tmp}"
|
||||
))?;
|
||||
let want = md5_hex(data);
|
||||
let got = out
|
||||
.split("RB=")
|
||||
.nth(1)
|
||||
.map(|s| s.trim().to_owned())
|
||||
.unwrap_or_default();
|
||||
if got != want {
|
||||
return Err(StockError::Method(format!(
|
||||
"staged {dest} md5 mismatch: want {want}, got {got}"
|
||||
)));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Restore an A113D running alkane back to genuine stock, network-only, in-band
|
||||
/// from the running alkane OS: erase the flag block (flag=stock) and reboot.
|
||||
/// Stock boots via `storeboot` from the untouched `boot` MTD; the alkane payload
|
||||
/// and env are left in place, so a re-install is just re-writing the flag.
|
||||
pub fn restore_to_stock(host: &str, password: Option<&str>) -> Result<(), StockError> {
|
||||
let mut sh = AlkaneShell::connect(host, password)?;
|
||||
|
||||
// Guard: must be the alkane a113d image (exposes 'misc' and 'nvdata' MTDs,
|
||||
// mainline 6.18.48). If 'misc' is absent this is not applicable.
|
||||
let proc_mtd = sh.exec("cat /proc/mtd 2>/dev/null").unwrap_or_default();
|
||||
if !proc_mtd.contains("\"misc\"") {
|
||||
return Err(StockError::NotApplicable);
|
||||
}
|
||||
let misc = find_mtd(&mut sh, "misc")?;
|
||||
clear_flag(&mut sh, &misc)?;
|
||||
reboot_alkane(&mut sh);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The on-board stock backup is structural on this board: `storeboot` always
|
||||
/// boots genuine stock from the `boot` MTD (mtd4), which this install never
|
||||
/// writes. So a complete backup is present whenever the board is an A113D.
|
||||
pub fn onboard_backup_present(host: &str, password: Option<&str>) -> Result<bool, StockError> {
|
||||
// Best-effort confirm over alkane that the flag chain is in place; if we
|
||||
// cannot reach alkane, report not-applicable so the caller falls through.
|
||||
let mut sh = AlkaneShell::connect(host, password)?;
|
||||
let proc_mtd = sh.exec("cat /proc/mtd 2>/dev/null").unwrap_or_default();
|
||||
if proc_mtd.contains("\"misc\"") {
|
||||
Ok(true)
|
||||
} else {
|
||||
Err(StockError::NotApplicable)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn env_roundtrips_with_crc() {
|
||||
let vars = vec![
|
||||
(
|
||||
"bootcmd".to_owned(),
|
||||
"run checkalk; run storeboot".to_owned(),
|
||||
),
|
||||
("bootdelay".to_owned(), "1".to_owned()),
|
||||
("checkalk".to_owned(), checkalk_value()),
|
||||
];
|
||||
let blob = build_env(&vars).unwrap();
|
||||
assert_eq!(blob.len(), ENV_SIZE);
|
||||
let stored = u32::from_le_bytes([blob[0], blob[1], blob[2], blob[3]]);
|
||||
assert_eq!(crc32(&blob[4..]), stored);
|
||||
let parsed = parse_env(&blob);
|
||||
assert_eq!(
|
||||
parsed.iter().find(|(k, _)| k == "bootcmd").unwrap().1,
|
||||
"run checkalk; run storeboot"
|
||||
);
|
||||
assert!(parsed.iter().any(|(k, _)| k == "checkalk"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn b64_roundtrip() {
|
||||
for n in [0usize, 1, 2, 3, 64, 2048, 65536] {
|
||||
let data: Vec<u8> = (0..n).map(|i| (i * 7 + 3) as u8).collect();
|
||||
let enc = b64_encode(&data);
|
||||
let dec = b64_decode(&enc).unwrap();
|
||||
assert_eq!(dec, data, "n={n}");
|
||||
}
|
||||
// wrapped base64 decodes the same
|
||||
let data: Vec<u8> = (0..100).map(|i| i as u8).collect();
|
||||
let mut wrapped = b64_encode(&data);
|
||||
wrapped.insert(20, '\n');
|
||||
wrapped.insert(50, '\n');
|
||||
assert_eq!(b64_decode(&wrapped).unwrap(), data);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn checkalk_is_raw_and_byte_tested() {
|
||||
let c = checkalk_value();
|
||||
assert!(c.starts_with("nand read 0x08000000"));
|
||||
assert!(c.contains("itest.b *0x08000000 == 0x41"));
|
||||
assert!(!c.contains("ubi")); // the stock path must never touch UBI
|
||||
assert!(c.contains("run alkboot"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn alkboot_loads_from_alkane_dir() {
|
||||
let a = alkboot_value("nvdata_log");
|
||||
assert!(a.contains("ubifsmount ubi0:nvdata_log"));
|
||||
assert!(a.contains("alkane/vmlinux.bin"));
|
||||
assert!(a.contains("booti ${krnaddr} ${rdaddr} ${fdtaddr}"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,880 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Amlogic A113D / AXG (Antminer S21 Pro-class) board module: tier-2 network
|
||||
//! UPDATE of a board already running alkane. Our OS is staged as FILES in the
|
||||
//! nvdata UBI volume: alkane/{vmlinux.bin, devicetree.dtb, uramdisk.image.gz}.
|
||||
//! (The legacy vendor path name "anthillos" from AnthillOS is no longer used;
|
||||
//! our own bootcmd loads from alkane/.)
|
||||
//!
|
||||
//! The running alkane image exposes ONLY the nvdata region as an MTD (the board
|
||||
//! DT declares a single `nvdata` fixed-partition; the FIP bootloader and the
|
||||
//! stock boot/recovery/misc/config regions are deliberately undeclared, so they
|
||||
//! are never registered as MTD devices and cannot be written from Linux). This
|
||||
//! module attaches UBI to that one nvdata MTD, mounts the UBIFS volume, and
|
||||
//! overwrites the three files under alkane/. It performs no raw mtd0-5 write and
|
||||
//! never changes the bootloader: the brick-sensitive regions are physically
|
||||
//! unreachable.
|
||||
//!
|
||||
//! The first from-stock install (past the signed bootloader) is handled
|
||||
//! elsewhere and is NOT this module. This is the repeatable alkane-to-alkane
|
||||
//! update.
|
||||
|
||||
use crate::md5::md5_hex;
|
||||
use crate::preflight::{classify, parse_digest};
|
||||
use crate::transport::{Remote, RemoteError};
|
||||
use alkane_artifacts::afw::{AfwImage, BootloaderPolicy, VerifiedAfw};
|
||||
use std::fs;
|
||||
use std::io::Write;
|
||||
use std::path::PathBuf;
|
||||
use std::time::{Duration, SystemTime, UNIX_EPOCH};
|
||||
use thiserror::Error;
|
||||
|
||||
pub const BOARD: &str = "a113d";
|
||||
pub const ARCH: &str = "arm64";
|
||||
/// The UBI volume subdirectory our boot chain reads our OS files from. This is
|
||||
/// alkane's own name; the board's `ourbootcmd` loads from here.
|
||||
pub const ALKANE_DIR: &str = "alkane";
|
||||
/// nvdata UBI usable size; the three files together must fit (0xB900000).
|
||||
pub const NVDATA_USABLE: u64 = 0xB900000;
|
||||
/// The only MTD partition our DT exposes. mtd0-5 (FIP + stock boot) are not
|
||||
/// declared in the DT at all, so they are not MTD devices on a running image.
|
||||
pub const NVDATA_LABEL: &str = "nvdata";
|
||||
|
||||
/// Authoritative file targets: (image, on-board basename, ceiling, format).
|
||||
/// Written rootfs -> dtb -> kernel so a mid-write interruption never leaves a
|
||||
/// new rootfs beside an old kernel (the kernel file lands last).
|
||||
const TARGETS: [(&str, &str, u64, &str); 3] = [
|
||||
("rootfs", "uramdisk.image.gz", 0x6000000, "uimage"),
|
||||
("dtb", "devicetree.dtb", 0x100000, "fdt"),
|
||||
("kernel", "vmlinux.bin", 0x4000000, "arm64-image"),
|
||||
];
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum A113dPlanError {
|
||||
#[error("bundle is for {0}, not a113d")]
|
||||
WrongBoard(String),
|
||||
#[error("bundle arch is {0}, a113d needs arm64")]
|
||||
WrongArch(String),
|
||||
#[error("a113d requires bootloader_policy preserve (the FIP is never written)")]
|
||||
BootloaderPolicy,
|
||||
#[error("a113d bundle carries a bootloader/spl/fip/tpl member: {0}")]
|
||||
BootloaderMember(String),
|
||||
#[error("manifest is not an OS payload")]
|
||||
PayloadType,
|
||||
#[error("manifest marker is empty")]
|
||||
Marker,
|
||||
#[error("a113d must install exactly kernel, dtb and rootfs")]
|
||||
InstallCount,
|
||||
#[error("a113d is missing the {0} image")]
|
||||
MissingImage(String),
|
||||
#[error("a113d {image} format is {actual}, expected {expected}")]
|
||||
ImageFormat {
|
||||
image: String,
|
||||
actual: String,
|
||||
expected: &'static str,
|
||||
},
|
||||
#[error("a113d {image} is {size} bytes, over the 0x{ceiling:x}-byte ceiling")]
|
||||
ImageTooLarge {
|
||||
image: String,
|
||||
size: u64,
|
||||
ceiling: u64,
|
||||
},
|
||||
#[error("a113d images total {total} bytes, over the nvdata UBI (0x{usable:x})")]
|
||||
OverNvdata { total: u64, usable: u64 },
|
||||
#[error("a113d {image} is not an arm64 Image")]
|
||||
NotArm64 { image: String },
|
||||
#[error("a113d {image} is not an FDT")]
|
||||
NotFdt { image: String },
|
||||
#[error("a113d {image} is not a legacy uImage")]
|
||||
NotUimage { image: String },
|
||||
#[error("a113d refuses: preserved partition {0} (mtd0-5) carries an image")]
|
||||
PreservedCarriesImage(String),
|
||||
#[error("a113d refuses an unsafe destination for {image}: {dest}")]
|
||||
UnsafeDest { image: String, dest: String },
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct A113dTarget {
|
||||
pub image_name: String,
|
||||
/// On-board basename inside the alkane directory (never a device path).
|
||||
pub dest: String,
|
||||
pub size: u64,
|
||||
pub data: Vec<u8>,
|
||||
pub expected_md5: String,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct A113dPlan {
|
||||
pub targets: Vec<A113dTarget>,
|
||||
pub marker: String,
|
||||
pub kernel_version: String,
|
||||
pub sdk_revision: String,
|
||||
pub os_revision: String,
|
||||
pub afw_sha256: String,
|
||||
pub min_free_bytes: u64,
|
||||
}
|
||||
|
||||
fn is_bootloaderish(image: &AfwImage) -> bool {
|
||||
let lowered = format!("{} {} {}", image.name, image.file, image.role).to_lowercase();
|
||||
image.role == "bootloader"
|
||||
|| lowered.contains("spl")
|
||||
|| lowered.contains("u-boot")
|
||||
|| lowered.contains("uboot")
|
||||
|| lowered.contains("fip")
|
||||
|| lowered.contains("tpl")
|
||||
}
|
||||
|
||||
/// A destination is safe only as a bare basename (no separators, no traversal,
|
||||
/// not a device path). This keeps every write inside the alkane/ directory.
|
||||
fn is_safe_dest(dest: &str) -> bool {
|
||||
!dest.is_empty()
|
||||
&& !dest.contains('/')
|
||||
&& !dest.contains("..")
|
||||
&& !dest.starts_with("/dev/")
|
||||
&& dest == dest.trim()
|
||||
}
|
||||
|
||||
impl A113dPlan {
|
||||
pub fn from_afw(afw: &VerifiedAfw) -> Result<Self, A113dPlanError> {
|
||||
let manifest = &afw.manifest;
|
||||
if manifest.board != BOARD {
|
||||
return Err(A113dPlanError::WrongBoard(manifest.board.clone()));
|
||||
}
|
||||
if manifest.arch != ARCH {
|
||||
return Err(A113dPlanError::WrongArch(manifest.arch.clone()));
|
||||
}
|
||||
if manifest.payload_type != "os" {
|
||||
return Err(A113dPlanError::PayloadType);
|
||||
}
|
||||
if manifest.bootloader_policy != BootloaderPolicy::Preserve {
|
||||
return Err(A113dPlanError::BootloaderPolicy);
|
||||
}
|
||||
if manifest.marker.is_empty() {
|
||||
return Err(A113dPlanError::Marker);
|
||||
}
|
||||
// FIP / bootloader members are never allowed - we reuse the board's.
|
||||
for image in &manifest.images {
|
||||
if is_bootloaderish(image) {
|
||||
return Err(A113dPlanError::BootloaderMember(image.file.clone()));
|
||||
}
|
||||
}
|
||||
// Defense in depth: only nvdata (mtd6) may carry an image; mtd0-5 preserved.
|
||||
for partition in &manifest.partitions {
|
||||
if partition.name != "nvdata" && partition.image.is_some() {
|
||||
return Err(A113dPlanError::PreservedCarriesImage(
|
||||
partition.name.clone(),
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
let installs: Vec<&AfwImage> = manifest.images.iter().filter(|i| i.install).collect();
|
||||
if installs.len() != TARGETS.len() {
|
||||
return Err(A113dPlanError::InstallCount);
|
||||
}
|
||||
|
||||
let mut targets = Vec::with_capacity(TARGETS.len());
|
||||
let mut total = 0u64;
|
||||
for (image_name, dest, ceiling, expected_format) in TARGETS {
|
||||
let image = manifest
|
||||
.images
|
||||
.iter()
|
||||
.find(|i| i.name == image_name && i.install)
|
||||
.ok_or_else(|| A113dPlanError::MissingImage(image_name.to_owned()))?;
|
||||
if image.format != expected_format {
|
||||
return Err(A113dPlanError::ImageFormat {
|
||||
image: image_name.to_owned(),
|
||||
actual: image.format.clone(),
|
||||
expected: expected_format,
|
||||
});
|
||||
}
|
||||
if image.size > ceiling {
|
||||
return Err(A113dPlanError::ImageTooLarge {
|
||||
image: image_name.to_owned(),
|
||||
size: image.size,
|
||||
ceiling,
|
||||
});
|
||||
}
|
||||
if !is_safe_dest(dest) {
|
||||
return Err(A113dPlanError::UnsafeDest {
|
||||
image: image_name.to_owned(),
|
||||
dest: dest.to_owned(),
|
||||
});
|
||||
}
|
||||
let data = afw
|
||||
.image(image_name)
|
||||
.map(|(_, data)| data)
|
||||
.ok_or_else(|| A113dPlanError::MissingImage(image_name.to_owned()))?;
|
||||
// Each arm validates a different magic; keeping them as explicit
|
||||
// arms (not match guards) reads more clearly than collapsing.
|
||||
#[allow(clippy::collapsible_match)]
|
||||
match expected_format {
|
||||
"arm64-image" => {
|
||||
if !(data.len() >= 0x3C && data[0x38..0x3C] == *b"ARMd") {
|
||||
return Err(A113dPlanError::NotArm64 {
|
||||
image: image_name.to_owned(),
|
||||
});
|
||||
}
|
||||
}
|
||||
"fdt" => {
|
||||
if !(data.len() >= 4 && data[0..4] == [0xd0, 0x0d, 0xfe, 0xed]) {
|
||||
return Err(A113dPlanError::NotFdt {
|
||||
image: image_name.to_owned(),
|
||||
});
|
||||
}
|
||||
}
|
||||
"uimage" => {
|
||||
if !(data.len() >= 4 && data[0..4] == [0x27, 0x05, 0x19, 0x56]) {
|
||||
return Err(A113dPlanError::NotUimage {
|
||||
image: image_name.to_owned(),
|
||||
});
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
total += image.size;
|
||||
targets.push(A113dTarget {
|
||||
image_name: image_name.to_owned(),
|
||||
dest: dest.to_owned(),
|
||||
size: image.size,
|
||||
expected_md5: md5_hex(data),
|
||||
data: data.to_vec(),
|
||||
});
|
||||
}
|
||||
if total > NVDATA_USABLE {
|
||||
return Err(A113dPlanError::OverNvdata {
|
||||
total,
|
||||
usable: NVDATA_USABLE,
|
||||
});
|
||||
}
|
||||
|
||||
Ok(Self {
|
||||
targets,
|
||||
marker: manifest.marker.clone(),
|
||||
kernel_version: manifest.kernel_version.clone(),
|
||||
sdk_revision: manifest.sdk_revision.clone(),
|
||||
os_revision: manifest.os_revision.clone(),
|
||||
afw_sha256: afw.archive_sha256.clone(),
|
||||
min_free_bytes: manifest
|
||||
.preflight
|
||||
.get("min_free_bytes")
|
||||
.and_then(|v| v.as_u64())
|
||||
.unwrap_or(16 * 1024 * 1024),
|
||||
})
|
||||
}
|
||||
|
||||
pub fn render(&self) -> String {
|
||||
let mut out = format!("board {BOARD} arch {ARCH}\n");
|
||||
out.push_str(
|
||||
"tier 2 update: attach UBI to the nvdata MTD, mount it, and overwrite the OS files \
|
||||
under alkane/; the FIP + stock boot/recovery/misc/config are not MTD devices at all, \
|
||||
so no raw NAND write is possible\n",
|
||||
);
|
||||
out.push_str("image format kernel=arm64-image, dtb=fdt, rootfs=uimage\n");
|
||||
for target in &self.targets {
|
||||
out.push_str(&format!(
|
||||
"write {} -> {ALKANE_DIR}/{} size {} B md5 {}\n",
|
||||
target.image_name, target.dest, target.size, target.expected_md5
|
||||
));
|
||||
}
|
||||
out.push_str(&format!(
|
||||
"marker {} kernel {} sdk {} os {}",
|
||||
self.marker,
|
||||
self.kernel_version,
|
||||
short(&self.sdk_revision),
|
||||
short(&self.os_revision),
|
||||
));
|
||||
out
|
||||
}
|
||||
}
|
||||
|
||||
fn short(rev: &str) -> &str {
|
||||
rev.get(..12).unwrap_or(rev)
|
||||
}
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum A113dError {
|
||||
#[error("preflight failed:\n{0}")]
|
||||
Preflight(String),
|
||||
#[error("--confirm FLASH is required to write")]
|
||||
Confirm,
|
||||
#[error("the running image exposes no '{0}' MTD; it needs a NAND-enabled a113d kernel")]
|
||||
NoNvdataMtd(String),
|
||||
#[error("could not attach UBI to the nvdata MTD / find its volume")]
|
||||
UbiAttach,
|
||||
#[error("could not mount the nvdata UBIFS volume")]
|
||||
Mount,
|
||||
#[error("refusing an unsafe destination: {0}")]
|
||||
UnsafeDest(String),
|
||||
#[error("{0} staged md5 differs from the verified bundle")]
|
||||
StageMismatch(String),
|
||||
#[error("{0} read-back md5 mismatch; do not reboot")]
|
||||
Readback(String),
|
||||
#[error(transparent)]
|
||||
Remote(#[from] RemoteError),
|
||||
#[error(transparent)]
|
||||
Io(#[from] std::io::Error),
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct A113dCheck {
|
||||
pub name: String,
|
||||
pub ok: bool,
|
||||
pub detail: String,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct A113dPreflight {
|
||||
pub host: String,
|
||||
pub checks: Vec<A113dCheck>,
|
||||
/// The nvdata MTD index (e.g. 0 for /dev/mtd0), when the running image
|
||||
/// exposes it. Used for `ubiattach -m <index>`.
|
||||
pub nvdata_mtd: Option<u32>,
|
||||
}
|
||||
|
||||
impl A113dPreflight {
|
||||
pub fn ok(&self) -> bool {
|
||||
self.checks.iter().all(|c| c.ok)
|
||||
}
|
||||
pub fn render(&self) -> String {
|
||||
let mut out = format!("preflight {}\n", self.host);
|
||||
for c in &self.checks {
|
||||
out.push_str(&format!(
|
||||
"check {} {}: {}\n",
|
||||
c.name,
|
||||
if c.ok { "ok" } else { "FAIL" },
|
||||
c.detail
|
||||
));
|
||||
}
|
||||
out.push_str(&format!(
|
||||
"result {}",
|
||||
if self.ok() {
|
||||
"PASS"
|
||||
} else {
|
||||
"FAIL (do not write)"
|
||||
}
|
||||
));
|
||||
out
|
||||
}
|
||||
}
|
||||
|
||||
/// Parse /proc/mtd for a partition labelled "nvdata" and return its mtd index.
|
||||
/// e.g. `mtd0: 0b900000 00020000 "nvdata"` -> Some(0).
|
||||
fn parse_nvdata_mtd(proc_mtd: &str) -> Option<u32> {
|
||||
for line in proc_mtd.lines() {
|
||||
let line = line.trim();
|
||||
if !line.starts_with("mtd") {
|
||||
continue;
|
||||
}
|
||||
let (dev, rest) = line.split_once(':')?;
|
||||
if rest.contains(&format!("\"{NVDATA_LABEL}\"")) {
|
||||
return dev.trim_start_matches("mtd").parse::<u32>().ok();
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
pub fn preflight(
|
||||
plan: &A113dPlan,
|
||||
remote: &mut dyn Remote,
|
||||
host: &str,
|
||||
) -> Result<A113dPreflight, A113dError> {
|
||||
let mut checks = Vec::new();
|
||||
|
||||
let fingerprint = remote.user_command(
|
||||
"uname -r; echo __MODEL__; cat /proc/device-tree/model 2>/dev/null; echo; \
|
||||
echo __RELEASE__; cat /etc/os-release 2>/dev/null; cat /etc/alkane-release 2>/dev/null \
|
||||
|| true",
|
||||
Duration::from_secs(20),
|
||||
)?;
|
||||
let text = String::from_utf8_lossy(&fingerprint).into_owned();
|
||||
let mut it = text.split("__MODEL__");
|
||||
let kernel = it.next().unwrap_or("").trim().to_owned();
|
||||
let rest = it.next().unwrap_or("");
|
||||
let mut it2 = rest.split("__RELEASE__");
|
||||
let _model = it2.next().unwrap_or("");
|
||||
let release = it2.next().unwrap_or("");
|
||||
let source = classify(&kernel, release, &text);
|
||||
checks.push(A113dCheck {
|
||||
name: "source-os".to_owned(),
|
||||
ok: source == "alkane",
|
||||
detail: format!("{source} (update path requires alkane)"),
|
||||
});
|
||||
|
||||
let uid = String::from_utf8_lossy(&remote.root_command("id -u", Duration::from_secs(20))?)
|
||||
.trim()
|
||||
.to_owned();
|
||||
checks.push(A113dCheck {
|
||||
name: "root".to_owned(),
|
||||
ok: uid == "0",
|
||||
detail: format!("uid {uid}"),
|
||||
});
|
||||
|
||||
let tools = remote.user_command(
|
||||
"for c in ubiattach ubidetach mount umount cp md5sum sync; do \
|
||||
command -v $c >/dev/null 2>&1 && echo $c || echo missing:$c; done",
|
||||
Duration::from_secs(15),
|
||||
)?;
|
||||
let missing: Vec<String> = String::from_utf8_lossy(&tools)
|
||||
.lines()
|
||||
.filter_map(|l| l.strip_prefix("missing:").map(str::to_owned))
|
||||
.collect();
|
||||
checks.push(A113dCheck {
|
||||
name: "commands".to_owned(),
|
||||
ok: missing.is_empty(),
|
||||
detail: if missing.is_empty() {
|
||||
"ubi/file tools present".to_owned()
|
||||
} else {
|
||||
format!("missing {}", missing.join(", "))
|
||||
},
|
||||
});
|
||||
|
||||
// The nvdata MTD must be exposed (NAND-enabled a113d kernel). If absent, the
|
||||
// running image cannot self-update - it needs the DT with the nvdata
|
||||
// fixed-partition. mtd0-5 are intentionally never exposed, so nvdata is the
|
||||
// ONLY mtd this board should ever present.
|
||||
let proc_mtd = String::from_utf8_lossy(
|
||||
&remote.user_command("cat /proc/mtd 2>/dev/null", Duration::from_secs(20))?,
|
||||
)
|
||||
.into_owned();
|
||||
let nvdata_mtd = parse_nvdata_mtd(&proc_mtd);
|
||||
checks.push(A113dCheck {
|
||||
name: "nvdata-mtd".to_owned(),
|
||||
ok: nvdata_mtd.is_some(),
|
||||
detail: match nvdata_mtd {
|
||||
Some(n) => format!("nvdata is /dev/mtd{n} (the only exposed MTD)"),
|
||||
None => format!("no 'nvdata' MTD exposed: {}", proc_mtd.replace('\n', " ")),
|
||||
},
|
||||
});
|
||||
|
||||
// Every destination is a bare basename - the structural brick guard.
|
||||
let dests_safe = plan.targets.iter().all(|t| is_safe_dest(&t.dest));
|
||||
checks.push(A113dCheck {
|
||||
name: "file-only".to_owned(),
|
||||
ok: dests_safe,
|
||||
detail: format!("all writes are files under {ALKANE_DIR}/ on the nvdata UBI"),
|
||||
});
|
||||
|
||||
Ok(A113dPreflight {
|
||||
host: host.to_owned(),
|
||||
checks,
|
||||
nvdata_mtd,
|
||||
})
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct A113dInstallOptions {
|
||||
pub dry_run: bool,
|
||||
pub confirm: Option<String>,
|
||||
pub no_reboot: bool,
|
||||
pub backup_dir: PathBuf,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct A113dBackup {
|
||||
pub image_name: String,
|
||||
pub dest: String,
|
||||
pub path: Option<PathBuf>,
|
||||
pub md5: Option<String>,
|
||||
pub size: u64,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct A113dReceipt {
|
||||
pub volume: String,
|
||||
pub backups: Vec<A113dBackup>,
|
||||
pub rebooted: bool,
|
||||
}
|
||||
|
||||
pub enum A113dOutcome {
|
||||
DryRun(Box<A113dPreflight>),
|
||||
Installed(A113dReceipt),
|
||||
}
|
||||
|
||||
const MNT: &str = "/tmp/.alkane-nvdata";
|
||||
|
||||
/// Attach UBI to the nvdata MTD and mount its single user volume read-write.
|
||||
/// Returns (ubi device number, volume name). The volume name is DISCOVERED, never
|
||||
/// assumed (vendor histories leave different names: umc_os_rootfs, nvdada_log,
|
||||
/// overlay, ...).
|
||||
fn attach_and_mount(remote: &mut dyn Remote, nvdata_mtd: u32) -> Result<String, A113dError> {
|
||||
// Attach (idempotent: if ubi0 already exists, reuse it).
|
||||
let _ = remote.root_command(
|
||||
&format!(
|
||||
"if [ ! -d /sys/class/ubi/ubi0 ]; then ubiattach -m {nvdata_mtd} -d 0 >/dev/null 2>&1; fi"
|
||||
),
|
||||
Duration::from_secs(60),
|
||||
)?;
|
||||
// Discover the first user volume name under ubi0.
|
||||
let name = String::from_utf8_lossy(&remote.root_command(
|
||||
"for n in /sys/class/ubi/ubi0_*/name; do [ -f \"$n\" ] && cat \"$n\" && break; done",
|
||||
Duration::from_secs(20),
|
||||
)?)
|
||||
.trim()
|
||||
.to_owned();
|
||||
if name.is_empty() {
|
||||
return Err(A113dError::UbiAttach);
|
||||
}
|
||||
// Mount it read-write.
|
||||
remote.root_command(
|
||||
&format!("mkdir -p {MNT} && mount -t ubifs ubi0:{name} {MNT}"),
|
||||
Duration::from_secs(60),
|
||||
)?;
|
||||
// Confirm the mount actually took.
|
||||
let mounted = remote.user_command(
|
||||
&format!("mount | grep -c ' {MNT} '"),
|
||||
Duration::from_secs(20),
|
||||
)?;
|
||||
if String::from_utf8_lossy(&mounted).trim() == "0" {
|
||||
return Err(A113dError::Mount);
|
||||
}
|
||||
Ok(name)
|
||||
}
|
||||
|
||||
fn unmount(remote: &mut dyn Remote) {
|
||||
let _ = remote.root_command(
|
||||
&format!(
|
||||
"sync; umount {MNT} 2>/dev/null; ubidetach -d 0 2>/dev/null; rmdir {MNT} 2>/dev/null"
|
||||
),
|
||||
Duration::from_secs(60),
|
||||
);
|
||||
}
|
||||
|
||||
pub fn install(
|
||||
plan: &A113dPlan,
|
||||
remote: &mut dyn Remote,
|
||||
options: &A113dInstallOptions,
|
||||
host: &str,
|
||||
) -> Result<A113dOutcome, A113dError> {
|
||||
let report = preflight(plan, remote, host)?;
|
||||
if !report.ok() {
|
||||
return Err(A113dError::Preflight(report.render()));
|
||||
}
|
||||
if options.dry_run {
|
||||
return Ok(A113dOutcome::DryRun(Box::new(report)));
|
||||
}
|
||||
if options.confirm.as_deref() != Some("FLASH") {
|
||||
return Err(A113dError::Confirm);
|
||||
}
|
||||
let nvdata_mtd = report
|
||||
.nvdata_mtd
|
||||
.ok_or_else(|| A113dError::NoNvdataMtd(NVDATA_LABEL.to_owned()))?;
|
||||
|
||||
fs::create_dir_all(&options.backup_dir)?;
|
||||
let epoch = SystemTime::now()
|
||||
.duration_since(UNIX_EPOCH)
|
||||
.unwrap_or_default()
|
||||
.as_secs();
|
||||
|
||||
let volume = attach_and_mount(remote, nvdata_mtd)?;
|
||||
let alkane_dir = format!("{MNT}/{ALKANE_DIR}");
|
||||
let _ = remote.root_command(&format!("mkdir -p {alkane_dir}"), Duration::from_secs(20))?;
|
||||
|
||||
let mut backups = Vec::new();
|
||||
let result = (|| -> Result<(), A113dError> {
|
||||
for target in &plan.targets {
|
||||
// Structural guard at the point of writing: a bare basename only.
|
||||
if !is_safe_dest(&target.dest) {
|
||||
return Err(A113dError::UnsafeDest(target.dest.clone()));
|
||||
}
|
||||
let name = &target.image_name;
|
||||
let dest_path = format!("{alkane_dir}/{}", target.dest);
|
||||
|
||||
// Back up the existing file, if present.
|
||||
let have = remote.user_command(
|
||||
&format!("test -f {dest_path} && echo __YES__"),
|
||||
Duration::from_secs(15),
|
||||
)?;
|
||||
if String::from_utf8_lossy(&have).contains("__YES__") {
|
||||
let local = options
|
||||
.backup_dir
|
||||
.join(format!("{}-{epoch}.bak", target.dest));
|
||||
remote.pull(&dest_path, &local, Duration::from_secs(300))?;
|
||||
let data = fs::read(&local)?;
|
||||
backups.push(A113dBackup {
|
||||
image_name: name.clone(),
|
||||
dest: target.dest.clone(),
|
||||
md5: Some(md5_hex(&data)),
|
||||
size: data.len() as u64,
|
||||
path: Some(local),
|
||||
});
|
||||
} else {
|
||||
backups.push(A113dBackup {
|
||||
image_name: name.clone(),
|
||||
dest: target.dest.clone(),
|
||||
md5: None,
|
||||
size: 0,
|
||||
path: None,
|
||||
});
|
||||
}
|
||||
|
||||
// Stage the verified payload and prove its remote md5 before copying.
|
||||
let mut staged = tempfile::NamedTempFile::new()?;
|
||||
staged.write_all(&target.data)?;
|
||||
staged.flush()?;
|
||||
let remote_stage = format!("/tmp/.alkane-a113d-{name}.img");
|
||||
remote.push(staged.path(), &remote_stage, Duration::from_secs(300))?;
|
||||
let staged_md5 = parse_digest(
|
||||
&remote.root_command(&format!("md5sum {remote_stage}"), Duration::from_secs(60))?,
|
||||
32,
|
||||
)
|
||||
.unwrap_or_default();
|
||||
if staged_md5 != target.expected_md5 {
|
||||
let _ =
|
||||
remote.root_command(&format!("rm -f {remote_stage}"), Duration::from_secs(15));
|
||||
return Err(A113dError::StageMismatch(name.clone()));
|
||||
}
|
||||
|
||||
// Copy into the UBIFS volume (file write only), then sync.
|
||||
remote.root_command(
|
||||
&format!("cp -f {remote_stage} {dest_path} && sync"),
|
||||
Duration::from_secs(300),
|
||||
)?;
|
||||
|
||||
// Read back the copied file and compare md5.
|
||||
let readback = parse_digest(
|
||||
&remote.root_command(&format!("md5sum {dest_path}"), Duration::from_secs(60))?,
|
||||
32,
|
||||
)
|
||||
.unwrap_or_default();
|
||||
let _ = remote.root_command(&format!("rm -f {remote_stage}"), Duration::from_secs(15));
|
||||
if readback != target.expected_md5 {
|
||||
return Err(A113dError::Readback(name.clone()));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
})();
|
||||
|
||||
// Always unmount/detach, success or failure, before returning or rebooting.
|
||||
unmount(remote);
|
||||
result?;
|
||||
|
||||
let rebooted = if options.no_reboot {
|
||||
false
|
||||
} else {
|
||||
remote.reboot()?;
|
||||
true
|
||||
};
|
||||
Ok(A113dOutcome::Installed(A113dReceipt {
|
||||
volume,
|
||||
backups,
|
||||
rebooted,
|
||||
}))
|
||||
}
|
||||
|
||||
pub fn owns_board(board: &str) -> bool {
|
||||
board == BOARD
|
||||
}
|
||||
|
||||
/// True when no plan target would ever name a preserved raw partition. Used by
|
||||
/// tests to assert the structural guard holds for the fixed TARGETS table.
|
||||
pub fn no_raw_device_targets(plan: &A113dPlan) -> bool {
|
||||
plan.targets.iter().all(|t| is_safe_dest(&t.dest))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use alkane_artifacts::afw::{AfwManifest, AfwMember};
|
||||
use serde_json::json;
|
||||
use sha2::{Digest, Sha256};
|
||||
|
||||
const REV: &str = "0123456789abcdef0123456789abcdef01234567";
|
||||
|
||||
fn arm64_image(payload: &[u8]) -> Vec<u8> {
|
||||
let mut b = vec![0u8; 64];
|
||||
b[0x38..0x3C].copy_from_slice(b"ARMd");
|
||||
b.extend_from_slice(payload);
|
||||
b
|
||||
}
|
||||
|
||||
fn dtb() -> Vec<u8> {
|
||||
let mut b = vec![0u8; 2048];
|
||||
b[0..4].copy_from_slice(&[0xd0, 0x0d, 0xfe, 0xed]);
|
||||
b
|
||||
}
|
||||
|
||||
fn uramdisk() -> Vec<u8> {
|
||||
let mut b = vec![0u8; 64];
|
||||
b[0..4].copy_from_slice(&[0x27, 0x05, 0x19, 0x56]);
|
||||
b
|
||||
}
|
||||
|
||||
fn afw_with(
|
||||
kernel: Vec<u8>,
|
||||
dtb: Vec<u8>,
|
||||
rootfs: Vec<u8>,
|
||||
partitions: serde_json::Value,
|
||||
) -> VerifiedAfw {
|
||||
let image = |name: &str, file: &str, role: &str, fmt: &str, data: &[u8]| {
|
||||
let sha: String = Sha256::digest(data)
|
||||
.iter()
|
||||
.map(|b| format!("{b:02x}"))
|
||||
.collect();
|
||||
json!({"name": name, "file": file, "role": role, "format": fmt,
|
||||
"size": data.len(), "sha256": sha, "partition": "nvdata", "install": true})
|
||||
};
|
||||
let value = json!({
|
||||
"schema": 2, "format": "afw", "board": "a113d", "arch": "arm64",
|
||||
"version": "0.1.0", "build_date": "2026-11-06T00:00:00Z",
|
||||
"sdk_revision": REV, "os_revision": REV, "payload_type": "os",
|
||||
"bootloader_policy": "preserve",
|
||||
"signature": {"type": "unsigned", "member": null, "public_key_hex": null},
|
||||
"partitions": partitions,
|
||||
"images": [
|
||||
image("kernel", "payload/vmlinux.bin", "kernel", "arm64-image", &kernel),
|
||||
image("dtb", "payload/devicetree.dtb", "dtb", "fdt", &dtb),
|
||||
image("rootfs", "payload/uramdisk.image.gz", "rootfs", "uimage", &rootfs),
|
||||
],
|
||||
"boot_switch": {}, "preflight": {"min_free_bytes": 16777216},
|
||||
"recovery": {}, "marker": "Alkane", "kernel_version": "6.18.48"
|
||||
});
|
||||
let manifest: AfwManifest = serde_json::from_value(value).unwrap();
|
||||
VerifiedAfw {
|
||||
manifest,
|
||||
members: vec![
|
||||
AfwMember {
|
||||
name: "payload/vmlinux.bin".to_owned(),
|
||||
data: kernel,
|
||||
},
|
||||
AfwMember {
|
||||
name: "payload/devicetree.dtb".to_owned(),
|
||||
data: dtb,
|
||||
},
|
||||
AfwMember {
|
||||
name: "payload/uramdisk.image.gz".to_owned(),
|
||||
data: rootfs,
|
||||
},
|
||||
],
|
||||
manifest_sha256: "0".repeat(64),
|
||||
archive_sha256: "0".repeat(64),
|
||||
}
|
||||
}
|
||||
|
||||
fn preserved_partitions() -> serde_json::Value {
|
||||
json!([
|
||||
{"name":"bootloader","device":"/dev/mtd0","offset":0,"size":2097152,
|
||||
"secure":true,"boot_critical":true,"write_order":0,"image":null},
|
||||
{"name":"nvdata","device":"/dev/mtd6","offset":74448896,"size":193986560,
|
||||
"secure":false,"boot_critical":true,"write_order":1,"image":"kernel"}
|
||||
])
|
||||
}
|
||||
|
||||
fn good() -> VerifiedAfw {
|
||||
afw_with(arm64_image(b"k"), dtb(), uramdisk(), preserved_partitions())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accepts_a_good_plan_as_file_copies() {
|
||||
let plan = A113dPlan::from_afw(&good()).unwrap();
|
||||
assert_eq!(plan.targets.len(), 3);
|
||||
// write order rootfs, dtb, kernel (kernel file lands last)
|
||||
assert_eq!(plan.targets[0].image_name, "rootfs");
|
||||
assert_eq!(plan.targets[2].image_name, "kernel");
|
||||
assert!(no_raw_device_targets(&plan));
|
||||
for t in &plan.targets {
|
||||
assert!(
|
||||
!t.dest.contains('/'),
|
||||
"{} has a path, not a basename",
|
||||
t.image_name
|
||||
);
|
||||
}
|
||||
assert!(plan.render().contains("alkane/"));
|
||||
assert!(plan.render().contains("no raw NAND write is possible"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_a_non_arm64_kernel() {
|
||||
let r = A113dPlan::from_afw(&afw_with(
|
||||
vec![0u8; 64],
|
||||
dtb(),
|
||||
uramdisk(),
|
||||
preserved_partitions(),
|
||||
));
|
||||
assert!(matches!(r, Err(A113dPlanError::NotArm64 { .. })));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_an_oversize_kernel() {
|
||||
let big = arm64_image(&vec![0u8; 0x4000000]);
|
||||
let r = A113dPlan::from_afw(&afw_with(big, dtb(), uramdisk(), preserved_partitions()));
|
||||
assert!(matches!(r, Err(A113dPlanError::ImageTooLarge { .. })));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_a_fip_member() {
|
||||
let mut v = good();
|
||||
v.manifest.images[0].role = "bootloader".to_owned();
|
||||
assert!(matches!(
|
||||
A113dPlan::from_afw(&v),
|
||||
Err(A113dPlanError::BootloaderMember(_))
|
||||
));
|
||||
let mut v = good();
|
||||
v.manifest.images[1].file = "payload/fip.bin".to_owned();
|
||||
assert!(matches!(
|
||||
A113dPlan::from_afw(&v),
|
||||
Err(A113dPlanError::BootloaderMember(_))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_a_preserved_partition_carrying_an_image() {
|
||||
let partitions = json!([
|
||||
{"name":"bootloader","device":"/dev/mtd0","offset":0,"size":2097152,
|
||||
"secure":true,"boot_critical":true,"write_order":0,"image":"kernel"},
|
||||
{"name":"nvdata","device":"/dev/mtd6","offset":74448896,"size":193986560,
|
||||
"secure":false,"boot_critical":true,"write_order":1,"image":"kernel"}
|
||||
]);
|
||||
let v = afw_with(arm64_image(b"k"), dtb(), uramdisk(), partitions);
|
||||
assert!(matches!(
|
||||
A113dPlan::from_afw(&v),
|
||||
Err(A113dPlanError::PreservedCarriesImage(_))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wrong_board_and_arch_are_refused() {
|
||||
let mut v = good();
|
||||
v.manifest.board = "zynq-7010".to_owned();
|
||||
assert!(matches!(
|
||||
A113dPlan::from_afw(&v),
|
||||
Err(A113dPlanError::WrongBoard(_))
|
||||
));
|
||||
let mut v = good();
|
||||
v.manifest.arch = "armv7".to_owned();
|
||||
assert!(matches!(
|
||||
A113dPlan::from_afw(&v),
|
||||
Err(A113dPlanError::WrongArch(_))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_target_is_a_basename_never_a_device() {
|
||||
for (image, dest, _ceiling, _fmt) in TARGETS {
|
||||
assert!(
|
||||
is_safe_dest(dest),
|
||||
"{image} dest {dest} is not a safe basename"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unsafe_dest_is_rejected_by_guard() {
|
||||
assert!(!is_safe_dest("/dev/mtd0"));
|
||||
assert!(!is_safe_dest("../escape"));
|
||||
assert!(!is_safe_dest("sub/dir/file"));
|
||||
assert!(is_safe_dest("vmlinux.bin"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_the_nvdata_mtd_index() {
|
||||
let proc_mtd = "dev: size erasesize name\n\
|
||||
mtd0: 0b900000 00020000 \"nvdata\"\n";
|
||||
assert_eq!(parse_nvdata_mtd(proc_mtd), Some(0));
|
||||
// No nvdata line -> None (the no-NAND running image).
|
||||
assert_eq!(parse_nvdata_mtd("dev: size erasesize name\n"), None);
|
||||
// Different index is honored.
|
||||
assert_eq!(
|
||||
parse_nvdata_mtd("mtd3: 0b900000 00020000 \"nvdata\"\n"),
|
||||
Some(3)
|
||||
);
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,406 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! CV1835 board module: the only write is the 16 MiB p1 FIT.
|
||||
//!
|
||||
//! The vendor boot0, BL2, BL31 and U-Boot chain is preserved. The board plan is
|
||||
//! read from the verified `.afw` manifest, not guessed at runtime.
|
||||
|
||||
use crate::md5::md5_hex;
|
||||
use alkane_artifacts::afw::{
|
||||
AfwImage, AfwManifest, AfwPartition, BootloaderPolicy, VerifiedAfw, CV1835_P1_SIZE,
|
||||
};
|
||||
use thiserror::Error;
|
||||
|
||||
pub const BOARD: &str = "cv1835";
|
||||
pub const ARCH: &str = "arm64";
|
||||
pub const P1_DEVICE: &str = "/dev/mmcblk0p1";
|
||||
pub const MARKER: &str = "CVBOOT";
|
||||
pub const UPDATE_DAEMON_PORT: u16 = 12887;
|
||||
pub const GOLDEN_LBA_BYTES: u64 = 0x300000 * 512;
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum CvPlanError {
|
||||
#[error("bundle is for {0}, not cv1835")]
|
||||
WrongBoard(String),
|
||||
#[error("bundle arch is {0}, cv1835 needs arm64")]
|
||||
WrongArch(String),
|
||||
#[error("cv1835 requires bootloader_policy preserve")]
|
||||
BootloaderPolicy,
|
||||
#[error("cv1835 bundle carries a bootloader member")]
|
||||
BootloaderMember,
|
||||
#[error("cv1835 bundle must install exactly p1")]
|
||||
MissingP1,
|
||||
#[error("cv1835 p1 is {0} bytes, not the 16 MiB padded FIT")]
|
||||
P1Size(u64),
|
||||
#[error("cv1835 p1 partition is not /dev/mmcblk0p1")]
|
||||
P1Device,
|
||||
#[error("cv1835 p1 partition must be 16 MiB, non-secure and written once")]
|
||||
P1Geometry,
|
||||
#[error("cv1835 p1 is not a bootable FIT: {0}")]
|
||||
Fit(String),
|
||||
#[error("manifest marker is empty")]
|
||||
Marker,
|
||||
#[error("manifest kernel_version is empty")]
|
||||
KernelVersion,
|
||||
#[error("manifest is not an OS payload")]
|
||||
PayloadType,
|
||||
#[error("manifest preflight is missing {0}")]
|
||||
Preflight(String),
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Cv1835Plan {
|
||||
pub image: AfwImage,
|
||||
pub data: Vec<u8>,
|
||||
pub partition: AfwPartition,
|
||||
pub expected_md5: String,
|
||||
pub expected_sha256: String,
|
||||
pub marker: String,
|
||||
pub kernel_version: String,
|
||||
pub sdk_revision: String,
|
||||
pub os_revision: String,
|
||||
pub source_os: Vec<String>,
|
||||
pub required_commands: Vec<String>,
|
||||
pub min_free_bytes: u64,
|
||||
pub golden_lba_bytes: u64,
|
||||
}
|
||||
|
||||
impl Cv1835Plan {
|
||||
pub fn from_afw(afw: &VerifiedAfw) -> Result<Self, CvPlanError> {
|
||||
let manifest = &afw.manifest;
|
||||
if manifest.board != BOARD {
|
||||
return Err(CvPlanError::WrongBoard(manifest.board.clone()));
|
||||
}
|
||||
if manifest.arch != ARCH {
|
||||
return Err(CvPlanError::WrongArch(manifest.arch.clone()));
|
||||
}
|
||||
if manifest.payload_type != "os" {
|
||||
return Err(CvPlanError::PayloadType);
|
||||
}
|
||||
if manifest.bootloader_policy != BootloaderPolicy::Preserve {
|
||||
return Err(CvPlanError::BootloaderPolicy);
|
||||
}
|
||||
if manifest
|
||||
.images
|
||||
.iter()
|
||||
.any(|image| image.role == "bootloader")
|
||||
{
|
||||
return Err(CvPlanError::BootloaderMember);
|
||||
}
|
||||
if manifest.marker.is_empty() {
|
||||
return Err(CvPlanError::Marker);
|
||||
}
|
||||
if manifest.kernel_version.is_empty() {
|
||||
return Err(CvPlanError::KernelVersion);
|
||||
}
|
||||
|
||||
let install: Vec<&AfwImage> = manifest
|
||||
.images
|
||||
.iter()
|
||||
.filter(|image| image.install)
|
||||
.collect();
|
||||
if install.len() != 1 || install[0].name != "p1" {
|
||||
return Err(CvPlanError::MissingP1);
|
||||
}
|
||||
let image = install[0].clone();
|
||||
if image.format != "fit" {
|
||||
return Err(CvPlanError::Fit("format is not fit".to_owned()));
|
||||
}
|
||||
if image.size != CV1835_P1_SIZE {
|
||||
return Err(CvPlanError::P1Size(image.size));
|
||||
}
|
||||
let (_, data) = afw.install_image().ok_or(CvPlanError::MissingP1)?;
|
||||
if !data.starts_with(b"\xd0\x0d\xfe\xed") {
|
||||
return Err(CvPlanError::Fit("missing FDT/FIT magic".to_owned()));
|
||||
}
|
||||
if !contains(data, b"config@cv1835_miner_emmc") {
|
||||
return Err(CvPlanError::Fit(
|
||||
"missing config@cv1835_miner_emmc".to_owned(),
|
||||
));
|
||||
}
|
||||
if contains(data, b"signature@") {
|
||||
return Err(CvPlanError::Fit("carries signature@ nodes".to_owned()));
|
||||
}
|
||||
|
||||
let partition = manifest
|
||||
.partitions
|
||||
.iter()
|
||||
.find(|part| part.name == "p1")
|
||||
.ok_or(CvPlanError::P1Device)?
|
||||
.clone();
|
||||
if partition.device != P1_DEVICE {
|
||||
return Err(CvPlanError::P1Device);
|
||||
}
|
||||
if partition.size != CV1835_P1_SIZE
|
||||
|| partition.secure
|
||||
|| !partition.boot_critical
|
||||
|| partition.write_order != 1
|
||||
{
|
||||
return Err(CvPlanError::P1Geometry);
|
||||
}
|
||||
if manifest
|
||||
.partitions
|
||||
.iter()
|
||||
.any(|part| part.write_order > 0 && part.name != "p1")
|
||||
{
|
||||
return Err(CvPlanError::MissingP1);
|
||||
}
|
||||
|
||||
let source_os = json_strings(&manifest.preflight, "source_os");
|
||||
let required_commands = json_strings(&manifest.preflight, "required_commands");
|
||||
let min_free_bytes = manifest
|
||||
.preflight
|
||||
.get("min_free_bytes")
|
||||
.and_then(|value| value.as_u64())
|
||||
.unwrap_or(32 * 1024 * 1024);
|
||||
let golden_lba_bytes = manifest
|
||||
.recovery
|
||||
.get("golden_lba_bytes")
|
||||
.and_then(|value| value.as_u64())
|
||||
.unwrap_or(GOLDEN_LBA_BYTES);
|
||||
|
||||
Ok(Self {
|
||||
expected_md5: md5_hex(data),
|
||||
expected_sha256: image.sha256.clone(),
|
||||
image,
|
||||
data: data.to_vec(),
|
||||
partition,
|
||||
marker: manifest.marker.clone(),
|
||||
kernel_version: manifest.kernel_version.clone(),
|
||||
sdk_revision: manifest.sdk_revision.clone(),
|
||||
os_revision: manifest.os_revision.clone(),
|
||||
source_os,
|
||||
required_commands,
|
||||
min_free_bytes,
|
||||
golden_lba_bytes,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn render(&self) -> String {
|
||||
format!(
|
||||
"board cv1835 arch arm64\n\
|
||||
partition {} {} {} B secure=false boot_critical=true write_order={}\n\
|
||||
image {} {} {} B sha256 {}\n\
|
||||
image md5 {}\n\
|
||||
bootloader preserve (vendor boot0/BL2/BL31/U-Boot kept)\n\
|
||||
boot switch partition-overwrite (p1 is the switch)\n\
|
||||
marker {} kernel {} sdk {} os {}",
|
||||
self.partition.name,
|
||||
self.partition.device,
|
||||
self.partition.size,
|
||||
self.partition.write_order,
|
||||
self.image.name,
|
||||
self.image.file,
|
||||
self.image.size,
|
||||
self.image.sha256,
|
||||
self.expected_md5,
|
||||
self.marker,
|
||||
self.kernel_version,
|
||||
short_revision(&self.sdk_revision),
|
||||
short_revision(&self.os_revision),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
fn short_revision(revision: &str) -> &str {
|
||||
revision.get(..12).unwrap_or(revision)
|
||||
}
|
||||
|
||||
fn contains(haystack: &[u8], needle: &[u8]) -> bool {
|
||||
haystack
|
||||
.windows(needle.len())
|
||||
.any(|window| window == needle)
|
||||
}
|
||||
|
||||
fn json_strings(value: &serde_json::Value, key: &str) -> Vec<String> {
|
||||
value
|
||||
.get(key)
|
||||
.and_then(|item| item.as_array())
|
||||
.map(|items| {
|
||||
items
|
||||
.iter()
|
||||
.filter_map(|item| item.as_str().map(str::to_owned))
|
||||
.collect()
|
||||
})
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
pub fn manifest_from_json(value: serde_json::Value) -> Result<AfwManifest, serde_json::Error> {
|
||||
serde_json::from_value(value)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use alkane_artifacts::afw::AfwMember;
|
||||
use serde_json::json;
|
||||
use sha2::{Digest, Sha256};
|
||||
|
||||
const P1: usize = CV1835_P1_SIZE as usize;
|
||||
const REV: &str = "0000000000000000000000000000000000000000";
|
||||
|
||||
fn sha_hex(data: &[u8]) -> String {
|
||||
Sha256::digest(data)
|
||||
.iter()
|
||||
.map(|byte| format!("{byte:02x}"))
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn p1_image() -> Vec<u8> {
|
||||
let mut fit = vec![0_u8; P1];
|
||||
fit[..4].copy_from_slice(b"\xd0\x0d\xfe\xed");
|
||||
let marker = b"config@cv1835_miner_emmc";
|
||||
fit[0x100..0x100 + marker.len()].copy_from_slice(marker);
|
||||
fit
|
||||
}
|
||||
|
||||
fn manifest_value(p1: &[u8]) -> serde_json::Value {
|
||||
json!({
|
||||
"schema": 2,
|
||||
"format": "afw",
|
||||
"board": "cv1835",
|
||||
"arch": "arm64",
|
||||
"version": "0.1.0",
|
||||
"build_date": "2026-11-04T00:00:00Z",
|
||||
"sdk_revision": REV,
|
||||
"os_revision": REV,
|
||||
"payload_type": "os",
|
||||
"bootloader_policy": "preserve",
|
||||
"signature": {"type": "unsigned", "member": null, "public_key_hex": null},
|
||||
"partitions": [
|
||||
{"name": "p1", "device": "/dev/mmcblk0p1", "offset": 0,
|
||||
"size": CV1835_P1_SIZE, "secure": false, "boot_critical": true,
|
||||
"write_order": 1, "image": "p1"},
|
||||
{"name": "boot0", "device": "/dev/mmcblk0boot0", "offset": 0,
|
||||
"size": 4194304, "secure": true, "boot_critical": true,
|
||||
"write_order": 0, "image": null}
|
||||
],
|
||||
"images": [
|
||||
{"name": "p1", "file": "payload/p1.fit", "role": "boot",
|
||||
"format": "fit", "size": p1.len(),
|
||||
"sha256": sha_hex(p1),
|
||||
"partition": "p1", "install": true}
|
||||
],
|
||||
"boot_switch": {"method": "partition-overwrite"},
|
||||
"preflight": {"required_commands": ["dd", "md5sum", "sync"],
|
||||
"source_os": ["stock-bitmain", "vnish", "braiins", "ouros", "alkane"],
|
||||
"min_free_bytes": 33554432},
|
||||
"recovery": {"network": "afw restore", "golden_lba_bytes": GOLDEN_LBA_BYTES},
|
||||
"marker": "CVBOOT",
|
||||
"kernel_version": "6.18.48"
|
||||
})
|
||||
}
|
||||
|
||||
fn afw(p1: &[u8]) -> VerifiedAfw {
|
||||
let manifest = manifest_from_json(manifest_value(p1)).unwrap();
|
||||
VerifiedAfw {
|
||||
manifest,
|
||||
members: vec![AfwMember {
|
||||
name: "payload/p1.fit".to_owned(),
|
||||
data: p1.to_vec(),
|
||||
}],
|
||||
manifest_sha256: "0".repeat(64),
|
||||
archive_sha256: "0".repeat(64),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accepts_the_cv_plan() {
|
||||
let data = p1_image();
|
||||
let plan = Cv1835Plan::from_afw(&afw(&data)).unwrap();
|
||||
assert_eq!(plan.partition.device, "/dev/mmcblk0p1");
|
||||
assert_eq!(plan.image.size, CV1835_P1_SIZE);
|
||||
assert_eq!(plan.marker, "CVBOOT");
|
||||
assert!(plan
|
||||
.render()
|
||||
.contains("partition p1 /dev/mmcblk0p1 16777216"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_a_bundle_for_another_board() {
|
||||
let data = p1_image();
|
||||
let mut verified = afw(&data);
|
||||
verified.manifest.board = "zynq-7010".to_owned();
|
||||
assert!(matches!(
|
||||
Cv1835Plan::from_afw(&verified),
|
||||
Err(CvPlanError::WrongBoard(_))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_include_bootloader_policy() {
|
||||
let data = p1_image();
|
||||
let mut verified = afw(&data);
|
||||
verified.manifest.bootloader_policy = BootloaderPolicy::Include;
|
||||
assert!(matches!(
|
||||
Cv1835Plan::from_afw(&verified),
|
||||
Err(CvPlanError::BootloaderPolicy)
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_a_bootloader_member() {
|
||||
let data = p1_image();
|
||||
let mut verified = afw(&data);
|
||||
verified.manifest.images.push(AfwImage {
|
||||
name: "u-boot".to_owned(),
|
||||
file: "payload/u-boot.img".to_owned(),
|
||||
role: "bootloader".to_owned(),
|
||||
format: "uimage".to_owned(),
|
||||
size: 4,
|
||||
sha256: "0".repeat(64),
|
||||
partition: None,
|
||||
install: false,
|
||||
});
|
||||
assert!(matches!(
|
||||
Cv1835Plan::from_afw(&verified),
|
||||
Err(CvPlanError::BootloaderMember)
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_a_short_p1() {
|
||||
let data = vec![0_u8; 1024];
|
||||
let verified = afw(&data);
|
||||
assert!(matches!(
|
||||
Cv1835Plan::from_afw(&verified),
|
||||
Err(CvPlanError::P1Size(1024))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_a_secure_p1() {
|
||||
let data = p1_image();
|
||||
let mut verified = afw(&data);
|
||||
verified.manifest.partitions[0].secure = true;
|
||||
assert!(matches!(
|
||||
Cv1835Plan::from_afw(&verified),
|
||||
Err(CvPlanError::P1Geometry)
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_a_wrong_device() {
|
||||
let data = p1_image();
|
||||
let mut verified = afw(&data);
|
||||
verified.manifest.partitions[0].device = "/dev/mmcblk0p3".to_owned();
|
||||
assert!(matches!(
|
||||
Cv1835Plan::from_afw(&verified),
|
||||
Err(CvPlanError::P1Device)
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_a_fit_without_the_board_config() {
|
||||
let mut data = p1_image();
|
||||
for byte in data.iter_mut() {
|
||||
if *byte == b'c' {
|
||||
*byte = b'x';
|
||||
}
|
||||
}
|
||||
let verified = afw(&data);
|
||||
assert!(matches!(
|
||||
Cv1835Plan::from_afw(&verified),
|
||||
Err(CvPlanError::Fit(_))
|
||||
));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Board modules. Each module validates the verified manifest for its family
|
||||
//! and exposes the exact write plan the installer follows.
|
||||
|
||||
pub mod a113d;
|
||||
pub mod am335x;
|
||||
pub mod cv1835;
|
||||
pub mod zynq;
|
||||
@@ -0,0 +1,410 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Zynq-7010 board module: the manifest gate and write plan for putting our
|
||||
//! OS onto a Zynq control board (Antminer S17/S19 class).
|
||||
//!
|
||||
//! This module decides WHAT may be written and WHERE, in absolute NAND terms.
|
||||
//! It does not write. The write itself (for a board already on alkane, and for
|
||||
//! the first install from stock) is done by the compiled-in method behind
|
||||
//! `crate::stock` (`update_in_place` / `install_from_stock`), because on a board
|
||||
//! running alkane the boot regions are deliberately not exposed to Linux and
|
||||
//! have to be re-registered first; that mechanism lives with the method.
|
||||
//!
|
||||
//! Layout (absolute NAND offsets, 128 KiB erase blocks): BOOT.bin (FSBL + FPGA
|
||||
//! bitstream + stock U-Boot + env) occupies 0x0..0x1a00000 and is never
|
||||
//! written. The stock U-Boot reads the dtb at 0x1a00000, the kernel at
|
||||
//! 0x2000000 and the ramdisk at 0x2800000, and boots the kernel and ramdisk as
|
||||
//! legacy uImages, so both are written with a 64-byte uImage header.
|
||||
//!
|
||||
//! History: an earlier version of this module wrote raw images at
|
||||
//! device-relative offsets on /dev/mtd0 and /dev/mtd1. That matched an early
|
||||
//! alkane image that exposed the whole NAND, not the current one (which exposes
|
||||
//! only the small `stock-cfg` and `alkane-cfg` partitions), and its raw kernel
|
||||
//! and ramdisk were not bootable by the stock U-Boot. It was removed.
|
||||
|
||||
use crate::md5::md5_hex;
|
||||
use alkane_artifacts::afw::{AfwImage, BootloaderPolicy, VerifiedAfw};
|
||||
use thiserror::Error;
|
||||
|
||||
pub const BOARD: &str = "zynq-7010";
|
||||
pub const ARCH: &str = "armv7";
|
||||
/// Absolute NAND 0x0..0x1a00000 is BOOT.bin (FSBL + FPGA bitstream + stock
|
||||
/// U-Boot) + the U-Boot env, and is NEVER erased or written.
|
||||
pub const BOOTBIN_PRESERVE: u64 = 0x1A00000;
|
||||
|
||||
/// Size of the legacy uImage header the stock U-Boot needs on the kernel and
|
||||
/// the ramdisk.
|
||||
const UIMAGE_HEADER: u64 = 64;
|
||||
|
||||
/// Write targets in write order (rootfs, dtb, kernel, so an interrupted write
|
||||
/// never leaves a new rootfs under an old kernel): (image, absolute NAND
|
||||
/// offset, slot size, expected manifest format, uImage-wrapped).
|
||||
const TARGETS: [(&str, u64, u64, &str, bool); 3] = [
|
||||
("rootfs", 0x2800000, 0x2000000, "cpio-gzip", true),
|
||||
("dtb", 0x1A00000, 0x20000, "fdt", false),
|
||||
("kernel", 0x2000000, 0x800000, "zimage", true),
|
||||
];
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum ZynqPlanError {
|
||||
#[error("bundle is for {0}, not zynq-7010")]
|
||||
WrongBoard(String),
|
||||
#[error("bundle arch is {0}, zynq-7010 needs armv7")]
|
||||
WrongArch(String),
|
||||
#[error("zynq-7010 requires bootloader_policy preserve")]
|
||||
BootloaderPolicy,
|
||||
#[error("zynq-7010 bundle carries a bootloader/spl/BOOT.bin member: {0}")]
|
||||
BootloaderMember(String),
|
||||
#[error("manifest is not an OS payload")]
|
||||
PayloadType,
|
||||
#[error("manifest marker is empty")]
|
||||
Marker,
|
||||
#[error("zynq-7010 must install exactly kernel, dtb and rootfs")]
|
||||
InstallCount,
|
||||
#[error("zynq-7010 is missing the {0} image")]
|
||||
MissingImage(String),
|
||||
#[error("zynq-7010 {image} format is {actual}, expected {expected}")]
|
||||
ImageFormat {
|
||||
image: String,
|
||||
actual: String,
|
||||
expected: &'static str,
|
||||
},
|
||||
#[error("zynq-7010 {image} is {size} bytes, over the {ceiling}-byte ceiling for its 0x{slot:x} slot")]
|
||||
ImageTooLarge {
|
||||
image: String,
|
||||
size: u64,
|
||||
ceiling: u64,
|
||||
slot: u64,
|
||||
},
|
||||
#[error("zynq-7010 {image} is not an ARM zImage")]
|
||||
NotZImage { image: String },
|
||||
#[error("zynq-7010 refuses to place {image} at 0x{offset:x}: below BOOT.bin (0x{bootbin:x})")]
|
||||
WouldClobberBootbin {
|
||||
image: String,
|
||||
offset: u64,
|
||||
bootbin: u64,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct ZynqTarget {
|
||||
pub image_name: String,
|
||||
/// Absolute NAND offset of the slot.
|
||||
pub absolute: u64,
|
||||
pub slot: u64,
|
||||
/// Size of the image as shipped in the `.afw` (before any uImage header).
|
||||
pub size: u64,
|
||||
pub uimage_wrapped: bool,
|
||||
pub data: Vec<u8>,
|
||||
pub expected_md5: String,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct ZynqPlan {
|
||||
pub targets: Vec<ZynqTarget>,
|
||||
pub marker: String,
|
||||
pub kernel_version: String,
|
||||
pub sdk_revision: String,
|
||||
pub os_revision: String,
|
||||
pub afw_sha256: String,
|
||||
}
|
||||
|
||||
fn is_bootloaderish(image: &AfwImage) -> bool {
|
||||
let lowered = format!("{} {} {}", image.name, image.file, image.role).to_lowercase();
|
||||
image.role == "bootloader"
|
||||
|| lowered.contains("spl")
|
||||
|| lowered.contains("u-boot")
|
||||
|| lowered.contains("uboot")
|
||||
|| lowered.contains("boot.bin")
|
||||
}
|
||||
|
||||
impl ZynqPlan {
|
||||
pub fn from_afw(afw: &VerifiedAfw) -> Result<Self, ZynqPlanError> {
|
||||
let manifest = &afw.manifest;
|
||||
if manifest.board != BOARD {
|
||||
return Err(ZynqPlanError::WrongBoard(manifest.board.clone()));
|
||||
}
|
||||
if manifest.arch != ARCH {
|
||||
return Err(ZynqPlanError::WrongArch(manifest.arch.clone()));
|
||||
}
|
||||
if manifest.payload_type != "os" {
|
||||
return Err(ZynqPlanError::PayloadType);
|
||||
}
|
||||
if manifest.bootloader_policy != BootloaderPolicy::Preserve {
|
||||
return Err(ZynqPlanError::BootloaderPolicy);
|
||||
}
|
||||
if manifest.marker.is_empty() {
|
||||
return Err(ZynqPlanError::Marker);
|
||||
}
|
||||
// BOOT.bin / bootloader members are never allowed - we reuse the board's.
|
||||
for image in &manifest.images {
|
||||
if is_bootloaderish(image) {
|
||||
return Err(ZynqPlanError::BootloaderMember(image.file.clone()));
|
||||
}
|
||||
}
|
||||
let installs: Vec<&AfwImage> = manifest.images.iter().filter(|i| i.install).collect();
|
||||
if installs.len() != TARGETS.len() {
|
||||
return Err(ZynqPlanError::InstallCount);
|
||||
}
|
||||
|
||||
let mut targets = Vec::with_capacity(TARGETS.len());
|
||||
for (image_name, absolute, slot, expected_format, wrapped) in TARGETS {
|
||||
let image = manifest
|
||||
.images
|
||||
.iter()
|
||||
.find(|i| i.name == image_name && i.install)
|
||||
.ok_or_else(|| ZynqPlanError::MissingImage(image_name.to_owned()))?;
|
||||
if image.format != expected_format {
|
||||
return Err(ZynqPlanError::ImageFormat {
|
||||
image: image_name.to_owned(),
|
||||
actual: image.format.clone(),
|
||||
expected: expected_format,
|
||||
});
|
||||
}
|
||||
let ceiling = if wrapped { slot - UIMAGE_HEADER } else { slot };
|
||||
if image.size > ceiling {
|
||||
return Err(ZynqPlanError::ImageTooLarge {
|
||||
image: image_name.to_owned(),
|
||||
size: image.size,
|
||||
ceiling,
|
||||
slot,
|
||||
});
|
||||
}
|
||||
// The hard brick guard: nothing is ever placed inside BOOT.bin.
|
||||
if absolute < BOOTBIN_PRESERVE {
|
||||
return Err(ZynqPlanError::WouldClobberBootbin {
|
||||
image: image_name.to_owned(),
|
||||
offset: absolute,
|
||||
bootbin: BOOTBIN_PRESERVE,
|
||||
});
|
||||
}
|
||||
let data = afw
|
||||
.image(image_name)
|
||||
.map(|(_, data)| data)
|
||||
.ok_or_else(|| ZynqPlanError::MissingImage(image_name.to_owned()))?;
|
||||
if expected_format == "zimage"
|
||||
&& !(data.len() >= 0x28 && data[0x24..0x28] == [0x18, 0x28, 0x6f, 0x01])
|
||||
{
|
||||
return Err(ZynqPlanError::NotZImage {
|
||||
image: image_name.to_owned(),
|
||||
});
|
||||
}
|
||||
targets.push(ZynqTarget {
|
||||
image_name: image_name.to_owned(),
|
||||
absolute,
|
||||
slot,
|
||||
size: image.size,
|
||||
uimage_wrapped: wrapped,
|
||||
expected_md5: md5_hex(data),
|
||||
data: data.to_vec(),
|
||||
});
|
||||
}
|
||||
|
||||
Ok(Self {
|
||||
targets,
|
||||
marker: manifest.marker.clone(),
|
||||
kernel_version: manifest.kernel_version.clone(),
|
||||
sdk_revision: manifest.sdk_revision.clone(),
|
||||
os_revision: manifest.os_revision.clone(),
|
||||
afw_sha256: afw.archive_sha256.clone(),
|
||||
})
|
||||
}
|
||||
|
||||
pub fn render(&self) -> String {
|
||||
let mut out = format!("board {BOARD} arch {ARCH}\n");
|
||||
out.push_str(&format!(
|
||||
"boot slots (absolute NAND); BOOT.bin 0x0..0x{BOOTBIN_PRESERVE:x} preserved, never written\n"
|
||||
));
|
||||
out.push_str(
|
||||
"kernel and rootfs are written as legacy uImages (what the stock U-Boot boots); dtb raw\n",
|
||||
);
|
||||
for target in &self.targets {
|
||||
out.push_str(&format!(
|
||||
"write {:<6} abs 0x{:x} slot 0x{:x} size {} B{} md5 {}\n",
|
||||
target.image_name,
|
||||
target.absolute,
|
||||
target.slot,
|
||||
target.size,
|
||||
if target.uimage_wrapped {
|
||||
" +64 B header"
|
||||
} else {
|
||||
""
|
||||
},
|
||||
target.expected_md5
|
||||
));
|
||||
}
|
||||
out.push_str(&format!(
|
||||
"marker {} kernel {} sdk {} os {}",
|
||||
self.marker,
|
||||
self.kernel_version,
|
||||
short(&self.sdk_revision),
|
||||
short(&self.os_revision),
|
||||
));
|
||||
out
|
||||
}
|
||||
}
|
||||
|
||||
fn short(rev: &str) -> &str {
|
||||
rev.get(..12).unwrap_or(rev)
|
||||
}
|
||||
|
||||
pub fn owns_board(board: &str) -> bool {
|
||||
board == BOARD
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use alkane_artifacts::afw::{AfwManifest, AfwMember};
|
||||
use serde_json::json;
|
||||
use sha2::{Digest, Sha256};
|
||||
|
||||
const REV: &str = "0123456789abcdef0123456789abcdef01234567";
|
||||
|
||||
fn zimage(payload: &[u8]) -> Vec<u8> {
|
||||
let mut b = vec![0u8; 64];
|
||||
b[0x24..0x28].copy_from_slice(&[0x18, 0x28, 0x6f, 0x01]);
|
||||
b.extend_from_slice(payload);
|
||||
b
|
||||
}
|
||||
|
||||
fn afw(kernel: Vec<u8>, dtb: Vec<u8>, rootfs: Vec<u8>) -> VerifiedAfw {
|
||||
let image = |name: &str, file: &str, role: &str, fmt: &str, data: &[u8]| {
|
||||
let sha: String = Sha256::digest(data)
|
||||
.iter()
|
||||
.map(|b| format!("{b:02x}"))
|
||||
.collect();
|
||||
json!({"name": name, "file": file, "role": role, "format": fmt,
|
||||
"size": data.len(), "sha256": sha, "partition": "x", "install": true})
|
||||
};
|
||||
let value = json!({
|
||||
"schema": 2, "format": "afw", "board": "zynq-7010", "arch": "armv7",
|
||||
"version": "0.1.0", "build_date": "2026-11-06T00:00:00Z",
|
||||
"sdk_revision": REV, "os_revision": REV, "payload_type": "os",
|
||||
"bootloader_policy": "preserve",
|
||||
"signature": {"type": "unsigned", "member": null, "public_key_hex": null},
|
||||
"partitions": [],
|
||||
"images": [
|
||||
image("kernel", "payload/zImage", "kernel", "zimage", &kernel),
|
||||
image("dtb", "payload/zynq-alkane.dtb", "dtb", "fdt", &dtb),
|
||||
image("rootfs", "payload/rootfs.cpio.gz", "rootfs", "cpio-gzip", &rootfs),
|
||||
],
|
||||
"boot_switch": {}, "preflight": {"min_free_bytes": 16777216},
|
||||
"recovery": {}, "marker": "Alkane", "kernel_version": "6.18.48"
|
||||
});
|
||||
let manifest: AfwManifest = serde_json::from_value(value).unwrap();
|
||||
VerifiedAfw {
|
||||
manifest,
|
||||
members: vec![
|
||||
AfwMember {
|
||||
name: "payload/zImage".to_owned(),
|
||||
data: kernel,
|
||||
},
|
||||
AfwMember {
|
||||
name: "payload/zynq-alkane.dtb".to_owned(),
|
||||
data: dtb,
|
||||
},
|
||||
AfwMember {
|
||||
name: "payload/rootfs.cpio.gz".to_owned(),
|
||||
data: rootfs,
|
||||
},
|
||||
],
|
||||
manifest_sha256: "0".repeat(64),
|
||||
archive_sha256: "0".repeat(64),
|
||||
}
|
||||
}
|
||||
|
||||
fn dtb() -> Vec<u8> {
|
||||
let mut b = vec![0u8; 1024];
|
||||
b[0..4].copy_from_slice(&[0xd0, 0x0d, 0xfe, 0xed]);
|
||||
b
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accepts_a_good_plan_and_places_above_bootbin() {
|
||||
let plan = ZynqPlan::from_afw(&afw(zimage(b"k"), dtb(), b"\x1f\x8brf".to_vec())).unwrap();
|
||||
assert_eq!(plan.targets.len(), 3);
|
||||
// write order rootfs, dtb, kernel
|
||||
assert_eq!(plan.targets[0].image_name, "rootfs");
|
||||
assert_eq!(plan.targets[2].image_name, "kernel");
|
||||
for t in &plan.targets {
|
||||
assert!(
|
||||
t.absolute >= BOOTBIN_PRESERVE,
|
||||
"{} below BOOT.bin",
|
||||
t.image_name
|
||||
);
|
||||
}
|
||||
let render = plan.render();
|
||||
assert!(render.contains("BOOT.bin"));
|
||||
assert!(render.contains("uImage"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn slots_match_the_stock_uboot_layout() {
|
||||
let plan = ZynqPlan::from_afw(&afw(zimage(b"k"), dtb(), b"\x1f\x8brf".to_vec())).unwrap();
|
||||
let at = |name: &str| plan.targets.iter().find(|t| t.image_name == name).unwrap();
|
||||
assert_eq!((at("dtb").absolute, at("dtb").slot), (0x1A00000, 0x20000));
|
||||
assert_eq!(
|
||||
(at("kernel").absolute, at("kernel").slot),
|
||||
(0x2000000, 0x800000)
|
||||
);
|
||||
assert_eq!(
|
||||
(at("rootfs").absolute, at("rootfs").slot),
|
||||
(0x2800000, 0x2000000)
|
||||
);
|
||||
assert!(at("kernel").uimage_wrapped && at("rootfs").uimage_wrapped);
|
||||
assert!(!at("dtb").uimage_wrapped);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_a_non_zimage_kernel() {
|
||||
let result = ZynqPlan::from_afw(&afw(vec![0u8; 64], dtb(), b"\x1f\x8brf".to_vec()));
|
||||
assert!(matches!(result, Err(ZynqPlanError::NotZImage { .. })));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_a_kernel_that_would_not_fit_with_its_uimage_header() {
|
||||
// Exactly the slot size is too big once the 64-byte header is added.
|
||||
let big = zimage(&vec![0u8; 0x800000 - 64]);
|
||||
assert_eq!(big.len(), 0x800000);
|
||||
let result = ZynqPlan::from_afw(&afw(big, dtb(), b"\x1f\x8brf".to_vec()));
|
||||
assert!(matches!(result, Err(ZynqPlanError::ImageTooLarge { .. })));
|
||||
let fits = zimage(&vec![0u8; 0x800000 - 128]);
|
||||
assert!(ZynqPlan::from_afw(&afw(fits, dtb(), b"\x1f\x8brf".to_vec())).is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn refuses_a_bootloader_member() {
|
||||
let mut verified = afw(zimage(b"k"), dtb(), b"\x1f\x8brf".to_vec());
|
||||
verified.manifest.images[0].role = "bootloader".to_owned();
|
||||
assert!(matches!(
|
||||
ZynqPlan::from_afw(&verified),
|
||||
Err(ZynqPlanError::BootloaderMember(_))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wrong_board_and_arch_are_refused() {
|
||||
let mut v = afw(zimage(b"k"), dtb(), b"\x1f\x8brf".to_vec());
|
||||
v.manifest.board = "am335x".to_owned();
|
||||
assert!(matches!(
|
||||
ZynqPlan::from_afw(&v),
|
||||
Err(ZynqPlanError::WrongBoard(_))
|
||||
));
|
||||
let mut v = afw(zimage(b"k"), dtb(), b"\x1f\x8brf".to_vec());
|
||||
v.manifest.arch = "arm".to_owned();
|
||||
assert!(matches!(
|
||||
ZynqPlan::from_afw(&v),
|
||||
Err(ZynqPlanError::WrongArch(_))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_target_is_above_bootbin() {
|
||||
for (image, absolute, _slot, _fmt, _wrapped) in TARGETS {
|
||||
assert!(
|
||||
absolute >= BOOTBIN_PRESERVE,
|
||||
"{image} target below BOOT.bin"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,920 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! CV1835 install, restore and live verification over the network.
|
||||
//!
|
||||
//! Order of operations for an install: verify the bundle, preflight the board,
|
||||
//! hold the current p1 over SSH, stage the new p1, write it once, read the whole
|
||||
//! partition back, and only then reboot. Any doubt before the first write stops
|
||||
//! the sequence. A read-back mismatch stops before reboot and prints the exact
|
||||
//! restore command.
|
||||
|
||||
use crate::boards::cv1835::{Cv1835Plan, CvPlanError};
|
||||
use crate::md5::md5_hex;
|
||||
use crate::preflight::{preflight, PreflightError, PreflightOptions, PreflightReport};
|
||||
use crate::transport::{Remote, RemoteError, SshOptions, SshTransport};
|
||||
use alkane_artifacts::afw::{AfwError, VerifiedAfw};
|
||||
use sha2::{Digest, Sha256};
|
||||
use std::fs;
|
||||
use std::io::{Read, Write};
|
||||
use std::net::{TcpStream, ToSocketAddrs};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
|
||||
use thiserror::Error;
|
||||
|
||||
const REMOTE_BACKUP: &str = "/tmp/.alkane-p1-backup.img";
|
||||
const REMOTE_STAGE: &str = "/tmp/.alkane-p1-stage.img";
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum InstallError {
|
||||
#[error("preflight failed; do not write\n{0}")]
|
||||
Preflight(String),
|
||||
#[error("install and restore need --confirm FLASH")]
|
||||
Confirm,
|
||||
#[error("verified .afw: {0}")]
|
||||
Afw(#[from] AfwError),
|
||||
#[error("cv1835 plan: {0}")]
|
||||
Plan(#[from] CvPlanError),
|
||||
#[error("preflight: {0}")]
|
||||
PreflightError(#[from] PreflightError),
|
||||
#[error("remote: {0}")]
|
||||
Remote(#[from] RemoteError),
|
||||
#[error("I/O: {0}")]
|
||||
Io(#[from] std::io::Error),
|
||||
#[error("backup {0} is not the 16 MiB p1 size")]
|
||||
BackupSize(PathBuf),
|
||||
#[error("backup md5 does not match the live p1; refusing to continue")]
|
||||
BackupMismatch,
|
||||
#[error("staged image md5 does not match the verified bundle; nothing written")]
|
||||
StageMismatch,
|
||||
#[error("p1 read-back md5 mismatch; do not reboot. Restore with: {0}")]
|
||||
Readback(String),
|
||||
#[error("restore read-back md5 mismatch; the board may still hold the new image")]
|
||||
RestoreReadback,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct InstallOptions {
|
||||
pub dry_run: bool,
|
||||
pub confirm: Option<String>,
|
||||
pub no_reboot: bool,
|
||||
pub backup_dir: PathBuf,
|
||||
pub held_backup: Option<PathBuf>,
|
||||
pub allow_unknown_source: bool,
|
||||
pub check_golden: bool,
|
||||
}
|
||||
|
||||
impl Default for InstallOptions {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
dry_run: false,
|
||||
confirm: None,
|
||||
no_reboot: false,
|
||||
backup_dir: default_backup_dir(),
|
||||
held_backup: None,
|
||||
allow_unknown_source: false,
|
||||
check_golden: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct InstallReceipt {
|
||||
pub backup_path: PathBuf,
|
||||
pub backup_md5: String,
|
||||
pub backup_sha256: String,
|
||||
pub image_md5: String,
|
||||
pub rebooted: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub enum InstallOutcome {
|
||||
DryRun(Box<PreflightReport>),
|
||||
Installed(InstallReceipt),
|
||||
}
|
||||
|
||||
pub fn install(
|
||||
_afw: &VerifiedAfw,
|
||||
plan: &Cv1835Plan,
|
||||
remote: &mut dyn Remote,
|
||||
options: &InstallOptions,
|
||||
host: &str,
|
||||
) -> Result<InstallOutcome, InstallError> {
|
||||
let report = preflight(
|
||||
plan,
|
||||
remote,
|
||||
&PreflightOptions {
|
||||
host,
|
||||
held_backup: options.held_backup.as_deref(),
|
||||
check_golden: options.check_golden,
|
||||
allow_unknown_source: options.allow_unknown_source,
|
||||
},
|
||||
)?;
|
||||
if !report.ok() {
|
||||
return Err(InstallError::Preflight(report.render()));
|
||||
}
|
||||
if options.dry_run {
|
||||
return Ok(InstallOutcome::DryRun(Box::new(report)));
|
||||
}
|
||||
if options.confirm.as_deref() != Some("FLASH") {
|
||||
return Err(InstallError::Confirm);
|
||||
}
|
||||
|
||||
fs::create_dir_all(&options.backup_dir)?;
|
||||
let epoch = SystemTime::now()
|
||||
.duration_since(UNIX_EPOCH)
|
||||
.unwrap_or_default()
|
||||
.as_secs();
|
||||
let backup_path = options.backup_dir.join(format!("p1-{epoch}.img"));
|
||||
let device = &plan.partition.device;
|
||||
|
||||
// Hold the current p1 as root, then pull it over the unprivileged SSH
|
||||
// session. The daemon channel is blind, so this two-step path is required.
|
||||
let remote_backup = REMOTE_BACKUP;
|
||||
remote.root_command(
|
||||
&format!("dd if={device} of={remote_backup} bs=1M 2>&1; chmod 644 {remote_backup}"),
|
||||
Duration::from_secs(180),
|
||||
)?;
|
||||
remote.pull(remote_backup, &backup_path, Duration::from_secs(240))?;
|
||||
let _ = remote.root_command(&format!("rm -f {remote_backup}"), Duration::from_secs(15));
|
||||
let backup_data = fs::read(&backup_path)?;
|
||||
if backup_data.len() as u64 != plan.partition.size {
|
||||
return Err(InstallError::BackupSize(backup_path));
|
||||
}
|
||||
let backup_md5 = md5_hex(&backup_data);
|
||||
if report.live_md5 != "unreadable" && backup_md5 != report.live_md5 {
|
||||
return Err(InstallError::BackupMismatch);
|
||||
}
|
||||
let backup_sha256: String = Sha256::digest(&backup_data)
|
||||
.iter()
|
||||
.map(|byte| format!("{byte:02x}"))
|
||||
.collect();
|
||||
write_sidecars(
|
||||
&backup_path,
|
||||
&backup_md5,
|
||||
&backup_sha256,
|
||||
&plan.partition,
|
||||
&plan.expected_sha256,
|
||||
epoch,
|
||||
)?;
|
||||
|
||||
stage_and_write(plan, remote, &backup_path)?;
|
||||
|
||||
let rebooted = if options.no_reboot {
|
||||
false
|
||||
} else {
|
||||
remote.reboot()?;
|
||||
true
|
||||
};
|
||||
Ok(InstallOutcome::Installed(InstallReceipt {
|
||||
backup_path,
|
||||
backup_md5,
|
||||
backup_sha256,
|
||||
image_md5: plan.expected_md5.clone(),
|
||||
rebooted,
|
||||
}))
|
||||
}
|
||||
|
||||
fn stage_and_write(
|
||||
plan: &Cv1835Plan,
|
||||
remote: &mut dyn Remote,
|
||||
backup_path: &Path,
|
||||
) -> Result<(), InstallError> {
|
||||
let mut staged =
|
||||
tempfile::NamedTempFile::new_in(backup_path.parent().unwrap_or_else(|| Path::new(".")))?;
|
||||
staged.write_all(&plan.data)?;
|
||||
staged.flush()?;
|
||||
remote.push(staged.path(), REMOTE_STAGE, Duration::from_secs(240))?;
|
||||
let staged_md5 =
|
||||
remote.root_command(&format!("md5sum {REMOTE_STAGE}"), Duration::from_secs(60))?;
|
||||
let staged_md5 = String::from_utf8_lossy(&staged_md5)
|
||||
.split_whitespace()
|
||||
.next()
|
||||
.unwrap_or("")
|
||||
.to_ascii_lowercase();
|
||||
if staged_md5 != plan.expected_md5 {
|
||||
let _ = remote.root_command(&format!("rm -f {REMOTE_STAGE}"), Duration::from_secs(15));
|
||||
return Err(InstallError::StageMismatch);
|
||||
}
|
||||
|
||||
remote.root_command(
|
||||
&format!(
|
||||
"dd if={REMOTE_STAGE} of={} bs=1M conv=fsync 2>&1; sync",
|
||||
plan.partition.device
|
||||
),
|
||||
Duration::from_secs(240),
|
||||
)?;
|
||||
let readback = remote.root_command(
|
||||
&format!("md5sum {}", plan.partition.device),
|
||||
Duration::from_secs(90),
|
||||
)?;
|
||||
let readback = String::from_utf8_lossy(&readback)
|
||||
.split_whitespace()
|
||||
.next()
|
||||
.unwrap_or("")
|
||||
.to_ascii_lowercase();
|
||||
let _ = remote.root_command(&format!("rm -f {REMOTE_STAGE}"), Duration::from_secs(15));
|
||||
if readback != plan.expected_md5 {
|
||||
return Err(InstallError::Readback(restore_command(
|
||||
&plan.partition.device,
|
||||
backup_path,
|
||||
)));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct RestoreOptions {
|
||||
pub confirm: Option<String>,
|
||||
pub no_reboot: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct RestoreReceipt {
|
||||
pub backup_path: PathBuf,
|
||||
pub image_md5: String,
|
||||
pub rebooted: bool,
|
||||
}
|
||||
|
||||
pub fn restore(
|
||||
backup: &Path,
|
||||
remote: &mut dyn Remote,
|
||||
options: &RestoreOptions,
|
||||
) -> Result<RestoreReceipt, InstallError> {
|
||||
if options.confirm.as_deref() != Some("FLASH") {
|
||||
return Err(InstallError::Confirm);
|
||||
}
|
||||
let data = fs::read(backup)?;
|
||||
if data.len() != 16 * 1024 * 1024 {
|
||||
return Err(InstallError::BackupSize(backup.to_path_buf()));
|
||||
}
|
||||
let md5 = md5_hex(&data);
|
||||
let sha256: String = Sha256::digest(&data)
|
||||
.iter()
|
||||
.map(|byte| format!("{byte:02x}"))
|
||||
.collect();
|
||||
if let Some(sidecar) = read_sidecar(backup) {
|
||||
if sidecar != sha256 {
|
||||
return Err(InstallError::BackupMismatch);
|
||||
}
|
||||
}
|
||||
|
||||
let root_uid = String::from_utf8_lossy(&remote.root_command("id -u", Duration::from_secs(20))?)
|
||||
.trim()
|
||||
.to_owned();
|
||||
if root_uid != "0" {
|
||||
return Err(InstallError::Preflight(format!(
|
||||
"root channel returned uid {root_uid}"
|
||||
)));
|
||||
}
|
||||
let size = remote.user_command(
|
||||
"cat /sys/class/block/mmcblk0p1/size 2>/dev/null || true",
|
||||
Duration::from_secs(15),
|
||||
)?;
|
||||
let sectors: u64 = String::from_utf8_lossy(&size).trim().parse().unwrap_or(0);
|
||||
if sectors.saturating_mul(512) != 16 * 1024 * 1024 {
|
||||
return Err(InstallError::Preflight(
|
||||
"the board does not expose a 16 MiB /dev/mmcblk0p1".to_owned(),
|
||||
));
|
||||
}
|
||||
|
||||
let staged = tempfile::NamedTempFile::new()?;
|
||||
fs::write(staged.path(), &data)?;
|
||||
remote.push(staged.path(), REMOTE_STAGE, Duration::from_secs(240))?;
|
||||
let staged_md5 =
|
||||
remote.root_command(&format!("md5sum {REMOTE_STAGE}"), Duration::from_secs(60))?;
|
||||
let staged_md5 = String::from_utf8_lossy(&staged_md5)
|
||||
.split_whitespace()
|
||||
.next()
|
||||
.unwrap_or("")
|
||||
.to_ascii_lowercase();
|
||||
if staged_md5 != md5 {
|
||||
let _ = remote.root_command(&format!("rm -f {REMOTE_STAGE}"), Duration::from_secs(15));
|
||||
return Err(InstallError::StageMismatch);
|
||||
}
|
||||
remote.root_command(
|
||||
&format!("dd if={REMOTE_STAGE} of=/dev/mmcblk0p1 bs=1M conv=fsync 2>&1; sync"),
|
||||
Duration::from_secs(240),
|
||||
)?;
|
||||
let readback = remote.root_command("md5sum /dev/mmcblk0p1", Duration::from_secs(90))?;
|
||||
let readback = String::from_utf8_lossy(&readback)
|
||||
.split_whitespace()
|
||||
.next()
|
||||
.unwrap_or("")
|
||||
.to_ascii_lowercase();
|
||||
let _ = remote.root_command(&format!("rm -f {REMOTE_STAGE}"), Duration::from_secs(15));
|
||||
if readback != md5 {
|
||||
return Err(InstallError::RestoreReadback);
|
||||
}
|
||||
let rebooted = if options.no_reboot {
|
||||
false
|
||||
} else {
|
||||
remote.reboot()?;
|
||||
true
|
||||
};
|
||||
Ok(RestoreReceipt {
|
||||
backup_path: backup.to_path_buf(),
|
||||
image_md5: md5,
|
||||
rebooted,
|
||||
})
|
||||
}
|
||||
|
||||
fn restore_command(device: &str, backup: &Path) -> String {
|
||||
format!(
|
||||
"alkane-cli afw restore --host <ip> --held-backup {} --confirm FLASH (the held copy of {device} is at {})",
|
||||
backup.display(),
|
||||
backup.display()
|
||||
)
|
||||
}
|
||||
|
||||
fn default_backup_dir() -> PathBuf {
|
||||
alkane_core::platform::config_path("backups")
|
||||
}
|
||||
|
||||
fn write_sidecars(
|
||||
path: &Path,
|
||||
md5: &str,
|
||||
sha256: &str,
|
||||
partition: &alkane_artifacts::afw::AfwPartition,
|
||||
image_sha256: &str,
|
||||
epoch: u64,
|
||||
) -> Result<(), InstallError> {
|
||||
let file_name = path
|
||||
.file_name()
|
||||
.map(|name| name.to_string_lossy().into_owned())
|
||||
.unwrap_or_else(|| "p1.img".to_owned());
|
||||
fs::write(
|
||||
path.with_extension("img.sha256"),
|
||||
format!("{sha256} {file_name}\n"),
|
||||
)?;
|
||||
let metadata = serde_json::json!({
|
||||
"board": "cv1835",
|
||||
"partition": partition.name,
|
||||
"device": partition.device,
|
||||
"size": partition.size,
|
||||
"md5": md5,
|
||||
"sha256": sha256,
|
||||
"afw_sha256": image_sha256,
|
||||
"created_unix": epoch,
|
||||
});
|
||||
fs::write(
|
||||
path.with_extension("img.json"),
|
||||
serde_json::to_vec_pretty(&metadata).unwrap_or_default(),
|
||||
)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn read_sidecar(path: &Path) -> Option<String> {
|
||||
let text = fs::read_to_string(path.with_extension("img.sha256")).ok()?;
|
||||
text.split_whitespace().next().map(str::to_owned)
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct LiveReport {
|
||||
pub attempts: u32,
|
||||
pub http: String,
|
||||
pub http_ok: bool,
|
||||
pub ssh: String,
|
||||
pub ssh_ok: bool,
|
||||
pub api: String,
|
||||
pub api_ok: bool,
|
||||
}
|
||||
|
||||
impl LiveReport {
|
||||
pub fn ok(&self) -> bool {
|
||||
self.http_ok && self.ssh_ok && self.api_ok
|
||||
}
|
||||
|
||||
pub fn render(&self) -> String {
|
||||
format!(
|
||||
"verify-live attempts {}\n http {}: {}\n ssh {}: {}\n api {}: {}\nresult {}",
|
||||
self.attempts,
|
||||
if self.http_ok { "ok" } else { "FAIL" },
|
||||
self.http,
|
||||
if self.ssh_ok { "ok" } else { "FAIL" },
|
||||
self.ssh,
|
||||
if self.api_ok { "ok" } else { "FAIL" },
|
||||
self.api,
|
||||
if self.ok() { "PASS" } else { "FAIL" }
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn verify_live(
|
||||
host: &str,
|
||||
marker: &str,
|
||||
kernel_version: &str,
|
||||
timeout: Duration,
|
||||
ssh_options: &SshOptions,
|
||||
) -> LiveReport {
|
||||
let deadline = Instant::now() + timeout;
|
||||
let mut attempts = 0;
|
||||
loop {
|
||||
attempts += 1;
|
||||
let (http, http_ok) = match http_get(host, "/", Duration::from_secs(5)) {
|
||||
Ok(body) => {
|
||||
let ok = body.contains(marker);
|
||||
(
|
||||
if ok {
|
||||
format!("marker {marker} present")
|
||||
} else {
|
||||
format!("marker {marker} absent ({} bytes)", body.len())
|
||||
},
|
||||
ok,
|
||||
)
|
||||
}
|
||||
Err(error) => (error, false),
|
||||
};
|
||||
let (ssh, ssh_ok) = match SshTransport::connect(ssh_options.clone(), false) {
|
||||
Ok(mut session) => match session.user_command("uname -r", Duration::from_secs(15)) {
|
||||
Ok(output) => {
|
||||
let kernel = String::from_utf8_lossy(&output).trim().to_owned();
|
||||
let ok = !kernel.is_empty()
|
||||
&& (kernel_version.is_empty() || kernel.contains(kernel_version));
|
||||
(
|
||||
format!(
|
||||
"kernel {kernel}{}",
|
||||
if ok {
|
||||
""
|
||||
} else {
|
||||
" (expected the installed kernel)"
|
||||
}
|
||||
),
|
||||
ok,
|
||||
)
|
||||
}
|
||||
Err(error) => (format!("{error}"), false),
|
||||
},
|
||||
Err(error) => (format!("{error}"), false),
|
||||
};
|
||||
let (api, api_ok) = match api_version(host, Duration::from_secs(5)) {
|
||||
Ok(body) => {
|
||||
let ok = body.contains("\"STATUS\"")
|
||||
|| body.contains("\"VERSION\"")
|
||||
|| body.to_lowercase().contains("version");
|
||||
(format!("{} bytes", body.len()), ok)
|
||||
}
|
||||
Err(error) => (error, false),
|
||||
};
|
||||
if http_ok && ssh_ok && api_ok {
|
||||
return LiveReport {
|
||||
attempts,
|
||||
http,
|
||||
http_ok,
|
||||
ssh,
|
||||
ssh_ok,
|
||||
api,
|
||||
api_ok,
|
||||
};
|
||||
}
|
||||
if Instant::now() >= deadline {
|
||||
return LiveReport {
|
||||
attempts,
|
||||
http,
|
||||
http_ok,
|
||||
ssh,
|
||||
ssh_ok,
|
||||
api,
|
||||
api_ok,
|
||||
};
|
||||
}
|
||||
std::thread::sleep(Duration::from_secs(5));
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn http_get(host: &str, path: &str, timeout: Duration) -> Result<String, String> {
|
||||
let address = (host, 80_u16)
|
||||
.to_socket_addrs()
|
||||
.map_err(|error| format!("resolve: {error}"))?
|
||||
.next()
|
||||
.ok_or_else(|| "no address".to_owned())?;
|
||||
let mut stream = TcpStream::connect_timeout(&address, timeout)
|
||||
.map_err(|error| format!("connect: {error}"))?;
|
||||
stream
|
||||
.set_read_timeout(Some(timeout))
|
||||
.map_err(|error| error.to_string())?;
|
||||
let request = format!("GET {path} HTTP/1.0\r\nHost: {host}\r\nConnection: close\r\n\r\n");
|
||||
stream
|
||||
.write_all(request.as_bytes())
|
||||
.map_err(|error| error.to_string())?;
|
||||
let mut data = Vec::new();
|
||||
let mut buffer = [0_u8; 8192];
|
||||
loop {
|
||||
match stream.read(&mut buffer) {
|
||||
Ok(0) => break,
|
||||
Ok(read) => {
|
||||
data.extend_from_slice(&buffer[..read]);
|
||||
if data.len() > 512 * 1024 {
|
||||
break;
|
||||
}
|
||||
}
|
||||
Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => break,
|
||||
Err(error) if error.kind() == std::io::ErrorKind::TimedOut => break,
|
||||
Err(error) => return Err(error.to_string()),
|
||||
}
|
||||
}
|
||||
let text = String::from_utf8_lossy(&data).into_owned();
|
||||
let status_ok = text
|
||||
.lines()
|
||||
.next()
|
||||
.map(|line| line.contains(" 200 ") || line.ends_with(" 200"))
|
||||
.unwrap_or(false);
|
||||
if status_ok {
|
||||
Ok(text)
|
||||
} else {
|
||||
Err(text.lines().next().unwrap_or("no HTTP response").to_owned())
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn api_version(host: &str, timeout: Duration) -> Result<String, String> {
|
||||
let address = (host, 4028_u16)
|
||||
.to_socket_addrs()
|
||||
.map_err(|error| format!("resolve: {error}"))?
|
||||
.next()
|
||||
.ok_or_else(|| "no address".to_owned())?;
|
||||
let mut stream = TcpStream::connect_timeout(&address, timeout)
|
||||
.map_err(|error| format!("connect: {error}"))?;
|
||||
stream
|
||||
.set_read_timeout(Some(timeout))
|
||||
.map_err(|error| error.to_string())?;
|
||||
stream
|
||||
.write_all(b"{\"command\":\"version\"}\n")
|
||||
.map_err(|error| error.to_string())?;
|
||||
let mut data = Vec::new();
|
||||
let mut buffer = [0_u8; 4096];
|
||||
loop {
|
||||
match stream.read(&mut buffer) {
|
||||
Ok(0) => break,
|
||||
Ok(read) => {
|
||||
data.extend_from_slice(&buffer[..read]);
|
||||
if data.len() > 64 * 1024 {
|
||||
break;
|
||||
}
|
||||
}
|
||||
Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => break,
|
||||
Err(error) if error.kind() == std::io::ErrorKind::TimedOut => break,
|
||||
Err(error) => return Err(error.to_string()),
|
||||
}
|
||||
}
|
||||
let text = String::from_utf8_lossy(&data).trim().to_owned();
|
||||
if text.is_empty() {
|
||||
Err("no API response".to_owned())
|
||||
} else {
|
||||
Ok(text)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn derives_backup_sidecar_names() {
|
||||
let path = Path::new("/tmp/p1-1.img");
|
||||
assert_eq!(
|
||||
path.with_extension("img.sha256"),
|
||||
Path::new("/tmp/p1-1.img.sha256")
|
||||
);
|
||||
assert_eq!(
|
||||
path.with_extension("img.json"),
|
||||
Path::new("/tmp/p1-1.img.json")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn restore_command_names_the_held_copy() {
|
||||
let command = restore_command("/dev/mmcblk0p1", Path::new("/tmp/p1.img"));
|
||||
assert!(command.contains("afw restore"));
|
||||
assert!(command.contains("/tmp/p1.img"));
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod network_tests {
|
||||
use super::*;
|
||||
use alkane_artifacts::afw::{AfwImage, AfwManifest, AfwMember, AfwPartition, BootloaderPolicy};
|
||||
use serde_json::json;
|
||||
use std::collections::HashMap;
|
||||
|
||||
const P1: usize = 16 * 1024 * 1024;
|
||||
const REV: &str = "0000000000000000000000000000000000000000";
|
||||
|
||||
struct MockRemote {
|
||||
partition: Vec<u8>,
|
||||
files: HashMap<String, Vec<u8>>,
|
||||
commands: Vec<String>,
|
||||
rebooted: bool,
|
||||
readback_corrupt: bool,
|
||||
}
|
||||
|
||||
impl MockRemote {
|
||||
fn new(partition: Vec<u8>) -> Self {
|
||||
Self {
|
||||
partition,
|
||||
files: HashMap::new(),
|
||||
commands: Vec::new(),
|
||||
rebooted: false,
|
||||
readback_corrupt: false,
|
||||
}
|
||||
}
|
||||
|
||||
fn md5(&self, data: &[u8]) -> String {
|
||||
md5_hex(data)
|
||||
}
|
||||
}
|
||||
|
||||
impl Remote for MockRemote {
|
||||
fn channel(&self) -> &str {
|
||||
"mock"
|
||||
}
|
||||
|
||||
fn root_method(&self) -> &'static str {
|
||||
"direct"
|
||||
}
|
||||
|
||||
fn user_command(
|
||||
&mut self,
|
||||
command: &str,
|
||||
_timeout: Duration,
|
||||
) -> Result<Vec<u8>, RemoteError> {
|
||||
self.commands.push(command.to_owned());
|
||||
let text = if command.contains("uname -r") {
|
||||
"6.18.48\n__MODEL__\nAlkane CV1835\n__RELEASE__\nalkane\n".to_owned()
|
||||
} else if command.contains("test -b") {
|
||||
"block".to_owned()
|
||||
} else if command.contains("/sys/class/block/mmcblk0p1/size") {
|
||||
"32768".to_owned()
|
||||
} else if command.contains("for c in dd") {
|
||||
"dd\nmd5sum\nsync\n".to_owned()
|
||||
} else if command.contains("df -k") {
|
||||
"Filesystem 1K-blocks Used Available Use% Mounted on\n/dev/root 100000 1 90000 1% /tmp\n".to_owned()
|
||||
} else if command.contains("mmcblk0boot0") {
|
||||
"yes".to_owned()
|
||||
} else {
|
||||
String::new()
|
||||
};
|
||||
Ok(text.into_bytes())
|
||||
}
|
||||
|
||||
fn root_command(
|
||||
&mut self,
|
||||
command: &str,
|
||||
_timeout: Duration,
|
||||
) -> Result<Vec<u8>, RemoteError> {
|
||||
self.commands.push(command.to_owned());
|
||||
if command.starts_with("id -u") || command == "id" {
|
||||
return Ok(b"0\n".to_vec());
|
||||
}
|
||||
if let Some(rest) = command.strip_prefix("md5sum /dev/mmcblk0p1") {
|
||||
let _ = rest;
|
||||
let mut data = self.partition.clone();
|
||||
if self.readback_corrupt && self.files.contains_key(REMOTE_STAGE) {
|
||||
if let Some(last) = data.last_mut() {
|
||||
*last ^= 0xff;
|
||||
}
|
||||
self.readback_corrupt = false;
|
||||
}
|
||||
return Ok(format!("{} /dev/mmcblk0p1\n", self.md5(&data)).into_bytes());
|
||||
}
|
||||
if let Some(rest) = command.strip_prefix("md5sum ") {
|
||||
let path = rest.split_whitespace().next().unwrap_or("");
|
||||
let data = self.files.get(path).cloned().unwrap_or_default();
|
||||
return Ok(format!("{} {path}\n", self.md5(&data)).into_bytes());
|
||||
}
|
||||
if let Some(rest) = command.strip_prefix("dd if=") {
|
||||
let mut parts = rest.splitn(2, " of=");
|
||||
let source = parts.next().unwrap_or("");
|
||||
let target = parts
|
||||
.next()
|
||||
.unwrap_or("")
|
||||
.split_whitespace()
|
||||
.next()
|
||||
.unwrap_or("");
|
||||
if source == "/dev/mmcblk0p1" {
|
||||
self.files.insert(target.to_owned(), self.partition.clone());
|
||||
} else if target == "/dev/mmcblk0p1" {
|
||||
if let Some(data) = self.files.get(source).cloned() {
|
||||
self.partition = data;
|
||||
}
|
||||
}
|
||||
return Ok(Vec::new());
|
||||
}
|
||||
if command.starts_with("rm -f ") {
|
||||
let path = command.trim_start_matches("rm -f ").trim();
|
||||
self.files.remove(path);
|
||||
return Ok(Vec::new());
|
||||
}
|
||||
Ok(Vec::new())
|
||||
}
|
||||
|
||||
fn push(
|
||||
&mut self,
|
||||
local: &Path,
|
||||
remote: &str,
|
||||
_timeout: Duration,
|
||||
) -> Result<(), RemoteError> {
|
||||
self.files.insert(remote.to_owned(), fs::read(local)?);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn pull(
|
||||
&mut self,
|
||||
remote: &str,
|
||||
local: &Path,
|
||||
_timeout: Duration,
|
||||
) -> Result<(), RemoteError> {
|
||||
let data = self
|
||||
.files
|
||||
.get(remote)
|
||||
.cloned()
|
||||
.ok_or_else(|| RemoteError::Daemon("missing file".to_owned()))?;
|
||||
fs::write(local, data)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn reboot(&mut self) -> Result<(), RemoteError> {
|
||||
self.rebooted = true;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn p1_image() -> Vec<u8> {
|
||||
let mut fit = vec![0_u8; P1];
|
||||
fit[..4].copy_from_slice(b"\xd0\x0d\xfe\xed");
|
||||
let marker = b"config@cv1835_miner_emmc";
|
||||
fit[0x100..0x100 + marker.len()].copy_from_slice(marker);
|
||||
fit
|
||||
}
|
||||
|
||||
fn verified(data: &[u8]) -> VerifiedAfw {
|
||||
let manifest = AfwManifest {
|
||||
schema: 2,
|
||||
format: "afw".to_owned(),
|
||||
board: "cv1835".to_owned(),
|
||||
arch: "arm64".to_owned(),
|
||||
version: "0.1.0".to_owned(),
|
||||
build_date: "2026-11-04T00:00:00Z".to_owned(),
|
||||
sdk_revision: REV.to_owned(),
|
||||
os_revision: REV.to_owned(),
|
||||
payload_type: "os".to_owned(),
|
||||
bootloader_policy: BootloaderPolicy::Preserve,
|
||||
signature: alkane_artifacts::afw::AfwSignature {
|
||||
kind: "unsigned".to_owned(),
|
||||
member: None,
|
||||
public_key_hex: None,
|
||||
},
|
||||
partitions: vec![
|
||||
AfwPartition {
|
||||
name: "p1".to_owned(),
|
||||
device: "/dev/mmcblk0p1".to_owned(),
|
||||
offset: 0,
|
||||
size: P1 as u64,
|
||||
secure: false,
|
||||
boot_critical: true,
|
||||
write_order: 1,
|
||||
image: Some("p1".to_owned()),
|
||||
},
|
||||
AfwPartition {
|
||||
name: "boot0".to_owned(),
|
||||
device: "/dev/mmcblk0boot0".to_owned(),
|
||||
offset: 0,
|
||||
size: 4 * 1024 * 1024,
|
||||
secure: true,
|
||||
boot_critical: true,
|
||||
write_order: 0,
|
||||
image: None,
|
||||
},
|
||||
],
|
||||
images: vec![AfwImage {
|
||||
name: "p1".to_owned(),
|
||||
file: "payload/p1.fit".to_owned(),
|
||||
role: "boot".to_owned(),
|
||||
format: "fit".to_owned(),
|
||||
size: P1 as u64,
|
||||
sha256: Sha256::digest(data)
|
||||
.iter()
|
||||
.map(|byte| format!("{byte:02x}"))
|
||||
.collect(),
|
||||
partition: Some("p1".to_owned()),
|
||||
install: true,
|
||||
}],
|
||||
boot_switch: json!({"method": "partition-overwrite"}),
|
||||
preflight: json!({"required_commands": ["dd", "md5sum", "sync"],
|
||||
"source_os": ["stock-bitmain", "vnish", "braiins", "ouros", "alkane"],
|
||||
"min_free_bytes": 33554432}),
|
||||
recovery: json!({"network": "afw restore", "golden_lba_bytes": 0x300000u64 * 512}),
|
||||
marker: "Alkane".to_owned(),
|
||||
kernel_version: "6.18.48".to_owned(),
|
||||
notes: None,
|
||||
};
|
||||
VerifiedAfw {
|
||||
manifest,
|
||||
members: vec![AfwMember {
|
||||
name: "payload/p1.fit".to_owned(),
|
||||
data: data.to_vec(),
|
||||
}],
|
||||
manifest_sha256: "0".repeat(64),
|
||||
archive_sha256: "0".repeat(64),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn installs_p1_holds_a_backup_and_verifies_before_reboot() {
|
||||
let original = vec![0x11_u8; P1];
|
||||
let new = p1_image();
|
||||
let afw = verified(&new);
|
||||
let plan = Cv1835Plan::from_afw(&afw).unwrap();
|
||||
let mut remote = MockRemote::new(original.clone());
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let options = InstallOptions {
|
||||
dry_run: false,
|
||||
confirm: Some("FLASH".to_owned()),
|
||||
no_reboot: true,
|
||||
backup_dir: temp.path().to_path_buf(),
|
||||
held_backup: None,
|
||||
allow_unknown_source: true,
|
||||
check_golden: false,
|
||||
};
|
||||
let outcome = install(&afw, &plan, &mut remote, &options, "10.255.1.1").unwrap();
|
||||
let InstallOutcome::Installed(receipt) = outcome else {
|
||||
panic!("expected an install");
|
||||
};
|
||||
assert_eq!(remote.partition, new);
|
||||
assert_eq!(receipt.backup_md5, md5_hex(&original));
|
||||
assert!(receipt.backup_path.is_file());
|
||||
assert!(!remote.rebooted);
|
||||
assert!(remote
|
||||
.commands
|
||||
.iter()
|
||||
.any(|command| command.starts_with("dd if=/tmp/.alkane-p1-stage.img")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dry_run_never_writes_the_partition() {
|
||||
let original = vec![0x22_u8; P1];
|
||||
let new = p1_image();
|
||||
let afw = verified(&new);
|
||||
let plan = Cv1835Plan::from_afw(&afw).unwrap();
|
||||
let mut remote = MockRemote::new(original.clone());
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let options = InstallOptions {
|
||||
dry_run: true,
|
||||
confirm: None,
|
||||
no_reboot: false,
|
||||
backup_dir: temp.path().to_path_buf(),
|
||||
held_backup: None,
|
||||
allow_unknown_source: true,
|
||||
check_golden: false,
|
||||
};
|
||||
let outcome = install(&afw, &plan, &mut remote, &options, "10.255.1.1").unwrap();
|
||||
assert!(matches!(outcome, InstallOutcome::DryRun(_)));
|
||||
assert_eq!(remote.partition, original);
|
||||
assert!(!remote
|
||||
.commands
|
||||
.iter()
|
||||
.any(|command| command.starts_with("dd if=/tmp/.alkane-p1-stage.img")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_readback_mismatch_stops_before_reboot() {
|
||||
let original = vec![0x33_u8; P1];
|
||||
let new = p1_image();
|
||||
let afw = verified(&new);
|
||||
let plan = Cv1835Plan::from_afw(&afw).unwrap();
|
||||
let mut remote = MockRemote::new(original);
|
||||
remote.readback_corrupt = true;
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let options = InstallOptions {
|
||||
dry_run: false,
|
||||
confirm: Some("FLASH".to_owned()),
|
||||
no_reboot: false,
|
||||
backup_dir: temp.path().to_path_buf(),
|
||||
held_backup: None,
|
||||
allow_unknown_source: true,
|
||||
check_golden: false,
|
||||
};
|
||||
let result = install(&afw, &plan, &mut remote, &options, "10.255.1.1");
|
||||
assert!(matches!(result, Err(InstallError::Readback(_))));
|
||||
assert!(!remote.rebooted);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn confirm_is_required_before_any_device_write() {
|
||||
let original = vec![0x44_u8; P1];
|
||||
let new = p1_image();
|
||||
let afw = verified(&new);
|
||||
let plan = Cv1835Plan::from_afw(&afw).unwrap();
|
||||
let mut remote = MockRemote::new(original.clone());
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let options = InstallOptions {
|
||||
dry_run: false,
|
||||
confirm: None,
|
||||
no_reboot: false,
|
||||
backup_dir: temp.path().to_path_buf(),
|
||||
held_backup: None,
|
||||
allow_unknown_source: true,
|
||||
check_golden: false,
|
||||
};
|
||||
let result = install(&afw, &plan, &mut remote, &options, "10.255.1.1");
|
||||
assert!(matches!(result, Err(InstallError::Confirm)));
|
||||
assert_eq!(remote.partition, original);
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,40 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Guarded write sequence for a verified artifact and an SDK partition plan.
|
||||
//! Board transport adapters must supply serial, recovery and readback evidence.
|
||||
//! Guarded writes plus the network-only CV1835 installer.
|
||||
//!
|
||||
//! The original guarded-write helpers remain for boards that need an attached
|
||||
//! recovery channel. CV1835 uses the network modules below: a verified `.afw`,
|
||||
//! a board plan, an SSH transport with a stock-root stage, a read-only
|
||||
//! preflight, a whole-partition read-back and a network restore.
|
||||
|
||||
// The board modules are driven by static NAND/partition map tables (tuples) and
|
||||
// multi-field hardware write functions; the two style lints below are design
|
||||
// choices for this crate rather than defects.
|
||||
#![allow(clippy::type_complexity, clippy::too_many_arguments)]
|
||||
|
||||
pub mod aml_ubi;
|
||||
pub mod boards;
|
||||
pub mod install;
|
||||
pub mod md5;
|
||||
pub mod preflight;
|
||||
pub mod stock;
|
||||
pub mod stock_firmware;
|
||||
pub mod uimage;
|
||||
pub mod zynq_nand;
|
||||
// Network-only stock-crossing method bodies compiled into the toolkit; the
|
||||
// public interface lives in `stock`. See stock_method.rs. This module is
|
||||
// maintained as a self-contained unit; the style lints below are allowed here so
|
||||
// its internal layout is not churned to satisfy them.
|
||||
#[allow(
|
||||
clippy::needless_range_loop,
|
||||
clippy::type_complexity,
|
||||
clippy::too_many_arguments,
|
||||
clippy::manual_repeat_n,
|
||||
clippy::manual_is_multiple_of,
|
||||
clippy::unnecessary_map_or,
|
||||
clippy::question_mark
|
||||
)]
|
||||
mod stock_method;
|
||||
pub mod transport;
|
||||
|
||||
use alkane_artifacts::VerifiedArtifact;
|
||||
use sha2::{Digest, Sha256};
|
||||
|
||||
@@ -0,0 +1,116 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! MD5 for the CV1835 whole-partition read-back.
|
||||
//!
|
||||
//! The stock busybox on this board ships `md5sum` but not `sha256sum`, and the
|
||||
//! proven installer gates the write on a whole-partition md5. This module is a
|
||||
//! small RFC 1321 implementation so the host can compare the same digest
|
||||
//! without shelling out to a tool that may not exist.
|
||||
|
||||
const S: [u32; 64] = [
|
||||
7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9,
|
||||
14, 20, 5, 9, 14, 20, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 6, 10, 15,
|
||||
21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21,
|
||||
];
|
||||
|
||||
const K: [u32; 64] = [
|
||||
0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
|
||||
0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
|
||||
0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
|
||||
0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
|
||||
0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
|
||||
0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
|
||||
0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
|
||||
0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
|
||||
];
|
||||
|
||||
pub fn md5(data: &[u8]) -> [u8; 16] {
|
||||
let mut state = [0x67452301_u32, 0xefcdab89, 0x98badcfe, 0x10325476];
|
||||
let bit_length = (data.len() as u64).wrapping_mul(8);
|
||||
let mut message = data.to_vec();
|
||||
message.push(0x80);
|
||||
while message.len() % 64 != 56 {
|
||||
message.push(0);
|
||||
}
|
||||
message.extend_from_slice(&bit_length.to_le_bytes());
|
||||
|
||||
for chunk in message.chunks_exact(64) {
|
||||
let mut words = [0_u32; 16];
|
||||
for (index, word) in words.iter_mut().enumerate() {
|
||||
let start = index * 4;
|
||||
*word = u32::from_le_bytes([
|
||||
chunk[start],
|
||||
chunk[start + 1],
|
||||
chunk[start + 2],
|
||||
chunk[start + 3],
|
||||
]);
|
||||
}
|
||||
let [mut a, mut b, mut c, mut d] = state;
|
||||
for index in 0..64 {
|
||||
let (f, g) = match index {
|
||||
0..=15 => ((b & c) | (!b & d), index),
|
||||
16..=31 => ((d & b) | (!d & c), (5 * index + 1) % 16),
|
||||
32..=47 => (b ^ c ^ d, (3 * index + 5) % 16),
|
||||
_ => (c ^ (b | !d), (7 * index) % 16),
|
||||
};
|
||||
let rotated = a
|
||||
.wrapping_add(f)
|
||||
.wrapping_add(K[index])
|
||||
.wrapping_add(words[g])
|
||||
.rotate_left(S[index]);
|
||||
a = d;
|
||||
d = c;
|
||||
c = b;
|
||||
b = b.wrapping_add(rotated);
|
||||
}
|
||||
state[0] = state[0].wrapping_add(a);
|
||||
state[1] = state[1].wrapping_add(b);
|
||||
state[2] = state[2].wrapping_add(c);
|
||||
state[3] = state[3].wrapping_add(d);
|
||||
}
|
||||
|
||||
let mut digest = [0_u8; 16];
|
||||
for (index, word) in state.iter().enumerate() {
|
||||
digest[index * 4..index * 4 + 4].copy_from_slice(&word.to_le_bytes());
|
||||
}
|
||||
digest
|
||||
}
|
||||
|
||||
pub fn md5_hex(data: &[u8]) -> String {
|
||||
md5(data).iter().map(|byte| format!("{byte:02x}")).collect()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn rfc1321_vectors() {
|
||||
assert_eq!(md5_hex(b""), "d41d8cd98f00b204e9800998ecf8427e");
|
||||
assert_eq!(md5_hex(b"a"), "0cc175b9c0f1b6a831c399e269772661");
|
||||
assert_eq!(md5_hex(b"abc"), "900150983cd24fb0d6963f7d28e17f72");
|
||||
assert_eq!(
|
||||
md5_hex(b"message digest"),
|
||||
"f96b697d7cb7938d525a2f31aaf161d0"
|
||||
);
|
||||
assert_eq!(
|
||||
md5_hex(b"abcdefghijklmnopqrstuvwxyz"),
|
||||
"c3fcd3d76192e4007dfb496cca67e13b"
|
||||
);
|
||||
assert_eq!(
|
||||
md5_hex(b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"),
|
||||
"d174ab98d277d9f5a5611c2c9f419d9f"
|
||||
);
|
||||
assert_eq!(
|
||||
md5_hex(
|
||||
b"12345678901234567890123456789012345678901234567890123456789012345678901234567890"
|
||||
),
|
||||
"57edf4a22be3c955ac49da2e2107b67a"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn handles_a_block_boundary() {
|
||||
let data = vec![0x42_u8; 64];
|
||||
assert_eq!(md5_hex(&data), "8e558437ffca99de04c18a63b55a4fad");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,420 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Read-only CV1835 preflight: source-OS fingerprint, root channel, partition
|
||||
//! identity, held/golden backup hashes, free space and secure-region refusal.
|
||||
//!
|
||||
//! Every check runs over the network. A failure is reported, never repaired.
|
||||
|
||||
use crate::boards::cv1835::{Cv1835Plan, CvPlanError};
|
||||
use crate::md5::md5_hex;
|
||||
use crate::transport::{Remote, RemoteError};
|
||||
use sha2::{Digest, Sha256};
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::time::Duration;
|
||||
use thiserror::Error;
|
||||
|
||||
const P1_NAME: &str = "mmcblk0p1";
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum PreflightError {
|
||||
#[error("preflight transport: {0}")]
|
||||
Remote(#[from] RemoteError),
|
||||
#[error("preflight I/O: {0}")]
|
||||
Io(#[from] std::io::Error),
|
||||
#[error("preflight plan: {0}")]
|
||||
Plan(#[from] CvPlanError),
|
||||
#[error("held backup {path} is {size} bytes, not 16 MiB")]
|
||||
BackupSize { path: PathBuf, size: u64 },
|
||||
#[error("held backup {0} has no readable md5")]
|
||||
BackupUnreadable(PathBuf),
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Check {
|
||||
pub name: &'static str,
|
||||
pub ok: bool,
|
||||
pub detail: String,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct BackupCheck {
|
||||
pub path: PathBuf,
|
||||
pub md5: String,
|
||||
pub sha256: String,
|
||||
pub matches_live: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct PreflightReport {
|
||||
pub host: String,
|
||||
pub source_os: String,
|
||||
pub kernel: String,
|
||||
pub model: String,
|
||||
pub root_method: String,
|
||||
pub root_uid: String,
|
||||
pub partition_device: String,
|
||||
pub partition_size: u64,
|
||||
pub live_md5: String,
|
||||
pub held_backup: Option<BackupCheck>,
|
||||
pub golden_md5: Option<String>,
|
||||
pub free_bytes: u64,
|
||||
pub boot0_present: bool,
|
||||
pub checks: Vec<Check>,
|
||||
}
|
||||
|
||||
impl PreflightReport {
|
||||
pub fn ok(&self) -> bool {
|
||||
self.checks.iter().all(|check| check.ok)
|
||||
}
|
||||
|
||||
pub fn failures(&self) -> Vec<&Check> {
|
||||
self.checks.iter().filter(|check| !check.ok).collect()
|
||||
}
|
||||
|
||||
pub fn render(&self) -> String {
|
||||
let mut out = String::new();
|
||||
out.push_str(&format!("preflight {}\n", self.host));
|
||||
out.push_str(&format!(
|
||||
"source-os {} (kernel {})\n",
|
||||
self.source_os, self.kernel
|
||||
));
|
||||
if !self.model.is_empty() {
|
||||
out.push_str(&format!("model {}\n", self.model));
|
||||
}
|
||||
out.push_str(&format!(
|
||||
"root {} (uid {})\n",
|
||||
self.root_method, self.root_uid
|
||||
));
|
||||
out.push_str(&format!(
|
||||
"partition {} {} B\n",
|
||||
self.partition_device, self.partition_size
|
||||
));
|
||||
out.push_str(&format!("live p1 md5 {}\n", self.live_md5));
|
||||
match &self.held_backup {
|
||||
Some(backup) => out.push_str(&format!(
|
||||
"held backup {} md5 {} ({})\n",
|
||||
backup.path.display(),
|
||||
backup.md5,
|
||||
if backup.matches_live {
|
||||
"matches live p1"
|
||||
} else {
|
||||
"differs from live p1"
|
||||
}
|
||||
)),
|
||||
None => out.push_str("held backup none (install will create one before writing)\n"),
|
||||
}
|
||||
if let Some(golden) = &self.golden_md5 {
|
||||
out.push_str(&format!("golden raw p1 md5 {golden}\n"));
|
||||
}
|
||||
out.push_str(&format!(
|
||||
"free tmp {} MiB\n",
|
||||
self.free_bytes / (1024 * 1024)
|
||||
));
|
||||
out.push_str(&format!(
|
||||
"boot0 {} (never written)\n",
|
||||
if self.boot0_present {
|
||||
"present"
|
||||
} else {
|
||||
"not present"
|
||||
}
|
||||
));
|
||||
for check in &self.checks {
|
||||
out.push_str(&format!(
|
||||
"check {} {}: {}\n",
|
||||
check.name,
|
||||
if check.ok { "ok" } else { "FAIL" },
|
||||
check.detail
|
||||
));
|
||||
}
|
||||
out.push_str(if self.ok() {
|
||||
"result PASS\n"
|
||||
} else {
|
||||
"result FAIL (do not write)\n"
|
||||
});
|
||||
out
|
||||
}
|
||||
}
|
||||
|
||||
pub struct PreflightOptions<'a> {
|
||||
pub host: &'a str,
|
||||
pub held_backup: Option<&'a Path>,
|
||||
pub check_golden: bool,
|
||||
pub allow_unknown_source: bool,
|
||||
}
|
||||
|
||||
pub fn preflight(
|
||||
plan: &Cv1835Plan,
|
||||
remote: &mut dyn Remote,
|
||||
options: &PreflightOptions<'_>,
|
||||
) -> Result<PreflightReport, PreflightError> {
|
||||
let mut checks = Vec::new();
|
||||
let fingerprint = remote.user_command(
|
||||
"uname -r; echo __MODEL__; cat /proc/device-tree/model 2>/dev/null; echo; \
|
||||
echo __RELEASE__; cat /etc/os-release 2>/dev/null; \
|
||||
ls /etc/bos_version /etc/fw-info /etc/alkane-release /etc/ouros-release 2>/dev/null; \
|
||||
test -x /nvdata/rroot && echo rroot; \
|
||||
test -x /usr/sbin/update-daemon && echo update-daemon",
|
||||
Duration::from_secs(20),
|
||||
)?;
|
||||
let text = String::from_utf8_lossy(&fingerprint).into_owned();
|
||||
let mut sections = text.split("__MODEL__");
|
||||
let kernel = sections.next().unwrap_or("").trim().to_owned();
|
||||
let rest = sections.next().unwrap_or("");
|
||||
let mut sections = rest.split("__RELEASE__");
|
||||
let model = sections.next().unwrap_or("").trim().to_owned();
|
||||
let release = sections.next().unwrap_or("");
|
||||
let source_os = classify(&kernel, release, &text);
|
||||
let source_ok = plan.source_os.is_empty()
|
||||
|| plan.source_os.iter().any(|item| item == &source_os)
|
||||
|| options.allow_unknown_source;
|
||||
checks.push(Check {
|
||||
name: "source-os",
|
||||
ok: source_ok,
|
||||
detail: format!(
|
||||
"{source_os} (allowed: {})",
|
||||
if plan.source_os.is_empty() {
|
||||
"any".to_owned()
|
||||
} else {
|
||||
plan.source_os.join(", ")
|
||||
}
|
||||
),
|
||||
});
|
||||
|
||||
let root_uid = String::from_utf8_lossy(&remote.root_command("id -u", Duration::from_secs(20))?)
|
||||
.trim()
|
||||
.to_owned();
|
||||
checks.push(Check {
|
||||
name: "root",
|
||||
ok: root_uid == "0",
|
||||
detail: format!("uid {root_uid}"),
|
||||
});
|
||||
|
||||
let partition_device = plan.partition.device.clone();
|
||||
let block = String::from_utf8_lossy(&remote.user_command(
|
||||
&format!("test -b {partition_device} && echo block || echo missing"),
|
||||
Duration::from_secs(15),
|
||||
)?)
|
||||
.trim()
|
||||
.to_owned();
|
||||
let size_out = remote.user_command(
|
||||
&format!("cat /sys/class/block/{P1_NAME}/size 2>/dev/null || true"),
|
||||
Duration::from_secs(15),
|
||||
)?;
|
||||
let sectors: u64 = String::from_utf8_lossy(&size_out)
|
||||
.trim()
|
||||
.parse()
|
||||
.unwrap_or(0);
|
||||
let partition_size = sectors.saturating_mul(512);
|
||||
checks.push(Check {
|
||||
name: "partition",
|
||||
ok: block == "block" && partition_size == plan.partition.size,
|
||||
detail: format!(
|
||||
"{partition_device} {partition_size} B (plan {} B)",
|
||||
plan.partition.size
|
||||
),
|
||||
});
|
||||
|
||||
let live = remote.root_command(
|
||||
&format!("md5sum {partition_device}"),
|
||||
Duration::from_secs(60),
|
||||
)?;
|
||||
let live_md5 = parse_digest(&live, 32).unwrap_or_else(|| "unreadable".to_owned());
|
||||
checks.push(Check {
|
||||
name: "live-p1-md5",
|
||||
ok: live_md5.len() == 32,
|
||||
detail: live_md5.clone(),
|
||||
});
|
||||
|
||||
let commands = remote.user_command(
|
||||
"for c in dd md5sum sync; do command -v $c >/dev/null 2>&1 && echo $c || echo missing:$c; done",
|
||||
Duration::from_secs(15),
|
||||
)?;
|
||||
let commands_text = String::from_utf8_lossy(&commands).into_owned();
|
||||
let missing: Vec<&str> = commands_text
|
||||
.lines()
|
||||
.filter_map(|line| line.strip_prefix("missing:"))
|
||||
.collect();
|
||||
checks.push(Check {
|
||||
name: "commands",
|
||||
ok: missing.is_empty(),
|
||||
detail: if missing.is_empty() {
|
||||
"dd, md5sum, sync present".to_owned()
|
||||
} else {
|
||||
format!("missing {}", missing.join(", "))
|
||||
},
|
||||
});
|
||||
|
||||
let free_bytes = free_bytes(remote)?;
|
||||
checks.push(Check {
|
||||
name: "free-space",
|
||||
ok: free_bytes >= plan.min_free_bytes,
|
||||
detail: format!(
|
||||
"{} MiB at /tmp (plan {} MiB)",
|
||||
free_bytes / (1024 * 1024),
|
||||
plan.min_free_bytes / (1024 * 1024)
|
||||
),
|
||||
});
|
||||
|
||||
let boot0 = String::from_utf8_lossy(&remote.user_command(
|
||||
"test -e /dev/mmcblk0boot0 && echo yes || echo no",
|
||||
Duration::from_secs(15),
|
||||
)?)
|
||||
.trim()
|
||||
.to_owned();
|
||||
let boot0_present = boot0 == "yes";
|
||||
checks.push(Check {
|
||||
name: "secure-regions",
|
||||
ok: !plan.partition.device.contains("boot0"),
|
||||
detail: format!(
|
||||
"boot0 {}; the write plan targets only {}",
|
||||
if boot0_present { "present" } else { "absent" },
|
||||
plan.partition.device
|
||||
),
|
||||
});
|
||||
|
||||
let mut held_backup = None;
|
||||
if let Some(path) = options.held_backup {
|
||||
let size = fs::metadata(path)?.len();
|
||||
if size != plan.partition.size {
|
||||
return Err(PreflightError::BackupSize {
|
||||
path: path.to_path_buf(),
|
||||
size,
|
||||
});
|
||||
}
|
||||
let data = fs::read(path)?;
|
||||
let md5 = md5_hex(&data);
|
||||
let sha256: String = Sha256::digest(&data)
|
||||
.iter()
|
||||
.map(|byte| format!("{byte:02x}"))
|
||||
.collect();
|
||||
let matches_live = md5 == live_md5;
|
||||
checks.push(Check {
|
||||
name: "held-backup",
|
||||
ok: true,
|
||||
detail: format!(
|
||||
"{} md5 {md5} ({})",
|
||||
path.display(),
|
||||
if matches_live {
|
||||
"matches live p1"
|
||||
} else {
|
||||
"differs from live p1; restore will still write it"
|
||||
}
|
||||
),
|
||||
});
|
||||
held_backup = Some(BackupCheck {
|
||||
path: path.to_path_buf(),
|
||||
md5,
|
||||
sha256,
|
||||
matches_live,
|
||||
});
|
||||
}
|
||||
|
||||
let mut golden_md5 = None;
|
||||
if options.check_golden {
|
||||
let out = remote.root_command(
|
||||
&format!(
|
||||
"dd if=/dev/mmcblk0 skip={} count=32768 bs=512 2>/dev/null | md5sum",
|
||||
plan.golden_lba_bytes / 512
|
||||
),
|
||||
Duration::from_secs(90),
|
||||
)?;
|
||||
if let Some(digest) = parse_digest(&out, 32) {
|
||||
golden_md5 = Some(digest);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(PreflightReport {
|
||||
host: options.host.to_owned(),
|
||||
source_os,
|
||||
kernel,
|
||||
model,
|
||||
root_method: remote.root_method().to_owned(),
|
||||
root_uid,
|
||||
partition_device,
|
||||
partition_size,
|
||||
live_md5,
|
||||
held_backup,
|
||||
golden_md5,
|
||||
free_bytes,
|
||||
boot0_present,
|
||||
checks,
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn classify(kernel: &str, release: &str, all: &str) -> String {
|
||||
if all.contains("/etc/bos_version") || release.contains("Braiins") {
|
||||
return "braiins".to_owned();
|
||||
}
|
||||
if all.contains("/etc/alkane-release") || kernel.starts_with("6.18") {
|
||||
return "alkane".to_owned();
|
||||
}
|
||||
if all.contains("/etc/ouros-release") || kernel.contains("6.6.147") {
|
||||
return "ouros".to_owned();
|
||||
}
|
||||
if all.contains("/etc/fw-info") || release.contains("Vnish") || release.contains("AnthillOS") {
|
||||
return "vnish".to_owned();
|
||||
}
|
||||
// Stock Bitmain control boards: Amlogic stock is kernel 4.9.38; the AM335x
|
||||
// (BeagleBone-class) stock is kernel 3.8.13+ with an "Antminer" model line.
|
||||
if kernel.contains("4.9.38")
|
||||
|| kernel.starts_with("3.8.13")
|
||||
|| all.contains("update-daemon")
|
||||
|| all.contains("rroot")
|
||||
|| all.to_lowercase().contains("antminer")
|
||||
{
|
||||
return "stock-bitmain".to_owned();
|
||||
}
|
||||
"unknown".to_owned()
|
||||
}
|
||||
|
||||
pub fn parse_digest(output: &[u8], length: usize) -> Option<String> {
|
||||
let text = String::from_utf8_lossy(output);
|
||||
text.split_whitespace()
|
||||
.map(|token| token.trim().to_ascii_lowercase())
|
||||
.find(|token| token.len() == length && token.bytes().all(|byte| byte.is_ascii_hexdigit()))
|
||||
}
|
||||
|
||||
fn free_bytes(remote: &mut dyn Remote) -> Result<u64, RemoteError> {
|
||||
let out = remote.user_command("df -k /tmp 2>/dev/null || df -k /", Duration::from_secs(15))?;
|
||||
let text = String::from_utf8_lossy(&out);
|
||||
for line in text.lines().rev() {
|
||||
let fields: Vec<&str> = line.split_whitespace().collect();
|
||||
if fields.len() >= 4 {
|
||||
if let Ok(kib) = fields[3].parse::<u64>() {
|
||||
return Ok(kib.saturating_mul(1024));
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(0)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn classifies_the_source_os() {
|
||||
assert_eq!(
|
||||
classify("4.9.38-tag-", "", "update-daemon\n"),
|
||||
"stock-bitmain"
|
||||
);
|
||||
assert_eq!(
|
||||
classify("4.9.38-tag-", "/etc/fw-info\n", "/etc/fw-info\n"),
|
||||
"vnish"
|
||||
);
|
||||
assert_eq!(classify("6.6.147", "/etc/ouros-release\n", ""), "ouros");
|
||||
assert_eq!(classify("6.18.48", "", ""), "alkane");
|
||||
assert_eq!(classify("4.9.38", "", "/etc/bos_version\n"), "braiins");
|
||||
assert_eq!(classify("5.10.0", "", ""), "unknown");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_md5_from_md5sum_output() {
|
||||
let output = b"3f43804f10ce256200bfc71e7fbdd9ee /dev/mmcblk0p1\n";
|
||||
assert_eq!(
|
||||
parse_digest(output, 32).as_deref(),
|
||||
Some("3f43804f10ce256200bfc71e7fbdd9ee")
|
||||
);
|
||||
assert_eq!(parse_digest(b"not a digest\n", 32), None);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,477 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Stock <-> alkane crossing, compiled into the toolkit.
|
||||
//!
|
||||
//! The toolkit is self-contained: it installs alkane onto a board on stock and
|
||||
//! returns a board to stock entirely on its own, with no external helper and no
|
||||
//! runtime dependency on any other tool. A user's machine needs only this
|
||||
//! binary.
|
||||
//!
|
||||
//! Getting our first image onto a board past its stock safeguards (with root),
|
||||
//! and the reverse, are implemented in the sibling module `stock_method`. This
|
||||
//! file is the stable public boundary around that work: the interface
|
||||
//! (`StockMethod`, `StockError`) plus the toolkit-side orchestration and
|
||||
//! verification around the method. The method is plain Rust and must be
|
||||
//! network-only.
|
||||
//!
|
||||
//! A from-stock install also leaves a complete genuine-stock backup on the
|
||||
//! board: the stock device tree, kernel and ramdisk, in the reserved NAND
|
||||
//! region after the alkane MAC area. The two on-board backup calls below check
|
||||
//! and restore that copy over the network, with no vendor firmware file.
|
||||
|
||||
use alkane_artifacts::afw::VerifiedAfw;
|
||||
use std::path::{Path, PathBuf};
|
||||
use thiserror::Error;
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum StockError {
|
||||
#[error("the stock method is not implemented in this build")]
|
||||
NotImplemented,
|
||||
#[error("could not reach the board: {0}")]
|
||||
Network(String),
|
||||
#[error("authentication failed: {0}")]
|
||||
Auth(String),
|
||||
#[error("the stock method failed: {0}")]
|
||||
Method(String),
|
||||
#[error("io: {0}")]
|
||||
Io(String),
|
||||
#[error("not applicable to this board; use the compiled-in method")]
|
||||
NotApplicable,
|
||||
}
|
||||
|
||||
/// The genuine Bitmain stock kernel and rootfs to write back when restoring to
|
||||
/// stock, parsed from a vendor firmware package (OTA or SD) by `stock_firmware`.
|
||||
/// The matching NAND device tree is NOT taken from the package: Bitmain never
|
||||
/// ships the kernel device tree in its distributable firmware (it is factory-
|
||||
/// provisioned and preserved by every update), so the method supplies the
|
||||
/// correct per-board dtb itself. Borrowed so the large rootfs is not copied
|
||||
/// before the method needs it.
|
||||
pub struct RestoreImages<'a> {
|
||||
pub kernel: &'a [u8],
|
||||
pub rootfs: &'a [u8],
|
||||
/// The genuine per-board device tree from the vendor package, when present
|
||||
/// (SD recovery images ship one; OTA packages omit it). When `None`, the
|
||||
/// zynq readable path takes the stock dtb from the on-board backup.
|
||||
pub dtb: Option<&'a [u8]>,
|
||||
}
|
||||
|
||||
/// Options for updating a board that already runs alkane, in place.
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct InPlaceOptions {
|
||||
/// Read-only: report the board state, the storage map and the write plan,
|
||||
/// and write nothing.
|
||||
pub dry_run: bool,
|
||||
/// Reboot after the images are written and read back, then wait for the
|
||||
/// board to return as alkane.
|
||||
pub reboot: bool,
|
||||
/// Where to keep a copy of each boot slot as it was before the write. When
|
||||
/// set, every slot is read and saved before any erase; a failed backup
|
||||
/// aborts the update with nothing written.
|
||||
pub backup_dir: Option<PathBuf>,
|
||||
}
|
||||
|
||||
/// One boot slot as it was before an in-place update.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct HeldSlot {
|
||||
pub name: String,
|
||||
/// Absolute NAND offset of the slot.
|
||||
pub absolute: u64,
|
||||
pub size: u64,
|
||||
pub path: PathBuf,
|
||||
pub md5: String,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct InPlaceReceipt {
|
||||
pub backups: Vec<HeldSlot>,
|
||||
pub rebooted: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub enum InPlaceOutcome {
|
||||
/// The dry-run report; nothing was written.
|
||||
DryRun(String),
|
||||
Updated(InPlaceReceipt),
|
||||
}
|
||||
|
||||
/// Result of a live check that a Zynq board is up on alkane: two channels
|
||||
/// (HTTP page marker, SSH kernel/OS) must agree.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct LiveCheck {
|
||||
pub attempts: u32,
|
||||
pub http: String,
|
||||
pub http_ok: bool,
|
||||
pub ssh: String,
|
||||
pub ssh_ok: bool,
|
||||
/// The running kernel command line (informational: on a NAND boot it is
|
||||
/// the board's U-Boot env bootargs).
|
||||
pub cmdline: String,
|
||||
}
|
||||
|
||||
impl LiveCheck {
|
||||
pub fn ok(&self) -> bool {
|
||||
self.http_ok && self.ssh_ok
|
||||
}
|
||||
|
||||
pub fn render(&self) -> String {
|
||||
format!(
|
||||
"verify-live attempts {}\n http {}: {}\n ssh {}: {}\n cmdline: {}\nresult {}\n",
|
||||
self.attempts,
|
||||
if self.http_ok { "PASS" } else { "FAIL" },
|
||||
self.http,
|
||||
if self.ssh_ok { "PASS" } else { "FAIL" },
|
||||
self.ssh,
|
||||
if self.cmdline.is_empty() {
|
||||
"(not read)"
|
||||
} else {
|
||||
&self.cmdline
|
||||
},
|
||||
if self.ok() { "PASS" } else { "FAIL" }
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/// The stock-side methods, implemented by `stock_method`. All implementations
|
||||
/// must be NETWORK-ONLY (no serial-console dependency).
|
||||
pub trait StockMethod {
|
||||
/// Put our first image (the `.afw`) onto a board currently on stock, past
|
||||
/// stock's gates and with root, over the network only. On Ok the board is
|
||||
/// installed with alkane; the caller verifies liveness.
|
||||
fn install_from_stock(
|
||||
&self,
|
||||
host: &str,
|
||||
afw_path: &Path,
|
||||
afw: &VerifiedAfw,
|
||||
password: Option<&str>,
|
||||
) -> Result<(), StockError>;
|
||||
|
||||
/// Return an aftermarket (alkane) board to genuine stock, over the network
|
||||
/// only, by writing the given genuine Bitmain stock images (`images`) back to
|
||||
/// NAND. `password` is the board's alkane root credential. On Ok the board is
|
||||
/// on stock; the caller verifies.
|
||||
fn restore_to_stock(
|
||||
&self,
|
||||
host: &str,
|
||||
images: &RestoreImages,
|
||||
password: Option<&str>,
|
||||
) -> Result<(), StockError>;
|
||||
|
||||
/// Run `cmd` as root on a board running stock, over the network only, and
|
||||
/// return its combined standard output and standard error. `cmd` is a
|
||||
/// `/bin/sh` command line. A non-zero exit is an `Err` whose message is that
|
||||
/// combined output. `password` is the board's stock login password; `None`
|
||||
/// falls back to the configured board credential.
|
||||
fn root_exec(
|
||||
&self,
|
||||
host: &str,
|
||||
password: Option<&str>,
|
||||
cmd: &str,
|
||||
) -> Result<String, StockError>;
|
||||
|
||||
/// Write `data` to `remote_path` as root on a board running stock, over the
|
||||
/// network only. Missing parent directories are created and the file is
|
||||
/// left mode 0644. The payload may be many megabytes; it is sent as a
|
||||
/// stream, not on a command line. `password` is the board's stock login
|
||||
/// password; `None` falls back to the configured board credential.
|
||||
fn root_put(
|
||||
&self,
|
||||
host: &str,
|
||||
password: Option<&str>,
|
||||
data: &[u8],
|
||||
remote_path: &str,
|
||||
) -> Result<(), StockError>;
|
||||
|
||||
/// Update a board that already runs alkane to the `.afw`'s images, over the
|
||||
/// network only. Refuses a board that is not running alkane (a board on
|
||||
/// stock is installed with `install_from_stock`). The boot regions are not
|
||||
/// exposed to Linux on alkane, so they are re-registered the same way as for
|
||||
/// a restore; the images are written in the form the board's stock U-Boot
|
||||
/// boots, each read back before reboot, and BOOT.bin is never written.
|
||||
fn update_in_place(
|
||||
&self,
|
||||
host: &str,
|
||||
afw: &VerifiedAfw,
|
||||
password: Option<&str>,
|
||||
options: &InPlaceOptions,
|
||||
) -> Result<InPlaceOutcome, StockError>;
|
||||
|
||||
/// Report, over the network only, whether the board holds a complete
|
||||
/// on-board stock backup that can be restored without a vendor firmware
|
||||
/// file. False means absent or incomplete; it is not an error.
|
||||
fn onboard_stock_backup_present(
|
||||
&self,
|
||||
host: &str,
|
||||
password: Option<&str>,
|
||||
) -> Result<bool, StockError>;
|
||||
|
||||
/// Return an alkane board to genuine stock, over the network only, using
|
||||
/// the on-board stock backup. The backup must be present and complete; call
|
||||
/// `onboard_stock_backup_present` first. `timeout` bounds the wait for the
|
||||
/// restored board to answer as stock after the reboot.
|
||||
fn restore_from_onboard_backup(
|
||||
&self,
|
||||
host: &str,
|
||||
password: Option<&str>,
|
||||
timeout: std::time::Duration,
|
||||
) -> Result<(), StockError>;
|
||||
}
|
||||
|
||||
/// The compiled-in method implementation.
|
||||
pub fn method() -> &'static dyn StockMethod {
|
||||
crate::stock_method::method()
|
||||
}
|
||||
|
||||
/// Report, over the network only, whether the board holds a complete on-board
|
||||
/// stock backup that can be restored without a vendor firmware file. Zynq uses
|
||||
/// the readable boot-slot path; other boards use the compiled-in method.
|
||||
pub fn onboard_stock_backup_present(
|
||||
host: &str,
|
||||
password: Option<&str>,
|
||||
) -> Result<bool, StockError> {
|
||||
match crate::zynq_nand::onboard_backup_present(host, password) {
|
||||
Err(StockError::NotApplicable) => method().onboard_stock_backup_present(host, password),
|
||||
other => other,
|
||||
}
|
||||
}
|
||||
|
||||
/// Return an alkane board to genuine stock (network-only) using its on-board
|
||||
/// stock backup, via the compiled-in method. The backup must be present and
|
||||
/// complete; check it first with [`onboard_stock_backup_present`].
|
||||
pub fn restore_from_onboard_backup(
|
||||
host: &str,
|
||||
password: Option<&str>,
|
||||
timeout: std::time::Duration,
|
||||
) -> Result<(), StockError> {
|
||||
match crate::zynq_nand::restore_from_onboard(host, password) {
|
||||
Err(StockError::NotApplicable) => {
|
||||
method().restore_from_onboard_backup(host, password, timeout)
|
||||
}
|
||||
other => other,
|
||||
}
|
||||
}
|
||||
|
||||
/// Install alkane onto a board on stock (network-only), via the compiled-in method.
|
||||
pub fn install_from_stock(
|
||||
host: &str,
|
||||
afw_path: &Path,
|
||||
afw: &VerifiedAfw,
|
||||
password: Option<&str>,
|
||||
) -> Result<(), StockError> {
|
||||
// Zynq-7010 uses the readable NAND path (uImage-wrap + flash_erase/nandwrite
|
||||
// over the DSH root primitive, with an on-board stock backup carved first);
|
||||
// other boards use the compiled-in method.
|
||||
if afw.manifest.board == crate::boards::zynq::BOARD {
|
||||
let img = |role: &str| {
|
||||
afw.image(role)
|
||||
.map(|(_, data)| data)
|
||||
.ok_or_else(|| StockError::Method(format!("afw missing {role} image")))
|
||||
};
|
||||
return crate::zynq_nand::install_from_stock(
|
||||
host,
|
||||
img("kernel")?,
|
||||
img("dtb")?,
|
||||
img("rootfs")?,
|
||||
password,
|
||||
);
|
||||
}
|
||||
// A113D (Amlogic AXG) uses the readable UBI-stage + flag-based boot chain.
|
||||
if afw.manifest.board == crate::aml_ubi::BOARD {
|
||||
let img = |role: &str| {
|
||||
afw.image(role)
|
||||
.map(|(_, data)| data)
|
||||
.ok_or_else(|| StockError::Method(format!("afw missing {role} image")))
|
||||
};
|
||||
return crate::aml_ubi::install_from_stock(
|
||||
host,
|
||||
img("kernel")?,
|
||||
img("dtb")?,
|
||||
img("rootfs")?,
|
||||
password,
|
||||
);
|
||||
}
|
||||
method().install_from_stock(host, afw_path, afw, password)
|
||||
}
|
||||
|
||||
/// Return an alkane board to stock (network-only) by writing the genuine Bitmain
|
||||
/// stock `images` back to NAND, via the compiled-in method.
|
||||
pub fn restore_to_stock(
|
||||
host: &str,
|
||||
images: &RestoreImages,
|
||||
password: Option<&str>,
|
||||
) -> Result<(), StockError> {
|
||||
match crate::zynq_nand::restore_to_stock(
|
||||
host,
|
||||
images.kernel,
|
||||
images.rootfs,
|
||||
images.dtb,
|
||||
password,
|
||||
) {
|
||||
Err(StockError::NotApplicable) => {
|
||||
// A113D restore is a one-byte flag flip in-band from alkane; it needs
|
||||
// no stock images. Try it, then fall through to the compiled-in method.
|
||||
match crate::aml_ubi::restore_to_stock(host, password) {
|
||||
Err(StockError::NotApplicable) => method().restore_to_stock(host, images, password),
|
||||
other => other,
|
||||
}
|
||||
}
|
||||
other => other,
|
||||
}
|
||||
}
|
||||
|
||||
/// Restore an alkane A113D to stock with no stock firmware file: a one-byte flag
|
||||
/// flip in-band from the running alkane OS (network-only). Returns
|
||||
/// `NotApplicable` if the board is not an alkane A113D.
|
||||
pub fn restore_aml_flag(host: &str, password: Option<&str>) -> Result<(), StockError> {
|
||||
crate::aml_ubi::restore_to_stock(host, password)
|
||||
}
|
||||
|
||||
/// Run `cmd` as root on a board running stock (network-only), via the
|
||||
/// compiled-in method. `cmd` is a `/bin/sh` command line; the returned string
|
||||
/// is its combined output. A non-zero exit is an error whose message is that
|
||||
/// output.
|
||||
pub fn root_exec(host: &str, password: Option<&str>, cmd: &str) -> Result<String, StockError> {
|
||||
method().root_exec(host, password, cmd)
|
||||
}
|
||||
|
||||
/// Write `data` to `remote_path` as root on a board running stock
|
||||
/// (network-only), via the compiled-in method. Missing parent directories are
|
||||
/// created and the file is left mode 0644. Large payloads are streamed.
|
||||
pub fn root_put(
|
||||
host: &str,
|
||||
password: Option<&str>,
|
||||
data: &[u8],
|
||||
remote_path: &str,
|
||||
) -> Result<(), StockError> {
|
||||
method().root_put(host, password, data, remote_path)
|
||||
}
|
||||
|
||||
/// Check, over the network, that a Zynq board is up on alkane: the web page
|
||||
/// carries `marker` (case-insensitive) and SSH reports alkane with a kernel
|
||||
/// containing `kernel_version` (if non-empty). Retries until `timeout`.
|
||||
pub fn verify_zynq_live(
|
||||
host: &str,
|
||||
password: Option<&str>,
|
||||
marker: &str,
|
||||
kernel_version: &str,
|
||||
timeout: std::time::Duration,
|
||||
) -> Result<LiveCheck, StockError> {
|
||||
crate::stock_method::live_check(host, password, marker, kernel_version, timeout)
|
||||
}
|
||||
|
||||
/// Update a board already on alkane to the `.afw`'s images, in place
|
||||
/// (network-only), via the compiled-in method.
|
||||
pub fn update_in_place(
|
||||
host: &str,
|
||||
afw: &VerifiedAfw,
|
||||
password: Option<&str>,
|
||||
options: &InPlaceOptions,
|
||||
) -> Result<InPlaceOutcome, StockError> {
|
||||
method().update_in_place(host, afw, password, options)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
// The interface is exercised against whatever `stock_method` provides. We
|
||||
// only assert the toolkit wires a method object in; its behaviour is the
|
||||
// method module's own tests.
|
||||
#[test]
|
||||
fn public_signatures_are_wired() {
|
||||
let _: fn(&str, Option<&str>) -> Result<bool, StockError> = onboard_stock_backup_present;
|
||||
let _: fn(&str, Option<&str>, std::time::Duration) -> Result<(), StockError> =
|
||||
restore_from_onboard_backup;
|
||||
let _: fn(&str, Option<&str>, &str) -> Result<String, StockError> = root_exec;
|
||||
let _: fn(&str, Option<&str>, &[u8], &str) -> Result<(), StockError> = root_put;
|
||||
}
|
||||
|
||||
struct FakeMethod {
|
||||
present: bool,
|
||||
}
|
||||
|
||||
impl StockMethod for FakeMethod {
|
||||
fn install_from_stock(
|
||||
&self,
|
||||
_: &str,
|
||||
_: &Path,
|
||||
_: &VerifiedAfw,
|
||||
_: Option<&str>,
|
||||
) -> Result<(), StockError> {
|
||||
Err(StockError::NotImplemented)
|
||||
}
|
||||
|
||||
fn restore_to_stock(
|
||||
&self,
|
||||
_: &str,
|
||||
_: &RestoreImages,
|
||||
_: Option<&str>,
|
||||
) -> Result<(), StockError> {
|
||||
Err(StockError::NotImplemented)
|
||||
}
|
||||
|
||||
fn root_exec(&self, _: &str, _: Option<&str>, _: &str) -> Result<String, StockError> {
|
||||
Err(StockError::NotImplemented)
|
||||
}
|
||||
|
||||
fn root_put(&self, _: &str, _: Option<&str>, _: &[u8], _: &str) -> Result<(), StockError> {
|
||||
Err(StockError::NotImplemented)
|
||||
}
|
||||
|
||||
fn update_in_place(
|
||||
&self,
|
||||
_: &str,
|
||||
_: &VerifiedAfw,
|
||||
_: Option<&str>,
|
||||
_: &InPlaceOptions,
|
||||
) -> Result<InPlaceOutcome, StockError> {
|
||||
Err(StockError::NotImplemented)
|
||||
}
|
||||
|
||||
fn onboard_stock_backup_present(
|
||||
&self,
|
||||
_: &str,
|
||||
_: Option<&str>,
|
||||
) -> Result<bool, StockError> {
|
||||
Ok(self.present)
|
||||
}
|
||||
|
||||
fn restore_from_onboard_backup(
|
||||
&self,
|
||||
_: &str,
|
||||
_: Option<&str>,
|
||||
_: std::time::Duration,
|
||||
) -> Result<(), StockError> {
|
||||
if self.present {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(StockError::Method(
|
||||
"no complete on-board stock backup".into(),
|
||||
))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_method_is_compiled_in() {
|
||||
let _m: &dyn StockMethod = method();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn onboard_backup_methods_report_present_or_absent() {
|
||||
let present = FakeMethod { present: true };
|
||||
assert!(present
|
||||
.onboard_stock_backup_present("192.0.2.10", Some("secret"))
|
||||
.unwrap());
|
||||
assert!(present
|
||||
.restore_from_onboard_backup("192.0.2.10", Some("secret"), std::time::Duration::ZERO)
|
||||
.is_ok());
|
||||
|
||||
let absent = FakeMethod { present: false };
|
||||
assert!(!absent
|
||||
.onboard_stock_backup_present("192.0.2.10", None)
|
||||
.unwrap());
|
||||
assert!(matches!(
|
||||
absent.restore_from_onboard_backup("192.0.2.10", None, std::time::Duration::ZERO),
|
||||
Err(StockError::Method(_))
|
||||
));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,282 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Parse a genuine Bitmain Antminer stock firmware package into the flashable
|
||||
//! stock images, so the toolkit can restore a board to genuine stock using the
|
||||
//! vendor's own files (no carved blobs).
|
||||
//!
|
||||
//! Two genuine source shapes are handled for the Zynq-7010 (Antminer S17):
|
||||
//!
|
||||
//! - OTA update `.tar.gz` (`Antminer-S17-user-OM-<date>-sig*.tar.gz`): a signed
|
||||
//! outer tar holding `cert.pem`, `fw.tar.gz` and `runme.sh` (each with a
|
||||
//! `.sig`). The inner `fw.tar.gz` holds `BOOT.bin`, `uImage` (legacy kernel),
|
||||
//! `uramdisk.image.gz` (rootfs) and `md5_info` (md5 of the rootfs). The OTA
|
||||
//! package does NOT carry the device tree: the factory SD provisioning writes
|
||||
//! it once and OTA upgrades preserve it.
|
||||
//! - SD recovery `.zip` (`SD_Antminer-S17-*.zip`): the full factory image,
|
||||
//! which DOES include `devicetree.dtb` alongside `BOOT.bin`/`uImage`/
|
||||
//! `uramdisk.image.gz`. This is the complete source for a from-anywhere
|
||||
//! restore, because it carries the device tree the stock kernel needs.
|
||||
//!
|
||||
//! Extraction shells out to the system `tar`/`unzip`/`gzip` (as the release
|
||||
//! fetch shells out to `curl`); nothing is written outside a private temp dir.
|
||||
|
||||
use std::path::Path;
|
||||
use std::process::Command;
|
||||
|
||||
use crate::md5::md5_hex;
|
||||
|
||||
#[derive(Debug, thiserror::Error)]
|
||||
pub enum StockFirmwareError {
|
||||
#[error("io: {0}")]
|
||||
Io(String),
|
||||
#[error("could not read {0}")]
|
||||
Read(String),
|
||||
#[error("unrecognised firmware package (not a .tar.gz or .zip): {0}")]
|
||||
Format(String),
|
||||
#[error("extraction failed: {0}")]
|
||||
Extract(String),
|
||||
#[error("the firmware package is missing a stock {0} image")]
|
||||
MissingImage(&'static str),
|
||||
#[error("rootfs md5 mismatch: package lists {expected}, image is {actual}")]
|
||||
RootfsMd5 { expected: String, actual: String },
|
||||
#[error("needed system tool not found: {0}")]
|
||||
MissingTool(String),
|
||||
}
|
||||
|
||||
/// The stock images carved from a genuine Bitmain firmware package, ready to
|
||||
/// write back to NAND. `boot_bin` and `dtb` are optional (an OTA package omits
|
||||
/// the dtb; the bootloader is only written on an explicit full restore).
|
||||
pub struct StockFirmware {
|
||||
pub boot_bin: Option<Vec<u8>>,
|
||||
pub dtb: Option<Vec<u8>>,
|
||||
pub kernel: Vec<u8>,
|
||||
pub rootfs: Vec<u8>,
|
||||
pub version: Option<String>,
|
||||
/// The source package kind, for logging.
|
||||
pub source_kind: &'static str,
|
||||
}
|
||||
|
||||
impl StockFirmware {
|
||||
pub fn summary(&self) -> String {
|
||||
let v = self.version.as_deref().unwrap_or("unknown");
|
||||
format!(
|
||||
"{} (version {}): kernel {} B, rootfs {} B, dtb {}, BOOT.bin {}",
|
||||
self.source_kind,
|
||||
v,
|
||||
self.kernel.len(),
|
||||
self.rootfs.len(),
|
||||
self.dtb.as_ref().map_or("absent", |_| "present"),
|
||||
self.boot_bin.as_ref().map_or("absent", |_| "present"),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
fn have_tool(tool: &str) -> bool {
|
||||
Command::new(tool)
|
||||
.arg("--version")
|
||||
.output()
|
||||
.map(|o| o.status.success() || !o.stdout.is_empty() || !o.stderr.is_empty())
|
||||
.unwrap_or(false)
|
||||
}
|
||||
|
||||
fn run(cmd: &mut Command, what: &str) -> Result<(), StockFirmwareError> {
|
||||
let out = cmd
|
||||
.output()
|
||||
.map_err(|e| StockFirmwareError::Extract(format!("{what}: {e}")))?;
|
||||
if !out.status.success() {
|
||||
return Err(StockFirmwareError::Extract(format!(
|
||||
"{what}: {}",
|
||||
String::from_utf8_lossy(&out.stderr).trim()
|
||||
)));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Recursively collect files under `dir` as (relative-path-lowercased, absolute path).
|
||||
fn collect_files(dir: &Path) -> Vec<(String, std::path::PathBuf)> {
|
||||
fn walk(base: &Path, dir: &Path, out: &mut Vec<(String, std::path::PathBuf)>) {
|
||||
let Ok(entries) = std::fs::read_dir(dir) else {
|
||||
return;
|
||||
};
|
||||
for entry in entries.flatten() {
|
||||
let path = entry.path();
|
||||
if path.is_dir() {
|
||||
walk(base, &path, out);
|
||||
} else if let Ok(rel) = path.strip_prefix(base) {
|
||||
out.push((rel.to_string_lossy().to_lowercase(), path.clone()));
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut out = Vec::new();
|
||||
walk(dir, dir, &mut out);
|
||||
out
|
||||
}
|
||||
|
||||
/// Pick the best file whose basename matches `name`, preferring paths that
|
||||
/// contain one of `prefer` path fragments (e.g. "bin/" for the SD image, "fw"
|
||||
/// for the OTA inner tree), then the shallowest path.
|
||||
fn pick<'a>(
|
||||
files: &'a [(String, std::path::PathBuf)],
|
||||
name: &str,
|
||||
prefer: &[&str],
|
||||
) -> Option<&'a std::path::PathBuf> {
|
||||
let name = name.to_lowercase();
|
||||
let mut matches: Vec<&(String, std::path::PathBuf)> = files
|
||||
.iter()
|
||||
.filter(|(rel, _)| rel.rsplit('/').next() == Some(name.as_str()) || *rel == name)
|
||||
.collect();
|
||||
if matches.is_empty() {
|
||||
return None;
|
||||
}
|
||||
matches.sort_by_key(|(rel, _)| {
|
||||
let pref_rank = prefer
|
||||
.iter()
|
||||
.position(|p| rel.contains(p))
|
||||
.unwrap_or(prefer.len());
|
||||
let depth = rel.matches('/').count();
|
||||
(pref_rank, depth)
|
||||
});
|
||||
matches.first().map(|(_, p)| p)
|
||||
}
|
||||
|
||||
fn read(path: &Path) -> Result<Vec<u8>, StockFirmwareError> {
|
||||
std::fs::read(path).map_err(|_| StockFirmwareError::Read(path.display().to_string()))
|
||||
}
|
||||
|
||||
/// Parse a genuine Bitmain stock firmware package (OTA `.tar.gz` or SD `.zip`)
|
||||
/// into its stock images.
|
||||
pub fn parse(path: &Path) -> Result<StockFirmware, StockFirmwareError> {
|
||||
let bytes = std::fs::read(path)
|
||||
.map_err(|e| StockFirmwareError::Io(format!("{}: {e}", path.display())))?;
|
||||
if bytes.len() < 4 {
|
||||
return Err(StockFirmwareError::Format(path.display().to_string()));
|
||||
}
|
||||
let is_gzip = bytes[0] == 0x1f && bytes[1] == 0x8b;
|
||||
let is_zip = &bytes[0..2] == b"PK";
|
||||
if !is_gzip && !is_zip {
|
||||
return Err(StockFirmwareError::Format(path.display().to_string()));
|
||||
}
|
||||
|
||||
let tmp = tempfile::Builder::new()
|
||||
.prefix("alkane-stockfw-")
|
||||
.tempdir()
|
||||
.map_err(|e| StockFirmwareError::Io(e.to_string()))?;
|
||||
let root = tmp.path();
|
||||
|
||||
let (source_kind, prefer): (&'static str, &[&str]) = if is_zip {
|
||||
if !have_tool("unzip") {
|
||||
return Err(StockFirmwareError::MissingTool("unzip".into()));
|
||||
}
|
||||
run(
|
||||
Command::new("unzip")
|
||||
.arg("-qq")
|
||||
.arg("-o")
|
||||
.arg(path)
|
||||
.arg("-d")
|
||||
.arg(root),
|
||||
"unzip SD recovery image",
|
||||
)?;
|
||||
("Bitmain SD recovery image", &["bin/"])
|
||||
} else {
|
||||
if !have_tool("tar") {
|
||||
return Err(StockFirmwareError::MissingTool("tar".into()));
|
||||
}
|
||||
run(
|
||||
Command::new("tar").arg("xzf").arg(path).arg("-C").arg(root),
|
||||
"untar OTA package",
|
||||
)?;
|
||||
// The signed OTA wraps the real images in an inner fw.tar.gz; extract it.
|
||||
let inner = collect_files(root)
|
||||
.into_iter()
|
||||
.find(|(rel, _)| rel.rsplit('/').next() == Some("fw.tar.gz"));
|
||||
if let Some((_, inner_path)) = inner {
|
||||
let inner_dir = root.join("fw");
|
||||
std::fs::create_dir_all(&inner_dir)
|
||||
.map_err(|e| StockFirmwareError::Io(e.to_string()))?;
|
||||
run(
|
||||
Command::new("tar")
|
||||
.arg("xzf")
|
||||
.arg(&inner_path)
|
||||
.arg("-C")
|
||||
.arg(&inner_dir),
|
||||
"untar OTA inner fw.tar.gz",
|
||||
)?;
|
||||
}
|
||||
("Bitmain OTA update package", &["fw/", "bin/"])
|
||||
};
|
||||
|
||||
let files = collect_files(root);
|
||||
|
||||
let kernel_path = pick(&files, "uImage", prefer)
|
||||
.ok_or(StockFirmwareError::MissingImage("uImage (kernel)"))?;
|
||||
let rootfs_path = pick(&files, "uramdisk.image.gz", prefer).ok_or(
|
||||
StockFirmwareError::MissingImage("uramdisk.image.gz (rootfs)"),
|
||||
)?;
|
||||
let kernel = read(kernel_path)?;
|
||||
let rootfs = read(rootfs_path)?;
|
||||
let boot_bin = pick(&files, "BOOT.bin", prefer)
|
||||
.map(|p| read(p))
|
||||
.transpose()?;
|
||||
let dtb = pick(&files, "devicetree.dtb", &["", "bin/"])
|
||||
.map(|p| read(p))
|
||||
.transpose()?;
|
||||
|
||||
// Verify the rootfs against md5_info when the package ships one (OTA does).
|
||||
if let Some(md5_path) = pick(&files, "md5_info", prefer) {
|
||||
if let Ok(raw) = std::fs::read_to_string(md5_path) {
|
||||
let expected = raw.split_whitespace().next().unwrap_or("").to_lowercase();
|
||||
if expected.len() == 32 {
|
||||
let actual = md5_hex(&rootfs);
|
||||
if actual != expected {
|
||||
return Err(StockFirmwareError::RootfsMd5 { expected, actual });
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let version = pick(&files, "version", prefer)
|
||||
.or_else(|| pick(&files, "version_number", &[""]))
|
||||
.and_then(|p| std::fs::read_to_string(p).ok())
|
||||
.map(|s| s.trim().to_string())
|
||||
.filter(|s| !s.is_empty());
|
||||
|
||||
Ok(StockFirmware {
|
||||
boot_bin,
|
||||
dtb,
|
||||
kernel,
|
||||
rootfs,
|
||||
version,
|
||||
source_kind,
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn rejects_non_archive() {
|
||||
let tmp = tempfile::NamedTempFile::new().unwrap();
|
||||
std::fs::write(tmp.path(), b"not an archive").unwrap();
|
||||
assert!(matches!(
|
||||
parse(tmp.path()),
|
||||
Err(StockFirmwareError::Format(_))
|
||||
));
|
||||
}
|
||||
|
||||
// Parse a real Bitmain firmware package. Set ALKANE_TEST_STOCK_FW to its path.
|
||||
// Ignored by default (needs the vendor file, not in the repo).
|
||||
#[test]
|
||||
#[ignore]
|
||||
fn parses_real_package() {
|
||||
let Ok(path) = std::env::var("ALKANE_TEST_STOCK_FW") else {
|
||||
eprintln!("set ALKANE_TEST_STOCK_FW to a firmware file");
|
||||
return;
|
||||
};
|
||||
let fw = parse(Path::new(&path)).expect("parse");
|
||||
eprintln!("{}", fw.summary());
|
||||
assert!(!fw.kernel.is_empty(), "kernel present");
|
||||
assert!(!fw.rootfs.is_empty(), "rootfs present");
|
||||
// The kernel is a legacy u-boot uImage: magic 0x27051956 big-endian.
|
||||
assert_eq!(&fw.kernel[0..4], &[0x27, 0x05, 0x19, 0x56], "uImage magic");
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,699 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Network transport for the CV1835 installer.
|
||||
//!
|
||||
//! Two root channels are implemented, both over the network:
|
||||
//!
|
||||
//! * `direct`: the SSH login is already uid 0 (Braiins OS, ourOS/alkane with a
|
||||
//! root key, or an operator-supplied root login).
|
||||
//! * `update-daemon`: stock Bitmain (and Vnish, which runs on the stock
|
||||
//! kernel) exposes an SSH login as `miner` (uid 1001). `/usr/sbin/update-daemon`
|
||||
//! listens on 127.0.0.1:12887 and pipes its socket into `system()` as root.
|
||||
//! We reach it through an SSH local forward, exactly as documented in the RE
|
||||
//! notes (`cv-kvm-host` / `cvbuild/cvroot.py`,
|
||||
//! `alkane-sdk-wiki/40-boot-os-and-build/cross-install-matrix.md`). The
|
||||
//! channel is blind, so root output is redirected to a world-readable file
|
||||
//! and read back over the unprivileged SSH session.
|
||||
//! * `rroot`: an existing `/nvdata/rroot` setuid helper on CV stock/Vnish,
|
||||
//! documented in `60-reverse-engineering-methods/rroot-setuid-escalation.md`.
|
||||
//! It is a fallback because the helper is not durable across a p7 reformat.
|
||||
//!
|
||||
//! Credentials are never read here: a password is used only through
|
||||
//! `sshpass -f <path>`, and that path comes from the operator (environment
|
||||
//! variable materialized by the CLI, or a file named on the command line).
|
||||
|
||||
use std::fs;
|
||||
use std::io::{Read, Write};
|
||||
use std::net::{SocketAddr, TcpStream};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::{Child, Command, ExitStatus, Stdio};
|
||||
use std::thread;
|
||||
use std::time::{Duration, Instant};
|
||||
use thiserror::Error;
|
||||
|
||||
const MAX_CAPTURE: usize = 64 * 1024 * 1024;
|
||||
|
||||
#[derive(Debug, Error)]
|
||||
pub enum RemoteError {
|
||||
#[error("remote I/O: {0}")]
|
||||
Io(#[from] std::io::Error),
|
||||
#[error("cannot start {0}")]
|
||||
MissingTool(&'static str),
|
||||
#[error("invalid target: {0}")]
|
||||
InvalidTarget(String),
|
||||
#[error("SSH transport: {0}")]
|
||||
Ssh(String),
|
||||
#[error("SSH command timed out after {0:?}")]
|
||||
Timeout(Duration),
|
||||
#[error("remote command failed ({status}): {stderr}")]
|
||||
Command { status: String, stderr: String },
|
||||
#[error("root access was not obtained: {0}")]
|
||||
NotRoot(String),
|
||||
#[error("no network root channel is available on this board")]
|
||||
NoRootMethod,
|
||||
#[error("update-daemon: {0}")]
|
||||
Daemon(String),
|
||||
#[error("remote output is over the {0}-byte cap")]
|
||||
OutputTooLarge(usize),
|
||||
}
|
||||
|
||||
impl RemoteError {
|
||||
fn sanitize(text: &str) -> String {
|
||||
let text = text.trim();
|
||||
let mut shortened: String = text.chars().take(300).collect();
|
||||
if shortened.len() < text.len() {
|
||||
shortened.push_str("...");
|
||||
}
|
||||
shortened
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum RootMethod {
|
||||
Auto,
|
||||
Direct,
|
||||
UpdateDaemon,
|
||||
Rroot,
|
||||
}
|
||||
|
||||
impl RootMethod {
|
||||
pub fn parse(value: &str) -> Option<Self> {
|
||||
match value {
|
||||
"auto" => Some(Self::Auto),
|
||||
"direct" => Some(Self::Direct),
|
||||
"update-daemon" => Some(Self::UpdateDaemon),
|
||||
"rroot" => Some(Self::Rroot),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct SshOptions {
|
||||
pub host: String,
|
||||
pub port: u16,
|
||||
pub user: String,
|
||||
pub identity_file: Option<PathBuf>,
|
||||
pub password_file: Option<PathBuf>,
|
||||
pub known_hosts: Option<PathBuf>,
|
||||
pub root_method: RootMethod,
|
||||
pub update_daemon_port: Option<u16>,
|
||||
}
|
||||
|
||||
impl Default for SshOptions {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
host: String::new(),
|
||||
port: 22,
|
||||
user: "miner".to_owned(),
|
||||
identity_file: None,
|
||||
password_file: None,
|
||||
known_hosts: None,
|
||||
root_method: RootMethod::Auto,
|
||||
update_daemon_port: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl SshOptions {
|
||||
fn validate(&self) -> Result<(), RemoteError> {
|
||||
if self.host.is_empty()
|
||||
|| self.host.len() > 253
|
||||
|| self.host.starts_with('-')
|
||||
|| !self.host.bytes().all(|byte| {
|
||||
byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'-' | b':' | b'_')
|
||||
})
|
||||
{
|
||||
return Err(RemoteError::InvalidTarget("host".to_owned()));
|
||||
}
|
||||
if self.user.is_empty()
|
||||
|| !self
|
||||
.user
|
||||
.bytes()
|
||||
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'_' | b'-' | b'.'))
|
||||
{
|
||||
return Err(RemoteError::InvalidTarget("user".to_owned()));
|
||||
}
|
||||
if self.port == 0 {
|
||||
return Err(RemoteError::InvalidTarget("port".to_owned()));
|
||||
}
|
||||
if let Some(path) = &self.password_file {
|
||||
if !path.is_file() {
|
||||
return Err(RemoteError::InvalidTarget(format!(
|
||||
"password file not found: {}",
|
||||
path.display()
|
||||
)));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
enum Strategy {
|
||||
Direct,
|
||||
Rroot,
|
||||
UpdateDaemon {
|
||||
local_port: u16,
|
||||
remote_port: u16,
|
||||
tunnel: Child,
|
||||
},
|
||||
}
|
||||
|
||||
impl Drop for Strategy {
|
||||
fn drop(&mut self) {
|
||||
if let Self::UpdateDaemon { tunnel, .. } = self {
|
||||
let _ = tunnel.kill();
|
||||
let _ = tunnel.wait();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct SshTransport {
|
||||
options: SshOptions,
|
||||
known_hosts: PathBuf,
|
||||
strategy: Strategy,
|
||||
counter: u64,
|
||||
}
|
||||
|
||||
impl SshTransport {
|
||||
/// Open a session and (when `require_root`) prove a uid-0 channel.
|
||||
pub fn connect(options: SshOptions, require_root: bool) -> Result<Self, RemoteError> {
|
||||
options.validate()?;
|
||||
let known_hosts = options
|
||||
.known_hosts
|
||||
.clone()
|
||||
.unwrap_or_else(|| alkane_core::platform::config_path("known_hosts"));
|
||||
if let Some(parent) = known_hosts.parent() {
|
||||
fs::create_dir_all(parent)?;
|
||||
}
|
||||
if !known_hosts.exists() {
|
||||
fs::write(&known_hosts, b"")?;
|
||||
}
|
||||
if options.password_file.is_some() {
|
||||
Command::new("sshpass")
|
||||
.arg("-V")
|
||||
.stdout(Stdio::null())
|
||||
.stderr(Stdio::null())
|
||||
.status()
|
||||
.map_err(|_| RemoteError::MissingTool("sshpass"))?;
|
||||
}
|
||||
let mut transport = Self {
|
||||
options,
|
||||
known_hosts,
|
||||
strategy: Strategy::Direct,
|
||||
counter: 0,
|
||||
};
|
||||
let identity = transport.user_command("uname -r", Duration::from_secs(15))?;
|
||||
let _ = identity;
|
||||
if !require_root {
|
||||
return Ok(transport);
|
||||
}
|
||||
|
||||
let uid =
|
||||
String::from_utf8_lossy(&transport.user_command("id -u", Duration::from_secs(15))?)
|
||||
.trim()
|
||||
.to_owned();
|
||||
let direct = uid == "0";
|
||||
let method = match transport.options.root_method {
|
||||
RootMethod::Auto if direct => RootMethod::Direct,
|
||||
RootMethod::Auto => {
|
||||
if transport.has_update_daemon()? {
|
||||
RootMethod::UpdateDaemon
|
||||
} else if transport.has_rroot()? {
|
||||
RootMethod::Rroot
|
||||
} else {
|
||||
return Err(RemoteError::NoRootMethod);
|
||||
}
|
||||
}
|
||||
other => other,
|
||||
};
|
||||
match method {
|
||||
RootMethod::Direct => {
|
||||
if !direct {
|
||||
return Err(RemoteError::NotRoot(
|
||||
"the SSH login is not uid 0; use --root-method auto, update-daemon or rroot"
|
||||
.to_owned(),
|
||||
));
|
||||
}
|
||||
transport.strategy = Strategy::Direct;
|
||||
}
|
||||
RootMethod::Rroot => {
|
||||
if !transport.has_rroot()? {
|
||||
return Err(RemoteError::NotRoot(
|
||||
"/nvdata/rroot is not present or not executable".to_owned(),
|
||||
));
|
||||
}
|
||||
transport.strategy = Strategy::Rroot;
|
||||
}
|
||||
RootMethod::UpdateDaemon => {
|
||||
if !transport.has_update_daemon()? {
|
||||
return Err(RemoteError::NotRoot(
|
||||
"/usr/sbin/update-daemon is not present".to_owned(),
|
||||
));
|
||||
}
|
||||
let remote_port = transport
|
||||
.options
|
||||
.update_daemon_port
|
||||
.unwrap_or(transport.detect_update_daemon_port()?);
|
||||
let (local_port, tunnel) = transport.start_tunnel(remote_port)?;
|
||||
transport.strategy = Strategy::UpdateDaemon {
|
||||
local_port,
|
||||
remote_port,
|
||||
tunnel,
|
||||
};
|
||||
}
|
||||
RootMethod::Auto => unreachable!(),
|
||||
}
|
||||
|
||||
let root_output = transport.root_command("id", Duration::from_secs(20))?;
|
||||
let root = String::from_utf8_lossy(&root_output);
|
||||
if !root.contains("uid=0") {
|
||||
return Err(RemoteError::NotRoot(
|
||||
"the selected channel did not return uid=0".to_owned(),
|
||||
));
|
||||
}
|
||||
Ok(transport)
|
||||
}
|
||||
|
||||
pub fn channel(&self) -> String {
|
||||
format!("ssh:{}@{}", self.options.user, self.options.host)
|
||||
}
|
||||
|
||||
pub fn root_method(&self) -> &'static str {
|
||||
match &self.strategy {
|
||||
Strategy::Direct => "direct",
|
||||
Strategy::Rroot => "rroot",
|
||||
Strategy::UpdateDaemon { .. } => "update-daemon",
|
||||
}
|
||||
}
|
||||
|
||||
pub fn update_daemon_port(&self) -> Option<u16> {
|
||||
match &self.strategy {
|
||||
Strategy::UpdateDaemon { remote_port, .. } => Some(*remote_port),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn ssh_base(&self) -> Command {
|
||||
let mut command = if let Some(password) = &self.options.password_file {
|
||||
let mut command = Command::new("sshpass");
|
||||
command.arg("-f").arg(password).arg("ssh");
|
||||
command
|
||||
} else {
|
||||
Command::new("ssh")
|
||||
};
|
||||
command
|
||||
.arg("-F")
|
||||
.arg("none")
|
||||
.arg("-o")
|
||||
.arg(if self.options.password_file.is_some() {
|
||||
"BatchMode=no"
|
||||
} else {
|
||||
"BatchMode=yes"
|
||||
})
|
||||
.arg("-o")
|
||||
.arg("StrictHostKeyChecking=accept-new")
|
||||
.arg("-o")
|
||||
.arg(format!("UserKnownHostsFile={}", self.known_hosts.display()))
|
||||
.arg("-o")
|
||||
.arg("GlobalKnownHostsFile=/dev/null")
|
||||
.arg("-o")
|
||||
.arg("ConnectTimeout=10")
|
||||
.arg("-o")
|
||||
.arg("ServerAliveInterval=5")
|
||||
.arg("-o")
|
||||
.arg("ServerAliveCountMax=3")
|
||||
.arg("-o")
|
||||
.arg("RequestTTY=no")
|
||||
.arg("-o")
|
||||
.arg("LogLevel=ERROR")
|
||||
.arg("-o")
|
||||
.arg("NumberOfPasswordPrompts=1")
|
||||
.arg("-o")
|
||||
.arg("PreferredAuthentications=publickey,password,keyboard-interactive");
|
||||
if let Some(identity) = &self.options.identity_file {
|
||||
command
|
||||
.arg("-i")
|
||||
.arg(identity)
|
||||
.arg("-o")
|
||||
.arg("IdentitiesOnly=yes");
|
||||
}
|
||||
command
|
||||
}
|
||||
|
||||
fn ssh_command(&self, command: &str) -> Command {
|
||||
let mut child = self.ssh_base();
|
||||
child
|
||||
.arg("-p")
|
||||
.arg(self.options.port.to_string())
|
||||
.arg(format!("{}@{}", self.options.user, self.options.host))
|
||||
.arg(command);
|
||||
child
|
||||
}
|
||||
|
||||
fn run_user(&self, command: &str, timeout: Duration) -> Result<Vec<u8>, RemoteError> {
|
||||
let (stdout, stderr, status) = run_bounded(self.ssh_command(command), timeout)?;
|
||||
if !status.success() {
|
||||
return Err(RemoteError::Command {
|
||||
status: status.to_string(),
|
||||
stderr: RemoteError::sanitize(&String::from_utf8_lossy(&stderr)),
|
||||
});
|
||||
}
|
||||
Ok(stdout)
|
||||
}
|
||||
|
||||
fn has_rroot(&self) -> Result<bool, RemoteError> {
|
||||
let out = self.run_user(
|
||||
"test -x /nvdata/rroot && echo yes || echo no",
|
||||
Duration::from_secs(15),
|
||||
)?;
|
||||
Ok(String::from_utf8_lossy(&out).contains("yes"))
|
||||
}
|
||||
|
||||
fn has_update_daemon(&self) -> Result<bool, RemoteError> {
|
||||
let out = self.run_user(
|
||||
"test -x /usr/sbin/update-daemon && echo yes || echo no",
|
||||
Duration::from_secs(15),
|
||||
)?;
|
||||
Ok(String::from_utf8_lossy(&out).contains("yes"))
|
||||
}
|
||||
|
||||
fn detect_update_daemon_port(&self) -> Result<u16, RemoteError> {
|
||||
let out = self.run_user(
|
||||
"cat /proc/net/tcp /proc/net/tcp6 2>/dev/null || true",
|
||||
Duration::from_secs(15),
|
||||
)?;
|
||||
let text = String::from_utf8_lossy(&out);
|
||||
for line in text.lines() {
|
||||
let fields: Vec<&str> = line.split_whitespace().collect();
|
||||
if fields.len() < 4 || fields[3] != "0A" {
|
||||
continue;
|
||||
}
|
||||
let local = fields[1];
|
||||
let port = local.rsplit(':').next().unwrap_or("");
|
||||
let port = u16::from_str_radix(port, 16).unwrap_or(0);
|
||||
if port == 12887 || port == 22026 {
|
||||
return Ok(port);
|
||||
}
|
||||
}
|
||||
// The CV1835 stock build listens on 12887. The fallback keeps the
|
||||
// explicit --update-daemon-port option available for other builds.
|
||||
Ok(12887)
|
||||
}
|
||||
|
||||
fn start_tunnel(&self, remote_port: u16) -> Result<(u16, Child), RemoteError> {
|
||||
let listener = std::net::TcpListener::bind(("127.0.0.1", 0))?;
|
||||
let local_port = listener.local_addr()?.port();
|
||||
drop(listener);
|
||||
let mut command = self.ssh_base();
|
||||
command
|
||||
.arg("-N")
|
||||
.arg("-o")
|
||||
.arg("ExitOnForwardFailure=yes")
|
||||
.arg("-L")
|
||||
.arg(format!("127.0.0.1:{local_port}:127.0.0.1:{remote_port}"))
|
||||
.arg("-p")
|
||||
.arg(self.options.port.to_string())
|
||||
.arg(format!("{}@{}", self.options.user, self.options.host))
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::null())
|
||||
.stderr(Stdio::null());
|
||||
let mut tunnel = command.spawn()?;
|
||||
let deadline = Instant::now() + Duration::from_secs(20);
|
||||
loop {
|
||||
if TcpStream::connect_timeout(
|
||||
&SocketAddr::from(([127, 0, 0, 1], local_port)),
|
||||
Duration::from_millis(500),
|
||||
)
|
||||
.is_ok()
|
||||
{
|
||||
return Ok((local_port, tunnel));
|
||||
}
|
||||
if let Some(status) = tunnel.try_wait()? {
|
||||
return Err(RemoteError::Daemon(format!(
|
||||
"SSH forward exited before it was ready ({status})"
|
||||
)));
|
||||
}
|
||||
if Instant::now() >= deadline {
|
||||
let _ = tunnel.kill();
|
||||
return Err(RemoteError::Daemon(
|
||||
"SSH forward did not become ready".to_owned(),
|
||||
));
|
||||
}
|
||||
thread::sleep(Duration::from_millis(250));
|
||||
}
|
||||
}
|
||||
|
||||
fn daemon_send(&self, command: &str) -> Result<(), RemoteError> {
|
||||
let Strategy::UpdateDaemon { local_port, .. } = &self.strategy else {
|
||||
return Err(RemoteError::Daemon("not using update-daemon".to_owned()));
|
||||
};
|
||||
let local_port = *local_port;
|
||||
if command.contains('\n') || command.contains('\r') {
|
||||
return Err(RemoteError::Daemon("command contains a newline".to_owned()));
|
||||
}
|
||||
let mut stream = TcpStream::connect_timeout(
|
||||
&SocketAddr::from(([127, 0, 0, 1], local_port)),
|
||||
Duration::from_secs(10),
|
||||
)?;
|
||||
stream.set_write_timeout(Some(Duration::from_secs(10)))?;
|
||||
stream.write_all(format!(";{command};").as_bytes())?;
|
||||
stream.flush()?;
|
||||
let _ = stream.set_read_timeout(Some(Duration::from_millis(500)));
|
||||
let mut sink = [0_u8; 256];
|
||||
let _ = stream.read(&mut sink);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn daemon_capture(&mut self, command: &str, timeout: Duration) -> Result<Vec<u8>, RemoteError> {
|
||||
let path = format!("/tmp/.alkane-root-{}-{}", std::process::id(), self.counter);
|
||||
self.counter += 1;
|
||||
let wrapped = format!("{{ {command} ; }} > {path} 2>&1; chmod 644 {path}");
|
||||
self.daemon_send(&wrapped)?;
|
||||
let deadline = Instant::now() + timeout;
|
||||
loop {
|
||||
let probe = format!("test -f {path} && echo ready || true");
|
||||
let out = self.run_user(&probe, Duration::from_secs(15))?;
|
||||
if String::from_utf8_lossy(&out).contains("ready") {
|
||||
break;
|
||||
}
|
||||
if Instant::now() >= deadline {
|
||||
return Err(RemoteError::Daemon(format!(
|
||||
"root command produced no output file within {timeout:?}"
|
||||
)));
|
||||
}
|
||||
thread::sleep(Duration::from_millis(200));
|
||||
}
|
||||
let output = self.run_user(&format!("cat {path}"), Duration::from_secs(60))?;
|
||||
let _ = self.run_user(&format!("rm -f {path}"), Duration::from_secs(15));
|
||||
Ok(output)
|
||||
}
|
||||
|
||||
fn daemon_reboot(&mut self) -> Result<(), RemoteError> {
|
||||
self.daemon_send("sync; echo b > /proc/sysrq-trigger")
|
||||
}
|
||||
}
|
||||
|
||||
impl Remote for SshTransport {
|
||||
fn channel(&self) -> &str {
|
||||
"ssh"
|
||||
}
|
||||
|
||||
fn root_method(&self) -> &'static str {
|
||||
SshTransport::root_method(self)
|
||||
}
|
||||
|
||||
fn user_command(&mut self, command: &str, timeout: Duration) -> Result<Vec<u8>, RemoteError> {
|
||||
self.run_user(command, timeout)
|
||||
}
|
||||
|
||||
fn root_command(&mut self, command: &str, timeout: Duration) -> Result<Vec<u8>, RemoteError> {
|
||||
match self.root_method() {
|
||||
"direct" => self.run_user(command, timeout),
|
||||
"rroot" => {
|
||||
let wrapped = format!("/nvdata/rroot -c {}", shell_quote(command));
|
||||
self.run_user(&wrapped, timeout)
|
||||
}
|
||||
"update-daemon" => self.daemon_capture(command, timeout),
|
||||
_ => Err(RemoteError::NoRootMethod),
|
||||
}
|
||||
}
|
||||
|
||||
fn push(&mut self, local: &Path, remote: &str, timeout: Duration) -> Result<(), RemoteError> {
|
||||
let remote = safe_remote_path(remote)?;
|
||||
let mut command = self.ssh_command(&format!("cat > {remote}"));
|
||||
command
|
||||
.stdin(Stdio::piped())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped());
|
||||
let mut child = command.spawn()?;
|
||||
let mut stdin = child.stdin.take().expect("piped stdin");
|
||||
let path = local.to_path_buf();
|
||||
let writer = thread::spawn(move || -> std::io::Result<()> {
|
||||
let mut source = fs::File::open(path)?;
|
||||
let mut buffer = [0_u8; 64 * 1024];
|
||||
loop {
|
||||
let read = source.read(&mut buffer)?;
|
||||
if read == 0 {
|
||||
break;
|
||||
}
|
||||
stdin.write_all(&buffer[..read])?;
|
||||
}
|
||||
stdin.flush()
|
||||
});
|
||||
let (stdout, stderr) = read_pipes(&mut child);
|
||||
let status = wait_timeout(&mut child, timeout)?;
|
||||
let _ = writer.join();
|
||||
let _ = stdout.join();
|
||||
let stderr = stderr.join().unwrap_or_default();
|
||||
if !status.success() {
|
||||
return Err(RemoteError::Command {
|
||||
status: status.to_string(),
|
||||
stderr: RemoteError::sanitize(&String::from_utf8_lossy(&stderr)),
|
||||
});
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn pull(&mut self, remote: &str, local: &Path, timeout: Duration) -> Result<(), RemoteError> {
|
||||
let remote = safe_remote_path(remote)?;
|
||||
let data = self.run_user(&format!("cat {remote}"), timeout)?;
|
||||
if data.len() > MAX_CAPTURE {
|
||||
return Err(RemoteError::OutputTooLarge(MAX_CAPTURE));
|
||||
}
|
||||
fs::write(local, data)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn reboot(&mut self) -> Result<(), RemoteError> {
|
||||
match self.root_method() {
|
||||
"update-daemon" => self.daemon_reboot(),
|
||||
_ => {
|
||||
// A successful sysrq reset drops the SSH connection mid-command.
|
||||
let _ = self.run_user(
|
||||
"sync; echo b > /proc/sysrq-trigger",
|
||||
Duration::from_secs(15),
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub trait Remote {
|
||||
fn channel(&self) -> &str;
|
||||
fn root_method(&self) -> &'static str {
|
||||
"network"
|
||||
}
|
||||
fn user_command(&mut self, command: &str, timeout: Duration) -> Result<Vec<u8>, RemoteError>;
|
||||
fn root_command(&mut self, command: &str, timeout: Duration) -> Result<Vec<u8>, RemoteError>;
|
||||
fn push(&mut self, local: &Path, remote: &str, timeout: Duration) -> Result<(), RemoteError>;
|
||||
fn pull(&mut self, remote: &str, local: &Path, timeout: Duration) -> Result<(), RemoteError>;
|
||||
fn reboot(&mut self) -> Result<(), RemoteError>;
|
||||
}
|
||||
|
||||
pub fn shell_quote(text: &str) -> String {
|
||||
format!("'{}'", text.replace('\'', "'\\''"))
|
||||
}
|
||||
|
||||
pub fn safe_remote_path(path: &str) -> Result<&str, RemoteError> {
|
||||
if !path.starts_with('/')
|
||||
|| path.len() > 200
|
||||
|| path.contains("..")
|
||||
|| !path
|
||||
.bytes()
|
||||
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'/' | b'.' | b'_' | b'-'))
|
||||
{
|
||||
return Err(RemoteError::InvalidTarget(format!(
|
||||
"unsafe remote path: {path}"
|
||||
)));
|
||||
}
|
||||
Ok(path)
|
||||
}
|
||||
|
||||
fn read_pipes(child: &mut Child) -> (thread::JoinHandle<Vec<u8>>, thread::JoinHandle<Vec<u8>>) {
|
||||
let mut stdout = child.stdout.take().expect("piped stdout");
|
||||
let mut stderr = child.stderr.take().expect("piped stderr");
|
||||
let out = thread::spawn(move || {
|
||||
let mut data = Vec::new();
|
||||
let _ = stdout.read_to_end(&mut data);
|
||||
data
|
||||
});
|
||||
let err = thread::spawn(move || {
|
||||
let mut data = Vec::new();
|
||||
let _ = stderr.read_to_end(&mut data);
|
||||
data
|
||||
});
|
||||
(out, err)
|
||||
}
|
||||
|
||||
fn wait_timeout(child: &mut Child, timeout: Duration) -> Result<ExitStatus, RemoteError> {
|
||||
let deadline = Instant::now() + timeout;
|
||||
loop {
|
||||
if let Some(status) = child.try_wait()? {
|
||||
return Ok(status);
|
||||
}
|
||||
if Instant::now() >= deadline {
|
||||
let _ = child.kill();
|
||||
let _ = child.wait();
|
||||
return Err(RemoteError::Timeout(timeout));
|
||||
}
|
||||
thread::sleep(Duration::from_millis(20));
|
||||
}
|
||||
}
|
||||
|
||||
fn run_bounded(
|
||||
mut command: Command,
|
||||
timeout: Duration,
|
||||
) -> Result<(Vec<u8>, Vec<u8>, ExitStatus), RemoteError> {
|
||||
command
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped());
|
||||
let mut child = command.spawn()?;
|
||||
let (stdout, stderr) = read_pipes(&mut child);
|
||||
let status = wait_timeout(&mut child, timeout)?;
|
||||
let stdout = stdout.join().unwrap_or_default();
|
||||
let stderr = stderr.join().unwrap_or_default();
|
||||
if stdout.len() > MAX_CAPTURE {
|
||||
return Err(RemoteError::OutputTooLarge(MAX_CAPTURE));
|
||||
}
|
||||
Ok((stdout, stderr, status))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn quotes_shell_arguments_for_rroot() {
|
||||
assert_eq!(shell_quote("id"), "'id'");
|
||||
assert_eq!(shell_quote("echo 'x'"), "'echo '\\''x'\\'''");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_option_injection_and_unsafe_paths() {
|
||||
let mut options = SshOptions {
|
||||
host: "-oProxyCommand=bad".to_owned(),
|
||||
user: "root".to_owned(),
|
||||
..SshOptions::default()
|
||||
};
|
||||
assert!(options.validate().is_err());
|
||||
options.host = "10.255.1.167".to_owned();
|
||||
options.user = "root;id".to_owned();
|
||||
assert!(options.validate().is_err());
|
||||
assert!(safe_remote_path("/tmp/ok.img").is_ok());
|
||||
assert!(safe_remote_path("relative").is_err());
|
||||
assert!(safe_remote_path("/tmp/../etc/passwd").is_err());
|
||||
assert!(safe_remote_path("/tmp/a;b").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_root_methods() {
|
||||
assert_eq!(RootMethod::parse("auto"), Some(RootMethod::Auto));
|
||||
assert_eq!(
|
||||
RootMethod::parse("update-daemon"),
|
||||
Some(RootMethod::UpdateDaemon)
|
||||
);
|
||||
assert_eq!(RootMethod::parse("serial"), None);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,152 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Legacy U-Boot image (`uImage`) header builder.
|
||||
//!
|
||||
//! The Zynq (Antminer S17/S19-class) stock U-Boot boots a legacy uImage: a
|
||||
//! 64-byte big-endian header (magic `0x27051956`) in front of the payload. We
|
||||
//! wrap the kernel (a raw ARM `zImage`) and the ramdisk (a gzipped cpio) in this
|
||||
//! header so the board's own U-Boot boots them unchanged. The device tree is
|
||||
//! written raw (no header).
|
||||
//!
|
||||
//! The header parameters below were read directly off a genuine stock S17 NAND
|
||||
//! (kernel: type Kernel, uncompressed, load/entry `0x8000`; ramdisk: type
|
||||
//! RAMDisk, gzip, load/entry `0`), so the images we write match exactly what the
|
||||
//! stock boot chain already boots.
|
||||
|
||||
/// Legacy uImage magic (big-endian).
|
||||
pub const IH_MAGIC: u32 = 0x2705_1956;
|
||||
/// Header length in bytes.
|
||||
pub const HEADER_LEN: usize = 64;
|
||||
|
||||
// ih_os
|
||||
const IH_OS_LINUX: u8 = 5;
|
||||
// ih_arch
|
||||
const IH_ARCH_ARM: u8 = 2;
|
||||
// ih_type
|
||||
const IH_TYPE_KERNEL: u8 = 2;
|
||||
const IH_TYPE_RAMDISK: u8 = 3;
|
||||
// ih_comp
|
||||
const IH_COMP_NONE: u8 = 0;
|
||||
const IH_COMP_GZIP: u8 = 1;
|
||||
|
||||
/// A CRC-32 (IEEE 802.3, the variant U-Boot uses) over `data`.
|
||||
pub fn crc32(data: &[u8]) -> u32 {
|
||||
let mut crc: u32 = 0xFFFF_FFFF;
|
||||
for &byte in data {
|
||||
crc ^= byte as u32;
|
||||
for _ in 0..8 {
|
||||
let mask = (crc & 1).wrapping_neg();
|
||||
crc = (crc >> 1) ^ (0xEDB8_8320 & mask);
|
||||
}
|
||||
}
|
||||
!crc
|
||||
}
|
||||
|
||||
/// Which kind of uImage to build.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Kind {
|
||||
/// ARM Linux kernel, uncompressed, load/entry 0x8000 (what the stock S17
|
||||
/// kernel uImage uses).
|
||||
Kernel,
|
||||
/// ARM Linux ramdisk, gzip, load/entry 0 (what the stock S17 ramdisk uImage
|
||||
/// uses).
|
||||
Ramdisk,
|
||||
}
|
||||
|
||||
impl Kind {
|
||||
fn ih_type(self) -> u8 {
|
||||
match self {
|
||||
Kind::Kernel => IH_TYPE_KERNEL,
|
||||
Kind::Ramdisk => IH_TYPE_RAMDISK,
|
||||
}
|
||||
}
|
||||
fn ih_comp(self) -> u8 {
|
||||
match self {
|
||||
Kind::Kernel => IH_COMP_NONE,
|
||||
Kind::Ramdisk => IH_COMP_GZIP,
|
||||
}
|
||||
}
|
||||
fn load_entry(self) -> u32 {
|
||||
match self {
|
||||
Kind::Kernel => 0x8000,
|
||||
Kind::Ramdisk => 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Wrap `payload` in a legacy uImage header of the given `kind` and return the
|
||||
/// full image (header followed by payload). `time` is the header timestamp; pass
|
||||
/// a fixed value for a reproducible image. `name` is truncated to 31 bytes.
|
||||
pub fn wrap(kind: Kind, payload: &[u8], time: u32, name: &str) -> Vec<u8> {
|
||||
let mut hdr = [0u8; HEADER_LEN];
|
||||
hdr[0..4].copy_from_slice(&IH_MAGIC.to_be_bytes());
|
||||
// hdr[4..8] header CRC: filled in last, over the header with this field zero.
|
||||
hdr[8..12].copy_from_slice(&time.to_be_bytes());
|
||||
hdr[12..16].copy_from_slice(&(payload.len() as u32).to_be_bytes());
|
||||
hdr[16..20].copy_from_slice(&kind.load_entry().to_be_bytes());
|
||||
hdr[20..24].copy_from_slice(&kind.load_entry().to_be_bytes());
|
||||
hdr[24..28].copy_from_slice(&crc32(payload).to_be_bytes());
|
||||
hdr[28] = IH_OS_LINUX;
|
||||
hdr[29] = IH_ARCH_ARM;
|
||||
hdr[30] = kind.ih_type();
|
||||
hdr[31] = kind.ih_comp();
|
||||
let name_bytes = name.as_bytes();
|
||||
let n = name_bytes.len().min(31);
|
||||
hdr[32..32 + n].copy_from_slice(&name_bytes[..n]);
|
||||
// Header CRC over the 64-byte header with the hcrc field (4..8) zeroed.
|
||||
let hcrc = crc32(&hdr);
|
||||
hdr[4..8].copy_from_slice(&hcrc.to_be_bytes());
|
||||
|
||||
let mut out = Vec::with_capacity(HEADER_LEN + payload.len());
|
||||
out.extend_from_slice(&hdr);
|
||||
out.extend_from_slice(payload);
|
||||
out
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn crc32_known_vector() {
|
||||
// CRC-32/ISO-HDLC of "123456789" is 0xCBF43926.
|
||||
assert_eq!(crc32(b"123456789"), 0xCBF4_3926);
|
||||
assert_eq!(crc32(b""), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn header_shape_and_fields() {
|
||||
let img = wrap(Kind::Kernel, b"payload-bytes", 0, "alkane");
|
||||
assert_eq!(img.len(), HEADER_LEN + 13);
|
||||
assert_eq!(&img[0..4], &IH_MAGIC.to_be_bytes());
|
||||
assert_eq!(u32::from_be_bytes([img[12], img[13], img[14], img[15]]), 13);
|
||||
// kernel: load/entry 0x8000, type kernel, comp none
|
||||
assert_eq!(&img[16..20], &0x8000u32.to_be_bytes());
|
||||
assert_eq!(&img[20..24], &0x8000u32.to_be_bytes());
|
||||
assert_eq!(img[28], IH_OS_LINUX);
|
||||
assert_eq!(img[29], IH_ARCH_ARM);
|
||||
assert_eq!(img[30], IH_TYPE_KERNEL);
|
||||
assert_eq!(img[31], IH_COMP_NONE);
|
||||
assert_eq!(&img[64..], b"payload-bytes");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ramdisk_fields() {
|
||||
let img = wrap(Kind::Ramdisk, b"rd", 0, "rd");
|
||||
assert_eq!(&img[16..20], &0u32.to_be_bytes());
|
||||
assert_eq!(img[30], IH_TYPE_RAMDISK);
|
||||
assert_eq!(img[31], IH_COMP_GZIP);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn header_crc_validates() {
|
||||
let img = wrap(Kind::Kernel, b"abc", 0x1234, "n");
|
||||
let mut hdr = [0u8; HEADER_LEN];
|
||||
hdr.copy_from_slice(&img[..HEADER_LEN]);
|
||||
let stored = u32::from_be_bytes([hdr[4], hdr[5], hdr[6], hdr[7]]);
|
||||
hdr[4..8].copy_from_slice(&[0, 0, 0, 0]);
|
||||
assert_eq!(crc32(&hdr), stored);
|
||||
// data CRC over payload
|
||||
let dcrc = u32::from_be_bytes([img[24], img[25], img[26], img[27]]);
|
||||
assert_eq!(crc32(b"abc"), dcrc);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,809 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
//! Readable Zynq-7010 NAND install / restore / on-board-backup, driven entirely
|
||||
//! over the network through two small root shells:
|
||||
//!
|
||||
//! * a board on **stock** is reached with the DSH root-on-stock primitives
|
||||
//! (`crate::stock::root_exec` / `root_put`): this is the only compartmentalised
|
||||
//! piece, and it is used only to get a root shell;
|
||||
//! * a board on **alkane** is reached with ordinary SSH (`crate::transport`).
|
||||
//!
|
||||
//! Everything else -- what to write, where, in what form, and the read-back
|
||||
//! verification -- lives here in plain, auditable Rust. The NAND writes
|
||||
//! themselves are the same `flash_erase` + `nandwrite` MTD operations on both
|
||||
//! sides; only the way we obtain the root shell differs.
|
||||
//!
|
||||
//! Absolute NAND map (Micron MT29F2G08, 256 MiB, 128 KiB erase, 2 KiB page),
|
||||
//! confirmed on a genuine stock S17 and mirrored by the alkane board DT:
|
||||
//! ```text
|
||||
//! 0x00000000 BOOT.bin (FSBL + bitstream + stock U-Boot + env) NEVER written
|
||||
//! 0x01a00000 device tree (raw fdt)
|
||||
//! 0x02000000 kernel (legacy uImage)
|
||||
//! 0x02800000 rootfs (legacy uImage ramdisk)
|
||||
//! 0x04800000 stock `configs` (UBI) exposed read-only on alkane
|
||||
//! 0x05000000 alkane-cfg (persisted MAC)
|
||||
//! 0x06000000 on-board genuine-stock backup (stock `ramfs-bak` region)
|
||||
//! 0x08000000 stock `reserve1` / nvdata (UBI) left untouched
|
||||
//! ```
|
||||
//! On a board running alkane the boot slots are exposed as the named partitions
|
||||
//! `boot-dtb` / `boot-kernel` / `boot-rootfs` / `stock-backup` (see the board
|
||||
//! DT); on stock they fall inside `mtd0` / `mtd1` / `ramfs-bak`. Because we map
|
||||
//! an absolute offset to whichever MTD partition contains it, the same code
|
||||
//! writes the same physical NAND on both sides.
|
||||
|
||||
use crate::md5::md5_hex;
|
||||
use crate::stock::StockError;
|
||||
use crate::transport::{Remote, SshOptions, SshTransport};
|
||||
use crate::uimage::{self, Kind};
|
||||
use std::path::Path;
|
||||
use std::sync::atomic::{AtomicU64, Ordering};
|
||||
use std::time::Duration;
|
||||
|
||||
/// NAND erase-block size (128 KiB).
|
||||
const ERASE: u64 = 0x20000;
|
||||
/// NAND page size (2 KiB); `nandwrite -p` pads the final page with 0xFF.
|
||||
const PAGE: u64 = 0x800;
|
||||
|
||||
/// Absolute boot-slot offsets (see the module map).
|
||||
const OFF_DTB: u64 = 0x1a00000;
|
||||
const OFF_KERNEL: u64 = 0x2000000;
|
||||
const OFF_ROOTFS: u64 = 0x2800000;
|
||||
const OFF_STOCK_BACKUP: u64 = 0x6000000;
|
||||
/// BOOT.bin occupies 0x0..0x1a00000 and is never written.
|
||||
const BOOTBIN_PRESERVE: u64 = 0x1a00000;
|
||||
|
||||
/// Slot ceilings (so a too-large image is refused before any erase).
|
||||
const SLOT_DTB: u64 = 0x600000;
|
||||
const SLOT_KERNEL: u64 = 0x800000;
|
||||
const SLOT_ROOTFS: u64 = 0x2000000;
|
||||
const SLOT_STOCK_BACKUP: u64 = 0x2000000;
|
||||
|
||||
/// Where the backup data lives inside the 32 MiB stock-backup region: the first
|
||||
/// erase block holds the manifest, the images follow, each erase-block aligned.
|
||||
const BK_MANIFEST: u64 = OFF_STOCK_BACKUP; // 0x6000000
|
||||
const BK_MAGIC: &[u8; 8] = b"ALKSTKB1";
|
||||
|
||||
fn round_up(value: u64, to: u64) -> u64 {
|
||||
value.div_ceil(to) * to
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Root shells
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// A root shell on the target board: run a `/bin/sh` command as root and stream
|
||||
/// a byte payload to a file as root. Both sides implement this; the NAND code
|
||||
/// below is written once against it.
|
||||
trait Shell {
|
||||
fn exec(&mut self, cmd: &str) -> Result<String, StockError>;
|
||||
fn put(&mut self, data: &[u8], remote_path: &str) -> Result<(), StockError>;
|
||||
/// Longer-running command (large nandwrite / nanddump).
|
||||
fn exec_long(&mut self, cmd: &str) -> Result<String, StockError>;
|
||||
}
|
||||
|
||||
/// Stock board: root obtained through the compartmentalised DSH primitive.
|
||||
struct StockShell {
|
||||
host: String,
|
||||
password: Option<String>,
|
||||
}
|
||||
|
||||
impl Shell for StockShell {
|
||||
fn exec(&mut self, cmd: &str) -> Result<String, StockError> {
|
||||
crate::stock::root_exec(&self.host, self.password.as_deref(), cmd)
|
||||
}
|
||||
fn exec_long(&mut self, cmd: &str) -> Result<String, StockError> {
|
||||
crate::stock::root_exec(&self.host, self.password.as_deref(), cmd)
|
||||
}
|
||||
fn put(&mut self, data: &[u8], remote_path: &str) -> Result<(), StockError> {
|
||||
crate::stock::root_put(&self.host, self.password.as_deref(), data, remote_path)
|
||||
}
|
||||
}
|
||||
|
||||
/// Alkane board: root over ordinary SSH. A throwaway known-hosts file is used
|
||||
/// so a board whose SSH host key legitimately changed across an install still
|
||||
/// connects (accept-new), which is the norm on the bench.
|
||||
struct AlkaneShell {
|
||||
transport: SshTransport,
|
||||
_secret: TempFile,
|
||||
}
|
||||
|
||||
static TEMP_SEQ: AtomicU64 = AtomicU64::new(0);
|
||||
|
||||
fn temp_path(tag: &str) -> std::path::PathBuf {
|
||||
let n = TEMP_SEQ.fetch_add(1, Ordering::Relaxed);
|
||||
std::env::temp_dir().join(format!("alkane-{}-{}-{}", std::process::id(), tag, n))
|
||||
}
|
||||
|
||||
/// A 0600 temp file removed on drop.
|
||||
struct TempFile(std::path::PathBuf);
|
||||
impl TempFile {
|
||||
fn with(contents: &[u8], tag: &str) -> Result<Self, StockError> {
|
||||
let path = temp_path(tag);
|
||||
write_private(&path, contents).map_err(|e| StockError::Io(e.to_string()))?;
|
||||
Ok(TempFile(path))
|
||||
}
|
||||
}
|
||||
impl Drop for TempFile {
|
||||
fn drop(&mut self) {
|
||||
let _ = std::fs::remove_file(&self.0);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
fn write_private(path: &Path, contents: &[u8]) -> std::io::Result<()> {
|
||||
use std::io::Write as _;
|
||||
use std::os::unix::fs::OpenOptionsExt;
|
||||
let mut f = std::fs::OpenOptions::new()
|
||||
.create(true)
|
||||
.truncate(true)
|
||||
.write(true)
|
||||
.mode(0o600)
|
||||
.open(path)?;
|
||||
f.write_all(contents)?;
|
||||
f.flush()
|
||||
}
|
||||
|
||||
#[cfg(not(unix))]
|
||||
fn write_private(path: &Path, contents: &[u8]) -> std::io::Result<()> {
|
||||
std::fs::write(path, contents)
|
||||
}
|
||||
|
||||
impl AlkaneShell {
|
||||
fn connect(host: &str, password: Option<&str>) -> Result<Self, StockError> {
|
||||
let secret = TempFile::with(password.unwrap_or("alkane").as_bytes(), "pw")?;
|
||||
let known = temp_path("kh");
|
||||
let _ = std::fs::File::create(&known); // empty -> accept-new always accepts
|
||||
let options = SshOptions {
|
||||
host: host.to_owned(),
|
||||
port: 22,
|
||||
user: "root".to_owned(),
|
||||
identity_file: None,
|
||||
password_file: Some(secret.0.clone()),
|
||||
known_hosts: Some(known),
|
||||
root_method: crate::transport::RootMethod::Auto,
|
||||
update_daemon_port: None,
|
||||
};
|
||||
let transport =
|
||||
SshTransport::connect(options, true).map_err(|e| StockError::Network(e.to_string()))?;
|
||||
Ok(AlkaneShell {
|
||||
transport,
|
||||
_secret: secret,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl Shell for AlkaneShell {
|
||||
fn exec(&mut self, cmd: &str) -> Result<String, StockError> {
|
||||
self.transport
|
||||
.root_command(cmd, Duration::from_secs(120))
|
||||
.map(|o| String::from_utf8_lossy(&o).into_owned())
|
||||
.map_err(|e| StockError::Method(e.to_string()))
|
||||
}
|
||||
fn exec_long(&mut self, cmd: &str) -> Result<String, StockError> {
|
||||
self.transport
|
||||
.root_command(cmd, Duration::from_secs(900))
|
||||
.map(|o| String::from_utf8_lossy(&o).into_owned())
|
||||
.map_err(|e| StockError::Method(e.to_string()))
|
||||
}
|
||||
fn put(&mut self, data: &[u8], remote_path: &str) -> Result<(), StockError> {
|
||||
let tmp = TempFile::with(data, "put")?;
|
||||
self.transport
|
||||
.push(&tmp.0, remote_path, Duration::from_secs(900))
|
||||
.map_err(|e| StockError::Method(e.to_string()))
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// MTD table: map an absolute NAND offset to (device, relative offset)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
struct Mtd {
|
||||
dev: String, // e.g. "mtd2"
|
||||
base: u64, // absolute NAND offset of the partition start
|
||||
size: u64,
|
||||
#[allow(dead_code)]
|
||||
name: String,
|
||||
}
|
||||
|
||||
/// Read the MTD partition table. Each partition's absolute base comes from
|
||||
/// `/sys/class/mtd/<dev>/offset` when present (alkane, where partitions are not
|
||||
/// contiguous), falling back to the cumulative sum of sizes in `/proc/mtd`
|
||||
/// order (stock, where they are contiguous from 0).
|
||||
fn read_mtd_table(sh: &mut dyn Shell) -> Result<Vec<Mtd>, StockError> {
|
||||
// name + size from /proc/mtd (always present); offset from sysfs if present.
|
||||
let proc = sh.exec("cat /proc/mtd")?;
|
||||
let mut out = Vec::new();
|
||||
let mut cursor = 0u64;
|
||||
for line in proc.lines() {
|
||||
let line = line.trim();
|
||||
if !line.starts_with("mtd") {
|
||||
continue;
|
||||
}
|
||||
// "mtd0: 02800000 00020000 \"name\""
|
||||
let (dev, rest) = match line.split_once(':') {
|
||||
Some(v) => v,
|
||||
None => continue,
|
||||
};
|
||||
let mut it = rest.split_whitespace();
|
||||
let size = it
|
||||
.next()
|
||||
.and_then(|h| u64::from_str_radix(h, 16).ok())
|
||||
.ok_or_else(|| StockError::Method(format!("bad /proc/mtd line: {line}")))?;
|
||||
let _erase = it.next();
|
||||
let name = line.split('"').nth(1).unwrap_or("").to_owned();
|
||||
let base = match sysfs_offset(sh, dev) {
|
||||
Some(off) => off,
|
||||
None => cursor,
|
||||
};
|
||||
cursor = cursor.max(base) + size;
|
||||
out.push(Mtd {
|
||||
dev: dev.to_owned(),
|
||||
base,
|
||||
size,
|
||||
name,
|
||||
});
|
||||
}
|
||||
if out.is_empty() {
|
||||
return Err(StockError::Method("no MTD partitions found".into()));
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
fn sysfs_offset(sh: &mut dyn Shell, dev: &str) -> Option<u64> {
|
||||
let out = sh
|
||||
.exec(&format!("cat /sys/class/mtd/{dev}/offset 2>/dev/null"))
|
||||
.ok()?;
|
||||
out.trim().parse::<u64>().ok()
|
||||
}
|
||||
|
||||
/// Find the partition that contains `abs` and holding at least `len` bytes from
|
||||
/// there; return (device, relative offset).
|
||||
fn locate(table: &[Mtd], abs: u64, len: u64) -> Result<(&str, u64), StockError> {
|
||||
for m in table {
|
||||
if abs >= m.base && abs < m.base + m.size {
|
||||
let rel = abs - m.base;
|
||||
if rel + len > m.size {
|
||||
return Err(StockError::Method(format!(
|
||||
"write of {len} B at abs 0x{abs:x} overruns {} (rel 0x{rel:x}, size 0x{:x})",
|
||||
m.dev, m.size
|
||||
)));
|
||||
}
|
||||
return Ok((&m.dev, rel));
|
||||
}
|
||||
}
|
||||
Err(StockError::Method(format!(
|
||||
"no MTD partition exposes absolute offset 0x{abs:x} (is the boot region mapped?)"
|
||||
)))
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// NAND primitives
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// MD5 of `data` padded with 0xFF up to the next page boundary -- what a
|
||||
/// `nandwrite -p` of `data` leaves on flash and what `nanddump -l <rounded>`
|
||||
/// reads back.
|
||||
fn padded_md5(data: &[u8]) -> String {
|
||||
let rounded = round_up(data.len() as u64, PAGE) as usize;
|
||||
let mut buf = data.to_vec();
|
||||
buf.resize(rounded, 0xFF);
|
||||
md5_hex(&buf)
|
||||
}
|
||||
|
||||
/// Write `data` to absolute NAND offset `abs`, staging it in `/tmp/alk`, erasing
|
||||
/// the covering erase blocks, writing with `nandwrite -p`, and verifying the
|
||||
/// read-back against the padded MD5. `abs` must be erase-block aligned.
|
||||
fn write_abs(
|
||||
sh: &mut dyn Shell,
|
||||
table: &[Mtd],
|
||||
abs: u64,
|
||||
data: &[u8],
|
||||
label: &str,
|
||||
) -> Result<(), StockError> {
|
||||
if abs < BOOTBIN_PRESERVE {
|
||||
return Err(StockError::Method(format!(
|
||||
"refusing to write {label} at 0x{abs:x}: inside preserved BOOT.bin"
|
||||
)));
|
||||
}
|
||||
if !abs.is_multiple_of(ERASE) {
|
||||
return Err(StockError::Method(format!(
|
||||
"{label} offset 0x{abs:x} is not erase-block aligned"
|
||||
)));
|
||||
}
|
||||
let (dev, rel) = locate(table, abs, data.len() as u64)?;
|
||||
let dev = dev.to_owned();
|
||||
let blocks = round_up(data.len() as u64, ERASE) / ERASE;
|
||||
let remote = format!("/tmp/alk/{label}.img");
|
||||
sh.exec("mkdir -p /tmp/alk")?;
|
||||
sh.put(data, &remote)?;
|
||||
// Confirm the staged payload arrived intact before we erase anything.
|
||||
let put_md5 = first_token(&sh.exec(&format!("md5sum {remote}"))?);
|
||||
if put_md5 != md5_hex(data) {
|
||||
return Err(StockError::Method(format!(
|
||||
"{label}: staged copy md5 {put_md5} != {} (transfer corrupted)",
|
||||
md5_hex(data)
|
||||
)));
|
||||
}
|
||||
sh.exec_long(&format!(
|
||||
"flash_erase /dev/{dev} 0x{rel:x} {blocks} >/dev/null 2>&1 && \
|
||||
nandwrite -p -s 0x{rel:x} /dev/{dev} {remote} >/dev/null 2>&1 && echo WROTE"
|
||||
))
|
||||
.and_then(|o| {
|
||||
if o.contains("WROTE") {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(StockError::Method(format!(
|
||||
"{label}: erase/write failed: {o}"
|
||||
)))
|
||||
}
|
||||
})?;
|
||||
let readlen = round_up(data.len() as u64, PAGE);
|
||||
let back = first_token(&sh.exec_long(&format!(
|
||||
"nanddump -s 0x{rel:x} -l {readlen} /dev/{dev} 2>/dev/null | md5sum"
|
||||
))?);
|
||||
let want = padded_md5(data);
|
||||
if back != want {
|
||||
return Err(StockError::Method(format!(
|
||||
"{label}: read-back md5 {back} != {want} at /dev/{dev} rel 0x{rel:x} \
|
||||
(write did not persist)"
|
||||
)));
|
||||
}
|
||||
sh.exec(&format!("rm -f {remote}"))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Copy `len` bytes already on NAND from absolute `src` to absolute `dst`
|
||||
/// (used when carving the on-board stock backup). `dst` must be erase aligned.
|
||||
fn copy_abs(
|
||||
sh: &mut dyn Shell,
|
||||
table: &[Mtd],
|
||||
src: u64,
|
||||
dst: u64,
|
||||
len: u64,
|
||||
label: &str,
|
||||
) -> Result<(), StockError> {
|
||||
let (sdev, srel) = locate(table, src, len)?;
|
||||
let sdev = sdev.to_owned();
|
||||
let (ddev, drel) = locate(table, dst, len)?;
|
||||
let ddev = ddev.to_owned();
|
||||
let blocks = round_up(len, ERASE) / ERASE;
|
||||
let tmp = format!("/tmp/alk/{label}.bak");
|
||||
sh.exec("mkdir -p /tmp/alk")?;
|
||||
let out = sh.exec_long(&format!(
|
||||
"nanddump -s 0x{srel:x} -l {len} /dev/{sdev} -f {tmp} >/dev/null 2>&1 && \
|
||||
flash_erase /dev/{ddev} 0x{drel:x} {blocks} >/dev/null 2>&1 && \
|
||||
nandwrite -p -s 0x{drel:x} /dev/{ddev} {tmp} >/dev/null 2>&1 && \
|
||||
rm -f {tmp} && echo COPIED"
|
||||
))?;
|
||||
if !out.contains("COPIED") {
|
||||
return Err(StockError::Method(format!(
|
||||
"{label}: backup copy failed: {out}"
|
||||
)));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Read `len` (even) bytes from NAND at (dev, rel) as raw bytes, via
|
||||
/// `od -v -x`, which is the only `od` form the stock busybox understands (no
|
||||
/// `-A`/`-t`). The leading octal address column and trailing byte-count line are
|
||||
/// discarded by [`parse_od`].
|
||||
fn read_small(sh: &mut dyn Shell, dev: &str, rel: u64, len: u64) -> Result<Vec<u8>, StockError> {
|
||||
let out = sh.exec(&format!(
|
||||
"nanddump -s 0x{rel:x} -l {len} /dev/{dev} 2>/dev/null | od -v -x"
|
||||
))?;
|
||||
Ok(parse_od(&out))
|
||||
}
|
||||
|
||||
/// Read a big-endian u32 at byte `field_off` within the image whose header
|
||||
/// starts at the (page-aligned) absolute NAND offset `region_abs`. `nanddump`
|
||||
/// needs a page-aligned `-s`, so we read the first 64 bytes of the region and
|
||||
/// slice the field in Rust (used to size the genuine stock images from their
|
||||
/// uImage / fdt headers before backing up).
|
||||
fn read_header_u32_be(
|
||||
sh: &mut dyn Shell,
|
||||
table: &[Mtd],
|
||||
region_abs: u64,
|
||||
field_off: usize,
|
||||
) -> Result<u32, StockError> {
|
||||
let (dev, rel) = locate(table, region_abs, 64)?;
|
||||
let dev = dev.to_owned();
|
||||
let b = read_small(sh, &dev, rel, 64)?;
|
||||
if b.len() < field_off + 4 {
|
||||
return Err(StockError::Method(format!(
|
||||
"short header read at 0x{region_abs:x} ({} bytes)",
|
||||
b.len()
|
||||
)));
|
||||
}
|
||||
Ok(u32::from_be_bytes([
|
||||
b[field_off],
|
||||
b[field_off + 1],
|
||||
b[field_off + 2],
|
||||
b[field_off + 3],
|
||||
]))
|
||||
}
|
||||
|
||||
fn first_token(s: &str) -> String {
|
||||
s.split_whitespace().next().unwrap_or("").to_owned()
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// On-board stock backup manifest
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
struct BackupManifest {
|
||||
kernel_abs: u64,
|
||||
kernel_len: u64,
|
||||
dtb_abs: u64,
|
||||
dtb_len: u64,
|
||||
rootfs_abs: u64,
|
||||
rootfs_len: u64,
|
||||
}
|
||||
|
||||
impl BackupManifest {
|
||||
fn encode(&self) -> Vec<u8> {
|
||||
let mut v = Vec::with_capacity(64);
|
||||
v.extend_from_slice(BK_MAGIC);
|
||||
for n in [
|
||||
self.kernel_abs,
|
||||
self.kernel_len,
|
||||
self.dtb_abs,
|
||||
self.dtb_len,
|
||||
self.rootfs_abs,
|
||||
self.rootfs_len,
|
||||
] {
|
||||
v.extend_from_slice(&n.to_be_bytes());
|
||||
}
|
||||
v
|
||||
}
|
||||
fn decode(b: &[u8]) -> Option<Self> {
|
||||
if b.len() < 8 + 6 * 8 || &b[..8] != BK_MAGIC {
|
||||
return None;
|
||||
}
|
||||
let g = |i: usize| {
|
||||
let mut a = [0u8; 8];
|
||||
a.copy_from_slice(&b[8 + i * 8..8 + i * 8 + 8]);
|
||||
u64::from_be_bytes(a)
|
||||
};
|
||||
Some(BackupManifest {
|
||||
kernel_abs: g(0),
|
||||
kernel_len: g(1),
|
||||
dtb_abs: g(2),
|
||||
dtb_len: g(3),
|
||||
rootfs_abs: g(4),
|
||||
rootfs_len: g(5),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Carve the genuine stock kernel + dtb + ramdisk (still on NAND) into the
|
||||
/// stock-backup region, with a manifest in its first block, so the board can be
|
||||
/// returned to its own factory stock later with no vendor file. Called on the
|
||||
/// stock side during a from-stock install, before the boot slots are overwritten.
|
||||
fn carve_backup(sh: &mut dyn Shell, table: &[Mtd]) -> Result<BackupManifest, StockError> {
|
||||
// Size the genuine images from their on-NAND headers (uImage data size at
|
||||
// header offset 12; fdt totalsize at offset 4).
|
||||
let kernel_len = 64 + read_header_u32_be(sh, table, OFF_KERNEL, 12)? as u64;
|
||||
let dtb_len = read_header_u32_be(sh, table, OFF_DTB, 4)? as u64;
|
||||
let rootfs_len = 64 + read_header_u32_be(sh, table, OFF_ROOTFS, 12)? as u64;
|
||||
// Sanity: headers must look like a uImage/fdt, sizes within slots.
|
||||
if !(64..=SLOT_KERNEL).contains(&kernel_len) || !(64..=SLOT_ROOTFS).contains(&rootfs_len) {
|
||||
return Err(StockError::Method(format!(
|
||||
"stock image sizes implausible (kernel {kernel_len}, rootfs {rootfs_len}); \
|
||||
refusing to back up"
|
||||
)));
|
||||
}
|
||||
let k_dst = BK_MANIFEST + ERASE; // images follow the manifest block
|
||||
let d_dst = k_dst + round_up(kernel_len, ERASE);
|
||||
let r_dst = d_dst + round_up(dtb_len, ERASE);
|
||||
if r_dst + round_up(rootfs_len, ERASE) > OFF_STOCK_BACKUP + SLOT_STOCK_BACKUP {
|
||||
return Err(StockError::Method(
|
||||
"stock backup does not fit in the 32 MiB backup region".into(),
|
||||
));
|
||||
}
|
||||
copy_abs(sh, table, OFF_KERNEL, k_dst, kernel_len, "stock-kernel")?;
|
||||
copy_abs(sh, table, OFF_DTB, d_dst, dtb_len, "stock-dtb")?;
|
||||
copy_abs(sh, table, OFF_ROOTFS, r_dst, rootfs_len, "stock-rootfs")?;
|
||||
let manifest = BackupManifest {
|
||||
kernel_abs: k_dst,
|
||||
kernel_len,
|
||||
dtb_abs: d_dst,
|
||||
dtb_len,
|
||||
rootfs_abs: r_dst,
|
||||
rootfs_len,
|
||||
};
|
||||
write_abs(
|
||||
sh,
|
||||
table,
|
||||
BK_MANIFEST,
|
||||
&manifest.encode(),
|
||||
"stock-backup-manifest",
|
||||
)?;
|
||||
Ok(manifest)
|
||||
}
|
||||
|
||||
/// Read and validate the on-board backup manifest, if present.
|
||||
fn read_backup_manifest(
|
||||
sh: &mut dyn Shell,
|
||||
table: &[Mtd],
|
||||
) -> Result<Option<BackupManifest>, StockError> {
|
||||
let (dev, rel) = match locate(table, BK_MANIFEST, 64) {
|
||||
Ok(v) => v,
|
||||
Err(_) => return Ok(None), // region not mapped -> treat as absent
|
||||
};
|
||||
let dev = dev.to_owned();
|
||||
// Pull the 64-byte manifest off NAND via `od -v -x` (busybox-safe) and parse.
|
||||
let bytes = read_small(sh, &dev, rel, 64)?;
|
||||
Ok(BackupManifest::decode(&bytes))
|
||||
}
|
||||
|
||||
/// Parse `od` hex output into bytes. Accepts both `-tx1` (byte hex) and `-x`
|
||||
/// (little-endian 16-bit words).
|
||||
fn parse_od(s: &str) -> Vec<u8> {
|
||||
let toks: Vec<&str> = s.split_whitespace().collect();
|
||||
// Heuristic: 2-char tokens are bytes (-tx1); 4-char tokens are LE words (-x).
|
||||
let mut out = Vec::new();
|
||||
for t in &toks {
|
||||
match t.len() {
|
||||
2 => {
|
||||
if let Ok(b) = u8::from_str_radix(t, 16) {
|
||||
out.push(b);
|
||||
}
|
||||
}
|
||||
4 => {
|
||||
if let Ok(w) = u16::from_str_radix(t, 16) {
|
||||
out.push((w & 0xff) as u8);
|
||||
out.push((w >> 8) as u8);
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Operations
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// What to write to the three boot slots (already in the exact on-NAND form:
|
||||
/// kernel and rootfs as legacy uImages, dtb as a raw fdt).
|
||||
struct BootImages {
|
||||
kernel_uimage: Vec<u8>,
|
||||
dtb: Vec<u8>,
|
||||
rootfs_uimage: Vec<u8>,
|
||||
}
|
||||
|
||||
fn write_boot_slots(sh: &mut dyn Shell, table: &[Mtd], img: &BootImages) -> Result<(), StockError> {
|
||||
// rootfs, dtb, kernel order: an interrupted run never leaves a new rootfs
|
||||
// under an old kernel.
|
||||
if img.rootfs_uimage.len() as u64 > SLOT_ROOTFS {
|
||||
return Err(StockError::Method("rootfs over slot ceiling".into()));
|
||||
}
|
||||
if img.dtb.len() as u64 > SLOT_DTB {
|
||||
return Err(StockError::Method("dtb over slot ceiling".into()));
|
||||
}
|
||||
if img.kernel_uimage.len() as u64 > SLOT_KERNEL {
|
||||
return Err(StockError::Method("kernel over slot ceiling".into()));
|
||||
}
|
||||
write_abs(sh, table, OFF_ROOTFS, &img.rootfs_uimage, "rootfs")?;
|
||||
write_abs(sh, table, OFF_DTB, &img.dtb, "dtb")?;
|
||||
write_abs(sh, table, OFF_KERNEL, &img.kernel_uimage, "kernel")?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Whether the connected board is a Zynq, so the readable boot-slot path
|
||||
/// applies. Other boards fall back to the compiled-in method.
|
||||
fn shell_is_zynq(sh: &mut dyn Shell) -> bool {
|
||||
sh.exec(
|
||||
"(grep -qi zynq /proc/cpuinfo 2>/dev/null || \
|
||||
grep -qai zynq /proc/device-tree/compatible 2>/dev/null) && echo yes || true",
|
||||
)
|
||||
.map(|o| o.contains("yes"))
|
||||
.unwrap_or(false)
|
||||
}
|
||||
|
||||
fn reboot(sh: &mut dyn Shell) {
|
||||
// Best-effort: the reboot drops the shell, so ignore the result.
|
||||
let _ = sh.exec("sync; (sleep 1; reboot) >/dev/null 2>&1 &");
|
||||
}
|
||||
|
||||
/// Install alkane onto a board currently on stock, over the network. The afw
|
||||
/// ships a raw `zImage`, a raw fdt and a gzipped cpio rootfs; we wrap the kernel
|
||||
/// and rootfs as the legacy uImages the preserved stock U-Boot boots, carve the
|
||||
/// genuine stock backup first, then write the boot slots and reboot.
|
||||
pub fn install_from_stock(
|
||||
host: &str,
|
||||
kernel_zimage: &[u8],
|
||||
dtb: &[u8],
|
||||
rootfs_cpio_gz: &[u8],
|
||||
password: Option<&str>,
|
||||
) -> Result<(), StockError> {
|
||||
let mut sh = StockShell {
|
||||
host: host.to_owned(),
|
||||
password: password.map(str::to_owned),
|
||||
};
|
||||
if first_token(&sh.exec("id -u")?) != "0" {
|
||||
return Err(StockError::Auth(
|
||||
"did not obtain root on the stock board".into(),
|
||||
));
|
||||
}
|
||||
let table = read_mtd_table(&mut sh)?;
|
||||
// Carve the genuine-stock backup from the live stock NAND before any write.
|
||||
carve_backup(&mut sh, &table)?;
|
||||
let img = BootImages {
|
||||
kernel_uimage: uimage::wrap(Kind::Kernel, kernel_zimage, 0, "alkane-kernel"),
|
||||
dtb: dtb.to_vec(),
|
||||
rootfs_uimage: uimage::wrap(Kind::Ramdisk, rootfs_cpio_gz, 0, "alkane-rootfs"),
|
||||
};
|
||||
write_boot_slots(&mut sh, &table, &img)?;
|
||||
reboot(&mut sh);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Return an alkane board to genuine stock by writing the vendor images back to
|
||||
/// the boot slots over SSH. `dtb` is the genuine per-board device tree (from the
|
||||
/// vendor package); if `None`, the stock dtb saved in the on-board backup is
|
||||
/// used. `kernel`/`rootfs` are the vendor legacy uImages, written as-is.
|
||||
pub fn restore_to_stock(
|
||||
host: &str,
|
||||
kernel_uimage: &[u8],
|
||||
rootfs_uimage: &[u8],
|
||||
dtb: Option<&[u8]>,
|
||||
password: Option<&str>,
|
||||
) -> Result<(), StockError> {
|
||||
let mut sh = AlkaneShell::connect(host, password)?;
|
||||
if !shell_is_zynq(&mut sh) {
|
||||
return Err(StockError::NotApplicable);
|
||||
}
|
||||
let table = read_mtd_table(&mut sh)?;
|
||||
if rootfs_uimage.len() as u64 > SLOT_ROOTFS || kernel_uimage.len() as u64 > SLOT_KERNEL {
|
||||
return Err(StockError::Method("vendor image over slot ceiling".into()));
|
||||
}
|
||||
// rootfs, dtb, kernel order (same safety ordering as install).
|
||||
write_abs(&mut sh, &table, OFF_ROOTFS, rootfs_uimage, "rootfs")?;
|
||||
match dtb {
|
||||
Some(d) => {
|
||||
if d.len() as u64 > SLOT_DTB {
|
||||
return Err(StockError::Method("dtb over slot ceiling".into()));
|
||||
}
|
||||
write_abs(&mut sh, &table, OFF_DTB, d, "dtb")?;
|
||||
}
|
||||
None => {
|
||||
// No vendor dtb (an OTA package omits it): restore the genuine
|
||||
// per-board dtb from the on-board backup by copying within NAND.
|
||||
let manifest = read_backup_manifest(&mut sh, &table)?.ok_or_else(|| {
|
||||
StockError::Method(
|
||||
"no stock dtb supplied and no on-board backup to take one from".into(),
|
||||
)
|
||||
})?;
|
||||
copy_abs(
|
||||
&mut sh,
|
||||
&table,
|
||||
manifest.dtb_abs,
|
||||
OFF_DTB,
|
||||
manifest.dtb_len,
|
||||
"dtb",
|
||||
)?;
|
||||
}
|
||||
}
|
||||
write_abs(&mut sh, &table, OFF_KERNEL, kernel_uimage, "kernel")?;
|
||||
reboot(&mut sh);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Whether the board holds a complete, restorable on-board stock backup.
|
||||
pub fn onboard_backup_present(host: &str, password: Option<&str>) -> Result<bool, StockError> {
|
||||
let mut sh = AlkaneShell::connect(host, password)?;
|
||||
if !shell_is_zynq(&mut sh) {
|
||||
return Err(StockError::NotApplicable);
|
||||
}
|
||||
let table = read_mtd_table(&mut sh)?;
|
||||
Ok(read_backup_manifest(&mut sh, &table)?.is_some())
|
||||
}
|
||||
|
||||
/// Return an alkane board to stock using only the on-board backup (no vendor
|
||||
/// file): copy the saved stock kernel, dtb and rootfs back to the boot slots.
|
||||
pub fn restore_from_onboard(host: &str, password: Option<&str>) -> Result<(), StockError> {
|
||||
let mut sh = AlkaneShell::connect(host, password)?;
|
||||
if !shell_is_zynq(&mut sh) {
|
||||
return Err(StockError::NotApplicable);
|
||||
}
|
||||
let table = read_mtd_table(&mut sh)?;
|
||||
let manifest = read_backup_manifest(&mut sh, &table)?
|
||||
.ok_or_else(|| StockError::Method("no complete on-board stock backup".into()))?;
|
||||
// Copy within NAND: backup region -> boot slots.
|
||||
copy_abs(
|
||||
&mut sh,
|
||||
&table,
|
||||
manifest.rootfs_abs,
|
||||
OFF_ROOTFS,
|
||||
manifest.rootfs_len,
|
||||
"rootfs",
|
||||
)?;
|
||||
copy_abs(
|
||||
&mut sh,
|
||||
&table,
|
||||
manifest.dtb_abs,
|
||||
OFF_DTB,
|
||||
manifest.dtb_len,
|
||||
"dtb",
|
||||
)?;
|
||||
copy_abs(
|
||||
&mut sh,
|
||||
&table,
|
||||
manifest.kernel_abs,
|
||||
OFF_KERNEL,
|
||||
manifest.kernel_len,
|
||||
"kernel",
|
||||
)?;
|
||||
reboot(&mut sh);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn round_up_works() {
|
||||
assert_eq!(round_up(1, PAGE), PAGE);
|
||||
assert_eq!(round_up(PAGE, PAGE), PAGE);
|
||||
assert_eq!(round_up(PAGE + 1, PAGE), 2 * PAGE);
|
||||
assert_eq!(round_up(0, ERASE), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn padded_md5_matches_manual_pad() {
|
||||
let data = b"hello";
|
||||
let mut padded = data.to_vec();
|
||||
padded.resize(PAGE as usize, 0xFF);
|
||||
assert_eq!(padded_md5(data), md5_hex(&padded));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn manifest_roundtrips() {
|
||||
let m = BackupManifest {
|
||||
kernel_abs: 0x6020000,
|
||||
kernel_len: 4006832,
|
||||
dtb_abs: 0x6420000,
|
||||
dtb_len: 7650,
|
||||
rootfs_abs: 0x6440000,
|
||||
rootfs_len: 26620582,
|
||||
};
|
||||
let enc = m.encode();
|
||||
let dec = BackupManifest::decode(&enc).unwrap();
|
||||
assert_eq!(dec.kernel_abs, m.kernel_abs);
|
||||
assert_eq!(dec.rootfs_len, m.rootfs_len);
|
||||
assert!(BackupManifest::decode(b"nope").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn locate_maps_absolute_to_partition() {
|
||||
let table = vec![
|
||||
Mtd {
|
||||
dev: "mtd0".into(),
|
||||
base: 0x0,
|
||||
size: 0x2800000,
|
||||
name: "x".into(),
|
||||
},
|
||||
Mtd {
|
||||
dev: "mtd1".into(),
|
||||
base: 0x2800000,
|
||||
size: 0x2000000,
|
||||
name: "y".into(),
|
||||
},
|
||||
];
|
||||
assert_eq!(locate(&table, 0x2000000, 100).unwrap(), ("mtd0", 0x2000000));
|
||||
assert_eq!(locate(&table, 0x2800000, 100).unwrap(), ("mtd1", 0));
|
||||
assert!(locate(&table, 0x9000000, 1).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_od_both_forms() {
|
||||
// -tx1 byte form
|
||||
assert_eq!(parse_od("41 42 43"), vec![0x41, 0x42, 0x43]);
|
||||
// -x little-endian word form -> bytes
|
||||
assert_eq!(parse_od("4241"), vec![0x41, 0x42]);
|
||||
}
|
||||
}
|
||||
@@ -11,6 +11,11 @@ path = "src/main.rs"
|
||||
[dependencies]
|
||||
alkane-core = { path = "../alkane-core" }
|
||||
alkane-discovery = { path = "../alkane-discovery" }
|
||||
# The self-contained stock <-> alkane engine (compiled-in method) and the .afw
|
||||
# verify/fetch, so the GUI can install-from-stock and restore-to-stock and scan
|
||||
# alkane-os releases through the same code paths the CLI uses.
|
||||
alkane-flash = { path = "../alkane-flash" }
|
||||
alkane-artifacts = { path = "../alkane-artifacts" }
|
||||
# vendored + patched wx-rs (see vendor/wx-rs/patches/)
|
||||
wx-rs = { path = "../../thirdparty/wx-rs/wx-rs-0.2.0-patched" }
|
||||
asic-rs = "0.8.1"
|
||||
|
||||
Binary file not shown.
Executable
+34
@@ -0,0 +1,34 @@
|
||||
#!/bin/sh
|
||||
# Regenerate alkane-toolkit.icns (the macOS app icon) from the in-repo
|
||||
# microchip glyph: the same white chip on a rounded amber tile as the Windows
|
||||
# icon, at the sizes macOS asks for (16-1024 px). Needs rsvg-convert,
|
||||
# ImageMagick and python3; the .icns is committed, so a build never runs this.
|
||||
set -e
|
||||
cd "$(dirname "$0")"
|
||||
GLYPH=../assets/icons/microchip-solid-full.svg
|
||||
TMP=$(mktemp -d)
|
||||
trap 'rm -rf "$TMP"' 0
|
||||
sed 's/currentColor/#ffffff/g; s/<svg /<svg fill="#ffffff" /' "$GLYPH" > "$TMP/glyph.svg"
|
||||
for s in 16 32 64 128 256 512 1024; do
|
||||
# Apple's grid: the tile fills ~80% of the canvas, centred.
|
||||
t=$((s * 80 / 100)); m=$(((s - t) / 2)); r=$((t * 22 / 100))
|
||||
g=$((t * 60 / 100)); o=$(((s - g) / 2))
|
||||
rsvg-convert -w "$g" -h "$g" "$TMP/glyph.svg" -o "$TMP/g$s.png"
|
||||
convert -size "${s}x${s}" xc:none -fill '#d9822b' \
|
||||
-draw "roundrectangle $m,$m $((m + t - 1)),$((m + t - 1)) $r,$r" \
|
||||
"$TMP/g$s.png" -geometry "+$o+$o" -composite "PNG32:$TMP/i$s.png"
|
||||
done
|
||||
python3 - "$TMP" alkane-toolkit.icns <<'PY'
|
||||
import pathlib, struct, sys
|
||||
tmp, out = pathlib.Path(sys.argv[1]), sys.argv[2]
|
||||
# ICNS element types that hold PNG data, by pixel size.
|
||||
types = [("icp4", 16), ("icp5", 32), ("icp6", 64), ("ic07", 128), ("ic08", 256),
|
||||
("ic09", 512), ("ic10", 1024), ("ic11", 32), ("ic12", 64), ("ic13", 256),
|
||||
("ic14", 512)]
|
||||
body = b""
|
||||
for kind, size in types:
|
||||
data = (tmp / f"i{size}.png").read_bytes()
|
||||
body += kind.encode() + struct.pack(">I", len(data) + 8) + data
|
||||
pathlib.Path(out).write_bytes(b"icns" + struct.pack(">I", len(body) + 8) + body)
|
||||
PY
|
||||
echo "wrote $(pwd)/alkane-toolkit.icns"
|
||||
@@ -0,0 +1,305 @@
|
||||
//! Boards running Alkane OS on the network, and which alkane-os actions apply to
|
||||
//! a scanned row.
|
||||
//!
|
||||
//! asic-rs recognises miners by their cgminer socket (:4028) or a vendor web UI.
|
||||
//! A board running Alkane OS keeps its cgminer-compatible socket on loopback and
|
||||
//! serves its own console, so asic-rs reports nothing at that address and the
|
||||
//! board never appeared in the fleet. This probe finds it over plain HTTP:
|
||||
//! - `GET /api/identity` (alkane-os 0.1.2 and later): os, os_version, board,
|
||||
//! sdk_revision, hostname, mac, kernel;
|
||||
//! - otherwise the cgminer-style `GET /api/summary`, whose STATUS Description
|
||||
//! is "alkane-os" (earlier images: found, but the board family is unknown).
|
||||
//!
|
||||
//! Both endpoints are public and read-only on the board.
|
||||
|
||||
use crate::model::MinerRow;
|
||||
use serde_json::{json, Value};
|
||||
use std::net::IpAddr;
|
||||
use std::time::Duration;
|
||||
|
||||
/// Firmware family shown for a board running Alkane OS.
|
||||
pub const FIRMWARE: &str = "Alkane";
|
||||
|
||||
const CONNECT_TIMEOUT: Duration = Duration::from_secs(2);
|
||||
const READ_TIMEOUT: Duration = Duration::from_secs(4);
|
||||
const MAX_RESPONSE: usize = 64 * 1024;
|
||||
|
||||
/// Probe `ip` for Alkane OS. Returns a row for the fleet table, or None when the
|
||||
/// address is not an Alkane board (or does not answer on :80).
|
||||
pub async fn detect(ip: IpAddr) -> Option<MinerRow> {
|
||||
if let Some(doc) = get_json(ip, "/api/identity").await {
|
||||
if doc.get("os").and_then(Value::as_str) == Some("alkane-os") {
|
||||
return Some(row_from_identity(ip, &doc));
|
||||
}
|
||||
}
|
||||
let summary = get_json(ip, "/api/summary").await?;
|
||||
if is_alkane_summary(&summary) {
|
||||
return Some(row_from_identity(ip, &json!({})));
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// The cgminer-style summary an Alkane board serves names "alkane-os" in its
|
||||
/// STATUS Description.
|
||||
fn is_alkane_summary(doc: &Value) -> bool {
|
||||
doc.get("STATUS")
|
||||
.and_then(Value::as_array)
|
||||
.and_then(|status| status.first())
|
||||
.and_then(|entry| entry.get("Description"))
|
||||
.and_then(Value::as_str)
|
||||
== Some("alkane-os")
|
||||
}
|
||||
|
||||
/// Control-board labels (cpu, code) for an Alkane board family, matching the
|
||||
/// labels the scan gives the same board on stock firmware.
|
||||
fn board_labels(board: &str) -> (&'static str, &'static str) {
|
||||
match board {
|
||||
"zynq-7010" => ("XIL", "C49"),
|
||||
"am335x" => ("BBB", "C77"),
|
||||
"cv1835" => ("CVI", "C88"),
|
||||
"a113d" => ("AML", "C76"),
|
||||
_ => ("", ""),
|
||||
}
|
||||
}
|
||||
|
||||
fn row_from_identity(ip: IpAddr, doc: &Value) -> MinerRow {
|
||||
let text = |key: &str| {
|
||||
doc.get(key)
|
||||
.and_then(Value::as_str)
|
||||
.unwrap_or("")
|
||||
.trim()
|
||||
.to_string()
|
||||
};
|
||||
let board = text("board");
|
||||
let (cpu, code) = board_labels(&board);
|
||||
let control_board = if cpu.is_empty() {
|
||||
board.clone()
|
||||
} else {
|
||||
format!("{cpu} ({code})")
|
||||
};
|
||||
MinerRow {
|
||||
ip: ip.to_string(),
|
||||
// The Alkane-supported control boards are all Bitmain (Antminer) boards.
|
||||
brand: if cpu.is_empty() {
|
||||
String::new()
|
||||
} else {
|
||||
"Antminer".to_string()
|
||||
},
|
||||
firmware: FIRMWARE.to_string(),
|
||||
fw_version: text("os_version"),
|
||||
api_version: "alkane-os".to_string(),
|
||||
mac: text("mac"),
|
||||
hostname: text("hostname"),
|
||||
control_board,
|
||||
cpu: cpu.to_string(),
|
||||
board_code: code.to_string(),
|
||||
alkane_board: Some(board),
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
/// HTTP/1.0 GET on :80 returning the JSON body of a 200 reply.
|
||||
async fn get_json(ip: IpAddr, path: &str) -> Option<Value> {
|
||||
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
||||
let connect = tokio::net::TcpStream::connect((ip, 80));
|
||||
let mut stream = tokio::time::timeout(CONNECT_TIMEOUT, connect)
|
||||
.await
|
||||
.ok()?
|
||||
.ok()?;
|
||||
let request = format!("GET {path} HTTP/1.0\r\nHost: {ip}\r\nConnection: close\r\n\r\n");
|
||||
stream.write_all(request.as_bytes()).await.ok()?;
|
||||
let mut raw = Vec::new();
|
||||
let _ = tokio::time::timeout(READ_TIMEOUT, async {
|
||||
let mut chunk = [0u8; 4096];
|
||||
loop {
|
||||
match stream.read(&mut chunk).await {
|
||||
Ok(0) | Err(_) => break,
|
||||
Ok(n) => {
|
||||
raw.extend_from_slice(&chunk[..n]);
|
||||
if raw.len() > MAX_RESPONSE {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
.await;
|
||||
parse_http_json(&raw)
|
||||
}
|
||||
|
||||
fn parse_http_json(raw: &[u8]) -> Option<Value> {
|
||||
let text = std::str::from_utf8(raw).ok()?;
|
||||
let (head, body) = text.split_once("\r\n\r\n")?;
|
||||
let status = head.lines().next()?;
|
||||
if status.split_whitespace().nth(1) != Some("200") {
|
||||
return None;
|
||||
}
|
||||
serde_json::from_str(body.trim()).ok()
|
||||
}
|
||||
|
||||
/// Whether the row is a board running Alkane OS (found by `detect`).
|
||||
pub fn is_alkane(row: &MinerRow) -> bool {
|
||||
row.alkane_board.is_some()
|
||||
}
|
||||
|
||||
/// The alkane-os board family the row's control board is, when it can be told:
|
||||
/// what an Alkane board reports, or for a stock Antminer the Zynq-7010 (S17/T17
|
||||
/// era, "XIL (C49)") control board.
|
||||
pub fn board_family(row: &MinerRow) -> Option<String> {
|
||||
if let Some(board) = &row.alkane_board {
|
||||
return (!board.is_empty()).then(|| board.clone());
|
||||
}
|
||||
if !row.brand.to_ascii_lowercase().contains("antminer") {
|
||||
return None;
|
||||
}
|
||||
if row.cpu == "XIL" && row.board_code == "C49" {
|
||||
return Some("zynq-7010".to_string());
|
||||
}
|
||||
// A stock S17 whose miner software is down (no hashboards attached: it
|
||||
// restart-loops) reports its model but no control board. Its model then
|
||||
// decides; a control board that IS reported always wins above.
|
||||
if row.cpu.is_empty() && is_zynq_7010_model(&row.model) {
|
||||
return Some("zynq-7010".to_string());
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Stock models built only on the Zynq-7010 (XIL C49) control board.
|
||||
fn is_zynq_7010_model(model: &str) -> bool {
|
||||
matches!(model.trim(), "S17" | "S17 Pro" | "T17")
|
||||
}
|
||||
|
||||
/// Whether alkane-os can be installed on the row's board: its control board is
|
||||
/// one the toolkit supports.
|
||||
pub fn install_supported(row: &MinerRow) -> bool {
|
||||
board_family(row).is_some_and(|board| crate::stock_ops::is_supported_board(&board))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn ip() -> IpAddr {
|
||||
"10.0.0.5".parse().unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_a_200_json_reply_only() {
|
||||
let ok = b"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n\r\n{\"os\":\"alkane-os\"}";
|
||||
assert_eq!(parse_http_json(ok).unwrap()["os"], "alkane-os");
|
||||
let denied = b"HTTP/1.1 401 Unauthorized\r\n\r\n{\"os\":\"alkane-os\"}";
|
||||
assert!(parse_http_json(denied).is_none());
|
||||
let html = b"HTTP/1.1 200 OK\r\n\r\n<!DOCTYPE html><title>x</title>";
|
||||
assert!(parse_http_json(html).is_none());
|
||||
assert!(parse_http_json(b"garbage").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recognises_the_alkane_summary() {
|
||||
let alkane = json!({"STATUS":[{"Code":0,"Description":"alkane-os","STATUS":"S"}]});
|
||||
assert!(is_alkane_summary(&alkane));
|
||||
let cgminer = json!({"STATUS":[{"Description":"cgminer 4.11.1","STATUS":"S"}]});
|
||||
assert!(!is_alkane_summary(&cgminer));
|
||||
assert!(!is_alkane_summary(&json!({})));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn identity_becomes_a_supported_alkane_row() {
|
||||
let doc = json!({
|
||||
"os": "alkane-os", "os_version": "0.1.2", "board": "zynq-7010",
|
||||
"sdk_revision": "6a9080ac82c1", "hostname": "alkane-zynq",
|
||||
"mac": "26:4e:52:8b:e2:48", "kernel": "6.18.48",
|
||||
});
|
||||
let row = row_from_identity(ip(), &doc);
|
||||
assert_eq!(row.ip, "10.0.0.5");
|
||||
assert_eq!(row.firmware, "Alkane");
|
||||
assert_eq!(row.fw_version, "0.1.2");
|
||||
assert_eq!(row.control_board, "XIL (C49)");
|
||||
assert_eq!(row.mac, "26:4e:52:8b:e2:48");
|
||||
assert!(is_alkane(&row));
|
||||
assert!(install_supported(&row));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_old_alkane_board_is_alkane_but_its_family_is_unknown() {
|
||||
// Found via /api/summary only: uninstall applies, install cannot be
|
||||
// confirmed as supported.
|
||||
let row = row_from_identity(ip(), &json!({}));
|
||||
assert!(is_alkane(&row));
|
||||
assert_eq!(board_family(&row), None);
|
||||
assert!(!install_supported(&row));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stock_antminers_are_supported_only_on_the_zynq_7010_board() {
|
||||
let stock = |cpu: &str, code: &str| MinerRow {
|
||||
brand: "Antminer".into(),
|
||||
firmware: "Stock".into(),
|
||||
cpu: cpu.into(),
|
||||
board_code: code.into(),
|
||||
..Default::default()
|
||||
};
|
||||
let s17 = stock("XIL", "C49");
|
||||
assert!(install_supported(&s17));
|
||||
assert!(!is_alkane(&s17));
|
||||
assert!(!install_supported(&stock("XIL", "C55"))); // S19-era Zynq
|
||||
assert!(!install_supported(&stock("AML", "C76")));
|
||||
assert!(!install_supported(&stock("", "")));
|
||||
let whatsminer = MinerRow {
|
||||
brand: "WhatsMiner".into(),
|
||||
cpu: "XIL".into(),
|
||||
board_code: "C49".into(),
|
||||
..Default::default()
|
||||
};
|
||||
assert!(!install_supported(&whatsminer));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_stock_s17_without_a_reported_control_board_is_supported_by_model() {
|
||||
// As seen live: stock S17, miner software down, control board blank.
|
||||
let s17 = MinerRow {
|
||||
brand: "Antminer".into(),
|
||||
model: "S17".into(),
|
||||
firmware: "Stock".into(),
|
||||
..Default::default()
|
||||
};
|
||||
assert!(install_supported(&s17));
|
||||
let other = |model: &str| MinerRow {
|
||||
brand: "Antminer".into(),
|
||||
model: model.into(),
|
||||
..Default::default()
|
||||
};
|
||||
assert!(install_supported(&other("S17 Pro")));
|
||||
assert!(install_supported(&other("T17")));
|
||||
assert!(!install_supported(&other("S19")));
|
||||
assert!(!install_supported(&other("S17+")));
|
||||
assert!(!install_supported(&other("")));
|
||||
// A reported control board overrides the model.
|
||||
let s17_on_aml = MinerRow {
|
||||
brand: "Antminer".into(),
|
||||
model: "S17".into(),
|
||||
cpu: "AML".into(),
|
||||
board_code: "C76".into(),
|
||||
..Default::default()
|
||||
};
|
||||
assert!(!install_supported(&s17_on_aml));
|
||||
}
|
||||
|
||||
/// Live check against a real board:
|
||||
/// `ALKANE_TEST_IP=10.255.1.111 cargo test -p alkane-gui live_detect -- --ignored --nocapture`
|
||||
#[test]
|
||||
#[ignore = "needs a board on the network (ALKANE_TEST_IP)"]
|
||||
fn live_detect() {
|
||||
let Ok(ip) = std::env::var("ALKANE_TEST_IP") else {
|
||||
return;
|
||||
};
|
||||
let rt = tokio::runtime::Builder::new_current_thread()
|
||||
.enable_all()
|
||||
.build()
|
||||
.unwrap();
|
||||
let row = rt.block_on(detect(ip.parse().unwrap()));
|
||||
println!("{row:#?}");
|
||||
let row = row.expect("an Alkane board at ALKANE_TEST_IP");
|
||||
assert!(is_alkane(&row));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,332 @@
|
||||
//! Headless bench automation (`ALKANE_BENCH_SEQUENCE`): drive the GUI's real
|
||||
//! install/restore operation layer (`stock_ops`) through the A113D network-only
|
||||
//! install <-> flag-restore cycle, with no window. This exercises the GUI
|
||||
//! operator flow end-to-end against real hardware, for bench proofs, without the
|
||||
//! wx event loop (the worker functions stream progress over a channel, exactly
|
||||
//! as the UI drains them).
|
||||
//!
|
||||
//! Spec: `ALKANE_BENCH_SEQUENCE="<host> <local.afw> [iterations]"`.
|
||||
//! The alkane root credential is read from the saved SSH credentials file.
|
||||
//!
|
||||
//! On the A113D, "restore to stock" is the one-byte flag flip (the install
|
||||
//! overwrites no stock partition), so the cycle is: install (stock -> alkane) ->
|
||||
//! verify alkane -> restore (flag flip -> stock) -> verify stock.
|
||||
|
||||
use std::io::Read;
|
||||
use std::net::TcpStream;
|
||||
use std::path::PathBuf;
|
||||
use std::process::Command;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use crate::credentials;
|
||||
use crate::stock_ops::{self, AfwSource, StockHandle, StockMsg};
|
||||
|
||||
/// Drain a `StockHandle` to completion, printing progress; returns true iff
|
||||
/// every board reported ok and at least one `Result` arrived.
|
||||
fn drive(label: &str, handle: StockHandle) -> bool {
|
||||
let mut ok = true;
|
||||
let mut saw = false;
|
||||
loop {
|
||||
match handle.rx.recv() {
|
||||
Ok(StockMsg::Started) => println!(" [{label}] started"),
|
||||
Ok(StockMsg::Progress(s)) => println!(" [{label}] {s}"),
|
||||
Ok(StockMsg::Result { ip, ok: r, detail }) => {
|
||||
saw = true;
|
||||
ok = ok && r;
|
||||
println!(
|
||||
" [{label}] {ip}: {} - {detail}",
|
||||
if r { "OK" } else { "FAIL" }
|
||||
);
|
||||
}
|
||||
Ok(StockMsg::Done) => break,
|
||||
Err(_) => {
|
||||
println!(" [{label}] channel closed early");
|
||||
ok = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
ok && saw
|
||||
}
|
||||
|
||||
/// Read the SSH identification banner (no auth), e.g. `SSH-2.0-dropbear_2026.93`.
|
||||
fn ssh_banner(host: &str) -> Option<String> {
|
||||
let addr: std::net::SocketAddr = format!("{host}:22").parse().ok()?;
|
||||
let mut stream = TcpStream::connect_timeout(&addr, Duration::from_secs(5)).ok()?;
|
||||
stream.set_read_timeout(Some(Duration::from_secs(5))).ok()?;
|
||||
let mut buf = [0u8; 256];
|
||||
let n = stream.read(&mut buf).ok()?;
|
||||
if n == 0 {
|
||||
return None;
|
||||
}
|
||||
Some(
|
||||
String::from_utf8_lossy(&buf[..n])
|
||||
.lines()
|
||||
.next()
|
||||
.unwrap_or("")
|
||||
.trim()
|
||||
.to_string(),
|
||||
)
|
||||
}
|
||||
|
||||
/// HTTP server header probe (stock serves lighttpd / an antMiner realm).
|
||||
fn http_is_stock(host: &str) -> Option<bool> {
|
||||
let out = Command::new("curl")
|
||||
.args([
|
||||
"-sS",
|
||||
"-m",
|
||||
"6",
|
||||
"-o",
|
||||
"/dev/null",
|
||||
"-D",
|
||||
"-",
|
||||
&format!("http://{host}/"),
|
||||
])
|
||||
.output()
|
||||
.ok()?;
|
||||
let h = String::from_utf8_lossy(&out.stdout).to_lowercase();
|
||||
if h.is_empty() {
|
||||
None
|
||||
} else if h.contains("lighttpd") || h.contains("antminer configuration") {
|
||||
Some(true)
|
||||
} else {
|
||||
Some(false)
|
||||
}
|
||||
}
|
||||
|
||||
/// Classify the board: `Some(true)` = looks like genuine stock, `Some(false)` =
|
||||
/// looks like alkane, `None` = no decisive answer (e.g. mid-reboot).
|
||||
///
|
||||
/// Primary signal is the SSH banner: stock A113D is `dropbear_2018.76`; alkane
|
||||
/// ships a much newer dropbear. HTTP (lighttpd) is a stock fallback.
|
||||
fn classify(host: &str) -> (String, Option<bool>) {
|
||||
let banner = ssh_banner(host);
|
||||
if let Some(b) = &banner {
|
||||
let lb = b.to_lowercase();
|
||||
if lb.contains("dropbear_2018") || lb.contains("dropbear_2019") {
|
||||
return (format!("ssh \"{b}\" -> stock"), Some(true));
|
||||
}
|
||||
if lb.contains("dropbear") || lb.contains("openssh") {
|
||||
return (format!("ssh \"{b}\" -> alkane"), Some(false));
|
||||
}
|
||||
}
|
||||
match http_is_stock(host) {
|
||||
Some(true) => ("http lighttpd/antMiner -> stock".to_string(), Some(true)),
|
||||
Some(false) => ("http non-stock -> alkane".to_string(), Some(false)),
|
||||
None => (
|
||||
banner
|
||||
.map(|b| format!("ssh \"{b}\" (unclassified), no http"))
|
||||
.unwrap_or_else(|| "no ssh, no http (mid-reboot?)".to_string()),
|
||||
None,
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
/// The MAC (lladdr) the kernel has cached for `host` (pings first to populate).
|
||||
fn mac_of(host: &str) -> Option<String> {
|
||||
let _ = Command::new("ping")
|
||||
.args(["-c", "1", "-W", "1", host])
|
||||
.output();
|
||||
let out = Command::new("ip")
|
||||
.args(["neigh", "show", host])
|
||||
.output()
|
||||
.ok()?;
|
||||
let s = String::from_utf8_lossy(&out.stdout);
|
||||
let mut it = s.split_whitespace();
|
||||
while let Some(t) = it.next() {
|
||||
if t == "lladdr" {
|
||||
return it.next().map(|m| m.to_lowercase());
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Populate the neighbour table by parallel-pinging the /24 of `sample` (a bench
|
||||
/// board can take a different DHCP lease across a reboot, so we must re-find it).
|
||||
fn sweep_subnet(sample: &str) {
|
||||
let base = match sample.rsplit_once('.') {
|
||||
Some((net, _)) => net.to_string(),
|
||||
None => return,
|
||||
};
|
||||
let mut kids = Vec::new();
|
||||
for h in 2..=254 {
|
||||
if let Ok(c) = Command::new("ping")
|
||||
.args(["-c", "1", "-W", "1", &format!("{base}.{h}")])
|
||||
.stdout(std::process::Stdio::null())
|
||||
.stderr(std::process::Stdio::null())
|
||||
.spawn()
|
||||
{
|
||||
kids.push(c);
|
||||
}
|
||||
}
|
||||
for mut c in kids {
|
||||
let _ = c.wait();
|
||||
}
|
||||
}
|
||||
|
||||
/// Current IPv4 for `mac` from the neighbour table, if present.
|
||||
fn ip_for_mac(mac: &str) -> Option<String> {
|
||||
let out = Command::new("ip").args(["neigh"]).output().ok()?;
|
||||
let s = String::from_utf8_lossy(&out.stdout);
|
||||
let mac = mac.to_lowercase();
|
||||
for line in s.lines() {
|
||||
if line.to_lowercase().contains(&mac) {
|
||||
if let Some(ip) = line.split_whitespace().next() {
|
||||
if ip.contains('.') {
|
||||
return Some(ip.to_string());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Poll until the board (located by MAC, so a changed DHCP lease is followed)
|
||||
/// reaches the wanted stock-ness, or `timeout` elapses. Returns the board's
|
||||
/// current IP, a description, and whether the target state was reached.
|
||||
fn wait_for(
|
||||
mac: Option<&str>,
|
||||
fallback: &str,
|
||||
want_stock: bool,
|
||||
timeout: Duration,
|
||||
) -> (String, String, bool) {
|
||||
let deadline = Instant::now() + timeout;
|
||||
let mut ip = fallback.to_string();
|
||||
let mut swept = Instant::now() - Duration::from_secs(60);
|
||||
loop {
|
||||
// Re-locate by MAC; sweep the subnet at most every ~25s to catch a new lease.
|
||||
if let Some(m) = mac {
|
||||
if ip_for_mac(m).is_none() && swept.elapsed() >= Duration::from_secs(25) {
|
||||
sweep_subnet(fallback);
|
||||
swept = Instant::now();
|
||||
}
|
||||
if let Some(found) = ip_for_mac(m) {
|
||||
ip = found;
|
||||
}
|
||||
}
|
||||
let (desc, is_stock) = classify(&ip);
|
||||
let line = format!("[{ip}] {desc}");
|
||||
if is_stock == Some(want_stock) {
|
||||
return (ip, line, true);
|
||||
}
|
||||
if Instant::now() >= deadline {
|
||||
return (ip, line, false);
|
||||
}
|
||||
std::thread::sleep(Duration::from_secs(5));
|
||||
}
|
||||
}
|
||||
|
||||
pub fn run(spec: &str) -> i32 {
|
||||
let mut it = spec.split_whitespace();
|
||||
let host = match it.next() {
|
||||
Some(h) => h.to_string(),
|
||||
None => {
|
||||
eprintln!("ALKANE_BENCH_SEQUENCE=\"<host> <local.afw> [iterations]\"");
|
||||
return 2;
|
||||
}
|
||||
};
|
||||
let afw = match it.next() {
|
||||
Some(a) => PathBuf::from(a),
|
||||
None => {
|
||||
eprintln!("missing local .afw path");
|
||||
return 2;
|
||||
}
|
||||
};
|
||||
let iterations: u32 = it.next().and_then(|s| s.parse().ok()).unwrap_or(1);
|
||||
let board = "a113d".to_string();
|
||||
// Install reaches STOCK via the compiled-in from-stock method; pass the saved
|
||||
// board SSH credential through to it.
|
||||
let stock_password = credentials::load_ssh_credentials().map(|(_, p)| p);
|
||||
// The flag-restore reaches the running ALKANE board over SSH as `root` - a
|
||||
// DIFFERENT credential from the stock login. Alkane bench images bake
|
||||
// root/alkane; allow an override via ALKANE_ROOT_PASSWORD.
|
||||
let alkane_password = std::env::var("ALKANE_ROOT_PASSWORD")
|
||||
.ok()
|
||||
.or_else(|| Some("alkane".to_string()));
|
||||
|
||||
println!("== A113D headless GUI bench sequence (network-only install <-> flag-restore) ==");
|
||||
println!(
|
||||
"host={host} afw={} board={board} iterations={iterations} stock_cred={} alkane_cred={}",
|
||||
afw.display(),
|
||||
if stock_password.is_some() { "loaded" } else { "none" },
|
||||
if alkane_password.is_some() { "set" } else { "none" }
|
||||
);
|
||||
if !afw.exists() {
|
||||
eprintln!("afw not found: {}", afw.display());
|
||||
return 2;
|
||||
}
|
||||
|
||||
// Resolve the board's MAC now (on stock) so we can re-find it after each
|
||||
// reboot even if its DHCP lease changes under alkane.
|
||||
let mac = mac_of(&host);
|
||||
println!(
|
||||
"board MAC: {}",
|
||||
mac.as_deref()
|
||||
.unwrap_or("unknown (will use the fixed host)")
|
||||
);
|
||||
|
||||
let boot_timeout = Duration::from_secs(300);
|
||||
let mut all_ok = true;
|
||||
|
||||
for i in 1..=iterations {
|
||||
println!("\n-- iteration {i}/{iterations} --");
|
||||
|
||||
// 1. install (stock -> alkane) through the GUI operation layer
|
||||
println!("[1/4] install: stock -> alkane");
|
||||
let h = stock_ops::start_install(
|
||||
vec![host.clone()],
|
||||
board.clone(),
|
||||
AfwSource::Local(afw.clone()),
|
||||
true, // allow unsigned (bench image)
|
||||
stock_password.clone(),
|
||||
false, // not an in-place update
|
||||
);
|
||||
if !drive("install", h) {
|
||||
all_ok = false;
|
||||
println!("[1/4] install FAILED; aborting");
|
||||
break;
|
||||
}
|
||||
|
||||
// 2. verify alkane is live (board reboots into alkane)
|
||||
println!(
|
||||
"[2/4] verify alkane (awaiting reboot, up to {}s)...",
|
||||
boot_timeout.as_secs()
|
||||
);
|
||||
let (alkane_ip, desc, ok) = wait_for(mac.as_deref(), &host, false, boot_timeout);
|
||||
println!(
|
||||
" {desc} => {}",
|
||||
if ok { "ALKANE" } else { "NOT ALKANE (fail)" }
|
||||
);
|
||||
all_ok = all_ok && ok;
|
||||
|
||||
// 3. restore (alkane -> stock) flag-flip at the board's CURRENT address
|
||||
println!("[3/4] restore: alkane -> stock (flag flip) at {alkane_ip}");
|
||||
let h = stock_ops::start_restore_flag(vec![alkane_ip.clone()], alkane_password.clone());
|
||||
if !drive("restore", h) {
|
||||
all_ok = false;
|
||||
println!("[3/4] restore FAILED");
|
||||
}
|
||||
|
||||
// 4. verify stock is back
|
||||
println!(
|
||||
"[4/4] verify stock (awaiting reboot, up to {}s)...",
|
||||
boot_timeout.as_secs()
|
||||
);
|
||||
let (_stock_ip, desc, ok) = wait_for(mac.as_deref(), &host, true, boot_timeout);
|
||||
println!(
|
||||
" {desc} => {}",
|
||||
if ok { "STOCK" } else { "NOT STOCK (fail)" }
|
||||
);
|
||||
all_ok = all_ok && ok;
|
||||
}
|
||||
|
||||
println!(
|
||||
"\n== BENCH RESULT: {} ==",
|
||||
if all_ok { "PASS" } else { "FAIL" }
|
||||
);
|
||||
if all_ok {
|
||||
0
|
||||
} else {
|
||||
1
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,437 @@
|
||||
//! Bug reports and feature requests from the toolbar's Bug report button.
|
||||
//!
|
||||
//! The app posts the report to the report relay (see tools/report-relay),
|
||||
//! which holds the Gitea token and files the issue in blueflare/alkane-toolkit.
|
||||
//! The app itself holds no secret. A report carries its type, the user's text,
|
||||
//! what the app knows about itself (version, OS, appearance, language, window
|
||||
//! size) and, if the user leaves it ticked, the recent activity log with
|
||||
//! credentials scrubbed. Nothing is stored locally.
|
||||
|
||||
use std::io::Write;
|
||||
use std::process::Stdio;
|
||||
use std::sync::mpsc::{channel, Receiver};
|
||||
|
||||
/// Where reports go. `ALKANE_REPORT_URL` overrides it (tests, staging).
|
||||
pub const DEFAULT_URL: &str = "https://gitea.bluefla.re/alkane-report/v1/report";
|
||||
/// Longest report text the relay accepts.
|
||||
pub const MAX_TEXT_CHARS: usize = 8000;
|
||||
/// Log sent with a report: at most this many of the newest lines...
|
||||
const LOG_LINES: usize = 80;
|
||||
/// ...cut to this many bytes on a line boundary.
|
||||
const LOG_BYTES: usize = 16 * 1024;
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Kind {
|
||||
Bug,
|
||||
Ui,
|
||||
Feature,
|
||||
}
|
||||
|
||||
impl Kind {
|
||||
/// In the order the dialog's type choice lists them.
|
||||
pub const ALL: [Kind; 3] = [Kind::Bug, Kind::Ui, Kind::Feature];
|
||||
|
||||
pub fn label(self) -> &'static str {
|
||||
match self {
|
||||
Kind::Bug => "Bug",
|
||||
Kind::Ui => "UI change",
|
||||
Kind::Feature => "Feature request",
|
||||
}
|
||||
}
|
||||
|
||||
/// The wire value, which is also the issue label.
|
||||
pub fn as_str(self) -> &'static str {
|
||||
match self {
|
||||
Kind::Bug => "bug",
|
||||
Kind::Ui => "ui",
|
||||
Kind::Feature => "feature",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// What the app knows about itself, sent with every report.
|
||||
#[derive(Clone, Debug, Default, PartialEq)]
|
||||
pub struct Context {
|
||||
pub app_version: String,
|
||||
pub platform: String,
|
||||
pub os: String,
|
||||
pub appearance: String,
|
||||
pub language: String,
|
||||
pub window: String,
|
||||
}
|
||||
|
||||
impl Context {
|
||||
/// The running app's context. `window` is the main window's size.
|
||||
pub fn current(dark: bool, language: &str, window: (i32, i32)) -> Context {
|
||||
Context {
|
||||
app_version: env!("CARGO_PKG_VERSION").to_string(),
|
||||
platform: format!("{}-{}", std::env::consts::OS, std::env::consts::ARCH),
|
||||
os: os_version(),
|
||||
appearance: if dark { "dark" } else { "light" }.to_string(),
|
||||
language: language.to_string(),
|
||||
window: format!("{}x{}", window.0, window.1),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A human-readable OS name and version, best effort.
|
||||
fn os_version() -> String {
|
||||
#[cfg(target_os = "linux")]
|
||||
{
|
||||
if let Ok(s) = std::fs::read_to_string("/etc/os-release") {
|
||||
for line in s.lines() {
|
||||
if let Some(v) = line.strip_prefix("PRETTY_NAME=") {
|
||||
return v.trim_matches('"').to_string();
|
||||
}
|
||||
}
|
||||
}
|
||||
"Linux".to_string()
|
||||
}
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
let out = alkane_core::platform::quiet_command("sw_vers")
|
||||
.arg("-productVersion")
|
||||
.output();
|
||||
match out {
|
||||
Ok(o) if o.status.success() => {
|
||||
format!("macOS {}", String::from_utf8_lossy(&o.stdout).trim())
|
||||
}
|
||||
_ => "macOS".to_string(),
|
||||
}
|
||||
}
|
||||
#[cfg(windows)]
|
||||
{
|
||||
let out = alkane_core::platform::quiet_command("cmd")
|
||||
.args(["/C", "ver"])
|
||||
.output();
|
||||
match out {
|
||||
Ok(o) if o.status.success() => {
|
||||
let v = String::from_utf8_lossy(&o.stdout).trim().to_string();
|
||||
if v.is_empty() {
|
||||
"Windows".to_string()
|
||||
} else {
|
||||
v
|
||||
}
|
||||
}
|
||||
_ => "Windows".to_string(),
|
||||
}
|
||||
}
|
||||
#[cfg(not(any(target_os = "linux", target_os = "macos", windows)))]
|
||||
{
|
||||
std::env::consts::OS.to_string()
|
||||
}
|
||||
}
|
||||
|
||||
/// Names whose values are secrets: `name=value`, `name: value` and
|
||||
/// `"name": "value"` have the value replaced.
|
||||
const SECRET_NAMES: [&str; 12] = [
|
||||
"password",
|
||||
"passwd",
|
||||
"pass",
|
||||
"pwd",
|
||||
"secret",
|
||||
"token",
|
||||
"apikey",
|
||||
"api_key",
|
||||
"authorization",
|
||||
"cookie",
|
||||
"psk",
|
||||
"credential",
|
||||
];
|
||||
|
||||
/// Remove credentials from log text before it leaves the machine: values of
|
||||
/// secret-looking names, `user:password@` in URLs, and PEM private keys.
|
||||
/// What is removed becomes `[redacted]`.
|
||||
pub fn scrub(text: &str) -> String {
|
||||
let mut out = Vec::new();
|
||||
let mut in_pem = false;
|
||||
for line in text.lines() {
|
||||
if line.contains("-----BEGIN") && line.contains("PRIVATE KEY") {
|
||||
in_pem = true;
|
||||
out.push("[redacted]".to_string());
|
||||
continue;
|
||||
}
|
||||
if in_pem {
|
||||
if line.contains("-----END") {
|
||||
in_pem = false;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
out.push(scrub_line(line));
|
||||
}
|
||||
out.join("\n")
|
||||
}
|
||||
|
||||
fn scrub_line(line: &str) -> String {
|
||||
let mut s = scrub_url_userinfo(line);
|
||||
let lower = s.to_ascii_lowercase();
|
||||
// Walk every occurrence of every secret name; redact the value after the
|
||||
// next `=` or `:` (quotes and spaces skipped) up to whitespace, a quote, a
|
||||
// comma, `&` or `;`.
|
||||
let mut cuts: Vec<(usize, usize)> = Vec::new();
|
||||
for name in SECRET_NAMES {
|
||||
let mut from = 0;
|
||||
while let Some(pos) = lower[from..].find(name) {
|
||||
let start = from + pos;
|
||||
from = start + name.len();
|
||||
let bytes = s.as_bytes();
|
||||
let mut i = start + name.len();
|
||||
// allow a closing quote and spaces between the name and the separator
|
||||
while i < bytes.len() && (bytes[i] == b'"' || bytes[i] == b'\'' || bytes[i] == b' ') {
|
||||
i += 1;
|
||||
}
|
||||
if i >= bytes.len() || (bytes[i] != b'=' && bytes[i] != b':') {
|
||||
continue;
|
||||
}
|
||||
i += 1;
|
||||
while i < bytes.len() && (bytes[i] == b' ' || bytes[i] == b'"' || bytes[i] == b'\'') {
|
||||
i += 1;
|
||||
}
|
||||
let vstart = i;
|
||||
if name == "authorization" || name == "cookie" {
|
||||
// "Authorization: Bearer <token>", "Cookie: a=b; c=d": the whole
|
||||
// rest of the line is the secret.
|
||||
i = bytes.len();
|
||||
}
|
||||
while i < bytes.len()
|
||||
&& !matches!(bytes[i], b' ' | b'"' | b'\'' | b',' | b'&' | b';' | b'\t')
|
||||
{
|
||||
i += 1;
|
||||
}
|
||||
if i > vstart {
|
||||
cuts.push((vstart, i));
|
||||
}
|
||||
}
|
||||
}
|
||||
if cuts.is_empty() {
|
||||
return s;
|
||||
}
|
||||
cuts.sort();
|
||||
let mut merged: Vec<(usize, usize)> = Vec::new();
|
||||
for (a, b) in cuts {
|
||||
match merged.last_mut() {
|
||||
Some(last) if a <= last.1 => last.1 = last.1.max(b),
|
||||
_ => merged.push((a, b)),
|
||||
}
|
||||
}
|
||||
for (a, b) in merged.into_iter().rev() {
|
||||
if s.is_char_boundary(a) && s.is_char_boundary(b) {
|
||||
s.replace_range(a..b, "[redacted]");
|
||||
}
|
||||
}
|
||||
s
|
||||
}
|
||||
|
||||
/// `scheme://user:password@host` -> `scheme://user:[redacted]@host`.
|
||||
fn scrub_url_userinfo(line: &str) -> String {
|
||||
let mut s = line.to_string();
|
||||
let mut from = 0;
|
||||
while let Some(p) = s[from..].find("://") {
|
||||
let auth_start = from + p + 3;
|
||||
let rest = &s[auth_start..];
|
||||
let end = rest
|
||||
.find(|c: char| c == '/' || c.is_whitespace())
|
||||
.unwrap_or(rest.len());
|
||||
let authority = &rest[..end];
|
||||
if let Some(at) = authority.rfind('@') {
|
||||
if let Some(colon) = authority[..at].find(':') {
|
||||
let a = auth_start + colon + 1;
|
||||
let b = auth_start + at;
|
||||
s.replace_range(a..b, "[redacted]");
|
||||
}
|
||||
}
|
||||
from = auth_start;
|
||||
if from >= s.len() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
s
|
||||
}
|
||||
|
||||
/// The newest activity-log lines, scrubbed and cut to the size limits.
|
||||
pub fn recent_log(full_log: &str) -> String {
|
||||
let lines: Vec<&str> = full_log.lines().collect();
|
||||
let tail = &lines[lines.len().saturating_sub(LOG_LINES)..];
|
||||
let mut text = scrub(&tail.join("\n"));
|
||||
if text.len() > LOG_BYTES {
|
||||
let mut cut = text.len() - LOG_BYTES;
|
||||
while !text.is_char_boundary(cut) {
|
||||
cut += 1;
|
||||
}
|
||||
text = text[cut..].to_string();
|
||||
if let Some(nl) = text.find('\n') {
|
||||
text = text[nl + 1..].to_string();
|
||||
}
|
||||
}
|
||||
text
|
||||
}
|
||||
|
||||
/// The JSON body the relay takes.
|
||||
pub fn payload(kind: Kind, text: &str, ctx: &Context, log: Option<&str>) -> String {
|
||||
serde_json::json!({
|
||||
"kind": kind.as_str(),
|
||||
"text": text,
|
||||
"app_version": ctx.app_version,
|
||||
"platform": ctx.platform,
|
||||
"os": ctx.os,
|
||||
"appearance": ctx.appearance,
|
||||
"language": ctx.language,
|
||||
"window": ctx.window,
|
||||
"log": log.unwrap_or(""),
|
||||
})
|
||||
.to_string()
|
||||
}
|
||||
|
||||
/// A filed issue: its number and web link.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct Filed {
|
||||
pub number: u64,
|
||||
pub url: String,
|
||||
}
|
||||
|
||||
/// Read the relay's answer: curl's body, then the HTTP status on the last line.
|
||||
pub fn parse_response(curl_stdout: &str) -> Result<Filed, String> {
|
||||
let trimmed = curl_stdout.trim_end();
|
||||
let (body, code) = match trimmed.rfind('\n') {
|
||||
Some(i) => (&trimmed[..i], trimmed[i + 1..].trim()),
|
||||
None => ("", trimmed),
|
||||
};
|
||||
let json: Option<serde_json::Value> = serde_json::from_str(body).ok();
|
||||
if code == "201" || code == "200" {
|
||||
let number = json.as_ref().and_then(|j| j["number"].as_u64());
|
||||
let url = json.as_ref().and_then(|j| j["url"].as_str()).unwrap_or("");
|
||||
return match number {
|
||||
Some(number) => Ok(Filed {
|
||||
number,
|
||||
url: url.to_string(),
|
||||
}),
|
||||
None => Err("the report service answered without an issue number; \
|
||||
check the issue list before sending again"
|
||||
.into()),
|
||||
};
|
||||
}
|
||||
let reason = json
|
||||
.as_ref()
|
||||
.and_then(|j| j["error"].as_str())
|
||||
.map(str::to_string);
|
||||
Err(match (code, reason) {
|
||||
(_, Some(r)) => r,
|
||||
("000", None) | ("", None) => "could not reach the report service".into(),
|
||||
(c, None) => format!("the report service answered HTTP {c}"),
|
||||
})
|
||||
}
|
||||
|
||||
/// Send a report on a worker thread; the receiver gets one result.
|
||||
pub fn send(body: String) -> Receiver<Result<Filed, String>> {
|
||||
let url = std::env::var("ALKANE_REPORT_URL").unwrap_or_else(|_| DEFAULT_URL.to_string());
|
||||
let (tx, rx) = channel();
|
||||
std::thread::spawn(move || {
|
||||
let result = (|| {
|
||||
let mut child = alkane_core::platform::quiet_command("curl")
|
||||
.args([
|
||||
"-sS",
|
||||
"--max-time",
|
||||
"40",
|
||||
"-X",
|
||||
"POST",
|
||||
"-H",
|
||||
"Content-Type: application/json",
|
||||
"--data-binary",
|
||||
"@-",
|
||||
"-w",
|
||||
"\n%{http_code}",
|
||||
&url,
|
||||
])
|
||||
.stdin(Stdio::piped())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
.spawn()
|
||||
.map_err(|e| format!("could not run curl: {e}"))?;
|
||||
if let Some(mut si) = child.stdin.take() {
|
||||
let _ = si.write_all(body.as_bytes());
|
||||
}
|
||||
let out = child
|
||||
.wait_with_output()
|
||||
.map_err(|e| format!("curl failed: {e}"))?;
|
||||
parse_response(&String::from_utf8_lossy(&out.stdout))
|
||||
})();
|
||||
let _ = tx.send(result);
|
||||
});
|
||||
rx
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn scrub_removes_credentials_and_keeps_the_rest() {
|
||||
let log = "12:00:01 set pools on 192.168.1.20: url=stratum+tcp://u:hunter2@pool:3333 password=hunter2\n\
|
||||
12:00:02 login {\"user\": \"root\", \"pass\": \"s3cret\"}\n\
|
||||
12:00:03 Authorization: Bearer abc.def\n\
|
||||
-----BEGIN OPENSSH PRIVATE KEY-----\nAAAA\n-----END OPENSSH PRIVATE KEY-----\n\
|
||||
12:00:04 scan finished: 9 miners";
|
||||
let s = scrub(log);
|
||||
assert!(!s.contains("hunter2"), "{s}");
|
||||
assert!(!s.contains("s3cret"), "{s}");
|
||||
assert!(!s.contains("abc.def"), "{s}");
|
||||
assert!(!s.contains("AAAA"), "{s}");
|
||||
assert!(s.contains("192.168.1.20"));
|
||||
assert!(s.contains("\"user\": \"root\""));
|
||||
assert!(s.contains("scan finished: 9 miners"));
|
||||
assert_eq!(s.matches("[redacted]").count(), 5, "{s}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recent_log_keeps_the_newest_lines_within_limits() {
|
||||
let log: Vec<String> = (0..500)
|
||||
.map(|i| format!("line {i} {}", "x".repeat(300)))
|
||||
.collect();
|
||||
let tail = recent_log(&log.join("\n"));
|
||||
assert!(tail.len() <= LOG_BYTES);
|
||||
assert!(tail.ends_with(&log[499]));
|
||||
assert!(tail.starts_with("line "), "cut on a line boundary");
|
||||
assert!(!tail.contains("line 400 "), "only the newest lines");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn payload_carries_kind_text_and_context() {
|
||||
let ctx = Context {
|
||||
app_version: "1.2.3".into(),
|
||||
platform: "macos-aarch64".into(),
|
||||
os: "macOS 15.1".into(),
|
||||
appearance: "dark".into(),
|
||||
language: "en".into(),
|
||||
window: "1280x800".into(),
|
||||
};
|
||||
let v: serde_json::Value =
|
||||
serde_json::from_str(&payload(Kind::Ui, "Text \"quoted\"", &ctx, None)).unwrap();
|
||||
assert_eq!(v["kind"], "ui");
|
||||
assert_eq!(v["text"], "Text \"quoted\"");
|
||||
assert_eq!(v["app_version"], "1.2.3");
|
||||
assert_eq!(v["log"], "");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn response_parsing() {
|
||||
assert_eq!(
|
||||
parse_response("{\"number\":42,\"url\":\"https://x/42\"}\n201"),
|
||||
Ok(Filed {
|
||||
number: 42,
|
||||
url: "https://x/42".into()
|
||||
})
|
||||
);
|
||||
assert_eq!(
|
||||
parse_response("{\"error\":\"Too many reports; try again later\"}\n429"),
|
||||
Err("Too many reports; try again later".into())
|
||||
);
|
||||
assert_eq!(
|
||||
parse_response("\n000"),
|
||||
Err("could not reach the report service".into())
|
||||
);
|
||||
assert_eq!(
|
||||
parse_response("<html>\n502"),
|
||||
Err("the report service answered HTTP 502".into())
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -69,13 +69,26 @@ pub fn load_ssh_credentials() -> Option<(String, String)> {
|
||||
load_creds_file(SSH_CREDENTIALS_FILE)
|
||||
}
|
||||
|
||||
/// Save the SSH username/password (0600). Retained for a future SSH-login dialog
|
||||
/// now that the SSH PIC probe that used to save it has been removed (round 14 #5).
|
||||
#[allow(dead_code)]
|
||||
/// Save the SSH username/password (0600), from the Credentials dialog.
|
||||
pub fn save_ssh_credentials(user: &str, pass: &str) -> std::io::Result<()> {
|
||||
save_creds_file(SSH_CREDENTIALS_FILE, user, pass)
|
||||
}
|
||||
|
||||
/// Remove the saved SSH login, if any. Not an error if none was saved.
|
||||
pub fn clear_ssh_credentials() -> std::io::Result<()> {
|
||||
clear_creds_file(SSH_CREDENTIALS_FILE)
|
||||
}
|
||||
|
||||
/// The SSH username to use: the saved one, or `root` (the control-board login
|
||||
/// on every firmware the restore flow drives over SSH) when none was entered.
|
||||
pub fn ssh_user_or_default(user: &str) -> String {
|
||||
if user.trim().is_empty() {
|
||||
"root".to_string()
|
||||
} else {
|
||||
user.trim().to_string()
|
||||
}
|
||||
}
|
||||
|
||||
/// Remove the saved web/API credentials, if any. Not an error if none were saved.
|
||||
pub fn clear_credentials() -> std::io::Result<()> {
|
||||
match clear_creds_file(CREDENTIALS_FILE) {
|
||||
@@ -93,6 +106,9 @@ pub fn clear_credentials() -> std::io::Result<()> {
|
||||
/// duplicated here; a firmware absent from this table defaults to blank.
|
||||
pub fn firmware_default_creds() -> &'static [(&'static str, &'static str, &'static str)] {
|
||||
&[
|
||||
// Alkane OS ships with this control-board login, so restore-to-stock on
|
||||
// an alkane board authenticates with no operator setup (issue #51).
|
||||
("Alkane", "root", "alkane"),
|
||||
("AntMiner Stock", "root", "root"),
|
||||
("WhatsMiner Stock", "admin", "admin"),
|
||||
("Braiins", "root", "root"),
|
||||
@@ -121,6 +137,18 @@ pub fn firmware_default_for(name: &str) -> (String, String) {
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
/// The login to use for a board running `firmware`: the operator's saved
|
||||
/// per-firmware override if any, else the shipped default. This is how install
|
||||
/// (a stock target) and restore (an alkane target) each pick the right login
|
||||
/// automatically, without a password field in the dialog (issues #46, #51).
|
||||
pub fn cred_for(firmware: &str) -> (String, String) {
|
||||
load_firmware_credentials()
|
||||
.get(firmware)
|
||||
.cloned()
|
||||
.filter(|(_, p)| !p.is_empty())
|
||||
.unwrap_or_else(|| firmware_default_for(firmware))
|
||||
}
|
||||
|
||||
/// Load the operator's per-firmware credential overrides, keyed by firmware
|
||||
/// Display name. Malformed lines are skipped.
|
||||
pub fn load_firmware_credentials() -> HashMap<String, (String, String)> {
|
||||
@@ -272,6 +300,28 @@ mod tests {
|
||||
assert_eq!(load_credentials(), None, "cleared -> None");
|
||||
clear_credentials().unwrap(); // idempotent: clearing an already-clear store is not an error
|
||||
|
||||
// SSH login: separate file, same 0600 rule, clear is idempotent.
|
||||
assert_eq!(load_ssh_credentials(), None, "no SSH file -> None");
|
||||
save_ssh_credentials("root", "ssh-pass").unwrap();
|
||||
assert_owner_only(
|
||||
&config_path(SSH_CREDENTIALS_FILE),
|
||||
"SSH creds file must be 0600",
|
||||
);
|
||||
assert_eq!(
|
||||
load_ssh_credentials(),
|
||||
Some(("root".to_string(), "ssh-pass".to_string()))
|
||||
);
|
||||
assert_eq!(
|
||||
load_credentials(),
|
||||
None,
|
||||
"SSH save leaves the web login alone"
|
||||
);
|
||||
clear_ssh_credentials().unwrap();
|
||||
assert_eq!(load_ssh_credentials(), None, "cleared -> None");
|
||||
clear_ssh_credentials().unwrap();
|
||||
assert_eq!(ssh_user_or_default(""), "root");
|
||||
assert_eq!(ssh_user_or_default(" admin "), "admin");
|
||||
|
||||
// Per-firmware overrides (round 12 #13). Kept in this same test because
|
||||
// HOME is process-global: a second #[test] mutating it would race under
|
||||
// cargo's default parallel runner.
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
//! Bench-fleet fixtures: the expected hardware output of the 9 boards on
|
||||
//! 10.255.1.0/24 (see ../../../HANDOFF.md section 7 and the parent project's
|
||||
//! [removed]). These are the reference values the workflow tests compare
|
||||
//! Fixture fleet: the expected hardware output of nine representative miners
|
||||
//! (one per control-board family / firmware). These are the reference values
|
||||
//! the workflow tests compare
|
||||
//! the application's actual output against, and the rows the offline
|
||||
//! `ALKANE_FAKE_SCAN` demo mode renders. Only miners that respond become rows,
|
||||
//! so there is no synthetic "offline" fixture.
|
||||
|
||||
@@ -34,7 +34,7 @@ impl Lang {
|
||||
Lang::Pt => "Portugu\u{ea}s",
|
||||
}
|
||||
}
|
||||
fn code(self) -> &'static str {
|
||||
pub fn code(self) -> &'static str {
|
||||
match self {
|
||||
Lang::En => "en",
|
||||
Lang::Zh => "zh",
|
||||
@@ -137,6 +137,13 @@ const TABLE: &[(&str, [&str; 6])] = &[
|
||||
("Credentials", ["Credentials", "\u{51ed}\u{636e}", "\u{0423}\u{0447}\u{0451}\u{0442}\u{043d}\u{044b}\u{0435} \u{0434}\u{0430}\u{043d}\u{043d}\u{044b}\u{0435}", "Identifiants", "Credenciales", "Credenciais"]),
|
||||
("Language", ["Language", "\u{8bed}\u{8a00}", "\u{042f}\u{0437}\u{044b}\u{043a}", "Langue", "Idioma", "Idioma"]),
|
||||
("Logs", ["Logs", "\u{65e5}\u{5fd7}", "\u{0416}\u{0443}\u{0440}\u{043d}\u{0430}\u{043b}", "Journaux", "Registros", "Registos"]),
|
||||
("Bug report", ["Bug report", "\u{95ee}\u{9898}\u{53cd}\u{9988}", "\u{421}\u{43e}\u{43e}\u{431}\u{449}\u{438}\u{442}\u{44c} \u{43e}\u{431} \u{43e}\u{448}\u{438}\u{431}\u{43a}\u{435}", "Signaler un bug", "Informar de un error", "Relatar um erro"]),
|
||||
("Type", ["Type", "\u{7c7b}\u{578b}", "\u{422}\u{438}\u{43f}", "Type", "Tipo", "Tipo"]),
|
||||
("Bug", ["Bug", "\u{7f3a}\u{9677}", "\u{41e}\u{448}\u{438}\u{431}\u{43a}\u{430}", "Bug", "Error", "Erro"]),
|
||||
("UI change", ["UI change", "\u{754c}\u{9762}\u{4fee}\u{6539}", "\u{418}\u{437}\u{43c}\u{435}\u{43d}\u{435}\u{43d}\u{438}\u{435} \u{438}\u{43d}\u{442}\u{435}\u{440}\u{444}\u{435}\u{439}\u{441}\u{430}", "Modification de l'interface", "Cambio de interfaz", "Altera\u{e7}\u{e3}o da interface"]),
|
||||
("Feature request", ["Feature request", "\u{529f}\u{80fd}\u{5efa}\u{8bae}", "\u{41f}\u{440}\u{435}\u{434}\u{43b}\u{43e}\u{436}\u{435}\u{43d}\u{438}\u{435} \u{444}\u{443}\u{43d}\u{43a}\u{446}\u{438}\u{438}", "Demande de fonctionnalit\u{e9}", "Solicitud de funci\u{f3}n", "Pedido de recurso"]),
|
||||
("Send", ["Send", "\u{53d1}\u{9001}", "\u{41e}\u{442}\u{43f}\u{440}\u{430}\u{432}\u{438}\u{442}\u{44c}", "Envoyer", "Enviar", "Enviar"]),
|
||||
("Open issue", ["Open issue", "\u{6253}\u{5f00}\u{95ee}\u{9898}", "\u{41e}\u{442}\u{43a}\u{440}\u{44b}\u{442}\u{44c} \u{437}\u{430}\u{434}\u{430}\u{447}\u{443}", "Ouvrir le ticket", "Abrir incidencia", "Abrir issue"]),
|
||||
// KPI captions
|
||||
("Total", ["Total", "\u{603b}\u{6570}", "\u{0412}\u{0441}\u{0435}\u{0433}\u{043e}", "Total", "Total", "Total"]),
|
||||
("Hashing", ["Hashing", "\u{6b63}\u{5728}\u{6316}\u{77ff}", "\u{0425}\u{0435}\u{0448}\u{0438}\u{0440}\u{043e}\u{0432}\u{0430}\u{043d}\u{0438}\u{0435}", "Minage", "Minando", "Minerando"]),
|
||||
|
||||
@@ -6,7 +6,10 @@
|
||||
#![cfg_attr(windows, windows_subsystem = "windows")]
|
||||
|
||||
mod access_probe;
|
||||
mod alkane_detect;
|
||||
mod askpass;
|
||||
mod bench_sequence;
|
||||
mod bug_report;
|
||||
mod credentials;
|
||||
mod export;
|
||||
mod fixtures;
|
||||
@@ -19,6 +22,7 @@ mod pool_prefs;
|
||||
mod presets;
|
||||
mod restore;
|
||||
mod scan;
|
||||
mod stock_ops;
|
||||
mod ui;
|
||||
|
||||
fn main() {
|
||||
@@ -38,6 +42,13 @@ fn main() {
|
||||
std::process::exit(run_selftest());
|
||||
}
|
||||
|
||||
// Headless bench automation: drive the real install/restore operation layer
|
||||
// (stock_ops) through the A113D network-only install <-> flag-restore cycle
|
||||
// against real hardware, with no window. See bench_sequence.rs.
|
||||
if let Some(spec) = std::env::var_os("ALKANE_BENCH_SEQUENCE") {
|
||||
std::process::exit(bench_sequence::run(&spec.to_string_lossy()));
|
||||
}
|
||||
|
||||
// Headless access-probe check: `ALKANE_ACCESS_PROBE="<ip> <make>"` prints the
|
||||
// lock state the real access probe computes (no GUI, no wx), so the WhatsMiner
|
||||
// :4028 token check and the Antminer digest check can be verified directly.
|
||||
@@ -99,6 +110,17 @@ fn run_selftest() -> i32 {
|
||||
let frame = wx_rs::Widget::main_frame();
|
||||
let mut app = ui::build(frame);
|
||||
let ok = app.run_fixture_selftest();
|
||||
// ALKANE_SNAPSHOT=path (macOS): also write a PNG of the window as the app
|
||||
// draws it, to check rendering without screen-recording permission.
|
||||
if let Some(path) = std::env::var_os("ALKANE_SNAPSHOT") {
|
||||
let path = path.to_string_lossy();
|
||||
let wrote = wx_rs::snapshot_png(&frame, &path);
|
||||
println!(
|
||||
"SNAPSHOT {} {}",
|
||||
if wrote { "wrote" } else { "unavailable" },
|
||||
path
|
||||
);
|
||||
}
|
||||
println!("SELFTEST {}", if ok { "PASS" } else { "FAIL" });
|
||||
if ok {
|
||||
0
|
||||
@@ -109,9 +131,14 @@ fn run_selftest() -> i32 {
|
||||
|
||||
/// True when the process runs one of the headless check modes instead of the GUI.
|
||||
fn headless_mode() -> bool {
|
||||
["ALKANE_SELFTEST", "ALKANE_ACCESS_PROBE", "ALKANE_LOG_SCAN"]
|
||||
.iter()
|
||||
.any(|v| std::env::var_os(v).is_some())
|
||||
[
|
||||
"ALKANE_SELFTEST",
|
||||
"ALKANE_ACCESS_PROBE",
|
||||
"ALKANE_LOG_SCAN",
|
||||
"ALKANE_BENCH_SEQUENCE",
|
||||
]
|
||||
.iter()
|
||||
.any(|v| std::env::var_os(v).is_some())
|
||||
}
|
||||
|
||||
/// A Windows GUI-subsystem process has no console, so output from the headless
|
||||
|
||||
@@ -527,6 +527,10 @@ pub struct MinerRow {
|
||||
/// from whether any control capability is available: `None` = unknown,
|
||||
/// `Some(true)` = locked, `Some(false)` = unlocked/writable.
|
||||
pub write_locked: Option<bool>,
|
||||
/// Set when the row is a board running Alkane OS (found by the toolkit's own
|
||||
/// probe, `alkane_detect`, not asic-rs): the board family it reports
|
||||
/// ("zynq-7010"), or an empty string for an older image that does not say.
|
||||
pub alkane_board: Option<String>,
|
||||
/// Structured error/event lines from the miner (severity + text), most
|
||||
/// severe first. Empty means none. The Error column shows a summary; the
|
||||
/// full list is the hover tooltip (added with the tooltip bridge support).
|
||||
@@ -688,9 +692,18 @@ impl MinerRow {
|
||||
/// live); grey (unknown) otherwise -- asic-rs has no direct PSU-fault flag, so
|
||||
/// a missing wattage reading is treated as unknown, never a false "down".
|
||||
pub fn power_health(&self) -> CompHealth {
|
||||
// A miner drawing power / spinning its PSU fan / actively mining has a live
|
||||
// PSU regardless of any warning flag.
|
||||
let delivering = self.power_w > 0.0 || self.psu_fan_rpm > 0.0 || self.is_mining;
|
||||
// A live PSU shows real evidence: measured draw, a spinning PSU fan, or
|
||||
// reported PSU output. A stock control board can assert a cgminer "mining"
|
||||
// status with no PSU and no hashboards attached (issue #39: a bare S17
|
||||
// control board showed a green PSU), so is_mining counts only when the
|
||||
// miner is actually hashing (hashrate, or at least one healthy board).
|
||||
let actually_hashing =
|
||||
self.hashrate_ths > 0.0 || self.board_status.contains(&BoardHealth::Ok);
|
||||
let delivering = self.power_w > 0.0
|
||||
|| self.psu_fan_rpm > 0.0
|
||||
|| self.psu_out_voltage_v.is_some()
|
||||
|| self.psu_out_current_a.is_some()
|
||||
|| (self.is_mining && actually_hashing);
|
||||
// A reported PSU fault while the miner is actually mining is a warning, not
|
||||
// a failure -- yellow, not red (round 18 #2: some WhatsMiners flag a PSU
|
||||
// error while running fine). A fault on a miner that is not mining is a real
|
||||
@@ -2472,6 +2485,52 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stock_board_with_nothing_attached_shows_grey_psu() {
|
||||
// Issue #39: a stock S17 control board with no PSU and no hashboards
|
||||
// attached asserts a cgminer "mining" status (is_mining = true) while
|
||||
// reporting zero watts, no PSU fan, and no PSU output. That is not
|
||||
// evidence of a live PSU, so the bolt must read grey (Unreachable).
|
||||
let bare = MinerRow {
|
||||
is_mining: true,
|
||||
power_w: 0.0,
|
||||
psu_fan_rpm: 0.0,
|
||||
hashrate_ths: 0.0,
|
||||
board_status: vec![BoardHealth::Missing, BoardHealth::Missing],
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(bare.power_health(), CompHealth::Unreachable);
|
||||
|
||||
// A genuinely-running miner still greens: is_mining with real hashing is
|
||||
// evidence enough even when the firmware reports no watts.
|
||||
let hashing = MinerRow {
|
||||
is_mining: true,
|
||||
power_w: 0.0,
|
||||
psu_fan_rpm: 0.0,
|
||||
hashrate_ths: 90.0,
|
||||
board_status: vec![BoardHealth::Ok, BoardHealth::Ok],
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(hashing.power_health(), CompHealth::Ok);
|
||||
|
||||
// Measured draw alone is always enough.
|
||||
let drawing = MinerRow {
|
||||
is_mining: false,
|
||||
power_w: 19.0,
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(drawing.power_health(), CompHealth::Ok);
|
||||
|
||||
// Reported PSU output alone is enough even with zero measured watts.
|
||||
let psu_out = MinerRow {
|
||||
is_mining: false,
|
||||
power_w: 0.0,
|
||||
psu_out_voltage_v: Some(12.0),
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(psu_out.power_health(), CompHealth::Ok);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn warning_fault_degrades_board_to_yellow_not_red() {
|
||||
// Round 21 #1: a board still mining near full hashrate with some failed/
|
||||
|
||||
@@ -245,7 +245,7 @@ fn restore_braiins(ip: &str, user: &str, pass: &str) -> (bool, String) {
|
||||
if pass.is_empty() {
|
||||
return (
|
||||
false,
|
||||
"Braiins restore needs an SSH password (set the SSH login)".into(),
|
||||
"Braiins restore needs an SSH password (Credentials > SSH)".into(),
|
||||
);
|
||||
}
|
||||
let target = format!("{user}@{ip}");
|
||||
|
||||
+129
-20
@@ -86,7 +86,9 @@ pub fn save_scan_concurrency(n: usize) -> std::io::Result<()> {
|
||||
.to_string(),
|
||||
)
|
||||
}
|
||||
pub const DEFAULT_RANGE: &str = "10.255.1.0/24";
|
||||
/// The usual home/site router subnet. Host bits are masked off, so this scans
|
||||
/// 192.168.1.0/24.
|
||||
pub const DEFAULT_RANGE: &str = "192.168.1.1/24";
|
||||
/// Default seconds between automatic rescans.
|
||||
pub const DEFAULT_AUTO_SECS: u64 = 300;
|
||||
|
||||
@@ -529,7 +531,10 @@ pub fn start_scan(lines: Vec<String>, timeout_secs: u64) -> ScanHandle {
|
||||
.ok();
|
||||
(ip, row)
|
||||
}
|
||||
None => (ip, None),
|
||||
// asic-rs does not recognise a board running Alkane
|
||||
// OS (no cgminer socket or vendor web UI exposed);
|
||||
// the toolkit's own probe finds it.
|
||||
None => (ip, crate::alkane_detect::detect(ip).await),
|
||||
}
|
||||
}
|
||||
})
|
||||
@@ -669,6 +674,62 @@ fn messages_to_faults(
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// A hashboard's health dot from its reported activity. `active` is the firmware's
|
||||
/// active flag; `working_chips` its working-chip count. Green needs positive
|
||||
/// evidence (active, or a nonzero chip count); a board with neither flag nor count
|
||||
/// reads grey ("not detected") rather than green (issue #39: an S17 control board
|
||||
/// with no hashboards attached showed its boards green). A board that is present
|
||||
/// but idle or has zero working chips reads as a fault (red).
|
||||
fn board_health(
|
||||
active: Option<bool>,
|
||||
working_chips: Option<u16>,
|
||||
miner_active: bool,
|
||||
) -> crate::model::BoardHealth {
|
||||
use crate::model::BoardHealth;
|
||||
match (active, working_chips) {
|
||||
(Some(true), _) => BoardHealth::Ok,
|
||||
(Some(false), _) => BoardHealth::Fault,
|
||||
(None, Some(c)) if c > 0 => BoardHealth::Ok,
|
||||
(None, Some(_)) => BoardHealth::Fault,
|
||||
// No per-board evidence. If the miner shows overall activity (hashing),
|
||||
// the board is clearly present and working -> green; only an idle miner
|
||||
// with no board telemetry reads grey (issue #39: bare S17; review #3: do
|
||||
// not grey a genuinely-mining miner whose backend omits per-board fields).
|
||||
(None, None) => {
|
||||
if miner_active {
|
||||
BoardHealth::Ok
|
||||
} else {
|
||||
BoardHealth::Missing
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod board_health_tests {
|
||||
use super::board_health;
|
||||
use crate::model::BoardHealth;
|
||||
|
||||
#[test]
|
||||
fn no_activity_evidence_reads_grey_not_green() {
|
||||
// Issue #39: the firmware lists a board but reports no active flag and no
|
||||
// working-chip count -> not detected (grey), not green.
|
||||
// Idle miner, no per-board evidence -> not detected (grey).
|
||||
assert_eq!(board_health(None, None, false), BoardHealth::Missing);
|
||||
// Mining miner, no per-board evidence -> still green (review #3).
|
||||
assert_eq!(board_health(None, None, true), BoardHealth::Ok);
|
||||
// Positive evidence still greens regardless of miner activity.
|
||||
assert_eq!(board_health(Some(true), None, false), BoardHealth::Ok);
|
||||
assert_eq!(board_health(None, Some(63), false), BoardHealth::Ok);
|
||||
// Present but idle / zero working chips -> fault (red).
|
||||
assert_eq!(
|
||||
board_health(Some(false), Some(63), false),
|
||||
BoardHealth::Fault
|
||||
);
|
||||
assert_eq!(board_health(None, Some(0), false), BoardHealth::Fault);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod board_index_tests {
|
||||
use super::board_index_from_text;
|
||||
@@ -1184,18 +1245,7 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
let mut board_status: Vec<crate::model::BoardHealth> = data
|
||||
.hashboards
|
||||
.iter()
|
||||
.map(|b| {
|
||||
let ok = match (b.active, b.working_chips) {
|
||||
(Some(a), _) => a,
|
||||
(None, Some(c)) => c > 0,
|
||||
(None, None) => true,
|
||||
};
|
||||
if ok {
|
||||
crate::model::BoardHealth::Ok
|
||||
} else {
|
||||
crate::model::BoardHealth::Fault
|
||||
}
|
||||
})
|
||||
.map(|b| board_health(b.active, b.working_chips, is_mining || hashrate_ths > 0.0))
|
||||
.collect();
|
||||
if let Some(exp) = data.expected_hashboards {
|
||||
while board_status.len() < exp as usize {
|
||||
@@ -1227,6 +1277,8 @@ async fn to_row(miner: &dyn Miner) -> MinerRow {
|
||||
.unwrap_or_default(),
|
||||
pic_present,
|
||||
write_locked,
|
||||
// asic-rs identified this miner, so it is not running Alkane OS.
|
||||
alkane_board: None,
|
||||
errors,
|
||||
faults,
|
||||
model,
|
||||
@@ -1915,13 +1967,25 @@ pub fn start_refresh(ips: Vec<String>) -> RefreshHandle {
|
||||
ok += 1;
|
||||
RefreshMsg::Row(to_row(&*miner).await)
|
||||
}
|
||||
Ok(None) => RefreshMsg::Failed {
|
||||
ip: ip_s,
|
||||
detail: "offline".to_string(),
|
||||
Ok(None) => match crate::alkane_detect::detect(ip).await {
|
||||
Some(row) => {
|
||||
ok += 1;
|
||||
RefreshMsg::Row(row)
|
||||
}
|
||||
None => RefreshMsg::Failed {
|
||||
ip: ip_s,
|
||||
detail: "offline".to_string(),
|
||||
},
|
||||
},
|
||||
Err(e) => RefreshMsg::Failed {
|
||||
ip: ip_s,
|
||||
detail: format!("{e}"),
|
||||
Err(e) => match crate::alkane_detect::detect(ip).await {
|
||||
Some(row) => {
|
||||
ok += 1;
|
||||
RefreshMsg::Row(row)
|
||||
}
|
||||
None => RefreshMsg::Failed {
|
||||
ip: ip_s,
|
||||
detail: format!("{e}"),
|
||||
},
|
||||
},
|
||||
},
|
||||
};
|
||||
@@ -2267,6 +2331,13 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn default_range_covers_the_whole_192_168_1_subnet() {
|
||||
let ips = parse_line(DEFAULT_RANGE).unwrap();
|
||||
let cidrs = targets_to_cidrs(&ips);
|
||||
assert_eq!(cidrs, vec![(Ipv4Addr::new(192, 168, 1, 0), 24)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cidr_aggregation_round_trips() {
|
||||
// a /24 must aggregate back to exactly one /24 block
|
||||
@@ -2606,3 +2677,41 @@ mod tests {
|
||||
std::env::remove_var(FAKE_SCAN_ENV);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod live_scan_tests {
|
||||
/// Run the real fleet scan over a range and print, per row found, what the
|
||||
/// alkane-os menu would offer:
|
||||
/// `ALKANE_TEST_SCAN_RANGE=10.255.1.0/24 cargo test -p alkane-gui live_scan -- --ignored --nocapture`
|
||||
#[test]
|
||||
#[ignore = "needs a reachable miner network (ALKANE_TEST_SCAN_RANGE)"]
|
||||
fn live_scan() {
|
||||
let Ok(range) = std::env::var("ALKANE_TEST_SCAN_RANGE") else {
|
||||
return;
|
||||
};
|
||||
let handle = super::start_scan(vec![range], 10);
|
||||
let mut rows = std::collections::BTreeMap::new();
|
||||
while let Ok(msg) = handle.rx.recv() {
|
||||
match msg {
|
||||
super::ScanMsg::Row(row) => {
|
||||
rows.insert(row.ip.clone(), row);
|
||||
}
|
||||
super::ScanMsg::Done(_) | super::ScanMsg::Failed(_) => break,
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
for row in rows.values() {
|
||||
println!(
|
||||
"{:<15} brand={:<10} model={:<12} fw={:<8} {:<8} board={:<10} install={} uninstall={}",
|
||||
row.ip,
|
||||
row.brand,
|
||||
row.model,
|
||||
row.firmware,
|
||||
row.fw_version,
|
||||
row.control_board,
|
||||
crate::alkane_detect::install_supported(row),
|
||||
crate::alkane_detect::is_alkane(row),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,477 @@
|
||||
//! Install alkane-os onto a board on stock, and restore an alkane board to
|
||||
//! stock, from the GUI - using the toolkit's own self-contained, network-only
|
||||
//! engine (`alkane_flash::stock`), the same code the CLI drives. There is no
|
||||
//! external helper and no runtime dependency on any other tool: the
|
||||
//! stock-crossing method is compiled into this binary. This module drives that
|
||||
//! engine on a background thread and reports progress.
|
||||
//!
|
||||
//! Both operations are DESTRUCTIVE (they reflash the control board) and run on a
|
||||
//! background thread so the reboot/flash latency never blocks the wx event loop.
|
||||
//! Results stream back over a channel, drained by the UI timer tick exactly like
|
||||
//! restore.rs. The UI gates each behind a typed-FLASH confirmation.
|
||||
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::mpsc::{channel, Receiver};
|
||||
use std::sync::Arc;
|
||||
|
||||
use alkane_artifacts::afw::{verify_afw, VerifyOptions};
|
||||
use alkane_artifacts::fetch::{self, ReleaseSource};
|
||||
use alkane_flash::stock::{self, RestoreImages};
|
||||
use alkane_flash::stock_firmware;
|
||||
|
||||
use crate::scan::fake_scan_enabled;
|
||||
|
||||
/// Control boards alkane-os can be installed onto from stock (mirrors the CLI's
|
||||
/// `SUPPORTED`). Only these are offered as install targets.
|
||||
pub const SUPPORTED_BOARDS: &[(&str, &str)] = &[
|
||||
("zynq-7010", "Antminer S17 (Xilinx Zynq-7010 control board)"),
|
||||
(
|
||||
"a113d",
|
||||
"Antminer S19j Pro (Amlogic A113D/AXG control board)",
|
||||
),
|
||||
];
|
||||
|
||||
/// The default install board when the user has not chosen another.
|
||||
pub const DEFAULT_BOARD: &str = "zynq-7010";
|
||||
|
||||
pub fn is_supported_board(board: &str) -> bool {
|
||||
SUPPORTED_BOARDS.iter().any(|(b, _)| *b == board)
|
||||
}
|
||||
|
||||
/// Where the `.afw` to install comes from. `Release` is a scanned Gitea asset
|
||||
/// (its filename and download URL), fetched on the worker thread so the download
|
||||
/// never blocks the UI. `Local` is a file the operator picked with the Browse
|
||||
/// button -- the same local-file install the CLI offers, now in the GUI too.
|
||||
pub enum AfwSource {
|
||||
Release { name: String, url: String },
|
||||
Local(PathBuf),
|
||||
}
|
||||
|
||||
impl AfwSource {
|
||||
/// A short human label for the status line (the filename in both cases).
|
||||
fn label(&self) -> String {
|
||||
match self {
|
||||
AfwSource::Release { name, .. } => name.clone(),
|
||||
AfwSource::Local(p) => p
|
||||
.file_name()
|
||||
.map(|n| n.to_string_lossy().into_owned())
|
||||
.unwrap_or_else(|| p.to_string_lossy().into_owned()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Progress + results streamed from the background worker to the UI.
|
||||
pub enum StockMsg {
|
||||
Started,
|
||||
/// A human-readable status line for the status bar (acquiring, verifying...).
|
||||
Progress(String),
|
||||
/// One board's outcome.
|
||||
Result {
|
||||
ip: String,
|
||||
ok: bool,
|
||||
detail: String,
|
||||
},
|
||||
Done,
|
||||
}
|
||||
|
||||
pub struct StockHandle {
|
||||
pub rx: Receiver<StockMsg>,
|
||||
// Cancellation is honoured between boards; a UI stop control is not wired yet.
|
||||
#[allow(dead_code)]
|
||||
cancel: Arc<AtomicBool>,
|
||||
}
|
||||
|
||||
impl StockHandle {
|
||||
#[allow(dead_code)]
|
||||
pub fn stop(&self) {
|
||||
self.cancel.store(true, Ordering::Relaxed);
|
||||
}
|
||||
}
|
||||
|
||||
fn download_dir() -> PathBuf {
|
||||
alkane_core::platform::config_path("downloads")
|
||||
}
|
||||
|
||||
/// Install alkane-os onto the given boards (currently on stock), over the
|
||||
/// network, via the compiled-in from-stock method. `board` is the target board
|
||||
/// family (gates the `.afw`); `password`, if set, is passed in-process to the
|
||||
/// method (never to the environment or an argument).
|
||||
pub fn start_install(
|
||||
ips: Vec<String>,
|
||||
board: String,
|
||||
source: AfwSource,
|
||||
allow_unsigned: bool,
|
||||
password: Option<String>,
|
||||
is_update: bool,
|
||||
) -> StockHandle {
|
||||
let (tx, rx) = channel();
|
||||
let cancel = Arc::new(AtomicBool::new(false));
|
||||
|
||||
if fake_scan_enabled() {
|
||||
let _ = tx.send(StockMsg::Started);
|
||||
let _ = tx.send(StockMsg::Progress(
|
||||
"install (demo): no hardware touched".into(),
|
||||
));
|
||||
for ip in ips {
|
||||
let _ = tx.send(StockMsg::Result {
|
||||
ip,
|
||||
ok: true,
|
||||
detail: "installed alkane-os (demo)".into(),
|
||||
});
|
||||
}
|
||||
let _ = tx.send(StockMsg::Done);
|
||||
return StockHandle { rx, cancel };
|
||||
}
|
||||
|
||||
let tc = cancel.clone();
|
||||
let err_tx = tx.clone();
|
||||
let spawned = std::thread::Builder::new()
|
||||
.name("install-from-stock".into())
|
||||
.spawn(move || {
|
||||
let _ = tx.send(StockMsg::Started);
|
||||
|
||||
// 1. Acquire the .afw: a local file is used in place; a release asset
|
||||
// is downloaded on this worker thread (never blocking the UI).
|
||||
let afw_path = match source {
|
||||
AfwSource::Local(path) => {
|
||||
let _ = tx.send(StockMsg::Progress(format!(
|
||||
"using local {}...",
|
||||
AfwSource::Local(path.clone()).label()
|
||||
)));
|
||||
if !path.is_file() {
|
||||
for ip in &ips {
|
||||
let _ = tx.send(StockMsg::Result {
|
||||
ip: ip.clone(),
|
||||
ok: false,
|
||||
detail: format!("local .afw not found: {}", path.display()),
|
||||
});
|
||||
}
|
||||
let _ = tx.send(StockMsg::Done);
|
||||
return;
|
||||
}
|
||||
path
|
||||
}
|
||||
AfwSource::Release { name, url } => {
|
||||
let _ = tx.send(StockMsg::Progress("acquiring .afw...".into()));
|
||||
match fetch::fetch_afw_url(
|
||||
&ReleaseSource::alkane_os(),
|
||||
&name,
|
||||
&url,
|
||||
&download_dir(),
|
||||
) {
|
||||
Ok(p) => p,
|
||||
Err(e) => {
|
||||
// One failure line per target so the UI clears its op-status.
|
||||
for ip in &ips {
|
||||
let _ = tx.send(StockMsg::Result {
|
||||
ip: ip.clone(),
|
||||
ok: false,
|
||||
detail: format!("could not fetch .afw: {e}"),
|
||||
});
|
||||
}
|
||||
let _ = tx.send(StockMsg::Done);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// 2. Verify + gate the bundle once (board/arch/bootloader + integrity).
|
||||
let _ = tx.send(StockMsg::Progress("verifying .afw...".into()));
|
||||
let verified = match verify_afw(
|
||||
&afw_path,
|
||||
&VerifyOptions {
|
||||
allow_unsigned,
|
||||
expect_board: Some(board.clone()),
|
||||
},
|
||||
) {
|
||||
Ok(v) => v,
|
||||
Err(e) => {
|
||||
for ip in &ips {
|
||||
let _ = tx.send(StockMsg::Result {
|
||||
ip: ip.clone(),
|
||||
ok: false,
|
||||
detail: format!(".afw rejected: {e}"),
|
||||
});
|
||||
}
|
||||
let _ = tx.send(StockMsg::Done);
|
||||
return;
|
||||
}
|
||||
};
|
||||
if !is_supported_board(&verified.manifest.board) {
|
||||
for ip in &ips {
|
||||
let _ = tx.send(StockMsg::Result {
|
||||
ip: ip.clone(),
|
||||
ok: false,
|
||||
detail: format!(
|
||||
"{} is not a supported install target",
|
||||
verified.manifest.board
|
||||
),
|
||||
});
|
||||
}
|
||||
let _ = tx.send(StockMsg::Done);
|
||||
return;
|
||||
}
|
||||
// An in-place Update must never rewrite the bootloader (review #1):
|
||||
// refuse a tier-3 (bootloader-writing) bundle so the "BOOT.bin is
|
||||
// never written" guarantee holds for an already-alkane board.
|
||||
if is_update && verified.manifest.flash_plan().writes_uboot {
|
||||
for ip in &ips {
|
||||
let _ = tx.send(StockMsg::Result {
|
||||
ip: ip.clone(),
|
||||
ok: false,
|
||||
detail: "update refused: this release reflashes the bootloader (tier 3); \
|
||||
pick a tier-1/2 release or use Install"
|
||||
.to_string(),
|
||||
});
|
||||
}
|
||||
let _ = tx.send(StockMsg::Done);
|
||||
return;
|
||||
}
|
||||
|
||||
// 3. Install onto each board via the network-only from-stock method.
|
||||
for ip in ips {
|
||||
if tc.load(Ordering::Relaxed) {
|
||||
break;
|
||||
}
|
||||
let _ = tx.send(StockMsg::Progress(format!(
|
||||
"installing {} onto {ip} (from stock)...",
|
||||
verified.manifest.board
|
||||
)));
|
||||
let (ok, detail) =
|
||||
match stock::install_from_stock(&ip, &afw_path, &verified, password.as_deref())
|
||||
{
|
||||
Ok(()) => (
|
||||
true,
|
||||
"installed alkane-os (verify liveness over the network)".to_string(),
|
||||
),
|
||||
Err(e) => (false, format!("install failed: {e}")),
|
||||
};
|
||||
if tx.send(StockMsg::Result { ip, ok, detail }).is_err() {
|
||||
return;
|
||||
}
|
||||
}
|
||||
let _ = tx.send(StockMsg::Done);
|
||||
});
|
||||
|
||||
if spawned.is_err() {
|
||||
let _ = err_tx.send(StockMsg::Result {
|
||||
ip: String::new(),
|
||||
ok: false,
|
||||
detail: "could not start the install worker thread".into(),
|
||||
});
|
||||
let _ = err_tx.send(StockMsg::Done);
|
||||
}
|
||||
StockHandle { rx, cancel }
|
||||
}
|
||||
|
||||
/// Restore one board to genuine Bitmain stock using the user-supplied vendor
|
||||
/// firmware package: parse it into the stock images and write them back over the
|
||||
/// network. `password`, if given, is the board's alkane root credential.
|
||||
fn restore_one(ip: &str, firmware: &Path, password: Option<&str>) -> (bool, String) {
|
||||
let fw = match stock_firmware::parse(firmware) {
|
||||
Ok(f) => f,
|
||||
Err(e) => return (false, format!("firmware: {e}")),
|
||||
};
|
||||
// The device tree comes from the toolkit's per-board asset, not the package,
|
||||
// so any genuine Bitmain firmware (OTA or SD) provides a usable kernel+rootfs.
|
||||
let images = RestoreImages {
|
||||
kernel: &fw.kernel,
|
||||
rootfs: &fw.rootfs,
|
||||
dtb: fw.dtb.as_deref(),
|
||||
};
|
||||
match stock::restore_to_stock(ip, &images, password) {
|
||||
Ok(()) => (
|
||||
true,
|
||||
"restored to stock (verify independently it no longer answers as alkane)".to_string(),
|
||||
),
|
||||
Err(e) => (false, format!("restore failed: {e}")),
|
||||
}
|
||||
}
|
||||
|
||||
/// Restore the given alkane boards to genuine Bitmain stock, over the network,
|
||||
/// by writing the stock images from `firmware` (a genuine vendor firmware
|
||||
/// package) back to NAND. `password`, if set, is the board's alkane root
|
||||
/// credential.
|
||||
pub fn start_restore(ips: Vec<String>, firmware: PathBuf, password: Option<String>) -> StockHandle {
|
||||
let (tx, rx) = channel();
|
||||
let cancel = Arc::new(AtomicBool::new(false));
|
||||
|
||||
if fake_scan_enabled() {
|
||||
let _ = tx.send(StockMsg::Started);
|
||||
for ip in ips {
|
||||
let _ = tx.send(StockMsg::Result {
|
||||
ip,
|
||||
ok: true,
|
||||
detail: "restored to stock (demo)".into(),
|
||||
});
|
||||
}
|
||||
let _ = tx.send(StockMsg::Done);
|
||||
return StockHandle { rx, cancel };
|
||||
}
|
||||
|
||||
let tc = cancel.clone();
|
||||
let err_tx = tx.clone();
|
||||
let spawned = std::thread::Builder::new()
|
||||
.name("restore-to-stock".into())
|
||||
.spawn(move || {
|
||||
let _ = tx.send(StockMsg::Started);
|
||||
for ip in ips {
|
||||
if tc.load(Ordering::Relaxed) {
|
||||
break;
|
||||
}
|
||||
let _ = tx.send(StockMsg::Progress(format!(
|
||||
"restoring {ip} to stock (network-only)..."
|
||||
)));
|
||||
let (ok, detail) = restore_one(&ip, &firmware, password.as_deref());
|
||||
if tx.send(StockMsg::Result { ip, ok, detail }).is_err() {
|
||||
return;
|
||||
}
|
||||
}
|
||||
let _ = tx.send(StockMsg::Done);
|
||||
});
|
||||
|
||||
if spawned.is_err() {
|
||||
let _ = err_tx.send(StockMsg::Result {
|
||||
ip: String::new(),
|
||||
ok: false,
|
||||
detail: "could not start the restore worker thread".into(),
|
||||
});
|
||||
let _ = err_tx.send(StockMsg::Done);
|
||||
}
|
||||
StockHandle { rx, cancel }
|
||||
}
|
||||
|
||||
/// Whether a board holds a restorable on-board stock backup (network probe). A
|
||||
/// quick, synchronous check the restore dialog uses to grey out the on-board
|
||||
/// option when no backup is present. Any error reads as "not present".
|
||||
pub fn onboard_backup_present(ip: &str, password: Option<&str>) -> bool {
|
||||
if fake_scan_enabled() {
|
||||
return true;
|
||||
}
|
||||
stock::onboard_stock_backup_present(ip, password).unwrap_or(false)
|
||||
}
|
||||
|
||||
/// Restore the given alkane boards to genuine stock, over the network, from each
|
||||
/// board's own on-board stock backup (no vendor firmware file). `password`, if
|
||||
/// set, is the board's alkane root credential.
|
||||
pub fn start_restore_onboard(ips: Vec<String>, password: Option<String>) -> StockHandle {
|
||||
let (tx, rx) = channel();
|
||||
let cancel = Arc::new(AtomicBool::new(false));
|
||||
|
||||
if fake_scan_enabled() {
|
||||
let _ = tx.send(StockMsg::Started);
|
||||
for ip in ips {
|
||||
let _ = tx.send(StockMsg::Result {
|
||||
ip,
|
||||
ok: true,
|
||||
detail: "restored to stock from on-board backup (demo)".into(),
|
||||
});
|
||||
}
|
||||
let _ = tx.send(StockMsg::Done);
|
||||
return StockHandle { rx, cancel };
|
||||
}
|
||||
|
||||
let tc = cancel.clone();
|
||||
let err_tx = tx.clone();
|
||||
let spawned = std::thread::Builder::new()
|
||||
.name("restore-onboard".into())
|
||||
.spawn(move || {
|
||||
let _ = tx.send(StockMsg::Started);
|
||||
let timeout = std::time::Duration::from_secs(300);
|
||||
for ip in ips {
|
||||
if tc.load(Ordering::Relaxed) {
|
||||
break;
|
||||
}
|
||||
let _ = tx.send(StockMsg::Progress(format!(
|
||||
"restoring {ip} to stock from its on-board backup..."
|
||||
)));
|
||||
let (ok, detail) =
|
||||
match stock::restore_from_onboard_backup(&ip, password.as_deref(), timeout) {
|
||||
Ok(()) => (
|
||||
true,
|
||||
"restored to stock from on-board backup (verify over the network)"
|
||||
.to_string(),
|
||||
),
|
||||
Err(e) => (false, format!("restore failed: {e}")),
|
||||
};
|
||||
if tx.send(StockMsg::Result { ip, ok, detail }).is_err() {
|
||||
return;
|
||||
}
|
||||
}
|
||||
let _ = tx.send(StockMsg::Done);
|
||||
});
|
||||
|
||||
if spawned.is_err() {
|
||||
let _ = err_tx.send(StockMsg::Result {
|
||||
ip: String::new(),
|
||||
ok: false,
|
||||
detail: "could not start the restore worker thread".into(),
|
||||
});
|
||||
let _ = err_tx.send(StockMsg::Done);
|
||||
}
|
||||
StockHandle { rx, cancel }
|
||||
}
|
||||
|
||||
/// Restore the given alkane A113D boards to genuine Bitmain stock, over the
|
||||
/// network, by clearing the one-byte boot flag in-band from the running alkane
|
||||
/// OS. The A113D install overwrites no stock partition, so this flag flip is the
|
||||
/// complete restore: clear `ALAN`, reboot, and stock boots via `storeboot` from
|
||||
/// the untouched `boot` MTD. No vendor firmware file or on-board backup needed.
|
||||
/// `password`, if set, is the board's alkane root credential.
|
||||
pub fn start_restore_flag(ips: Vec<String>, password: Option<String>) -> StockHandle {
|
||||
let (tx, rx) = channel();
|
||||
let cancel = Arc::new(AtomicBool::new(false));
|
||||
|
||||
if fake_scan_enabled() {
|
||||
let _ = tx.send(StockMsg::Started);
|
||||
for ip in ips {
|
||||
let _ = tx.send(StockMsg::Result {
|
||||
ip,
|
||||
ok: true,
|
||||
detail: "restored to stock (flag flip, demo)".into(),
|
||||
});
|
||||
}
|
||||
let _ = tx.send(StockMsg::Done);
|
||||
return StockHandle { rx, cancel };
|
||||
}
|
||||
|
||||
let tc = cancel.clone();
|
||||
let err_tx = tx.clone();
|
||||
let spawned = std::thread::Builder::new()
|
||||
.name("restore-flag".into())
|
||||
.spawn(move || {
|
||||
let _ = tx.send(StockMsg::Started);
|
||||
for ip in ips {
|
||||
if tc.load(Ordering::Relaxed) {
|
||||
break;
|
||||
}
|
||||
let _ = tx.send(StockMsg::Progress(format!(
|
||||
"restoring {ip} to stock (clearing the alkane boot flag)..."
|
||||
)));
|
||||
let (ok, detail) = match stock::restore_aml_flag(&ip, password.as_deref()) {
|
||||
Ok(()) => (
|
||||
true,
|
||||
"restored to stock (flag cleared, rebooting; verify over the network)"
|
||||
.to_string(),
|
||||
),
|
||||
Err(e) => (false, format!("restore failed: {e}")),
|
||||
};
|
||||
if tx.send(StockMsg::Result { ip, ok, detail }).is_err() {
|
||||
return;
|
||||
}
|
||||
}
|
||||
let _ = tx.send(StockMsg::Done);
|
||||
});
|
||||
|
||||
if spawned.is_err() {
|
||||
let _ = err_tx.send(StockMsg::Result {
|
||||
ip: String::new(),
|
||||
ok: false,
|
||||
detail: "could not start the restore worker thread".into(),
|
||||
});
|
||||
let _ = err_tx.send(StockMsg::Done);
|
||||
}
|
||||
StockHandle { rx, cancel }
|
||||
}
|
||||
+1498
-28
File diff suppressed because it is too large
Load Diff
@@ -25,11 +25,11 @@ BEGIN
|
||||
BEGIN
|
||||
BLOCK "040904B0"
|
||||
BEGIN
|
||||
VALUE "CompanyName", "Blueflare"
|
||||
VALUE "CompanyName", "BlueFlare Energy Solutions Inc."
|
||||
VALUE "FileDescription", "Alkane Toolkit"
|
||||
VALUE "FileVersion", ALKANE_VER_STR
|
||||
VALUE "InternalName", "alkane-toolkit"
|
||||
VALUE "LegalCopyright", "Copyright (c) 2026 Blueflare (MIT License)"
|
||||
VALUE "LegalCopyright", "Copyright (c) 2026 BlueFlare Energy Solutions Inc. (MIT License)"
|
||||
VALUE "OriginalFilename", "alkane-toolkit.exe"
|
||||
VALUE "ProductName", "Alkane Toolkit"
|
||||
VALUE "ProductVersion", ALKANE_VER_STR
|
||||
|
||||
+171
@@ -0,0 +1,171 @@
|
||||
# Installing and removing alkane-os
|
||||
|
||||
Two front-ends drive the same self-contained engine:
|
||||
|
||||
- The CLI (`alkane-cli afw ...`), documented below, is the scriptable path.
|
||||
- The GUI (`alkane-toolkit`) can scan the fleet, then right-click a board to
|
||||
install alkane-os onto it from stock or restore it to stock. See
|
||||
"GUI (right-click install / uninstall)" at the end. (The GUI's older asic-rs
|
||||
firmware-upload path stays disabled; these two actions use the compiled-in
|
||||
network-only engine, the same one the CLI uses.)
|
||||
|
||||
## Compatible miners
|
||||
|
||||
```
|
||||
alkane-cli afw compat
|
||||
```
|
||||
|
||||
Lists the control boards alkane-os can be installed on. For now that is the
|
||||
Antminer S17 (`zynq-7010`). The install/restore commands refuse any board whose
|
||||
`.afw` is not one of these.
|
||||
|
||||
## Install
|
||||
|
||||
From a local bundle:
|
||||
|
||||
```
|
||||
alkane-cli afw install path/to/alkane-os-<ver>-zynq-7010-armv7.afw \
|
||||
--host <miner-ip> --confirm FLASH
|
||||
```
|
||||
|
||||
From the latest release (pulled from Gitea, not GitHub, which is retired):
|
||||
|
||||
```
|
||||
alkane-cli afw install --latest --board zynq-7010 --host <miner-ip> --confirm FLASH
|
||||
# or fetch only:
|
||||
alkane-cli afw fetch-latest --board zynq-7010 --output ./downloads
|
||||
```
|
||||
|
||||
A private release repo needs a token, read from `ALKANE_RELEASE_TOKEN` (else
|
||||
`GITEA_TOKEN`) at run time and passed to curl through a 0600 config file - never
|
||||
on the command line, never stored by the toolkit.
|
||||
|
||||
### A board still on stock
|
||||
|
||||
Writing our first image onto a board that is still on genuine stock (past the
|
||||
stock gates and getting root) is done by the toolkit itself, over the network.
|
||||
The method is part of this binary; nothing else needs to be installed on your
|
||||
machine. On first use it fetches a small set of per-board assets from our Gitea
|
||||
(repo `blueflare/alkane-stock-assets`, release `zynq-7010-v1`) and caches them
|
||||
locally, verifying each against a known SHA-256. That repo is public, so no token
|
||||
is needed for the stock assets. The asset base URL can be overridden with
|
||||
`ALKANE_STOCK_ASSETS_BASE`.
|
||||
|
||||
Add `--from-stock` (the token below is only to resolve `--latest` from the
|
||||
private alkane-os release repo; a local `.afw` needs no token):
|
||||
|
||||
```
|
||||
export ALKANE_RELEASE_TOKEN=<your-gitea-token>
|
||||
alkane-cli afw install --latest --board zynq-7010 --host <miner-ip> \
|
||||
--from-stock --confirm FLASH
|
||||
```
|
||||
|
||||
The toolkit acquires and verifies the `.afw`, gates on compatibility, fetches
|
||||
and verifies its assets, performs the network-only stock-side install, then you
|
||||
verify the board came up as alkane:
|
||||
|
||||
```
|
||||
alkane-cli afw verify-live --host <miner-ip> --timeout 300
|
||||
```
|
||||
|
||||
On Zynq (S17/S19 class) pass the `.afw` (or `--board zynq-7010`) and the board's
|
||||
alkane root credential; the check needs the web page to carry the image marker
|
||||
and SSH to report alkane with the installed kernel, and prints the running kernel
|
||||
command line (on a NAND boot it is the board's U-Boot env bootargs):
|
||||
|
||||
```
|
||||
alkane-cli afw verify-live path/to/alkane-os-<ver>-zynq-7010-armv7.afw \
|
||||
--host <miner-ip> --password-file <alkane-root-pw> --timeout 300
|
||||
```
|
||||
|
||||
For a bench image that is not signed, add `--allow-unsigned`.
|
||||
|
||||
Without `--from-stock`, `install` performs a tier-2 update of a board already on
|
||||
alkane, in place, over the network:
|
||||
|
||||
```
|
||||
alkane-cli afw install path/to/alkane-os-<ver>-zynq-7010-armv7.afw \
|
||||
--host <miner-ip> --password-file <alkane-root-pw> --dry-run
|
||||
alkane-cli afw install path/to/alkane-os-<ver>-zynq-7010-armv7.afw \
|
||||
--host <miner-ip> --password-file <alkane-root-pw> --confirm FLASH
|
||||
```
|
||||
|
||||
On Zynq (S17/S19 class) the update refuses a board that is not running alkane.
|
||||
Alkane does not expose the NAND boot regions to Linux (only the small
|
||||
`stock-cfg` and `alkane-cfg` partitions), so the toolkit re-registers them
|
||||
first, the same way a restore does. It saves each boot slot to `--backup-dir`
|
||||
(default: the toolkit's `backups` directory) before any erase, then writes the
|
||||
rootfs (absolute NAND `0x2800000`), dtb (`0x1a00000`) and kernel (`0x2000000`),
|
||||
with the kernel and rootfs wrapped as the legacy uImages the board's stock
|
||||
U-Boot boots, and reads each back (md5) before rebooting. Nothing below
|
||||
`0x1a00000` (BOOT.bin: FSBL, FPGA bitstream, U-Boot) is ever written.
|
||||
`afw preflight` runs the same checks read-only. `--no-reboot` skips the reboot.
|
||||
|
||||
## Remove (back to stock)
|
||||
|
||||
```
|
||||
alkane-cli afw restore-stock --host <miner-ip> \
|
||||
--stock-firmware <genuine-Bitmain-firmware> \
|
||||
--password-file <alkane-root-pw> --confirm FLASH
|
||||
```
|
||||
|
||||
Returning an aftermarket board to genuine stock is done by the toolkit itself,
|
||||
over the network. It writes the genuine Bitmain stock **kernel and rootfs** -
|
||||
parsed from a vendor firmware file you supply with `--stock-firmware` (an OTA
|
||||
update `.tar.gz` or an SD recovery `.zip` for the board) - back to NAND,
|
||||
preserving BOOT.bin.
|
||||
|
||||
The one piece that is NOT in Bitmain's distributable firmware is the kernel
|
||||
**device tree**: it is factory-provisioned and preserved by every vendor update,
|
||||
so no OTA/SD package ships it. The toolkit supplies the correct per-board dtb
|
||||
itself (fetched + verified from the public assets repo, so no token is needed)
|
||||
and pairs it with the genuine kernel/rootfs. The board's alkane root credential
|
||||
is given with `--password-file` (or
|
||||
`ALKANE_BOARD_PASSWORD`/`ALKANE_BOARD_PASSWORD_FILE`).
|
||||
|
||||
After a restore the board returns to stock under its stock MAC and typically
|
||||
takes a new DHCP lease, so it may not reappear on the same address; verify
|
||||
independently that the board no longer answers as alkane and presents its stock
|
||||
OS.
|
||||
|
||||
## GUI (right-click install / uninstall)
|
||||
|
||||
The GUI binary is `alkane-toolkit`. Launch it, let the scan list the fleet, then
|
||||
right-click one or more boards. The scan finds boards running Alkane OS too
|
||||
(Firmware column "Alkane"): they expose no cgminer socket or vendor web UI, so the
|
||||
toolkit identifies them itself from the board's public read-only
|
||||
`GET /api/identity` (alkane-os 0.1.2 and later; earlier images are found from
|
||||
`/api/summary`). Each action below is offered only when it applies to every
|
||||
selected board:
|
||||
|
||||
- "Install alkane OS..." - for a supported board (one alkane-os has an image
|
||||
for; today the Zynq-7010 Antminer S17/S17 Pro/T17) that is not running Alkane
|
||||
OS yet. Scans the alkane-os releases on Gitea, lets you pick one (newest first;
|
||||
pre-releases are marked), optionally takes a board password and an "allow
|
||||
unsigned .afw (bench)" toggle, then - when you click Install - downloads and
|
||||
verifies the `.afw` and installs it onto each selected board over the network,
|
||||
via the same compiled-in engine the CLI uses.
|
||||
- "Update alkane OS..." - for a supported board already running Alkane OS: the
|
||||
same release picker and confirmation; the board is updated in place (BOOT.bin
|
||||
is never written).
|
||||
- "Uninstall alkane OS (restore to stock)..." - for a board running Alkane OS:
|
||||
takes the board's alkane root password and a genuine Bitmain firmware package,
|
||||
then - when you click Restore - restores each selected board to genuine stock
|
||||
over the network.
|
||||
|
||||
A stock board the scan identifies but cannot place on a supported control board
|
||||
(or a mixed stock/Alkane selection) gets neither Install nor Update.
|
||||
|
||||
Progress and per-board results appear on the status bar; verify board state
|
||||
independently afterwards (the GUI does not claim liveness on its own).
|
||||
|
||||
Release scanning reads the private `alkane-os` repo, so it needs a Gitea token.
|
||||
A read-only token can be baked into the GUI at build time
|
||||
(`ALKANE_EMBEDDED_TOKEN=<token>` when building), so the shipped binary scans
|
||||
releases with no setup; otherwise set `ALKANE_RELEASE_TOKEN` (or `GITEA_TOKEN`)
|
||||
in the environment before launching. The stock-asset fetch needs no token (that
|
||||
repo is public), so install-from-stock and restore-to-stock work without one -
|
||||
only the release picker needs it.
|
||||
|
||||
Runtime dependencies (Linux): the GUI links wxWidgets 3.2 (wxGTK) and GTK 3, so
|
||||
the target machine needs `libwxgtk3.2-1` and `libgtk-3-0` installed.
|
||||
@@ -0,0 +1,62 @@
|
||||
# macOS
|
||||
|
||||
The macOS build is one universal app, `Alkane Toolkit.app`, that runs natively
|
||||
on Apple Silicon and Intel Macs with macOS 11 (Big Sur) or later. It ships as
|
||||
`alkane-toolkit-vX.Y.Z-macos-universal.zip`, holding the app, `LICENSE` and a
|
||||
`README.txt`.
|
||||
|
||||
## Using it
|
||||
|
||||
- Settings live in `~/.config/alkane-toolkit`, the same files as on Linux.
|
||||
- SSH actions use the system `ssh`; HTTP actions use the system `curl`.
|
||||
- The app is ad-hoc signed but not notarized, so macOS blocks the first launch.
|
||||
On macOS 15 or later, try to open it, then choose **Open Anyway** in
|
||||
System Settings > Privacy & Security. On macOS 11 to 14, Control-click the
|
||||
app and choose **Open**. Or clear the quarantine flag once:
|
||||
`xattr -dr com.apple.quarantine "/Applications/Alkane Toolkit.app"`.
|
||||
- The first scan asks for permission to find devices on the local network
|
||||
(macOS 15 and later). Scanning needs it.
|
||||
- Offline demo: `ALKANE_FAKE_SCAN=1 "/Applications/Alkane Toolkit.app/Contents/MacOS/alkane-toolkit"`.
|
||||
|
||||
## Building
|
||||
|
||||
macOS builds only on a Mac. It needs the Xcode Command Line Tools
|
||||
(`xcode-select --install`) and rustup with both Apple targets:
|
||||
|
||||
```sh
|
||||
rustup target add aarch64-apple-darwin x86_64-apple-darwin
|
||||
scripts/build-wx-macos.sh # once: universal static wxOSX 3.3.3 in ~/.cache/wx-3.3.3-macos
|
||||
scripts/build-gui-macos.sh # both slices, merged with lipo
|
||||
python3 ci/package-macos.py X.Y.Z target/universal-apple-darwin/release/alkane-toolkit dist
|
||||
```
|
||||
|
||||
`build-wx-macos.sh` builds wxWidgets once for arm64 and x86_64 together, with
|
||||
wx's bundled image, zlib, regex and expat libraries, so the app links only
|
||||
against system frameworks. `build-gui-macos.sh` builds each Rust target
|
||||
against that prefix and merges them. `package-macos.py` writes the bundle
|
||||
(Info.plist, icon), ad-hoc signs it and zips it with `ditto`.
|
||||
|
||||
To test on the Mac:
|
||||
|
||||
```sh
|
||||
ALKANE_SELFTEST=1 target/universal-apple-darwin/release/alkane-toolkit # headless UI self-test
|
||||
cargo test --release --offline --target aarch64-apple-darwin --workspace --exclude wx-rs
|
||||
```
|
||||
|
||||
The self-test opens a window briefly, so it needs a logged-in desktop
|
||||
session. Running the x86_64 slice on Apple Silicon needs Rosetta 2.
|
||||
|
||||
## Why macOS 11
|
||||
|
||||
Current Xcode SDKs ship a libc++ that supports macOS 11 and later only;
|
||||
building for an older target compiles, but the app could fail at run time on
|
||||
the older system. macOS 11 is also the first release for Apple Silicon. Older
|
||||
Intel Macs would need a build with an older SDK.
|
||||
|
||||
## Notes for the bridge
|
||||
|
||||
wxOSX reports logical (point) sizes, like the GTK and MSW bridges; the
|
||||
bridge never scales to physical pixels. wxOSX's Objective-C uses
|
||||
`@available`, so `build.rs` links clang's compiler runtime
|
||||
(`libclang_rt.osx.a`), which rustc's link does not include by itself. Both
|
||||
are wx-rs patch `0009`.
|
||||
@@ -0,0 +1,66 @@
|
||||
# Getting started
|
||||
|
||||
Alkane Toolkit finds the ASIC miners on your network and shows them in one
|
||||
table: model, firmware, hashrate, power, temperatures, fans and the health of
|
||||
every hashboard. From the same table you can run the controls each miner's
|
||||
firmware supports, such as pausing, restarting or changing pools.
|
||||
|
||||
## Download
|
||||
|
||||
Get the latest release from the
|
||||
[downloads page](https://gitea.bluefla.re/blueflare/alkane-toolkit/releases).
|
||||
|
||||
| Platform | File | Notes |
|
||||
|---|---|---|
|
||||
| Windows 10 and 11 (x86_64) | `alkane-toolkit-vX.Y.Z-windows-x86_64.zip` | One signed `alkane-toolkit.exe`; nothing to install |
|
||||
| Linux (x86_64) | `alkane-toolkit-vX.Y.Z-linux-x86_64.tar.gz` | One binary; needs GTK 3 (`sudo apt install libgtk-3-0`) |
|
||||
| macOS 11 or later (Apple Silicon and Intel) | `alkane-toolkit-vX.Y.Z-macos-universal.zip` | One app; not notarized, so confirm the first launch |
|
||||
|
||||
### Windows
|
||||
|
||||
1. Download the zip, right-click it, choose **Properties**, tick **Unblock** if
|
||||
it is shown, then extract it.
|
||||
2. Run `alkane-toolkit.exe`. Windows shows *BlueFlare Energy Solutions Inc.* as
|
||||
the verified publisher. To check the signature yourself, right-click the exe,
|
||||
choose **Properties** and open **Digital Signatures**.
|
||||
|
||||
### macOS
|
||||
|
||||
1. Download the zip and open it; drag **Alkane Toolkit** to Applications.
|
||||
2. Open it. The app is not notarized, so macOS blocks the first launch:
|
||||
- macOS 15 or later: open **System Settings > Privacy & Security** and
|
||||
choose **Open Anyway** for Alkane Toolkit.
|
||||
- macOS 11 to 14: Control-click the app, choose **Open**, then **Open**.
|
||||
3. When asked, allow it to find devices on your local network. Scanning
|
||||
needs this.
|
||||
|
||||
### Linux
|
||||
|
||||
```sh
|
||||
tar xzf alkane-toolkit-vX.Y.Z-linux-x86_64.tar.gz
|
||||
./alkane-toolkit-vX.Y.Z-linux-x86_64/alkane-toolkit
|
||||
```
|
||||
|
||||
## First run
|
||||
|
||||
The toolkit starts a scan as soon as it opens. Set your own ranges first with
|
||||
**Scan ranges** (see [Scanning](02-scanning.md)); until you do, it scans
|
||||
192.168.1.0/24, the usual router subnet.
|
||||
|
||||
To look around without touching any miner, start it in demo mode. It shows a
|
||||
built-in sample fleet and simulates every action:
|
||||
|
||||
| Platform | Command |
|
||||
|---|---|
|
||||
| Windows (Command Prompt) | `set ALKANE_FAKE_SCAN=1 && alkane-toolkit.exe` |
|
||||
| Linux | `ALKANE_FAKE_SCAN=1 ./alkane-toolkit` |
|
||||
|
||||
## Where settings are kept
|
||||
|
||||
| Platform | Folder |
|
||||
|---|---|
|
||||
| Windows | `%APPDATA%\alkane-toolkit` |
|
||||
| Linux | `~/.config/alkane-toolkit` |
|
||||
|
||||
See [Settings and credentials](06-settings.md) for the files in that folder.
|
||||
Deleting the folder resets the toolkit to its defaults.
|
||||
@@ -0,0 +1,51 @@
|
||||
# Scanning
|
||||
|
||||
Discovery is read-only: a scan asks each address what it is and records what
|
||||
it reports. It never changes a miner.
|
||||
|
||||
## Scan ranges
|
||||
|
||||
Click **Scan ranges** to edit the addresses to scan. Put one entry per line;
|
||||
blank lines and lines starting with `#` are ignored.
|
||||
|
||||
| Form | Example | Scans |
|
||||
|---|---|---|
|
||||
| Single address | `192.168.1.50` | that address |
|
||||
| CIDR block | `192.168.1.0/24` | the whole block |
|
||||
| Full range | `192.168.1.10-192.168.2.40` | every address between the two, inclusive |
|
||||
| Short range | `192.168.1.10-90` | `.10` to `.90` within the same /24 |
|
||||
| Per-octet ranges | `10.1-4.0-1.1-255` | every combination (10.1.0.1 ... 10.4.1.255) |
|
||||
|
||||
Commas or spaces between several entries on one line are not accepted; use one
|
||||
line each. Duplicates are removed automatically. One line, and all lines
|
||||
together, may cover at most 1,000,000 addresses.
|
||||
|
||||
**Apply** saves the ranges and starts a scan. A mistake keeps the dialog open
|
||||
and the status bar explains it, for example `invalid range: bad octet range`.
|
||||
|
||||
The same dialog has three numbers:
|
||||
|
||||
| Field | Meaning | Default |
|
||||
|---|---|---|
|
||||
| Rescan (s) | seconds between automatic rescans; `0` turns auto-rescan off | 300 |
|
||||
| Timeout (s) | how long to wait for one miner (scans, refreshes, actions and log fetches) | 10 |
|
||||
| Concurrency | how many addresses are probed at once (8 to 256); higher is faster but slow miners may report fewer values | 128 |
|
||||
|
||||
When the ranges change, miners outside the new ranges leave the table at the
|
||||
next scan.
|
||||
|
||||
## Running, pausing and stopping
|
||||
|
||||
The three buttons next to **Scan ranges** control scanning:
|
||||
|
||||
- **Play** (green) turns auto-rescan on and starts a scan now if none is running.
|
||||
- **Pause** (amber) turns auto-rescan off and lets the current scan finish.
|
||||
- **Stop** (red) turns auto-rescan off and cancels the current scan.
|
||||
|
||||
While a scan runs, a progress bar spans the top of the table and the status bar
|
||||
shows progress such as `1935/4590 - scanning 192.168.1.86 (92 found)`. Afterwards
|
||||
it shows the count and the time to the next scan, for example
|
||||
`245 miners - next scan in 4m 12s`.
|
||||
|
||||
Actions that change miners wait for the scan to finish; see
|
||||
[Actions](05-actions.md).
|
||||
@@ -0,0 +1,80 @@
|
||||
# The table and header
|
||||
|
||||
## Summary cards
|
||||
|
||||
The cards at the top count the miners **currently shown** (after any filter).
|
||||
Each miner is in exactly one status: slow, paused, hashing or not hashing.
|
||||
|
||||
| Card | Counts | Click |
|
||||
|---|---|---|
|
||||
| Total | rows in the view | - |
|
||||
| Hashing (green rabbit) | mining at 80% of expected hashrate or more | show only these; click again to clear |
|
||||
| Slow (amber turtle) | mining below 80% of expected hashrate | show only these |
|
||||
| Not hashing (red glass) | answering but not mining | show only these |
|
||||
| Paused (blue otter) | stopped on purpose (paused, stopped, suspended) | show only these |
|
||||
| SHA-256 Hashrate | total hashrate, per algorithm | switch algorithm when the fleet runs more than one |
|
||||
| Est. power | total reported power draw | - |
|
||||
|
||||
On a narrow window the hashrate and power cards are hidden.
|
||||
|
||||
## Columns
|
||||
|
||||
IP is always the first column. The default view shows Model, Health,
|
||||
Hashrate, Power, Chip temp, Firmware, CPU, Access and Light. More than seventy
|
||||
other columns are available, grouped as Identity, Firmware and board, Health
|
||||
and status, Performance, Temperature, Cooling, Hardware and Pools.
|
||||
|
||||
- **Columns** opens a checklist: tick to show, drag to reorder, or sort the list
|
||||
alphabetically or by category. *Hide columns with no scanned values* hides
|
||||
columns that are empty for every miner (it resets when the app restarts).
|
||||
- Drag a column header to move it.
|
||||
- Right-click a header to sort by it, auto-size one or all columns, hide it, or
|
||||
open the column chooser.
|
||||
|
||||
Some values worth knowing:
|
||||
|
||||
| Column | Shows |
|
||||
|---|---|
|
||||
| Hashrate | actual/expected, for example `95.0T/96.0T`; the actual part is red at 50% of expected or less, amber around 75%, green at 100% |
|
||||
| Chip temp | hottest chip on each hashboard, for example `77 / 64 / 74`; blue when cool, red at 90 C and above |
|
||||
| Firmware | the firmware family, coloured (Braiins purple, LuxOS gold, VNish green, ePIC light blue, Hiveon orange, Bixbit pink); stock firmware uses the normal text colour |
|
||||
| Pool account / Worker | the pool user split at the first dot |
|
||||
| Board HR / V / freq | per-hashboard hashrate, voltage and frequency |
|
||||
|
||||
A blank cell means the miner did not report that value.
|
||||
|
||||
## Sorting
|
||||
|
||||
Click a header to sort ascending, again for descending, again to clear.
|
||||
|
||||
- **Hashrate** also sorts by *relative* hashrate (actual as a share of
|
||||
expected), shown as `%^` and `%v` in the header.
|
||||
- **Health** sorts by overall health, then by power (`Pwr`), fans (`Fan`) and
|
||||
hashboards (`Brd`). Ascending puts the most broken miners first.
|
||||
|
||||
## Selecting miners
|
||||
|
||||
Click a row to select it; Ctrl-click and Shift-click add to the selection, and
|
||||
you can drag across rows to select a block. The selection follows miners by IP,
|
||||
so it survives rescans. Double-click a row (or press Enter) to open the miner's
|
||||
web page in your browser. Right-click the selection for [actions](05-actions.md).
|
||||
|
||||
## Filters and presets
|
||||
|
||||
**Filter** keeps only the rows that match. Pick a column, then:
|
||||
|
||||
- for numbers: between, =, !=, >, >=, < or <= (blank cells never match);
|
||||
- for text: *is any of* (tick values; `(blank)` matches empty cells), contains,
|
||||
does not contain, begins with, ends with or equals (case does not matter).
|
||||
|
||||
Filters on different columns must all match. **Reset** clears them. Clicking a
|
||||
status card is a quick filter of its own.
|
||||
|
||||
**Presets** saves and loads whole views: column order and visibility, sort and
|
||||
filters. *Default* is built in and cannot be deleted; saving under an existing
|
||||
name replaces it.
|
||||
|
||||
## Zoom and theme
|
||||
|
||||
The slider in the bottom-right corner zooms the table: text, icons and column
|
||||
widths scale together. The window follows the system light or dark theme.
|
||||
@@ -0,0 +1,54 @@
|
||||
# Health, access and light
|
||||
|
||||
## The Health column
|
||||
|
||||
Each miner gets a row of icons, always in the same order, so problems line up
|
||||
across the table:
|
||||
|
||||
1. **Bolt**: the power supply
|
||||
2. **Brain**: the control board
|
||||
3. **Fan**: one icon per fan
|
||||
4. **Chip**: one icon per hashboard
|
||||
|
||||
Hover over any icon to see its details: PSU voltage and current, the fan speed,
|
||||
or a hashboard's actual and expected hashrate, frequency and voltage, and any
|
||||
fault message with its code.
|
||||
|
||||
| Colour | Meaning |
|
||||
|---|---|
|
||||
| Green | healthy |
|
||||
| Amber | working but below par (a slow board, a fan well below the others, a PSU fault while still mining) |
|
||||
| Red | detected but down (a faulted board, a stopped fan, a PSU that is not delivering) |
|
||||
| Grey | expected but not detected or not reachable |
|
||||
| Blue | the miner is paused, so its boards and stopped fans are idle on purpose |
|
||||
|
||||
How each part is judged:
|
||||
|
||||
- **Power** is green when the miner draws power, its PSU fan turns or it is
|
||||
mining; a reported PSU fault makes it amber (still mining) or red.
|
||||
- **Control board** is red for a control-board fault and amber for a
|
||||
miner-wide warning such as a high ambient temperature.
|
||||
- **Fans** are red at 0 rpm and amber below half the speed of the fastest fan.
|
||||
- **Hashboards** follow the status the miner reports for each board. When the
|
||||
firmware names the failing boards, only those turn red. A board the miner
|
||||
cannot see is grey.
|
||||
|
||||
While an action runs on a miner, its Health cell shows progress such as
|
||||
`restarting...` or `refreshing...`.
|
||||
|
||||
## Access
|
||||
|
||||
The padlock shows whether the toolkit can change the miner:
|
||||
|
||||
- **green, open**: changes are possible with the saved credentials;
|
||||
- **red, closed**: view only;
|
||||
- **blank**: not known yet.
|
||||
|
||||
After a scan the padlock is an estimate from what the firmware offers. Use
|
||||
**Check access (auth)** in the right-click menu for a real, read-only login
|
||||
test.
|
||||
|
||||
## Light
|
||||
|
||||
A flashing green-over-red dot means the miner's locate light is on. Turn it on
|
||||
or off with **Flash lights** / **Stop flashing lights**.
|
||||
@@ -0,0 +1,60 @@
|
||||
# Actions
|
||||
|
||||
Right-click one or more selected miners for the actions menu. With several
|
||||
miners selected, labels show the count, for example *Restart (12)*. An action
|
||||
appears only when **every** selected miner's firmware supports it, so the menu
|
||||
changes with the selection.
|
||||
|
||||
| Action | What it does | Changes the miner |
|
||||
|---|---|---|
|
||||
| Open in browser | opens each miner's web page | no |
|
||||
| Refresh | re-reads just these miners | no |
|
||||
| Check access (auth) | tests whether the saved login is accepted | no |
|
||||
| View log (API)... | shows the first selected miner's log (WhatsMiner: its active fault codes) | no |
|
||||
| Restore to stock firmware... | removes aftermarket firmware; see [Restore to stock](07-restore.md) | yes, reboots |
|
||||
| Flash lights / Stop flashing lights | locate light on or off | yes, harmless |
|
||||
| Pause mining / Resume mining | stop or start hashing | yes |
|
||||
| Set tuning %... | tuning level, 0 to 100 | yes |
|
||||
| Set power target... | power target in watts; the prompt shows the current value and the allowed range | yes |
|
||||
| Set hashrate target... | hashrate target in TH/s, for firmware that tunes by hashrate | yes |
|
||||
| Set profile... | pick a firmware profile or preset (only profiles every selected miner has are listed) | yes |
|
||||
| Restart | reboot | yes |
|
||||
| Configure pools... | set up to three pools | yes |
|
||||
| Set timezone... | IANA time zone, for example `America/Edmonton` | yes |
|
||||
| Change password... | new web/API password | yes |
|
||||
| Factory reset... | wipes pools, tuning and network settings and reboots; the miner may come back on a new DHCP address | yes, destructive |
|
||||
|
||||
## Safety
|
||||
|
||||
- Pause, Resume, Restart and Factory reset ask for confirmation. Value prompts
|
||||
(tuning, targets, timezone, password) apply when you confirm the value.
|
||||
- Actions that change miners do not start while a scan is running, including an
|
||||
automatic rescan. Wait for it to finish or press **Pause**. Scans in turn wait
|
||||
for running actions.
|
||||
- Each changed miner is re-read automatically when the action finishes. Results
|
||||
and failures appear in the bottom-right corner of the status bar and in
|
||||
**Settings > Logs**.
|
||||
- If **Change password** succeeds on every selected miner, the saved global
|
||||
login is updated to the new password. If only some succeed, the saved login
|
||||
is left alone and the log says so.
|
||||
|
||||
## Configuring pools
|
||||
|
||||
The pool dialog has three rows: Address, Account, Worker and Password. A row is
|
||||
used only when it has an address and an account. A blank password becomes `x`.
|
||||
The miner's username becomes `account.worker`.
|
||||
|
||||
Each field has a **+** menu with common pool addresses and the values you saved
|
||||
before (**Add new...** edits that list). Worker names can use placeholders that
|
||||
are filled in per miner:
|
||||
|
||||
| Placeholder | Becomes |
|
||||
|---|---|
|
||||
| `{ip1}` to `{ip4}` | one octet of the miner's IP |
|
||||
| `{serial}`, `{mac}` | serial number; MAC without colons |
|
||||
| `{hostname}` | the miner's hostname |
|
||||
| `{brand}`, `{model}`, `{submodel}` | make and model |
|
||||
| `{firmware}`, `{cpu}`, `{cb}` | firmware family, control-board CPU and board |
|
||||
| `{nameplate-hr}` | the model's rated hashrate |
|
||||
|
||||
For example, `rack3-{ip3}-{ip4}` gives `rack3-1-50` for `10.0.1.50`.
|
||||
@@ -0,0 +1,72 @@
|
||||
# Settings and credentials
|
||||
|
||||
**Settings** opens a menu with Credentials, Language and Logs.
|
||||
|
||||
## Credentials
|
||||
|
||||
Miners need a login for anything beyond basic discovery: for some details, and
|
||||
for every action. The Credentials dialog has three parts:
|
||||
|
||||
- **All firmwares** at the top: one username and password tried on every miner.
|
||||
The saved password is never shown; leave the field blank to keep it. Blank
|
||||
username and password clear it.
|
||||
- **SSH (restore)**: the control-board SSH login used to restore Braiins OS to
|
||||
stock (see [SSH login](#ssh-login)).
|
||||
- **One row per firmware**, pre-filled with that firmware's factory default.
|
||||
Change a row to override the login for that firmware only.
|
||||
|
||||
The toolkit tries, in order, the firmware's own row, then the global login,
|
||||
then the firmware's built-in default.
|
||||
|
||||
| Firmware | Factory default (user / password) |
|
||||
|---|---|
|
||||
| AntMiner Stock | root / root |
|
||||
| WhatsMiner Stock | admin / admin |
|
||||
| Braiins | root / root |
|
||||
| VNish | (none) / admin |
|
||||
| LuxOS | root / root |
|
||||
| UMC OS | (none) / letmein |
|
||||
| Marathon | root / root |
|
||||
| VolcMiner Stock | root / ltc@dog |
|
||||
| Elphapex Stock | root / root |
|
||||
| FutureBit Stock | futurebit / futurebit123 |
|
||||
| SealMiner Stock | seal / seal |
|
||||
| Auradine Stock | admin / admin |
|
||||
|
||||
**Reset to defaults** clears every override, the global login and the SSH
|
||||
login at once.
|
||||
|
||||
Logins are stored as plain text in the settings folder, readable only by your
|
||||
user account (Linux file mode 0600; on Windows, your profile folder's
|
||||
permissions).
|
||||
|
||||
### SSH login
|
||||
|
||||
Restoring Braiins to stock runs a command over SSH, using the system `ssh`
|
||||
client (built into Windows 10/11). Set its login in the **SSH (restore)** row
|
||||
of the Credentials dialog. The username defaults to `root`. As with the global
|
||||
login, the saved password is never shown and a blank password keeps it.
|
||||
|
||||
## Language
|
||||
|
||||
English, Chinese, Russian, French, Spanish and Portuguese. The toolbar, cards
|
||||
and column headers switch immediately; menus and dialogs not yet translated
|
||||
stay in English.
|
||||
|
||||
## Logs
|
||||
|
||||
An activity log of scans, actions, errors and exports, newest last, kept for
|
||||
the current session (the last 2000 lines). Times are shown in UTC.
|
||||
|
||||
## Files in the settings folder
|
||||
|
||||
| File | Holds |
|
||||
|---|---|
|
||||
| `scan-ranges.txt` | scan ranges, one per line |
|
||||
| `auto-rescan-secs.txt`, `scan-timeout-secs.txt`, `scan-concurrency.txt` | the three scan numbers |
|
||||
| `scan-credentials.txt` | global login |
|
||||
| `firmware-credentials.txt` | per-firmware logins |
|
||||
| `ssh-credentials.txt` | SSH login |
|
||||
| `presets.json` | saved views |
|
||||
| `language.txt` | UI language |
|
||||
| `pool-addresses.txt`, `pool-accounts.txt`, `pool-workers.txt`, `pool-passwords.txt` | saved pool values |
|
||||
@@ -0,0 +1,18 @@
|
||||
# Restore to stock firmware
|
||||
|
||||
**Restore to stock firmware...** removes aftermarket firmware and returns the
|
||||
miner to the manufacturer's firmware it keeps on board. Nothing is uploaded.
|
||||
The miner reboots, and some firmwares come back on a new address.
|
||||
|
||||
It is offered when the selection includes a supported firmware, and asks for
|
||||
confirmation with the list of miners first.
|
||||
|
||||
| Firmware | How it is removed | Login used |
|
||||
|---|---|---|
|
||||
| VNish (and builds based on it) | web API: unlock, then remove firmware; reboots in seconds | the VNish row in Credentials, else `admin` |
|
||||
| LuxOS | miner API: log on, then uninstall | none |
|
||||
| Braiins OS | SSH: runs the firmware's own `uninstall.sh` | the SSH row in Credentials (see [Settings](06-settings.md#ssh-login)) |
|
||||
|
||||
Miners are restored one at a time. A dropped connection after the command is
|
||||
sent counts as success, because that is the reboot. A refused login counts as
|
||||
a failure and leaves the miner unchanged.
|
||||
@@ -0,0 +1,14 @@
|
||||
# Export
|
||||
|
||||
**Export** saves the scan as a CSV file for spreadsheets or other tools.
|
||||
|
||||
1. Choose the fields to include (all are ticked by default; **All** and
|
||||
**None** help).
|
||||
2. Pick where to save. The suggested name is `alkane-export-YYYYMMDD-HHMMSS.csv`.
|
||||
|
||||
The export contains **every scanned miner**, not just the rows the current
|
||||
filter shows. Per-board temperatures, fan speeds, board status and pools
|
||||
become numbered columns (`board_temp_1_c`, `fan_2_rpm`, `pool_1_url`, ...).
|
||||
|
||||
Values that start with `=`, `+`, `-` or `@` are prefixed with `'` so a
|
||||
spreadsheet treats them as text, not formulas.
|
||||
@@ -0,0 +1,32 @@
|
||||
# Command line and environment
|
||||
|
||||
## Environment variables
|
||||
|
||||
| Variable | Effect |
|
||||
|---|---|
|
||||
| `ALKANE_FAKE_SCAN=1` | demo mode: a built-in sample fleet, no network traffic, simulated actions |
|
||||
| `ALKANE_APPEARANCE=light` or `dark` | force the light or dark theme |
|
||||
| `ALKANE_SELFTEST=1` | run the built-in UI self-test on the sample fleet and exit (prints `SELFTEST PASS` or `FAIL`) |
|
||||
| `ALKANE_ACCESS_PROBE="<ip> <make>"` | print whether the saved login can change that miner, then exit |
|
||||
| `ALKANE_LOG_SCAN="<ip> <brand>"` | fetch that miner's log through its API, print the size, then exit |
|
||||
|
||||
On Windows these one-shot modes print to the Command Prompt they are started
|
||||
from.
|
||||
|
||||
## miner_probe
|
||||
|
||||
`miner_probe` is a command-line companion for scripting and diagnosis. These
|
||||
commands only read:
|
||||
|
||||
| Command | Prints |
|
||||
|---|---|
|
||||
| `miner_probe scan <cidr> [<cidr>...]` | discovered miners and their telemetry, as tab-separated values |
|
||||
| `miner_probe hashrate <cidr>...` | raw hashrate and algorithm |
|
||||
| `miner_probe msgs <ip>` | fault messages and per-board data |
|
||||
| `miner_probe tune <ip>` | tuning support and limits |
|
||||
| `miner_probe presets <ip>` | available firmware profiles |
|
||||
| `miner_probe timezone <ip>` | the current time zone |
|
||||
|
||||
Its other commands change miners. It uses the global login from the settings
|
||||
folder, or `ALKANE_PROBE_USER` and `ALKANE_PROBE_PASS`, and
|
||||
`ALKANE_PROBE_CONCURRENCY` (default 128).
|
||||
@@ -0,0 +1,46 @@
|
||||
# Troubleshooting
|
||||
|
||||
**Windows says "Windows protected your PC".** SmartScreen warns about new
|
||||
downloads until a certificate has built up reputation. The publisher shown
|
||||
should be *BlueFlare Energy Solutions Inc.*; click **More info**, then **Run
|
||||
anyway**. If no publisher is shown, do not run the file and download it again
|
||||
from the releases page.
|
||||
|
||||
**A miner is missing.** Check that its address is inside the scan ranges and
|
||||
that it answers on its web page from this computer. On busy or slow networks,
|
||||
raise **Timeout** or lower **Concurrency** in the Scan ranges dialog.
|
||||
|
||||
**An action is missing from the right-click menu.** Actions appear only when
|
||||
every selected miner supports them. Select fewer miners, or only miners with
|
||||
the same firmware.
|
||||
|
||||
**An action does nothing and the status says a scan is in progress.** Changes
|
||||
wait for scans. Press **Pause**, let the scan finish, then try again.
|
||||
|
||||
**Check access says locked.** The saved login is not accepted. Set the right
|
||||
password in **Settings > Credentials**, either for all firmwares or for that
|
||||
firmware's row.
|
||||
|
||||
**Values are blank.** The firmware did not report them, or it needs a login to
|
||||
report them. Try **Check access** and the Credentials dialog.
|
||||
|
||||
**The window is too small or too large.** It opens at most as large as your
|
||||
screen's work area. Use the zoom slider in the status bar to scale the table.
|
||||
|
||||
## Reporting a problem
|
||||
|
||||
**Bug report** in the toolbar, between Export and Settings, files a bug or a
|
||||
feature request with the developers. Choose the type (Bug, UI change or
|
||||
Feature request) and describe it; the first line becomes the title. **Send**
|
||||
shows the issue number when it is filed, and **Open issue** opens it in the
|
||||
browser. If it was not sent, the reason is shown and the text stays in the
|
||||
box.
|
||||
|
||||
A report includes the app version, the operating system, the light or dark
|
||||
appearance, the language and the window size. **Include the recent activity
|
||||
log** adds the newest lines of the Settings > Logs page, with passwords,
|
||||
tokens and similar values removed first; untick it to leave the log out.
|
||||
Reports become public issues on
|
||||
[gitea.bluefla.re](https://gitea.bluefla.re/blueflare/alkane-toolkit/issues),
|
||||
so do not put passwords or customer details in the text. A computer can send
|
||||
five reports an hour.
|
||||
+38
-2
@@ -59,11 +59,47 @@ target and a prebuilt wxMSW prefix to the Linux image. Rebuild it with
|
||||
`ci/images/build-image.sh TAG` from the workstation that holds the registry
|
||||
credential; the script pins the new digest everywhere.
|
||||
|
||||
## Code signing
|
||||
|
||||
Release and `-rc` executables are Authenticode-signed with Azure Artifact
|
||||
Signing (formerly Trusted Signing), so Windows and SmartScreen show
|
||||
"BlueFlare Energy Solutions Inc." as the verified publisher instead of "Unknown publisher".
|
||||
|
||||
| Piece | Where |
|
||||
|-------|-------|
|
||||
| Signing account | `blueflaresigning` (Basic), resource group `rg-blueflare-signing`, West US 2, endpoint `https://wus2.codesigning.azure.net` |
|
||||
| CI identity | service principal `alkane-toolkit-ci-signer`, role "Artifact Signing Certificate Profile Signer" on the certificate profile only; Gitea secrets `AZURE_SIGNING_TENANT_ID`, `AZURE_SIGNING_CLIENT_ID`, `AZURE_SIGNING_CLIENT_SECRET` (secret expires 2027-11-03) |
|
||||
| Switch | Gitea repository variable `AZURE_SIGNING_PROFILE` (certificate profile name); unset = builds stay unsigned |
|
||||
| Signer | `ci/sign-windows.sh` (jsign from the CI image, RFC 3161 timestamp from `timestamp.acs.microsoft.com`) |
|
||||
| Check | `windows-native.yml` requires `Get-AuthenticodeSignature` = Valid on real Windows once signing is on |
|
||||
|
||||
Signing is on since 2026-11-03 (identity validation approved, certificate
|
||||
profile `alkane-toolkit`, PublicTrust). The zip's README.txt states whether its
|
||||
executable is signed. To set it up again, e.g. for a new profile, after an
|
||||
identity validation is approved (portal: signing account > Identity
|
||||
validations):
|
||||
|
||||
```sh
|
||||
scripts/enable-windows-signing.sh <identity-validation-id>
|
||||
```
|
||||
|
||||
It creates the PublicTrust certificate profile, narrows the CI identity to it,
|
||||
and sets `AZURE_SIGNING_PROFILE`. From then on a signing failure fails the
|
||||
release. Rotate the CI secret before it expires with
|
||||
`az ad sp credential reset --id <appId> --years 1` and update the Gitea secret.
|
||||
|
||||
Sign by hand (any machine with Java, `az login` and the Signer role):
|
||||
|
||||
```sh
|
||||
AZURE_SIGNING_PROFILE=alkane-toolkit ALKANE_JSIGN_JAR=jsign.jar \
|
||||
AZURE_SIGNING_TOKEN=$(az account get-access-token --resource https://codesigning.azure.net --query accessToken -o tsv) \
|
||||
ci/sign-windows.sh alkane-toolkit.exe
|
||||
```
|
||||
|
||||
## Native Windows runner
|
||||
|
||||
`windows-native.yml` runs on the self-hosted runner `win11-test-vm`
|
||||
(label `alkane-windows`, host mode) inside the Windows 11 test VM
|
||||
(a local test VM). It downloads the
|
||||
(label `alkane-windows`, host mode) inside a Windows 11 test VM. It downloads the
|
||||
`alkane-toolkit-windows-tests` artifact of the triggering main run, runs every
|
||||
test executable and the UI self-test natively, and never blocks a release:
|
||||
while the VM is off, the job waits for the runner.
|
||||
|
||||
@@ -1,9 +1,28 @@
|
||||
#!/bin/sh
|
||||
# Build the alkane-toolkit GUI on macOS.
|
||||
# wx-rs upstream supports macOS: its build.rs clones/builds wx 3.2.2.1 into
|
||||
# ./dist (osx-release-build) on first build. Requires Xcode Command Line
|
||||
# Tools. Run this ON a Mac - macOS cannot be linked from Linux.
|
||||
# Build the alkane-toolkit GUI on macOS as one universal binary.
|
||||
#
|
||||
# scripts/build-gui-macos.sh [extra cargo build args]
|
||||
# -> target/universal-apple-darwin/release/alkane-toolkit (arm64 + x86_64)
|
||||
#
|
||||
# Needs the Xcode Command Line Tools, rustup with the aarch64-apple-darwin and
|
||||
# x86_64-apple-darwin targets, and the universal static wx prefix from
|
||||
# scripts/build-wx-macos.sh (WX_MACOS_PREFIX, default ~/.cache/wx-3.3.3-macos).
|
||||
# Each target is built separately against that prefix, then the two slices
|
||||
# are merged with lipo. MACOSX_DEPLOYMENT_TARGET matches the wx build.
|
||||
set -e
|
||||
cd "$(dirname -- "$0")/.."
|
||||
cargo build --release -p alkane-gui
|
||||
echo "binary: target/release/alkane-toolkit (app bundle packaging is follow-up)"
|
||||
PREFIX="${WX_MACOS_PREFIX:-$HOME/.cache/wx-3.3.3-macos}"
|
||||
[ -x "$PREFIX/bin/wx-config" ] || {
|
||||
echo "no wx prefix at $PREFIX; run scripts/build-wx-macos.sh first" >&2; exit 1; }
|
||||
export WX_RS_WXCONFIG="$PREFIX/bin/wx-config"
|
||||
export MACOSX_DEPLOYMENT_TARGET="${MACOSX_MIN:-11.0}"
|
||||
for target in aarch64-apple-darwin x86_64-apple-darwin; do
|
||||
cargo build --release --offline -p alkane-gui --target "$target" "$@"
|
||||
done
|
||||
out=target/universal-apple-darwin/release
|
||||
mkdir -p "$out"
|
||||
lipo -create -output "$out/alkane-toolkit" \
|
||||
target/aarch64-apple-darwin/release/alkane-toolkit \
|
||||
target/x86_64-apple-darwin/release/alkane-toolkit
|
||||
lipo -info "$out/alkane-toolkit"
|
||||
echo "binary: $out/alkane-toolkit"
|
||||
|
||||
Executable
+43
@@ -0,0 +1,43 @@
|
||||
#!/bin/sh
|
||||
# Build the vendored wxWidgets 3.3.3 for macOS: wxOSX/Cocoa, static,
|
||||
# monolithic, and universal (arm64 + x86_64) so one prefix serves both Rust
|
||||
# targets. Run on a Mac with the Xcode Command Line Tools.
|
||||
#
|
||||
# scripts/build-wx-macos.sh -> ~/.cache/wx-3.3.3-macos
|
||||
#
|
||||
# Dependency tracking is off: its bootstrap fails with several -arch flags.
|
||||
# MACOSX_MIN (default 11.0) is the oldest macOS the app runs on, for both
|
||||
# slices: the libc++ in current SDKs supports nothing older, and macOS 11 is
|
||||
# also where Apple Silicon starts. Image/zlib/regex/expat libraries are
|
||||
# wx's bundled copies, so the app links only against system frameworks.
|
||||
# The repo's vendor tree stays pristine; the build lives in ~/.cache/wxbuild.
|
||||
set -e
|
||||
REPO=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
|
||||
SRC="$REPO/thirdparty/wxwidgets/wxWidgets-3.3.3"
|
||||
BUILD="$HOME/.cache/wxbuild/wxWidgets-3.3.3-macos"
|
||||
PREFIX="${WX_MACOS_PREFIX:-$HOME/.cache/wx-3.3.3-macos}"
|
||||
MACOSX_MIN="${MACOSX_MIN:-11.0}"
|
||||
JOBS="${JOBS:-$(sysctl -n hw.ncpu)}"
|
||||
[ -d "$SRC" ] || { echo "thirdparty wxWidgets tree missing: $SRC" >&2; exit 1; }
|
||||
rm -rf "$BUILD"
|
||||
mkdir -p "$HOME/.cache/wxbuild"
|
||||
cp -R "$SRC" "$BUILD"
|
||||
trap 'rm -rf "$BUILD"' 0
|
||||
chmod +x "$BUILD/configure" "$BUILD/config.guess" "$BUILD/config.sub" "$BUILD/install-sh" 2>/dev/null || true
|
||||
mkdir -p "$BUILD/build-macos"
|
||||
cd "$BUILD/build-macos"
|
||||
sh ../configure --prefix="$PREFIX" --with-osx_cocoa \
|
||||
--disable-shared --enable-monolithic \
|
||||
--enable-universal_binary=arm64,x86_64 \
|
||||
--with-macosx-version-min="$MACOSX_MIN" \
|
||||
--disable-dependency-tracking \
|
||||
--with-libpng=builtin --with-libjpeg=builtin --without-libtiff \
|
||||
--with-zlib=builtin --with-expat=builtin --with-regex=builtin \
|
||||
--without-liblzma --without-libcurl \
|
||||
--with-opengl=no --disable-stc --disable-webview --disable-mediactrl \
|
||||
--disable-tests
|
||||
make -j"$JOBS"
|
||||
make install
|
||||
lib=$(ls "$PREFIX"/lib/libwx_osx_cocoau-3.3*.a | head -1)
|
||||
lipo -info "$lib"
|
||||
echo "installed: $PREFIX ($lib)"
|
||||
Executable
+58
@@ -0,0 +1,58 @@
|
||||
#!/bin/sh
|
||||
# Turn on Authenticode signing of the Windows build, once Microsoft has
|
||||
# approved the publisher identity validation for the Artifact Signing account.
|
||||
#
|
||||
# scripts/enable-windows-signing.sh IDENTITY_VALIDATION_ID [PROFILE]
|
||||
#
|
||||
# IDENTITY_VALIDATION_ID is shown in the Azure portal: signing account
|
||||
# "blueflaresigning" > Objects > Identity validations > (approved entry).
|
||||
# The script
|
||||
# 1. creates the PublicTrust certificate profile PROFILE (default
|
||||
# alkane-toolkit) bound to that identity,
|
||||
# 2. narrows the CI signer's role from the whole account to that profile,
|
||||
# 3. sets the Gitea repository variable AZURE_SIGNING_PROFILE, which makes
|
||||
# ci/sign-windows.sh sign every release and candidate from then on.
|
||||
#
|
||||
# Run on the workstation: it needs `az login` as an account owner and the
|
||||
# Gitea admin token (~/.config/gitea/token), neither of which CI ever sees.
|
||||
# Re-running is safe.
|
||||
set -eu
|
||||
IVID=${1:?usage: enable-windows-signing.sh IDENTITY_VALIDATION_ID [PROFILE]}
|
||||
PROFILE=${2:-alkane-toolkit}
|
||||
RG=rg-blueflare-signing
|
||||
ACCOUNT=blueflaresigning
|
||||
SIGNER=alkane-toolkit-ci-signer
|
||||
REPO=blueflare/alkane-toolkit
|
||||
TOKEN_FILE=${GITEA_TOKEN_FILE:-$HOME/.config/gitea/token}
|
||||
|
||||
if ! az trustedsigning certificate-profile show -g "$RG" --account-name "$ACCOUNT" \
|
||||
-n "$PROFILE" --only-show-errors -o none 2>/dev/null; then
|
||||
az trustedsigning certificate-profile create -g "$RG" --account-name "$ACCOUNT" \
|
||||
-n "$PROFILE" --profile-type PublicTrust --identity-validation-id "$IVID" \
|
||||
--only-show-errors -o none
|
||||
fi
|
||||
az trustedsigning certificate-profile show -g "$RG" --account-name "$ACCOUNT" -n "$PROFILE" \
|
||||
--only-show-errors --query "{profile:name, state:provisioningState, status:status}" -o table
|
||||
|
||||
# Least privilege: the CI identity may sign with this profile and nothing else.
|
||||
profile_id=$(az trustedsigning certificate-profile show -g "$RG" --account-name "$ACCOUNT" \
|
||||
-n "$PROFILE" --only-show-errors --query id -o tsv)
|
||||
account_id=${profile_id%/certificateProfiles/*}
|
||||
sp=$(az ad sp list --display-name "$SIGNER" --query "[0].id" -o tsv)
|
||||
role="Artifact Signing Certificate Profile Signer"
|
||||
az role assignment create --assignee-object-id "$sp" --assignee-principal-type ServicePrincipal \
|
||||
--role "$role" --scope "$profile_id" -o none
|
||||
az role assignment delete --assignee "$sp" --role "$role" --scope "$account_id" 2>/dev/null || true
|
||||
|
||||
# Switch signing on for CI (repository variable, not a secret).
|
||||
api=https://gitea.bluefla.re/api/v1/repos/$REPO/actions/variables/AZURE_SIGNING_PROFILE
|
||||
body=$(printf '{"value":"%s"}' "$PROFILE")
|
||||
auth() { printf 'header = "Authorization: token %s"\n' "$(cat "$TOKEN_FILE")"; }
|
||||
code=$(auth | curl -sS --config - -X PUT -H 'Content-Type: application/json' -d "$body" \
|
||||
-o /dev/null -w '%{http_code}' "$api")
|
||||
[ "$code" = 204 ] || [ "$code" = 201 ] || {
|
||||
code=$(auth | curl -sS --config - -X POST -H 'Content-Type: application/json' -d "$body" \
|
||||
-o /dev/null -w '%{http_code}' "$api")
|
||||
}
|
||||
case "$code" in 201|204) echo "Gitea AZURE_SIGNING_PROFILE=$PROFILE: signing is on" ;;
|
||||
*) echo "setting the Gitea variable failed (HTTP $code)" >&2; exit 1 ;; esac
|
||||
+308
@@ -0,0 +1,308 @@
|
||||
Subject: [PATCH 0034] vnish: keep the reported boards and infer the algorithm for unknown models
|
||||
|
||||
Field report 2026-11-03: VNish Antminer S19 (88) units showed no hashboard
|
||||
icons while hashing. VNish reports the model as "Antminer S19 (88)", which is
|
||||
not in asic-rs' alias table, so it parses to AntMinerModel::Unknown with no
|
||||
hardware table. parse_hashboards sized the board list from that table
|
||||
(board_count() = None -> 0 boards) and dropped all three live chains the
|
||||
miner reports in /summary. The same Unknown model also got
|
||||
HashAlgorithm::Unknown, so its hashrate was bucketed as "Unknown Hashrate".
|
||||
|
||||
- VNish v1.2.x and v1.3.x parse_hashboards: when the model has no hardware
|
||||
table, size the boards from the highest 1-based chain id the miner reports
|
||||
(a dead middle board keeps its slot). Known models are unchanged.
|
||||
- infer_antminer_algo (family letter: S/T -> SHA-256, L -> Scrypt,
|
||||
Z -> Equihash, ambiguous -> Unknown) moves from the stock v2020 backend
|
||||
into asic-rs-makes-antminer as a public function; the stock backend and
|
||||
both VNish backends now use it for models the table cannot place.
|
||||
|
||||
Tests: unknown_model_keeps_the_reported_chains (both VNish backends, chain
|
||||
data from the live 10.4.0.179 unit); the existing
|
||||
unknown_models_infer_algo_from_family_letter still passes against the moved
|
||||
helper. Live-verified read-only on all 13 fleet S19 (88) units (10.4.x,
|
||||
10.7.1.190): three hashboard icons each, per-board state intact (e.g. one red
|
||||
board on 10.4.1.111), and the KPI reads "SHA-256 Hashrate".
|
||||
|
||||
diff --git a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
|
||||
index 71195737..872bd1de 100644
|
||||
--- a/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-antminer/src/backends/v2020/mod.rs
|
||||
@@ -202,27 +202,7 @@ fn miner_conf_with_fan_config(miner_conf: &Value, config: FanConfig) -> Value {
|
||||
Value::Object(payload)
|
||||
}
|
||||
|
||||
-/// Infer an Antminer's hash algorithm from its model-family letter, for models
|
||||
-/// asic-rs' alias table doesn't recognise (round 13 #5). Only the families whose
|
||||
-/// entire product line shares one algorithm are inferred; anything ambiguous
|
||||
-/// (the K-series spans Kadena/KHeavyHash/Eaglesong, DR is Blake256 while D is
|
||||
-/// X11) is left Unknown rather than guessed wrong.
|
||||
-fn infer_antminer_algo(model: &str) -> HashAlgorithm {
|
||||
- let upper = model.to_ascii_uppercase();
|
||||
- let name = upper
|
||||
- .strip_prefix("ANTMINER ")
|
||||
- .unwrap_or(&upper)
|
||||
- .trim_start();
|
||||
- match name.chars().next() {
|
||||
- // Z9 / Z11 / Z15 / Z15 Pro / Z15J -- the whole Z line is Equihash.
|
||||
- Some('Z') => HashAlgorithm::Equihash,
|
||||
- // L3+ / L7 / L9 / L11 -- the whole L line is Scrypt.
|
||||
- Some('L') => HashAlgorithm::Scrypt,
|
||||
- // S9..S21 and T9..T21 (and future revisions) are all SHA-256.
|
||||
- Some('S') | Some('T') => HashAlgorithm::SHA256,
|
||||
- _ => HashAlgorithm::Unknown,
|
||||
- }
|
||||
-}
|
||||
+use asic_rs_makes_antminer::models::infer_antminer_algo;
|
||||
|
||||
impl AntMinerV2020 {
|
||||
pub fn new(ip: IpAddr, model: impl MinerModel) -> Self {
|
||||
diff --git a/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs b/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs
|
||||
index 2c14f217..3c8e1bee 100644
|
||||
--- a/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-vnish/src/backends/v1_2_0/mod.rs
|
||||
@@ -1,5 +1,6 @@
|
||||
use std::{collections::HashMap, net::IpAddr, str::FromStr, time::Duration};
|
||||
|
||||
+use asic_rs_makes_antminer::models::infer_antminer_algo;
|
||||
use anyhow;
|
||||
use asic_rs_core::{
|
||||
config::{
|
||||
@@ -17,7 +18,7 @@ use asic_rs_core::{
|
||||
DataCollector, DataExtensions, DataExtractor, DataField, DataLocation, get_by_pointer,
|
||||
},
|
||||
command::MinerCommand,
|
||||
- device::DeviceInfo,
|
||||
+ device::{DeviceInfo, HashAlgorithm},
|
||||
fan::FanData,
|
||||
hashrate::{HashRate, HashRateUnit},
|
||||
message::{MessageSeverity, MinerComponent, MinerMessage},
|
||||
@@ -52,7 +53,14 @@ pub struct VnishV120 {
|
||||
impl VnishV120 {
|
||||
pub fn new(ip: IpAddr, model: impl MinerModel) -> Self {
|
||||
let auth = Self::default_auth();
|
||||
- let algo = model.hash_algorithm();
|
||||
+ // A model outside asic-rs' alias table (VNish's "Antminer S19 (88)")
|
||||
+ // resolves to HashAlgorithm::Unknown, which left its hashrate bucketed
|
||||
+ // as "Unknown Hashrate". Infer it from the Antminer family letter, as
|
||||
+ // the stock backend does.
|
||||
+ let algo = match model.hash_algorithm() {
|
||||
+ HashAlgorithm::Unknown => infer_antminer_algo(&model.to_string()),
|
||||
+ known => known,
|
||||
+ };
|
||||
VnishV120 {
|
||||
ip,
|
||||
web: VnishWebAPI::new(ip, 80, auth),
|
||||
@@ -509,8 +517,24 @@ impl GetHashboards for VnishV120 {
|
||||
.and_then(|v| v.pointer("/factory"))
|
||||
.and_then(|v| v.as_array());
|
||||
|
||||
- let mut hashboards: Vec<BoardData> =
|
||||
- (0..self.device_info.hardware.board_count().unwrap_or(0) as usize)
|
||||
+ // The model's hardware table gives the board count. For a model asic-rs
|
||||
+ // does not know (e.g. VNish "Antminer S19 (88)") there is no table, and
|
||||
+ // sizing from it dropped every live chain -- the boards then vanished
|
||||
+ // from the data although the miner reports them. Fall back to what the
|
||||
+ // miner reports: the highest 1-based chain id, so a dead middle board
|
||||
+ // still keeps its slot.
|
||||
+ let reported_boards = all_chains
|
||||
+ .iter()
|
||||
+ .filter_map(|c| c.pointer("/id").and_then(|v| v.as_u64()))
|
||||
+ .max()
|
||||
+ .unwrap_or(0) as usize;
|
||||
+ let board_count = self
|
||||
+ .device_info
|
||||
+ .hardware
|
||||
+ .board_count()
|
||||
+ .map(|n| n as usize)
|
||||
+ .unwrap_or(reported_boards);
|
||||
+ let mut hashboards: Vec<BoardData> = (0..board_count)
|
||||
.map(|idx| {
|
||||
BoardData::new(idx as u8, self.device_info.hardware.chips_for_board(idx))
|
||||
})
|
||||
@@ -1524,4 +1548,42 @@ mod tests {
|
||||
assert!(config.available.contains(&Tz::Etc__GMT));
|
||||
assert_eq!(config.available.last(), Some(&Tz::Etc__GMTMinus14));
|
||||
}
|
||||
+
|
||||
+ /// Same as the 1.3.x backend: a model with no hardware table (VNish's
|
||||
+ /// "Antminer S19 (88)") must keep the chains the miner reports instead of
|
||||
+ /// sizing the board list to zero. Live 1.2.7 units (e.g. 10.4.1.111) run it.
|
||||
+ #[tokio::test]
|
||||
+ async fn unknown_model_keeps_the_reported_chains() {
|
||||
+ let miner = VnishV120::new(
|
||||
+ IpAddr::from([127, 0, 0, 1]),
|
||||
+ AntMinerModel::Unknown("ANTMINER S19 (88)".to_string()),
|
||||
+ );
|
||||
+ let mut results = HashMap::new();
|
||||
+ results.insert(
|
||||
+ MinerCommand::WebAPI {
|
||||
+ command: "info",
|
||||
+ parameters: None,
|
||||
+ },
|
||||
+ json!({ "miner": "Antminer S19 (88)", "hr_measure": "GH/s", "fw_version": "1.2.7" }),
|
||||
+ );
|
||||
+ results.insert(
|
||||
+ MinerCommand::WebAPI {
|
||||
+ command: "summary",
|
||||
+ parameters: None,
|
||||
+ },
|
||||
+ json!({ "miner": { "hr_realtime": 82600.0, "chains": [
|
||||
+ { "id": 1, "hashrate_rt": 27537.83 },
|
||||
+ { "id": 2, "hashrate_rt": 27511.20 },
|
||||
+ { "id": 3, "hashrate_rt": 27601.04 }
|
||||
+ ] } }),
|
||||
+ );
|
||||
+ let mock_api = MockAPIClient::new(results);
|
||||
+ let mut collector = DataCollector::new_with_client(&miner, &mock_api);
|
||||
+ let miner_data = miner.parse_data(collector.collect_all().await);
|
||||
+
|
||||
+ assert_eq!(miner_data.hashboards.len(), 3, "one board per reported chain");
|
||||
+ // ...and its hashrate is SHA-256 (family letter S), not "Unknown".
|
||||
+ assert_eq!(miner_data.hashrate.expect("hashrate").algo, HashAlgorithm::SHA256);
|
||||
+ assert!(miner_data.hashboards.iter().all(|b| b.hashrate.is_some()));
|
||||
+ }
|
||||
}
|
||||
diff --git a/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs b/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs
|
||||
index e6247923..0e009f1c 100644
|
||||
--- a/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs
|
||||
+++ b/vendor/asic-rs-firmwares-vnish/src/backends/v1_3_0/mod.rs
|
||||
@@ -1,5 +1,6 @@
|
||||
use std::{collections::HashMap, net::IpAddr, str::FromStr, time::Duration};
|
||||
|
||||
+use asic_rs_makes_antminer::models::infer_antminer_algo;
|
||||
use anyhow;
|
||||
use asic_rs_core::{
|
||||
config::{
|
||||
@@ -17,7 +18,7 @@ use asic_rs_core::{
|
||||
DataCollector, DataExtensions, DataExtractor, DataField, DataLocation, get_by_pointer,
|
||||
},
|
||||
command::MinerCommand,
|
||||
- device::DeviceInfo,
|
||||
+ device::{DeviceInfo, HashAlgorithm},
|
||||
fan::FanData,
|
||||
hashrate::{HashRate, HashRateUnit},
|
||||
message::{MessageSeverity, MinerComponent, MinerMessage},
|
||||
@@ -52,7 +53,14 @@ pub struct VnishV130 {
|
||||
impl VnishV130 {
|
||||
pub fn new(ip: IpAddr, model: impl MinerModel) -> Self {
|
||||
let auth = Self::default_auth();
|
||||
- let algo = model.hash_algorithm();
|
||||
+ // A model outside asic-rs' alias table (VNish's "Antminer S19 (88)")
|
||||
+ // resolves to HashAlgorithm::Unknown, which left its hashrate bucketed
|
||||
+ // as "Unknown Hashrate". Infer it from the Antminer family letter, as
|
||||
+ // the stock backend does.
|
||||
+ let algo = match model.hash_algorithm() {
|
||||
+ HashAlgorithm::Unknown => infer_antminer_algo(&model.to_string()),
|
||||
+ known => known,
|
||||
+ };
|
||||
VnishV130 {
|
||||
ip,
|
||||
web: VnishWebAPI::new(ip, 80, auth),
|
||||
@@ -516,8 +524,24 @@ impl GetHashboards for VnishV130 {
|
||||
.and_then(|v| v.pointer("/factory"))
|
||||
.and_then(|v| v.as_array());
|
||||
|
||||
- let mut hashboards: Vec<BoardData> =
|
||||
- (0..self.device_info.hardware.board_count().unwrap_or(0) as usize)
|
||||
+ // The model's hardware table gives the board count. For a model asic-rs
|
||||
+ // does not know (e.g. VNish "Antminer S19 (88)") there is no table, and
|
||||
+ // sizing from it dropped every live chain -- the boards then vanished
|
||||
+ // from the data although the miner reports them. Fall back to what the
|
||||
+ // miner reports: the highest 1-based chain id, so a dead middle board
|
||||
+ // still keeps its slot.
|
||||
+ let reported_boards = all_chains
|
||||
+ .iter()
|
||||
+ .filter_map(|c| c.pointer("/id").and_then(|v| v.as_u64()))
|
||||
+ .max()
|
||||
+ .unwrap_or(0) as usize;
|
||||
+ let board_count = self
|
||||
+ .device_info
|
||||
+ .hardware
|
||||
+ .board_count()
|
||||
+ .map(|n| n as usize)
|
||||
+ .unwrap_or(reported_boards);
|
||||
+ let mut hashboards: Vec<BoardData> = (0..board_count)
|
||||
.map(|idx| {
|
||||
BoardData::new(idx as u8, self.device_info.hardware.chips_for_board(idx))
|
||||
})
|
||||
@@ -1661,4 +1685,46 @@ mod tests {
|
||||
assert!(config.available.contains(&Tz::Etc__GMT));
|
||||
assert_eq!(config.available.last(), Some(&Tz::Etc__GMTMinus14));
|
||||
}
|
||||
+
|
||||
+ /// A model asic-rs has no hardware table for -- VNish reports the 88-chip
|
||||
+ /// S19 as "Antminer S19 (88)" -- must still surface the boards the miner
|
||||
+ /// reports. Sizing the board list from the (absent) table dropped all
|
||||
+ /// three live chains, so the GUI drew no hashboard icons for a hashing
|
||||
+ /// miner. Chain values match the live 10.4.0.179 unit.
|
||||
+ #[tokio::test]
|
||||
+ async fn unknown_model_keeps_the_reported_chains() {
|
||||
+ let miner = VnishV130::new(
|
||||
+ IpAddr::from([127, 0, 0, 1]),
|
||||
+ AntMinerModel::Unknown("ANTMINER S19 (88)".to_string()),
|
||||
+ );
|
||||
+ let mut results = HashMap::new();
|
||||
+ results.insert(
|
||||
+ web("info"),
|
||||
+ json!({ "miner": "Antminer S19 (88)", "model": "s19-88", "hr_measure": "GH/s" }),
|
||||
+ );
|
||||
+ results.insert(
|
||||
+ web("summary"),
|
||||
+ json!({
|
||||
+ "miner": {
|
||||
+ "hr_realtime": 82600.0,
|
||||
+ "chains": [
|
||||
+ { "id": 1, "hashrate_rt": 27537.83, "chip_statuses": { "grey": 88 } },
|
||||
+ { "id": 2, "hashrate_rt": 27511.20, "chip_statuses": { "grey": 88 } },
|
||||
+ { "id": 3, "hashrate_rt": 27601.04, "chip_statuses": { "grey": 88 } }
|
||||
+ ]
|
||||
+ }
|
||||
+ }),
|
||||
+ );
|
||||
+ let mock_api = MockAPIClient::new(results);
|
||||
+ let mut collector = DataCollector::new_with_client(&miner, &mock_api);
|
||||
+ let miner_data = miner.parse_data(collector.collect_all().await);
|
||||
+
|
||||
+ assert_eq!(miner_data.hashboards.len(), 3, "one board per reported chain");
|
||||
+ // ...and its hashrate is SHA-256 (family letter S), not "Unknown".
|
||||
+ assert_eq!(miner_data.hashrate.expect("hashrate").algo, HashAlgorithm::SHA256);
|
||||
+ for (i, board) in miner_data.hashboards.iter().enumerate() {
|
||||
+ assert_eq!(board.position as usize, i);
|
||||
+ assert!(board.hashrate.is_some(), "board {i} keeps its live hashrate");
|
||||
+ }
|
||||
+ }
|
||||
}
|
||||
diff --git a/vendor/asic-rs-makes-antminer/src/models.rs b/vendor/asic-rs-makes-antminer/src/models.rs
|
||||
index f52639fe..e3185089 100644
|
||||
--- a/vendor/asic-rs-makes-antminer/src/models.rs
|
||||
+++ b/vendor/asic-rs-makes-antminer/src/models.rs
|
||||
@@ -201,6 +201,29 @@ pub enum AntMinerModel {
|
||||
Unknown(String),
|
||||
}
|
||||
|
||||
+/// Infer an Antminer's hash algorithm from its model-family letter, for models
|
||||
+/// asic-rs' alias table doesn't recognise (round 13 #5). Only the families whose
|
||||
+/// entire product line shares one algorithm are inferred; anything ambiguous
|
||||
+/// (the K-series spans Kadena/KHeavyHash/Eaglesong, DR is Blake256 while D is
|
||||
+/// X11) is left Unknown rather than guessed wrong. Shared by every firmware
|
||||
+/// backend that runs on Antminer hardware (stock, VNish).
|
||||
+pub fn infer_antminer_algo(model: &str) -> HashAlgorithm {
|
||||
+ let upper = model.to_ascii_uppercase();
|
||||
+ let name = upper
|
||||
+ .strip_prefix("ANTMINER ")
|
||||
+ .unwrap_or(&upper)
|
||||
+ .trim_start();
|
||||
+ match name.chars().next() {
|
||||
+ // Z9 / Z11 / Z15 / Z15 Pro / Z15J -- the whole Z line is Equihash.
|
||||
+ Some('Z') => HashAlgorithm::Equihash,
|
||||
+ // L3+ / L7 / L9 / L11 -- the whole L line is Scrypt.
|
||||
+ Some('L') => HashAlgorithm::Scrypt,
|
||||
+ // S9..S21 and T9..T21 (and future revisions) are all SHA-256.
|
||||
+ Some('S') | Some('T') => HashAlgorithm::SHA256,
|
||||
+ _ => HashAlgorithm::Unknown,
|
||||
+ }
|
||||
+}
|
||||
+
|
||||
impl FromStr for AntMinerModel {
|
||||
type Err = ModelSelectionError;
|
||||
|
||||
+140
@@ -0,0 +1,140 @@
|
||||
Subject: [PATCH 0009] macOS: wxOSX through wx-config, logical sizes, clang runtime
|
||||
|
||||
--- a/build.rs
|
||||
+++ b/build.rs
|
||||
@@ -42,12 +42,12 @@
|
||||
target_os() == "linux"
|
||||
}
|
||||
|
||||
-// alkane-toolkit patch: Linux (wxGTK) and Windows/GNU (wxMSW built with
|
||||
-// mingw-w64, natively or cross from Linux) both build against a wx prefix
|
||||
-// described by its wx-config script, so they share one code path. Upstream's
|
||||
-// MSVC/nmake and macOS download-and-build paths are left as they were.
|
||||
+// alkane-toolkit patch: Linux (wxGTK), macOS (wxOSX/Cocoa, universal static
|
||||
+// build) and Windows/GNU (wxMSW built with mingw-w64, natively or cross from
|
||||
+// Linux) all build against a wx prefix described by its wx-config script, so
|
||||
+// they share one code path. Upstream's MSVC/nmake path is left as it was.
|
||||
fn uses_wx_config() -> bool {
|
||||
- is_linux() || (is_windows() && !is_msvc())
|
||||
+ is_linux() || is_osx() || (is_windows() && !is_msvc())
|
||||
}
|
||||
|
||||
fn is_stub() -> bool {
|
||||
@@ -278,7 +278,14 @@
|
||||
build.cpp(true)
|
||||
.file("cpp_src/wxbridge.cpp")
|
||||
.file("cpp_src/widgets_bridge.cpp");
|
||||
- for f in cxxflags.split_whitespace() {
|
||||
+ let mut flags = cxxflags.split_whitespace();
|
||||
+ while let Some(f) = flags.next() {
|
||||
+ // A universal wx prefix reports `-arch arm64 -arch x86_64`; cargo builds
|
||||
+ // one target at a time and cc adds that target's own -arch.
|
||||
+ if is_osx() && f == "-arch" {
|
||||
+ flags.next();
|
||||
+ continue;
|
||||
+ }
|
||||
build.flag(f);
|
||||
}
|
||||
if is_linux() {
|
||||
@@ -308,7 +315,53 @@
|
||||
}
|
||||
build.compile("wxbridge");
|
||||
|
||||
- for flag in libs.split_whitespace() {
|
||||
+ if is_osx() {
|
||||
+ // wxOSX's Objective-C uses @available, which calls
|
||||
+ // ___isPlatformVersionAtLeast from clang's compiler runtime. clang
|
||||
+ // links that runtime itself, but rustc drives the link without it.
|
||||
+ let resource_dir = Command::new("clang")
|
||||
+ .arg("-print-resource-dir")
|
||||
+ .output()
|
||||
+ .ok()
|
||||
+ .filter(|o| o.status.success())
|
||||
+ .and_then(|o| String::from_utf8(o.stdout).ok())
|
||||
+ .map(|s| s.trim().to_string())
|
||||
+ .ok_or("wx-rs: cannot ask clang for its resource directory")?;
|
||||
+ let rt = Path::new(&resource_dir).join("lib").join("darwin");
|
||||
+ if !rt.join("libclang_rt.osx.a").exists() {
|
||||
+ return Err(format!("wx-rs: no libclang_rt.osx.a in {}", rt.display()).into());
|
||||
+ }
|
||||
+ println!("cargo:rustc-link-search=native={}", rt.display());
|
||||
+ println!("cargo:rustc-link-lib=static=clang_rt.osx");
|
||||
+ }
|
||||
+
|
||||
+ let mut lib_flags = libs.split_whitespace();
|
||||
+ while let Some(flag) = lib_flags.next() {
|
||||
+ if is_osx() {
|
||||
+ match flag {
|
||||
+ "-arch" => {
|
||||
+ lib_flags.next();
|
||||
+ continue;
|
||||
+ }
|
||||
+ "-framework" => {
|
||||
+ if let Some(name) = lib_flags.next() {
|
||||
+ println!("cargo:rustc-link-lib=framework={}", name);
|
||||
+ }
|
||||
+ continue;
|
||||
+ }
|
||||
+ "-weak_framework" => {
|
||||
+ if let Some(name) = lib_flags.next() {
|
||||
+ println!("cargo:rustc-link-arg=-Wl,-weak_framework,{}", name);
|
||||
+ }
|
||||
+ continue;
|
||||
+ }
|
||||
+ _ if flag.starts_with("-Wl,") => {
|
||||
+ println!("cargo:rustc-link-arg={}", flag);
|
||||
+ continue;
|
||||
+ }
|
||||
+ _ => {}
|
||||
+ }
|
||||
+ }
|
||||
if flag.ends_with(".a") && Path::new(flag).is_absolute() {
|
||||
// static wx builds: wx-config emits the archive as a full path
|
||||
let file = Path::new(flag).file_name().and_then(|f| f.to_str()).unwrap_or(flag);
|
||||
--- a/cpp_src/wxbridge.cpp
|
||||
+++ b/cpp_src/wxbridge.cpp
|
||||
@@ -492,21 +492,12 @@
|
||||
|
||||
// The logical window size
|
||||
Size get_client_size() {
|
||||
-#ifdef __APPLE__
|
||||
- int status_bar_height;
|
||||
- if (wxGetApp().frame->GetStatusBar()) {
|
||||
- status_bar_height = wxGetApp().frame->GetStatusBar()->GetRect().height;
|
||||
- } else {
|
||||
- status_bar_height = 0;
|
||||
- }
|
||||
- float scale_factor = wxGetApp().frame->GetDPIScaleFactor();
|
||||
- wxSize s = wxGetApp().frame->GetClientSize();
|
||||
- struct Size sz = {s.x * scale_factor, (s.y + status_bar_height) * scale_factor};
|
||||
- return sz;
|
||||
-#elif defined(__linux__)
|
||||
- // alkane-toolkit patch: wxGTK3 path (upstream only knew Apple vs Windows)
|
||||
+#if defined(__linux__) || defined(__APPLE__)
|
||||
+ // alkane-toolkit patch: wxGTK3 and wxOSX both report logical (DIP) sizes,
|
||||
+ // like every other bridge size. Upstream's Apple branch scaled to physical
|
||||
+ // pixels through a float -> int narrowing current clang rejects.
|
||||
wxSize s = wxGetApp().frame->GetClientSize();
|
||||
- return Size {(unsigned int)s.x, (unsigned int)s.y};
|
||||
+ return Size {s.x, s.y};
|
||||
#else
|
||||
HWND hwnd = (HWND) wxGetApp().frame->GetHandle();
|
||||
RECT rect;
|
||||
@@ -559,15 +550,10 @@
|
||||
}
|
||||
|
||||
Size get_mouse_position(wxMouseEvent &event) {
|
||||
-#ifdef __APPLE__
|
||||
- wxPoint p = event.GetPosition();
|
||||
- float scale_factor = wxGetApp().frame->GetDPIScaleFactor();
|
||||
- struct Size s = {p.x * scale_factor, p.y * scale_factor};
|
||||
- return s;
|
||||
-#else
|
||||
+ // alkane-toolkit patch: logical (DIP) coordinates on every platform,
|
||||
+ // matching get_client_size (upstream scaled them on Apple).
|
||||
wxPoint p = event.GetPosition();
|
||||
return Size {p.x, p.y};
|
||||
-#endif
|
||||
}
|
||||
|
||||
int get_mouse_wheel_rotation(wxMouseEvent &event) {
|
||||
@@ -0,0 +1,162 @@
|
||||
Subject: [PATCH 0010] macOS: native alternating rows, theme text colour, self-test snapshot
|
||||
|
||||
--- a/build.rs
|
||||
+++ b/build.rs
|
||||
@@ -278,6 +278,12 @@
|
||||
build.cpp(true)
|
||||
.file("cpp_src/wxbridge.cpp")
|
||||
.file("cpp_src/widgets_bridge.cpp");
|
||||
+ if is_osx() {
|
||||
+ // Cocoa calls wx does not wrap (native alternating rows, self-test
|
||||
+ // snapshot); clang compiles .mm as Objective-C++.
|
||||
+ println!("cargo:rerun-if-changed=cpp_src/osx_native.mm");
|
||||
+ build.file("cpp_src/osx_native.mm");
|
||||
+ }
|
||||
let mut flags = cxxflags.split_whitespace();
|
||||
while let Some(f) = flags.next() {
|
||||
// A universal wx prefix reports `-arch arm64 -arch x86_64`; cargo builds
|
||||
--- a/cpp_src/widgets_bridge.cpp
|
||||
+++ b/cpp_src/widgets_bridge.cpp
|
||||
@@ -597,7 +597,11 @@
|
||||
} else if (GetAttr().HasBackgroundColour()) {
|
||||
cellbg = GetAttr().GetBackgroundColour();
|
||||
} else {
|
||||
+#ifdef __WXOSX__
|
||||
+ cellbg = wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOX);
|
||||
+#else
|
||||
cellbg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
|
||||
+#endif
|
||||
}
|
||||
x += DrawShape(dc, shape, x, cell, seg.has_colour ? seg.colour : plain, cellbg);
|
||||
continue;
|
||||
@@ -688,6 +692,11 @@
|
||||
(unsigned char)(c.blue * 255.0 + 0.5));
|
||||
}
|
||||
}
|
||||
+#elif defined(__WXOSX__)
|
||||
+ // The DC arrives with the control's foreground colour, which is not the
|
||||
+ // theme-aware label colour native cells use; take the list text colour so
|
||||
+ // uncoloured segments follow light/dark like the native columns.
|
||||
+ return wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOXTEXT);
|
||||
#endif
|
||||
return wxColour();
|
||||
}
|
||||
@@ -1463,8 +1472,21 @@
|
||||
|
||||
// Set (or clear, when r<0) the alternating-row (zebra) background colour. The
|
||||
// app passes a theme-aware colour; odd rows get it (see AttrListStore).
|
||||
+#ifdef __WXOSX__
|
||||
+extern "C" void wxbr_osx_set_alternating_rows(void* win, int on);
|
||||
+#endif
|
||||
void wxbr_dvlc_set_zebra(void* win, int r, int g, int b) {
|
||||
+#ifdef __WXOSX__
|
||||
+ // wxOSX draws custom cells without clipping them to the cell, so the
|
||||
+ // renderer's over-sized background fill (which GTK/MSW clip) painted over
|
||||
+ // neighbouring cells and hid their text until a row was selected. Use the
|
||||
+ // table's native alternating rows instead: AppKit paints them under every
|
||||
+ // cell, in the theme's colours, and no row carries a background attribute.
|
||||
+ dvlc_store(win)->zebra = wxColour();
|
||||
+ wxbr_osx_set_alternating_rows(win, r >= 0 ? 1 : 0);
|
||||
+#else
|
||||
dvlc_store(win)->zebra = (r < 0) ? wxColour() : wxColour(r, g, b);
|
||||
+#endif
|
||||
}
|
||||
|
||||
// The model-row index of the first (top) visible row, or -1 if none. Used to
|
||||
--- a/cpp_src/osx_native.mm
|
||||
+++ b/cpp_src/osx_native.mm
|
||||
@@ -0,0 +1,60 @@
|
||||
+// osx_native.mm -- alkane-toolkit extension: the few wxOSX/Cocoa calls the
|
||||
+// bridge needs that wx does not wrap. Compiled on macOS only (see build.rs).
|
||||
+
|
||||
+#include <wx/wx.h>
|
||||
+#include <wx/dataview.h>
|
||||
+
|
||||
+#import <Cocoa/Cocoa.h>
|
||||
+
|
||||
+// The NSTableView (NSOutlineView) behind a wxDataViewCtrl. wx's handle is the
|
||||
+// enclosing NSScrollView.
|
||||
+static NSTableView* TableOf(wxWindow* win) {
|
||||
+ if (!win) return nil;
|
||||
+ id h = (id)win->GetHandle();
|
||||
+ if ([h isKindOfClass:[NSTableView class]]) return (NSTableView*)h;
|
||||
+ if ([h isKindOfClass:[NSScrollView class]]) {
|
||||
+ id doc = [(NSScrollView*)h documentView];
|
||||
+ if ([doc isKindOfClass:[NSTableView class]]) return (NSTableView*)doc;
|
||||
+ }
|
||||
+ return nil;
|
||||
+}
|
||||
+
|
||||
+extern "C" {
|
||||
+
|
||||
+// Native alternating-row backgrounds. AppKit paints them under every cell,
|
||||
+// custom-drawn ones included, in the theme's own colours (light and dark), so
|
||||
+// custom renderers never paint row backgrounds on macOS.
|
||||
+void wxbr_osx_set_alternating_rows(void* win, int on) {
|
||||
+ NSTableView* tv = TableOf((wxWindow*)win);
|
||||
+ if (tv) [tv setUsesAlternatingRowBackgroundColors:(on ? YES : NO)];
|
||||
+}
|
||||
+
|
||||
+// Write a PNG of a top-level window's content, rendered by the app itself
|
||||
+// (no screen-recording permission needed). Used by the self-test with
|
||||
+// ALKANE_SNAPSHOT=path to check what the table really draws. Returns 1 on
|
||||
+// success.
|
||||
+int wxbr_osx_snapshot(void* win, const char* path) {
|
||||
+ wxWindow* w = (wxWindow*)win;
|
||||
+ if (!w || !path) return 0;
|
||||
+ wxTopLevelWindow* tlw = wxDynamicCast(wxGetTopLevelParent(w), wxTopLevelWindow);
|
||||
+ if (!tlw) return 0;
|
||||
+ tlw->Show();
|
||||
+ tlw->Raise();
|
||||
+ // Let the window lay out and paint before capturing it.
|
||||
+ for (int i = 0; i < 30; ++i) {
|
||||
+ wxYield();
|
||||
+ wxMilliSleep(30);
|
||||
+ }
|
||||
+ NSWindow* nsw = (NSWindow*)tlw->GetWXWindow();
|
||||
+ NSView* view = [nsw contentView];
|
||||
+ if (!view) return 0;
|
||||
+ NSRect rect = [view bounds];
|
||||
+ NSBitmapImageRep* rep = [view bitmapImageRepForCachingDisplayInRect:rect];
|
||||
+ if (!rep) return 0;
|
||||
+ [view cacheDisplayInRect:rect toBitmapImageRep:rep];
|
||||
+ NSData* png = [rep representationUsingType:NSBitmapImageFileTypePNG properties:@{}];
|
||||
+ if (!png) return 0;
|
||||
+ return [png writeToFile:[NSString stringWithUTF8String:path] atomically:YES] ? 1 : 0;
|
||||
+}
|
||||
+
|
||||
+}
|
||||
--- a/src/widgets.rs
|
||||
+++ b/src/widgets.rs
|
||||
@@ -107,6 +107,8 @@
|
||||
pub fn wxbr_launch_browser(url: *const c_char) -> c_int;
|
||||
pub fn wxbr_set_appearance_system();
|
||||
pub fn wxbr_is_dark() -> c_int;
|
||||
+ #[cfg(target_os = "macos")]
|
||||
+ pub fn wxbr_osx_snapshot(win: *mut c_void, path: *const c_char) -> c_int;
|
||||
pub fn wxbr_system_color(which: c_int, r: *mut u8, g: *mut u8, b: *mut u8);
|
||||
pub fn wxbr_set_bg(win: *mut c_void, r: c_int, g: c_int, b: c_int);
|
||||
pub fn wxbr_set_fg(win: *mut c_void, r: c_int, g: c_int, b: c_int);
|
||||
@@ -271,6 +273,22 @@
|
||||
unsafe { notsafe::wxbr_is_dark() != 0 }
|
||||
}
|
||||
|
||||
+/// Write a PNG of `win`'s top-level window as the app itself renders it (shows
|
||||
+/// the window and lets it paint first). macOS only, for the self-test's
|
||||
+/// `ALKANE_SNAPSHOT`; returns false elsewhere or on failure.
|
||||
+pub fn snapshot_png(win: &Widget, path: &str) -> bool {
|
||||
+ #[cfg(target_os = "macos")]
|
||||
+ {
|
||||
+ let Ok(p) = CString::new(path) else { return false };
|
||||
+ unsafe { notsafe::wxbr_osx_snapshot(win.0, p.as_ptr()) != 0 }
|
||||
+ }
|
||||
+ #[cfg(not(target_os = "macos"))]
|
||||
+ {
|
||||
+ let _ = (win, path);
|
||||
+ false
|
||||
+ }
|
||||
+}
|
||||
+
|
||||
/// A theme colour. `which`: 0=window bg, 1=window text, 2=highlight,
|
||||
/// 3=button face, 4=grey text. Returns (r, g, b).
|
||||
pub fn system_color(which: i32) -> (u8, u8, u8) {
|
||||
@@ -0,0 +1,53 @@
|
||||
Subject: [PATCH 0011] Build on wxWidgets 3.2: version-guard the 3.3 appearance API and link GTK libs
|
||||
|
||||
diff -ruN a/build.rs b/build.rs
|
||||
--- a/build.rs
|
||||
+++ b/build.rs
|
||||
@@ -309,6 +309,25 @@
|
||||
for f in gtk_cflags.split_whitespace() {
|
||||
build.flag(f);
|
||||
}
|
||||
+ // ...and GTK's own shared libraries at link time. `wx-config --libs`
|
||||
+ // lists only the wx libraries, not the GTK libraries the widget bridge
|
||||
+ // calls directly (gtk_*, g_*), so without this the final link fails with
|
||||
+ // undefined GTK symbols. Best-effort: empty if pkg-config/gtk3-dev is
|
||||
+ // missing, in which case the GTK-only bridge code was also compiled out.
|
||||
+ let gtk_libs = Command::new("pkg-config")
|
||||
+ .args(["--libs", "gtk+-3.0"])
|
||||
+ .output()
|
||||
+ .ok()
|
||||
+ .filter(|o| o.status.success())
|
||||
+ .and_then(|o| String::from_utf8(o.stdout).ok())
|
||||
+ .unwrap_or_default();
|
||||
+ for f in gtk_libs.split_whitespace() {
|
||||
+ if let Some(lib) = f.strip_prefix("-l") {
|
||||
+ println!("cargo:rustc-link-lib={}", lib);
|
||||
+ } else if let Some(path) = f.strip_prefix("-L") {
|
||||
+ println!("cargo:rustc-link-search=native={}", path);
|
||||
+ }
|
||||
+ }
|
||||
}
|
||||
if is_windows() {
|
||||
// Ship one self-contained .exe: link the C++ runtime statically rather
|
||||
diff -ruN a/cpp_src/wxbridge.cpp b/cpp_src/wxbridge.cpp
|
||||
--- a/cpp_src/wxbridge.cpp
|
||||
+++ b/cpp_src/wxbridge.cpp
|
||||
@@ -375,6 +375,10 @@
|
||||
// then returns CannotChange). System follows the desktop: the GTK theme's
|
||||
// colour scheme, or the Windows 10/11 "app mode" setting, which wxMSW
|
||||
// otherwise ignores and stays light. ALKANE_APPEARANCE=light|dark forces one.
|
||||
+ // The explicit appearance API (wxApp::Appearance / SetAppearance /
|
||||
+ // MSWEnableDarkMode) only exists in wxWidgets >= 3.3. On 3.2.x the GTK/Win
|
||||
+ // system theme is still followed; we just cannot force it via ALKANE_APPEARANCE.
|
||||
+#if wxCHECK_VERSION(3, 3, 0)
|
||||
{
|
||||
wxString pref;
|
||||
wxGetEnv("ALKANE_APPEARANCE", &pref);
|
||||
@@ -394,6 +398,7 @@
|
||||
wxTheApp->SetAppearance(appearance);
|
||||
#endif
|
||||
}
|
||||
+#endif
|
||||
wxTheApp->OnInit();
|
||||
|
||||
#ifdef __WINDOWS__
|
||||
@@ -0,0 +1,17 @@
|
||||
Subject: [PATCH 0011] macOS self-test snapshot includes the window background
|
||||
|
||||
--- a/cpp_src/osx_native.mm
|
||||
+++ b/cpp_src/osx_native.mm
|
||||
@@ -46,7 +46,11 @@
|
||||
wxMilliSleep(30);
|
||||
}
|
||||
NSWindow* nsw = (NSWindow*)tlw->GetWXWindow();
|
||||
- NSView* view = [nsw contentView];
|
||||
+ // The content view's superview (the window's frame view) also draws the
|
||||
+ // window background and title bar. The content view alone leaves every
|
||||
+ // area the app's panels do not paint transparent, which read as white.
|
||||
+ NSView* view = [[nsw contentView] superview];
|
||||
+ if (!view) view = [nsw contentView];
|
||||
if (!view) return 0;
|
||||
NSRect rect = [view bounds];
|
||||
NSBitmapImageRep* rep = [view bitmapImageRepForCachingDisplayInRect:rect];
|
||||
@@ -0,0 +1,43 @@
|
||||
Subject: [PATCH 0012] linux: word-wrapping multiline text control
|
||||
|
||||
--- a/cpp_src/widgets_bridge.cpp
|
||||
+++ b/cpp_src/widgets_bridge.cpp
|
||||
@@ -890,6 +890,15 @@
|
||||
wxDefaultPosition, wxSize(-1, -1), style);
|
||||
}
|
||||
|
||||
+// A multiline text control that word-wraps at the control's width instead of
|
||||
+// scrolling horizontally (no wxTE_DONTWRAP). For prose entry such as the bug
|
||||
+// report box, where long lines should wrap rather than run off the edge.
|
||||
+void* wxbr_text_ctrl_wrap(void* parent) {
|
||||
+ return (void*)new wxTextCtrl((wxWindow*)parent, wxID_ANY, wxT(""),
|
||||
+ wxDefaultPosition, wxSize(-1, -1),
|
||||
+ wxTE_MULTILINE | wxTE_BESTWRAP);
|
||||
+}
|
||||
+
|
||||
// A single-line text control that masks its content (wxTE_PASSWORD), for secret
|
||||
// entry so a saved password is never rendered in the clear (round 18 #12).
|
||||
void* wxbr_text_ctrl_password(void* parent) {
|
||||
--- a/src/widgets.rs
|
||||
+++ b/src/widgets.rs
|
||||
@@ -41,6 +41,7 @@
|
||||
pub fn wxbr_button(parent: *mut c_void, label: *const c_char, id: c_int) -> *mut c_void;
|
||||
pub fn wxbr_bind_click(win: *mut c_void, id: c_int);
|
||||
pub fn wxbr_text_ctrl(parent: *mut c_void, multiline: c_int) -> *mut c_void;
|
||||
+ pub fn wxbr_text_ctrl_wrap(parent: *mut c_void) -> *mut c_void;
|
||||
pub fn wxbr_text_ctrl_password(parent: *mut c_void) -> *mut c_void;
|
||||
pub fn wxbr_text_ctrl_get(win: *mut c_void, buf: *mut c_char, cap: c_int) -> c_int;
|
||||
pub fn wxbr_text_ctrl_set(win: *mut c_void, value: *const c_char);
|
||||
@@ -463,6 +464,12 @@
|
||||
Widget(unsafe { notsafe::wxbr_text_ctrl(parent.0, multiline as c_int) })
|
||||
}
|
||||
|
||||
+ /// A multiline text control that word-wraps at its width (no horizontal
|
||||
+ /// scroll), for prose entry such as the bug-report box.
|
||||
+ pub fn text_ctrl_wrapped(parent: Widget) -> Widget {
|
||||
+ Widget(unsafe { notsafe::wxbr_text_ctrl_wrap(parent.0) })
|
||||
+ }
|
||||
+
|
||||
/// A single-line text control that masks its content (for password entry).
|
||||
pub fn password_ctrl(parent: Widget) -> Widget {
|
||||
Widget(unsafe { notsafe::wxbr_text_ctrl_password(parent.0) })
|
||||
@@ -0,0 +1,38 @@
|
||||
Subject: [PATCH 0013] linux: Enable/disable (grey out) a control
|
||||
|
||||
--- a/cpp_src/widgets_bridge.cpp
|
||||
+++ b/cpp_src/widgets_bridge.cpp
|
||||
@@ -945,6 +945,11 @@
|
||||
((wxCheckBox*)win)->SetValue(v != 0);
|
||||
}
|
||||
|
||||
+// Enable or disable (grey out) any window/control.
|
||||
+void wxbr_enable(void* win, int on) {
|
||||
+ ((wxWindow*)win)->Enable(on != 0);
|
||||
+}
|
||||
+
|
||||
// ---- check list box ---------------------------------------------------------
|
||||
|
||||
void* wxbr_check_list_box(void* parent) {
|
||||
--- a/src/widgets.rs
|
||||
+++ b/src/widgets.rs
|
||||
@@ -49,6 +49,7 @@
|
||||
pub fn wxbr_check_box(parent: *mut c_void, label: *const c_char) -> *mut c_void;
|
||||
pub fn wxbr_check_box_get(win: *mut c_void) -> c_int;
|
||||
pub fn wxbr_check_box_set(win: *mut c_void, v: c_int);
|
||||
+ pub fn wxbr_enable(win: *mut c_void, on: c_int);
|
||||
pub fn wxbr_check_list_box(parent: *mut c_void) -> *mut c_void;
|
||||
pub fn wxbr_clb_append(win: *mut c_void, label: *const c_char);
|
||||
pub fn wxbr_clb_clear(win: *mut c_void);
|
||||
@@ -508,6 +509,11 @@
|
||||
unsafe { notsafe::wxbr_check_box_set(self.0, v as c_int) }
|
||||
}
|
||||
|
||||
+ /// Enable or disable (grey out) this control.
|
||||
+ pub fn set_enabled(&self, on: bool) {
|
||||
+ unsafe { notsafe::wxbr_enable(self.0, on as c_int) }
|
||||
+ }
|
||||
+
|
||||
pub fn check_list_box(parent: Widget) -> Widget {
|
||||
Widget(unsafe { notsafe::wxbr_check_list_box(parent.0) })
|
||||
}
|
||||
Vendored
+3
@@ -27,6 +27,9 @@ later changes go in new patches.
|
||||
| 0006 | Build: platform from the target, not the host; Windows/GNU via `wx-config` |
|
||||
| 0007 | `wxbridge.cpp` on wxMSW: no input-swallowing overlay, appearance before the first window, work-area sizing, executable icon, UTF-8 menu fix |
|
||||
| 0008 | Widget bridge on wxMSW: generic data-view input and tooltips, DIP boundary, anti-aliased shapes, themed selection colours |
|
||||
| 0009 | macOS: wxOSX (universal static) through `wx-config`, logical sizes on Apple, clang compiler runtime for `@available` |
|
||||
| 0010 | macOS table: native alternating rows instead of the unclipped custom-cell background fill (it hid neighbouring cells' text), theme-aware text colour, `osx_native.mm`, self-test window snapshot |
|
||||
| 0011 | macOS self-test snapshot captures the window's frame view, so areas the app does not paint show the real window background instead of transparency |
|
||||
|
||||
History: the round 19 health-tooltip fix (GTK tip area converted from
|
||||
bin-window to widget coordinates) used to be a separate patch on top of an
|
||||
|
||||
+85
-7
@@ -42,12 +42,12 @@ fn is_linux() -> bool {
|
||||
target_os() == "linux"
|
||||
}
|
||||
|
||||
// alkane-toolkit patch: Linux (wxGTK) and Windows/GNU (wxMSW built with
|
||||
// mingw-w64, natively or cross from Linux) both build against a wx prefix
|
||||
// described by its wx-config script, so they share one code path. Upstream's
|
||||
// MSVC/nmake and macOS download-and-build paths are left as they were.
|
||||
// alkane-toolkit patch: Linux (wxGTK), macOS (wxOSX/Cocoa, universal static
|
||||
// build) and Windows/GNU (wxMSW built with mingw-w64, natively or cross from
|
||||
// Linux) all build against a wx prefix described by its wx-config script, so
|
||||
// they share one code path. Upstream's MSVC/nmake path is left as it was.
|
||||
fn uses_wx_config() -> bool {
|
||||
is_linux() || (is_windows() && !is_msvc())
|
||||
is_linux() || is_osx() || (is_windows() && !is_msvc())
|
||||
}
|
||||
|
||||
fn is_stub() -> bool {
|
||||
@@ -278,7 +278,20 @@ fn build_with_wx_config() -> Result<(), Box<dyn Error>> {
|
||||
build.cpp(true)
|
||||
.file("cpp_src/wxbridge.cpp")
|
||||
.file("cpp_src/widgets_bridge.cpp");
|
||||
for f in cxxflags.split_whitespace() {
|
||||
if is_osx() {
|
||||
// Cocoa calls wx does not wrap (native alternating rows, self-test
|
||||
// snapshot); clang compiles .mm as Objective-C++.
|
||||
println!("cargo:rerun-if-changed=cpp_src/osx_native.mm");
|
||||
build.file("cpp_src/osx_native.mm");
|
||||
}
|
||||
let mut flags = cxxflags.split_whitespace();
|
||||
while let Some(f) = flags.next() {
|
||||
// A universal wx prefix reports `-arch arm64 -arch x86_64`; cargo builds
|
||||
// one target at a time and cc adds that target's own -arch.
|
||||
if is_osx() && f == "-arch" {
|
||||
flags.next();
|
||||
continue;
|
||||
}
|
||||
build.flag(f);
|
||||
}
|
||||
if is_linux() {
|
||||
@@ -296,6 +309,25 @@ fn build_with_wx_config() -> Result<(), Box<dyn Error>> {
|
||||
for f in gtk_cflags.split_whitespace() {
|
||||
build.flag(f);
|
||||
}
|
||||
// ...and GTK's own shared libraries at link time. `wx-config --libs`
|
||||
// lists only the wx libraries, not the GTK libraries the widget bridge
|
||||
// calls directly (gtk_*, g_*), so without this the final link fails with
|
||||
// undefined GTK symbols. Best-effort: empty if pkg-config/gtk3-dev is
|
||||
// missing, in which case the GTK-only bridge code was also compiled out.
|
||||
let gtk_libs = Command::new("pkg-config")
|
||||
.args(["--libs", "gtk+-3.0"])
|
||||
.output()
|
||||
.ok()
|
||||
.filter(|o| o.status.success())
|
||||
.and_then(|o| String::from_utf8(o.stdout).ok())
|
||||
.unwrap_or_default();
|
||||
for f in gtk_libs.split_whitespace() {
|
||||
if let Some(lib) = f.strip_prefix("-l") {
|
||||
println!("cargo:rustc-link-lib={}", lib);
|
||||
} else if let Some(path) = f.strip_prefix("-L") {
|
||||
println!("cargo:rustc-link-search=native={}", path);
|
||||
}
|
||||
}
|
||||
}
|
||||
if is_windows() {
|
||||
// Ship one self-contained .exe: link the C++ runtime statically rather
|
||||
@@ -308,7 +340,53 @@ fn build_with_wx_config() -> Result<(), Box<dyn Error>> {
|
||||
}
|
||||
build.compile("wxbridge");
|
||||
|
||||
for flag in libs.split_whitespace() {
|
||||
if is_osx() {
|
||||
// wxOSX's Objective-C uses @available, which calls
|
||||
// ___isPlatformVersionAtLeast from clang's compiler runtime. clang
|
||||
// links that runtime itself, but rustc drives the link without it.
|
||||
let resource_dir = Command::new("clang")
|
||||
.arg("-print-resource-dir")
|
||||
.output()
|
||||
.ok()
|
||||
.filter(|o| o.status.success())
|
||||
.and_then(|o| String::from_utf8(o.stdout).ok())
|
||||
.map(|s| s.trim().to_string())
|
||||
.ok_or("wx-rs: cannot ask clang for its resource directory")?;
|
||||
let rt = Path::new(&resource_dir).join("lib").join("darwin");
|
||||
if !rt.join("libclang_rt.osx.a").exists() {
|
||||
return Err(format!("wx-rs: no libclang_rt.osx.a in {}", rt.display()).into());
|
||||
}
|
||||
println!("cargo:rustc-link-search=native={}", rt.display());
|
||||
println!("cargo:rustc-link-lib=static=clang_rt.osx");
|
||||
}
|
||||
|
||||
let mut lib_flags = libs.split_whitespace();
|
||||
while let Some(flag) = lib_flags.next() {
|
||||
if is_osx() {
|
||||
match flag {
|
||||
"-arch" => {
|
||||
lib_flags.next();
|
||||
continue;
|
||||
}
|
||||
"-framework" => {
|
||||
if let Some(name) = lib_flags.next() {
|
||||
println!("cargo:rustc-link-lib=framework={}", name);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
"-weak_framework" => {
|
||||
if let Some(name) = lib_flags.next() {
|
||||
println!("cargo:rustc-link-arg=-Wl,-weak_framework,{}", name);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
_ if flag.starts_with("-Wl,") => {
|
||||
println!("cargo:rustc-link-arg={}", flag);
|
||||
continue;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
if flag.ends_with(".a") && Path::new(flag).is_absolute() {
|
||||
// static wx builds: wx-config emits the archive as a full path
|
||||
let file = Path::new(flag).file_name().and_then(|f| f.to_str()).unwrap_or(flag);
|
||||
|
||||
@@ -0,0 +1,64 @@
|
||||
// osx_native.mm -- alkane-toolkit extension: the few wxOSX/Cocoa calls the
|
||||
// bridge needs that wx does not wrap. Compiled on macOS only (see build.rs).
|
||||
|
||||
#include <wx/wx.h>
|
||||
#include <wx/dataview.h>
|
||||
|
||||
#import <Cocoa/Cocoa.h>
|
||||
|
||||
// The NSTableView (NSOutlineView) behind a wxDataViewCtrl. wx's handle is the
|
||||
// enclosing NSScrollView.
|
||||
static NSTableView* TableOf(wxWindow* win) {
|
||||
if (!win) return nil;
|
||||
id h = (id)win->GetHandle();
|
||||
if ([h isKindOfClass:[NSTableView class]]) return (NSTableView*)h;
|
||||
if ([h isKindOfClass:[NSScrollView class]]) {
|
||||
id doc = [(NSScrollView*)h documentView];
|
||||
if ([doc isKindOfClass:[NSTableView class]]) return (NSTableView*)doc;
|
||||
}
|
||||
return nil;
|
||||
}
|
||||
|
||||
extern "C" {
|
||||
|
||||
// Native alternating-row backgrounds. AppKit paints them under every cell,
|
||||
// custom-drawn ones included, in the theme's own colours (light and dark), so
|
||||
// custom renderers never paint row backgrounds on macOS.
|
||||
void wxbr_osx_set_alternating_rows(void* win, int on) {
|
||||
NSTableView* tv = TableOf((wxWindow*)win);
|
||||
if (tv) [tv setUsesAlternatingRowBackgroundColors:(on ? YES : NO)];
|
||||
}
|
||||
|
||||
// Write a PNG of a top-level window's content, rendered by the app itself
|
||||
// (no screen-recording permission needed). Used by the self-test with
|
||||
// ALKANE_SNAPSHOT=path to check what the table really draws. Returns 1 on
|
||||
// success.
|
||||
int wxbr_osx_snapshot(void* win, const char* path) {
|
||||
wxWindow* w = (wxWindow*)win;
|
||||
if (!w || !path) return 0;
|
||||
wxTopLevelWindow* tlw = wxDynamicCast(wxGetTopLevelParent(w), wxTopLevelWindow);
|
||||
if (!tlw) return 0;
|
||||
tlw->Show();
|
||||
tlw->Raise();
|
||||
// Let the window lay out and paint before capturing it.
|
||||
for (int i = 0; i < 30; ++i) {
|
||||
wxYield();
|
||||
wxMilliSleep(30);
|
||||
}
|
||||
NSWindow* nsw = (NSWindow*)tlw->GetWXWindow();
|
||||
// The content view's superview (the window's frame view) also draws the
|
||||
// window background and title bar. The content view alone leaves every
|
||||
// area the app's panels do not paint transparent, which read as white.
|
||||
NSView* view = [[nsw contentView] superview];
|
||||
if (!view) view = [nsw contentView];
|
||||
if (!view) return 0;
|
||||
NSRect rect = [view bounds];
|
||||
NSBitmapImageRep* rep = [view bitmapImageRepForCachingDisplayInRect:rect];
|
||||
if (!rep) return 0;
|
||||
[view cacheDisplayInRect:rect toBitmapImageRep:rep];
|
||||
NSData* png = [rep representationUsingType:NSBitmapImageFileTypePNG properties:@{}];
|
||||
if (!png) return 0;
|
||||
return [png writeToFile:[NSString stringWithUTF8String:path] atomically:YES] ? 1 : 0;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -597,7 +597,11 @@ class SegmentRenderer : public wxDataViewCustomRenderer {
|
||||
} else if (GetAttr().HasBackgroundColour()) {
|
||||
cellbg = GetAttr().GetBackgroundColour();
|
||||
} else {
|
||||
#ifdef __WXOSX__
|
||||
cellbg = wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOX);
|
||||
#else
|
||||
cellbg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
|
||||
#endif
|
||||
}
|
||||
x += DrawShape(dc, shape, x, cell, seg.has_colour ? seg.colour : plain, cellbg);
|
||||
continue;
|
||||
@@ -688,6 +692,11 @@ class SegmentRenderer : public wxDataViewCustomRenderer {
|
||||
(unsigned char)(c.blue * 255.0 + 0.5));
|
||||
}
|
||||
}
|
||||
#elif defined(__WXOSX__)
|
||||
// The DC arrives with the control's foreground colour, which is not the
|
||||
// theme-aware label colour native cells use; take the list text colour so
|
||||
// uncoloured segments follow light/dark like the native columns.
|
||||
return wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOXTEXT);
|
||||
#endif
|
||||
return wxColour();
|
||||
}
|
||||
@@ -881,6 +890,15 @@ void* wxbr_text_ctrl(void* parent, int multiline) {
|
||||
wxDefaultPosition, wxSize(-1, -1), style);
|
||||
}
|
||||
|
||||
// A multiline text control that word-wraps at the control's width instead of
|
||||
// scrolling horizontally (no wxTE_DONTWRAP). For prose entry such as the bug
|
||||
// report box, where long lines should wrap rather than run off the edge.
|
||||
void* wxbr_text_ctrl_wrap(void* parent) {
|
||||
return (void*)new wxTextCtrl((wxWindow*)parent, wxID_ANY, wxT(""),
|
||||
wxDefaultPosition, wxSize(-1, -1),
|
||||
wxTE_MULTILINE | wxTE_BESTWRAP);
|
||||
}
|
||||
|
||||
// A single-line text control that masks its content (wxTE_PASSWORD), for secret
|
||||
// entry so a saved password is never rendered in the clear (round 18 #12).
|
||||
void* wxbr_text_ctrl_password(void* parent) {
|
||||
@@ -927,6 +945,11 @@ void wxbr_check_box_set(void* win, int v) {
|
||||
((wxCheckBox*)win)->SetValue(v != 0);
|
||||
}
|
||||
|
||||
// Enable or disable (grey out) any window/control.
|
||||
void wxbr_enable(void* win, int on) {
|
||||
((wxWindow*)win)->Enable(on != 0);
|
||||
}
|
||||
|
||||
// ---- check list box ---------------------------------------------------------
|
||||
|
||||
void* wxbr_check_list_box(void* parent) {
|
||||
@@ -1463,8 +1486,21 @@ void wxbr_dvlc_set_row_color(void* win, unsigned row, int r, int g, int b) {
|
||||
|
||||
// Set (or clear, when r<0) the alternating-row (zebra) background colour. The
|
||||
// app passes a theme-aware colour; odd rows get it (see AttrListStore).
|
||||
#ifdef __WXOSX__
|
||||
extern "C" void wxbr_osx_set_alternating_rows(void* win, int on);
|
||||
#endif
|
||||
void wxbr_dvlc_set_zebra(void* win, int r, int g, int b) {
|
||||
#ifdef __WXOSX__
|
||||
// wxOSX draws custom cells without clipping them to the cell, so the
|
||||
// renderer's over-sized background fill (which GTK/MSW clip) painted over
|
||||
// neighbouring cells and hid their text until a row was selected. Use the
|
||||
// table's native alternating rows instead: AppKit paints them under every
|
||||
// cell, in the theme's colours, and no row carries a background attribute.
|
||||
dvlc_store(win)->zebra = wxColour();
|
||||
wxbr_osx_set_alternating_rows(win, r >= 0 ? 1 : 0);
|
||||
#else
|
||||
dvlc_store(win)->zebra = (r < 0) ? wxColour() : wxColour(r, g, b);
|
||||
#endif
|
||||
}
|
||||
|
||||
// The model-row index of the first (top) visible row, or -1 if none. Used to
|
||||
|
||||
+12
-21
@@ -375,6 +375,10 @@ extern "C" {
|
||||
// then returns CannotChange). System follows the desktop: the GTK theme's
|
||||
// colour scheme, or the Windows 10/11 "app mode" setting, which wxMSW
|
||||
// otherwise ignores and stays light. ALKANE_APPEARANCE=light|dark forces one.
|
||||
// The explicit appearance API (wxApp::Appearance / SetAppearance /
|
||||
// MSWEnableDarkMode) only exists in wxWidgets >= 3.3. On 3.2.x the GTK/Win
|
||||
// system theme is still followed; we just cannot force it via ALKANE_APPEARANCE.
|
||||
#if wxCHECK_VERSION(3, 3, 0)
|
||||
{
|
||||
wxString pref;
|
||||
wxGetEnv("ALKANE_APPEARANCE", &pref);
|
||||
@@ -394,6 +398,7 @@ extern "C" {
|
||||
wxTheApp->SetAppearance(appearance);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
wxTheApp->OnInit();
|
||||
|
||||
#ifdef __WINDOWS__
|
||||
@@ -492,21 +497,12 @@ extern "C" {
|
||||
|
||||
// The logical window size
|
||||
Size get_client_size() {
|
||||
#ifdef __APPLE__
|
||||
int status_bar_height;
|
||||
if (wxGetApp().frame->GetStatusBar()) {
|
||||
status_bar_height = wxGetApp().frame->GetStatusBar()->GetRect().height;
|
||||
} else {
|
||||
status_bar_height = 0;
|
||||
}
|
||||
float scale_factor = wxGetApp().frame->GetDPIScaleFactor();
|
||||
wxSize s = wxGetApp().frame->GetClientSize();
|
||||
struct Size sz = {s.x * scale_factor, (s.y + status_bar_height) * scale_factor};
|
||||
return sz;
|
||||
#elif defined(__linux__)
|
||||
// alkane-toolkit patch: wxGTK3 path (upstream only knew Apple vs Windows)
|
||||
#if defined(__linux__) || defined(__APPLE__)
|
||||
// alkane-toolkit patch: wxGTK3 and wxOSX both report logical (DIP) sizes,
|
||||
// like every other bridge size. Upstream's Apple branch scaled to physical
|
||||
// pixels through a float -> int narrowing current clang rejects.
|
||||
wxSize s = wxGetApp().frame->GetClientSize();
|
||||
return Size {(unsigned int)s.x, (unsigned int)s.y};
|
||||
return Size {s.x, s.y};
|
||||
#else
|
||||
HWND hwnd = (HWND) wxGetApp().frame->GetHandle();
|
||||
RECT rect;
|
||||
@@ -559,15 +555,10 @@ extern "C" {
|
||||
}
|
||||
|
||||
Size get_mouse_position(wxMouseEvent &event) {
|
||||
#ifdef __APPLE__
|
||||
wxPoint p = event.GetPosition();
|
||||
float scale_factor = wxGetApp().frame->GetDPIScaleFactor();
|
||||
struct Size s = {p.x * scale_factor, p.y * scale_factor};
|
||||
return s;
|
||||
#else
|
||||
// alkane-toolkit patch: logical (DIP) coordinates on every platform,
|
||||
// matching get_client_size (upstream scaled them on Apple).
|
||||
wxPoint p = event.GetPosition();
|
||||
return Size {p.x, p.y};
|
||||
#endif
|
||||
}
|
||||
|
||||
int get_mouse_wheel_rotation(wxMouseEvent &event) {
|
||||
|
||||
@@ -41,6 +41,7 @@ mod notsafe {
|
||||
pub fn wxbr_button(parent: *mut c_void, label: *const c_char, id: c_int) -> *mut c_void;
|
||||
pub fn wxbr_bind_click(win: *mut c_void, id: c_int);
|
||||
pub fn wxbr_text_ctrl(parent: *mut c_void, multiline: c_int) -> *mut c_void;
|
||||
pub fn wxbr_text_ctrl_wrap(parent: *mut c_void) -> *mut c_void;
|
||||
pub fn wxbr_text_ctrl_password(parent: *mut c_void) -> *mut c_void;
|
||||
pub fn wxbr_text_ctrl_get(win: *mut c_void, buf: *mut c_char, cap: c_int) -> c_int;
|
||||
pub fn wxbr_text_ctrl_set(win: *mut c_void, value: *const c_char);
|
||||
@@ -48,6 +49,7 @@ mod notsafe {
|
||||
pub fn wxbr_check_box(parent: *mut c_void, label: *const c_char) -> *mut c_void;
|
||||
pub fn wxbr_check_box_get(win: *mut c_void) -> c_int;
|
||||
pub fn wxbr_check_box_set(win: *mut c_void, v: c_int);
|
||||
pub fn wxbr_enable(win: *mut c_void, on: c_int);
|
||||
pub fn wxbr_check_list_box(parent: *mut c_void) -> *mut c_void;
|
||||
pub fn wxbr_clb_append(win: *mut c_void, label: *const c_char);
|
||||
pub fn wxbr_clb_clear(win: *mut c_void);
|
||||
@@ -107,6 +109,8 @@ mod notsafe {
|
||||
pub fn wxbr_launch_browser(url: *const c_char) -> c_int;
|
||||
pub fn wxbr_set_appearance_system();
|
||||
pub fn wxbr_is_dark() -> c_int;
|
||||
#[cfg(target_os = "macos")]
|
||||
pub fn wxbr_osx_snapshot(win: *mut c_void, path: *const c_char) -> c_int;
|
||||
pub fn wxbr_system_color(which: c_int, r: *mut u8, g: *mut u8, b: *mut u8);
|
||||
pub fn wxbr_set_bg(win: *mut c_void, r: c_int, g: c_int, b: c_int);
|
||||
pub fn wxbr_set_fg(win: *mut c_void, r: c_int, g: c_int, b: c_int);
|
||||
@@ -271,6 +275,22 @@ pub fn is_dark() -> bool {
|
||||
unsafe { notsafe::wxbr_is_dark() != 0 }
|
||||
}
|
||||
|
||||
/// Write a PNG of `win`'s top-level window as the app itself renders it (shows
|
||||
/// the window and lets it paint first). macOS only, for the self-test's
|
||||
/// `ALKANE_SNAPSHOT`; returns false elsewhere or on failure.
|
||||
pub fn snapshot_png(win: &Widget, path: &str) -> bool {
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
let Ok(p) = CString::new(path) else { return false };
|
||||
unsafe { notsafe::wxbr_osx_snapshot(win.0, p.as_ptr()) != 0 }
|
||||
}
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
{
|
||||
let _ = (win, path);
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
/// A theme colour. `which`: 0=window bg, 1=window text, 2=highlight,
|
||||
/// 3=button face, 4=grey text. Returns (r, g, b).
|
||||
pub fn system_color(which: i32) -> (u8, u8, u8) {
|
||||
@@ -445,6 +465,12 @@ impl Widget {
|
||||
Widget(unsafe { notsafe::wxbr_text_ctrl(parent.0, multiline as c_int) })
|
||||
}
|
||||
|
||||
/// A multiline text control that word-wraps at its width (no horizontal
|
||||
/// scroll), for prose entry such as the bug-report box.
|
||||
pub fn text_ctrl_wrapped(parent: Widget) -> Widget {
|
||||
Widget(unsafe { notsafe::wxbr_text_ctrl_wrap(parent.0) })
|
||||
}
|
||||
|
||||
/// A single-line text control that masks its content (for password entry).
|
||||
pub fn password_ctrl(parent: Widget) -> Widget {
|
||||
Widget(unsafe { notsafe::wxbr_text_ctrl_password(parent.0) })
|
||||
@@ -483,6 +509,11 @@ impl Widget {
|
||||
unsafe { notsafe::wxbr_check_box_set(self.0, v as c_int) }
|
||||
}
|
||||
|
||||
/// Enable or disable (grey out) this control.
|
||||
pub fn set_enabled(&self, on: bool) {
|
||||
unsafe { notsafe::wxbr_enable(self.0, on as c_int) }
|
||||
}
|
||||
|
||||
pub fn check_list_box(parent: Widget) -> Widget {
|
||||
Widget(unsafe { notsafe::wxbr_check_list_box(parent.0) })
|
||||
}
|
||||
|
||||
@@ -0,0 +1,7 @@
|
||||
# Report relay for the Alkane Toolkit's Bug report button (see README.md).
|
||||
FROM python:3.13-alpine
|
||||
RUN adduser -D -H -u 10001 relay
|
||||
COPY relay.py /app/relay.py
|
||||
USER relay
|
||||
EXPOSE 8080
|
||||
ENTRYPOINT ["python3", "-u", "/app/relay.py"]
|
||||
@@ -0,0 +1,65 @@
|
||||
# Report relay
|
||||
|
||||
Files the app's bug reports and feature requests as issues in
|
||||
`blueflare/alkane-toolkit`. The app's **Bug report** button posts the report
|
||||
here; the relay holds the only token, so the public app download carries no
|
||||
secret.
|
||||
|
||||
```
|
||||
app --HTTPS--> gitea.bluefla.re/alkane-report/ (nginx) --> relay --> Gitea API
|
||||
```
|
||||
|
||||
## What it does
|
||||
|
||||
- `POST /v1/report` takes the JSON the app sends (`kind`, `text`, version and
|
||||
OS context, optional `log`) and answers `201 {"number", "url"}` or an error
|
||||
`{"error": "..."}` the app shows as is. `GET /healthz` answers `200`.
|
||||
- Checks: type is `bug`, `ui` or `feature`; text 1 to 8,000 characters;
|
||||
each context value at most 120 printable characters; log at most 16 KiB;
|
||||
body at most 64 KiB (nginx enforces the same).
|
||||
- Rate limits, in memory: 5 reports per client IP per hour and 60 in all.
|
||||
Over the limit: `429` with `Retry-After`. At most 4 reports in flight.
|
||||
The client IP is `X-Real-IP` from nginx. Office LAN clients reach nginx
|
||||
through the router's hairpin NAT, so they share one IP and one limit.
|
||||
- Scrubs the log a second time (the app scrubs first): password, token,
|
||||
secret and similar values, `Authorization`/`Cookie` values, URL passwords
|
||||
and PEM private keys become `[redacted]`.
|
||||
- `@name` in a report cannot notify anyone (a zero-width space follows `@`).
|
||||
- The issue title is the text's first line (up to 100 characters). The body
|
||||
has the type, a context table, the text, and the log in a collapsed block.
|
||||
Labels: the type (`bug`, `ui`, `feature`) and `from-app`.
|
||||
- Nothing is stored. Each report leaves one log line: the client IP and the
|
||||
outcome (`filed #N`, `refused <status>`, `rate limited`, `tracker error`),
|
||||
never the report's text.
|
||||
|
||||
## Gitea account
|
||||
|
||||
Issues are filed as `alkane-reporter`, a local non-admin user with a random
|
||||
password that is never used. Its only access is the org team
|
||||
`alkane-reporters` (units `repo.code: read`, `repo.issues: write`) on
|
||||
`alkane-toolkit`. Its token `alkane-toolkit-bug-reports` has the scopes
|
||||
`write:issue` and `read:repository`. This mirrors FLARE's `flare-reporter`.
|
||||
|
||||
## Deployment
|
||||
|
||||
On the Gitea host, recorded in the `flare-deployment` repository
|
||||
(`runbooks/alkane-report-relay.md`):
|
||||
|
||||
```sh
|
||||
# in /opt/flare/deploy/alkane-report-relay, holding relay.py, Dockerfile, compose.yml
|
||||
PROXY_NETWORK=flare_default docker compose -p alkane-report-relay up -d --build
|
||||
```
|
||||
|
||||
The token file is `secrets/gitea_token` next to the compose file (directory
|
||||
`0700`, never committed). nginx routes `location /alkane-report/` in the
|
||||
`gitea.bluefla.re` server block to `alkane-report-relay:8080`.
|
||||
|
||||
## Tests
|
||||
|
||||
```sh
|
||||
python3 tools/report-relay/test_relay.py
|
||||
```
|
||||
|
||||
They run the real HTTP handler against a fake Gitea: filing, scrubbing,
|
||||
mention handling, validation, size and rate limits, and tracker errors. CI
|
||||
runs them in the `verify` workflow's unit tests.
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user