bsncubed/ipswap
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Scaffold ipswap: tray-driven Windows IP preset switcher

Browse Source 
Implements the design in claude.md as a building skeleton: pure Go, no cgo,
cross-compiles to a single Windows .exe from Linux.

Architecture follows the spec's deliberate split. The fast path is native —
tray icon, grouped submenus, a Win32 MessageBox showing a live before/after
diff, then netsh. The slow path is an embedded web editor served on a random
loopback port and opened in the default browser.

Two decisions worth recording:

Reads use GetAdaptersAddresses, writes use netsh. The spec left the
enumeration mechanism open; parsing `netsh show config` breaks on a
non-English Windows because the output is localised. DNS static-vs-DHCP
origin is not exposed by that API, so it comes from one registry read.

The netsh command plan is built in portable code. That puts the delete-every-
existing-address step — the one that stops secondary addresses leaking across
switches — under test without needing a Windows box.

The editor requires the session token in a header for mutations, not just the
cookie: any page in the browser can make it POST to 127.0.0.1 with the cookie
attached, but it cannot set a header. The updater refuses to install a release
that publishes no SHA256.

Not yet done: no group picker for export (the API supports it), no
single-instance guard, and internal/server/web/app.css is reconstructed from
the description in claude.md rather than the canonical apointless.css.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Ben Nicholson
2026-08-20 13:29:35 +10:00
commit 23dcfb393f
46 changed files with 5782 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitea/workflows/release.yml
+61
View File
@@ -0,0 +1,61 @@
# Builds ipswap.exe on every tag and attaches it, with its checksum, to the
# Gitea release.
#
# There is no Wine step and no mingw step: ipswap is pure Go with no cgo, so a
# Linux runner cross-compiles the Windows binary directly. That constraint is
# why the tray is fyne.io/systray and the dialogs are raw user32 calls — keep
# it that way and this file stays this short.
#
# The SHA256SUMS artifact is not decoration. The in-app updater refuses to
# install a release that publishes no checksum, so a release built without this
# step cannot be auto-updated to.
name: release
on:
push:
tags:
- "v*"
jobs:
build:
runs-on: ubuntu-latest
steps:
- name: Check out
uses: actions/checkout@v4
- name: Set up Go
uses: actions/setup-go@v5
with:
go-version: "1.26"
cache: true
- name: Derive version from the tag
id: version
run: echo "version=${GITEA_REF_NAME#v}" >> "$GITHUB_OUTPUT"
env:
GITEA_REF_NAME: ${{ gitea.ref_name }}
- name: Test
run: go test ./...
- name: Vet both targets
run: |
go vet ./...
GOOS=windows GOARCH=amd64 go vet ./...
- name: Build
run: make dist VERSION=${{ steps.version.outputs.version }}
- name: Publish the release
uses: akkuman/gitea-release-action@v1
with:
token: ${{ secrets.GITEA_TOKEN }}
files: |
dist/ipswap.exe
dist/SHA256SUMS
body: |
ipswap v${{ steps.version.outputs.version }}
SHA256 of `ipswap.exe` is published in the `SHA256SUMS` asset;
the in-app updater verifies against it before installing.
.gitignore
+6
View File
@@ -0,0 +1,6 @@
bin/
dist/
Output/
*.exe
*.syso
SHA256SUMS
Makefile
+67
View File
@@ -0,0 +1,67 @@
VERSION ?= 0.1.0
# -H windowsgui suppresses the console window that would otherwise sit behind
# the tray icon. -s -w strips the symbol table and DWARF; nothing here needs a
# Go stack trace off a customer's laptop, and it roughly halves the binary.
LDFLAGS := -s -w -H windowsgui -X main.version=$(VERSION)
# Go is installed at ~/.local/go on this box and deliberately kept off PATH, so
# prefer that toolchain and fall back to whatever `go` is in PATH elsewhere.
GO ?= $(shell test -x $(HOME)/.local/go/bin/go && echo $(HOME)/.local/go/bin/go || echo go)
# Pinned and run through `go run` so CI needs no separate install step.
GOVERSIONINFO ?= $(GO) run github.com/josephspurrier/goversioninfo/cmd/goversioninfo@v1.4.1
SYSO := cmd/ipswap/resource_windows.syso
.PHONY: build syso test vet check dist sums clean help
help: ## List targets
@grep -hE '^[a-zA-Z_-]+:.*?## ' $(MAKEFILE_LIST) | awk 'BEGIN{FS=":.*?## "}{printf " %-14s %s\n", $$1, $$2}'
# ipswap is pure Go with no cgo anywhere, which is the whole reason the tray is
# fyne.io/systray and the dialogs are raw user32 rather than a GUI toolkit:
# `GOOS=windows go build` cross-compiles straight from Linux, no Wine, no
# mingw, no fyne-cross.
build: syso ## Cross-compile bin/ipswap.exe from any host
@mkdir -p bin
GOOS=windows GOARCH=amd64 $(GO) build -trimpath -ldflags "$(LDFLAGS)" -o bin/ipswap.exe ./cmd/ipswap
# The .syso carries the icon, the version resource and — the part that matters
# — the manifest that asks for asInvoker and per-monitor DPI. A plain `go
# build` with no .syso produces a binary with the generic executable icon and
# the default (unaware, asInvoker-by-omission) manifest.
#
# -64 is not optional: goversioninfo emits a 386 object by default, and linking
# that into an amd64 build fails with "unknown relocation type 7".
syso: ## Generate the Windows resource object
cd cmd/ipswap && $(GOVERSIONINFO) \
-64 \
-o resource_windows.syso \
-platform-specific=false \
versioninfo.json
test: ## Run tests
$(GO) test ./...
vet: ## Run go vet for both targets
$(GO) vet ./...
GOOS=windows GOARCH=amd64 $(GO) vet ./...
# The Windows-only files (netsh, user32, the registry) are the bulk of the
# risk, and a Linux `go build` never looks at them. This is the cheap way to
# keep them compiling.
check: test vet ## Typecheck both targets and run tests
GOOS=windows GOARCH=amd64 $(GO) build ./...
dist: build sums ## Build the release artifacts into dist/
@echo "dist/ contains:" && ls -1 dist
sums: ## Write dist/SHA256SUMS for the built binary
@mkdir -p dist
@cp bin/ipswap.exe dist/ipswap.exe
cd dist && sha256sum ipswap.exe > SHA256SUMS
@cat dist/SHA256SUMS
clean: ## Remove build artifacts
rm -rf bin dist $(SYSO)
README.md
+125
View File
@@ -0,0 +1,125 @@
# ipswap
A tray-resident Windows utility for switching a network adapter between saved
static-IP configurations. Built for field and support work, where a laptop hops
between customer subnets — broadcast control networks, media networks,
management VLANs — many times a day.
Switching a preset is two clicks and no browser. Editing fifty presets happens
in a real UI. Those are different problems, so they use different interfaces.
## How it works
**Fast path (native, no browser).** The tray icon holds a menu of presets
grouped into submenus. Clicking one reads the adapter's live configuration,
shows a Win32 message box with a before/after diff, and on Yes runs the netsh
sequence. The tray tooltip then names the preset that is actually applied.
**Slow path (browser).** "Manage presets…" starts a local HTTP server on a
random loopback port and opens your default browser to it. Full CRUD, adapter
picker, import/export, settings. The server shuts itself down five minutes
after the browser stops sending heartbeats, and on exit.
## Building
Pure Go, no cgo anywhere, so a Linux or macOS host cross-compiles the Windows
binary directly — no Wine, no mingw, no fyne-cross.
```
make build # -> bin/ipswap.exe
make check # tests + vet + typecheck for both targets
make dist # bin/ipswap.exe plus dist/SHA256SUMS
```
`make build` regenerates `cmd/ipswap/resource_windows.syso` first. That object
carries the icon, the version resource and the manifest — the manifest is the
part that matters, because it is what asks for `asInvoker` and per-monitor DPI.
`GOOS=windows go vet ./...` is worth running on its own during development: the
Windows-only files (netsh, user32, the registry) are most of the risk and a
plain Linux build never looks at them. `make vet` does both targets.
## Layout
```
cmd/ipswap/ entrypoint, manifest, version resource
internal/preset/ data model, store, prefix parsing, import/export
internal/netcfg/ adapter reads (Win32) and the netsh command plan
internal/tray/ tray menu, confirm-then-apply, icon
internal/server/ the local editor server and its embedded web app
internal/updater/ Gitea release check, download, verify, swap
internal/dialog/ Win32 MessageBoxW wrappers
internal/elevate/ token elevation check, relaunch via ShellExecuteW runas
internal/desktop/ open-in-browser, HKCU Run key
internal/config/ paths and settings
internal/applog/ rotating log
```
Two rules shape the split. Anything portable lives in portable code and is
tested on any host — most usefully `netcfg.Plan`, which builds the exact netsh
sequence and is covered without a Windows box. Anything Windows-specific has a
`_windows.go` and an `_other.go`, so the whole tree stays buildable and
vettable during development on Linux.
## Elevation
The manifest asks for `asInvoker`, not `requireAdministrator`. On a machine
with UAC relaxed, or when the parent process is already elevated, that means
zero prompts — including at login, if start-with-Windows is on.
Membership of the Administrators group is not the same as holding an elevated
token: with UAC on, a member's process gets a filtered token and `netsh
interface ipv4 set address` fails with "The requested operation requires
elevation." So ipswap checks the token at startup, and if it is not elevated it
adds a "Relaunch as administrator" item to the tray. A failed apply offers the
same thing. Nothing blocks startup either way.
## Data
```
%APPDATA%\ipswap\presets.json presets
%APPDATA%\ipswap\config.json settings
%APPDATA%\ipswap\ipswap.log rotating, 5 × 1 MB
```
`presets.json` is the export format too, so a preset pack is just this file and
stays hand-editable. See `examples/preset-pack.json`.
Masks are stored as an integer prefix. Both `/24` and `255.255.255.0` are
accepted on input, in the editor and in a hand-written file; the display style
is a single global setting.
## Why applies are destructive
After an apply, the adapter has exactly the addresses in the preset and nothing
else.
`netsh interface ipv4 set address … static` replaces the primary address but
leaves previously-added secondary addresses attached. A naive implementation
therefore leaks addresses across switches — after visiting three presets the
adapter is still carrying secondaries from the first two. So every apply
enumerates the live addresses, deletes each one, then sets the primary and adds
the preset's secondaries. `internal/netcfg/plan_test.go` pins that ordering.
Reads use `GetAdaptersAddresses`, not `netsh show config`: netsh's output is
localised and parsing it breaks on a non-English Windows.
## Updates
Set an update repository in Settings (`https://host/owner/repo`) and ipswap
checks its Gitea releases API at startup, in a goroutine, behind a short
timeout, failing silently to the log — a laptop on a customer site usually
cannot reach the host, and that is not an error worth showing.
A newer tag adds "Update available — vX.Y.Z" to the top of the tray menu.
Clicking it downloads the `.exe`, verifies its SHA256 against the release, and
hands off to a small batch helper that waits for ipswap to exit, swaps the
binary and relaunches. **A release that publishes no checksum is refused** — an
unverified binary that is about to be run is not worth the convenience. It
never installs on its own.
## Not in v1
Revert / restore-previous / timed auto-revert; post-apply connectivity checks
(the confirmation diff is the check); global hotkeys; IPv6; adapter matching by
MAC address; per-preset scripts.
claude.md
+252
View File
@@ -0,0 +1,252 @@
# ipswap — Windows IP preset switcher
## Purpose
A tray-resident Windows utility for rapidly switching a network adapter between saved
static-IP configurations. Built for field/support work where a laptop needs to hop
between customer subnets (broadcast control networks, media networks, management VLANs)
many times a day.
Working name `ipswap` — rename freely.
## Stack
- **Go**, single static `.exe`, no runtime dependency, no CGO.
- **Tray**: `fyne.io/systray` (pure-Go on Windows — keeps `GOOS=windows go build` cross-compiling from Linux CI without Wine).
- **Fast-path dialogs**: native Win32 `MessageBoxW` via `syscall.NewLazyDLL("user32.dll")`. No GUI toolkit.
- **Editor UI**: embedded static web app (`embed.FS`) served on `127.0.0.1:<random port>`, opened in the default browser.
- **No CGO anywhere.** If a dependency needs it, pick another dependency.
## Architecture
Two interaction paths, deliberately split:
**Fast path (native, no browser)**
Tray icon → menu of presets, grouped into submenus → click → confirmation MessageBox
showing a before/after diff → Yes → apply → tray tooltip updates to the active preset name.
**Slow path (browser)**
Tray → "Manage presets…" → spawns local HTTP server, opens default browser to
`http://127.0.0.1:<port>/?t=<session-token>`. Full CRUD on presets, adapter picker,
import/export, settings. Server shuts down when the browser session goes idle (no
heartbeat for 5 min) or on app exit.
Rationale: switching must be two clicks and zero browser. Editing 50 presets in a
MessageBox would be miserable.
### Web UI styling
Use the **apointless.css** design system: dark-first, JetBrains Mono + DM Sans, blue
accent `#3b82f6`, bg `#0b0d11`, surfaces `#12151b`/`#1a1e28`/`#232838`, subtle blue grid
via `body::before`, semantic colour tokens, light mode via `html.light` class +
localStorage. Use its existing components (cards, stat cards, badges, pills, buttons,
inputs, tables, alerts, code blocks, spinners) rather than inventing new ones.
## Data model
Stored at `%APPDATA%\ipswap\presets.json`. Settings at `%APPDATA%\ipswap\config.json`.
Log at `%APPDATA%\ipswap\ipswap.log` (rotating, keep last 5 × 1 MB).
```json
{
"version": 1,
"presets": [
{
"id": "01J8X...",
"name": "Artist frame — control",
"group": "Riedel",
"adapter": "Ethernet",
"mode": "static",
"primary": {
"address": "192.168.42.100",
"prefix": 24,
"gateway": "192.168.42.1",
"gateway_metric": 0
},
"secondary": [
{ "address": "10.0.10.50", "prefix": 24 }
],
"dns": {
"mode": "static",
"servers": ["192.168.42.1", "1.1.1.1"]
},
"notes": "Frame A, rack 3"
},
{
"id": "01J8Y...",
"name": "DHCP",
"group": "General",
"adapter": "Ethernet",
"mode": "dhcp",
"dns": { "mode": "dhcp" }
}
]
}
```
Notes:
- `adapter` is the Windows friendly name (`Ethernet`, `Wi-Fi`, `Ethernet 3`). Bound per
preset and editable in the preset editor. `net.Interfaces()` on Windows returns these
names and they match what `netsh` expects.
- Subnet mask stored internally as an integer prefix. The editor must **accept both**
`/24` and `255.255.255.0` on input and display whichever the user last used
(per-preset display preference is overkill — a single global setting is fine).
- `gateway` optional. `gateway_metric` 0 = automatic.
- Wi-Fi adapters are supported and treated identically. No special-casing.
## Applying a preset
Applies are **destructive**: after apply, the adapter has exactly the addresses in the
preset and nothing else.
`netsh interface ipv4 set address … static` replaces the primary but leaves previously
added secondary addresses in place, so a naive implementation leaks addresses across
switches. Sequence:
1. Enumerate current IPv4 addresses on the target adapter.
2. `netsh interface ipv4 delete address name="<adapter>" addr=<each existing>` for every
existing static address.
3. Set the primary:
`netsh interface ipv4 set address name="<adapter>" static <addr> <mask> <gateway> <gwmetric>`
4. Add each secondary:
`netsh interface ipv4 add address name="<adapter>" <addr> <mask>`
5. DNS static:
`netsh interface ipv4 set dnsservers name="<adapter>" static <first> primary validate=no`
then for each subsequent, `netsh interface ipv4 add dnsservers name="<adapter>" <addr> index=<n>`
6. DNS DHCP: `netsh interface ipv4 set dnsservers name="<adapter>" source=dhcp`
For `mode: "dhcp"`:
`netsh interface ipv4 set address name="<adapter>" source=dhcp`
(this also clears statics, so step 2 can be skipped).
Fallback if step 2 proves unreliable: set the adapter to DHCP first to flush statics,
then immediately apply the static config. Costs ~1s and a brief DHCP solicit — use only
if needed.
Run every `netsh` invocation **off the UI goroutine**. Applies take 1–3 s. Capture
stdout/stderr and exit code, log all of it, surface failures in a MessageBox with the
raw netsh output included.
### Confirmation prompt
Before applying, show a Win32 MessageBox (`MB_YESNO | MB_ICONQUESTION`) containing:
```
Apply preset "Artist frame — control" to adapter "Ethernet"?
CURRENT
192.168.1.87/24 (DHCP)
Gateway: 192.168.1.1
DNS: 192.168.1.1
NEW
192.168.42.100/24
+ 10.0.10.50/24
Gateway: 192.168.42.1
DNS: 192.168.42.1, 1.1.1.1
```
Read the current config live at prompt time, not from cache. A "don't ask again for this
session" checkbox is out of scope — the prompt is the safety net.
### Active preset detection
On startup, after any apply, and every 30 s, read each adapter's live config and mark any
preset that matches exactly. Show a check/radio mark next to it in the tray menu and set
the tray tooltip to `ipswap — <preset name>` (or `ipswap — unmatched`).
## Elevation
Manifest as `asInvoker`, **not** `requireAdministrator`. On a machine with UAC relaxed or
an already-elevated parent, this means zero prompts.
At startup, check whether the process token is actually elevated
(`windows.Token.IsElevated()` or `GetTokenInformation`/`TokenElevation`). If it is not:
- Do not fail, do not block startup.
- Add a tray menu item "Relaunch as administrator" that re-execs via `ShellExecuteW` with
the `runas` verb.
- If an apply fails with an elevation error, the failure MessageBox offers the same
relaunch action.
Being in the Administrators group is not the same as holding an elevated token — with UAC
on, the process gets a filtered token and `netsh set address` returns "The requested
operation requires elevation." This design costs nothing on a permissive machine and
degrades cleanly on a locked-down one.
## Tray menu layout
```
ipswap — Artist frame — control
─────────────────────────────
Riedel ▸ [submenu of presets in this group]
Herespace ▸
General ▸
─────────────────────────────
Manage presets…
Check for updates
─────────────────────────────
Relaunch as administrator [only shown if not elevated]
Exit
```
Presets with no `group` go into a top-level "Ungrouped" submenu. Design for ~50 presets:
submenus are mandatory, a flat list is not acceptable. No global hotkeys.
## Import / export
- Export: write the full `presets.json`, or a filtered subset by group, to a user-chosen
path. Include `version`.
- Import: merge or replace, user's choice. On merge, collide on `id` → keep both, suffix
the incoming name with `(imported)`. Validate the schema and reject with a clear error
rather than partially importing.
This is the mechanism for shipping preset packs to colleagues, so keep the file format
clean and hand-editable.
## Update checker
Gitea-hosted, same pattern as ShippingTracker.
- On startup (and on demand from the tray), GET
`https://<gitea-host>/api/v1/repos/<owner>/<repo>/releases/latest`.
- Compare the release tag against the compiled-in version using semver.
- If newer: tray menu gains "Update available — v1.2.0" as the top item.
- On click: download the `.exe` asset to `%TEMP%`, verify the SHA256 against a checksum
published in the release body or as a sibling asset, then write a small batch/helper
that waits for the parent to exit, swaps the binary, and relaunches.
- Never auto-install. Never block startup on the network call — run it in a goroutine
with a short timeout and fail silently to the log.
## Build & CI
- `GOOS=windows GOARCH=amd64 go build -ldflags="-H windowsgui -X main.version=$VERSION"`.
`-H windowsgui` suppresses the console window.
- Embed an icon and a manifest (`asInvoker`, `dpiAware`) — `goversioninfo` or a `.syso`.
- Gitea Actions: build on tag, attach the `.exe` and a `SHA256SUMS` file to the release.
Pure Go means no Wine step is needed.
## Out of scope for v1
- Revert / restore-previous / timed auto-revert.
- Post-apply connectivity verification (ping/ARP). The confirmation diff is the check.
- Global hotkeys.
- IPv6.
- Adapter matching by MAC address (name only for now — worth revisiting if dock/USB-NIC
name drift becomes a problem).
- Per-preset scripts or hooks.
## Open questions for Ben
1. Gitea host/owner/repo for the update endpoint.
2. Whether the app should start with Windows (registry `Run` key, toggleable in settings)
— assumed **yes, off by default**.
3. Confirm the split UI (native tray + browser editor) is right. You picked "menu only"
for hotkeys but also wanted a confirmation prompt and 50 presets — those pull toward
needing a real editor window, hence the browser. Say if you'd rather have a native
window instead.
# Side note
Claude will be running in a tmux session
cmd/ipswap/fatal_other.go
+13
View File
@@ -0,0 +1,13 @@
//go:build !windows
package main
import (
"fmt"
"os"
)
// showFatal prints, since a development build on Linux has a console.
func showFatal(msg string) {
fmt.Fprintln(os.Stderr, msg)
}
cmd/ipswap/fatal_windows.go
+11
View File
@@ -0,0 +1,11 @@
//go:build windows
package main
import "gitea.apointless.space/bsncubed/ipswap/internal/dialog"
// showFatal puts a startup failure on screen. Without this the binary would
// simply not appear: -H windowsgui means there is no console to print to.
func showFatal(msg string) {
dialog.Error("ipswap", msg)
}
cmd/ipswap/ipswap.manifest
+58
View File
@@ -0,0 +1,58 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
<assemblyIdentity
type="win32"
name="space.apointless.ipswap"
version="1.0.0.0"
processorArchitecture="*"/>
<!--
asInvoker, NOT requireAdministrator.
requireAdministrator would put a UAC prompt in front of every launch,
including the ones that start with Windows. asInvoker means zero prompts on
a machine with UAC relaxed or an already-elevated parent, and on a
locked-down machine ipswap still starts — it just offers "Relaunch as
administrator" in the tray and when an apply is refused.
-->
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
<security>
<requestedPrivileges>
<requestedExecutionLevel level="asInvoker" uiAccess="false"/>
</requestedPrivileges>
</security>
</trustInfo>
<!-- Per-monitor v2 so the confirmation MessageBox is not blurry on a scaled
laptop panel driving an unscaled external monitor. -->
<application xmlns="urn:schemas-microsoft-com:asm.v3">
<windowsSettings>
<dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true/pm</dpiAware>
<dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2, PerMonitor</dpiAwareness>
<activeCodePage xmlns="http://schemas.microsoft.com/SMI/2019/WindowsSettings">UTF-8</activeCodePage>
</windowsSettings>
</application>
<!-- Common Controls v6, so the message boxes use the modern theme. -->
<dependency>
<dependentAssembly>
<assemblyIdentity
type="win32"
name="Microsoft.Windows.Common-Controls"
version="6.0.0.0"
processorArchitecture="*"
publicKeyToken="6595b64144ccf1df"
language="*"/>
</dependentAssembly>
</dependency>
<!-- Declare support through Windows 11 so version APIs do not lie to us. -->
<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
<application>
<supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/> <!-- 10 / 11 -->
<supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/> <!-- 8.1 -->
<supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/> <!-- 8 -->
<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/> <!-- 7 -->
</application>
</compatibility>
</assembly>
cmd/ipswap/main.go
+96
View File
@@ -0,0 +1,96 @@
// Command ipswap is a tray-resident switcher for saved static-IP presets.
//
// Build for Windows with:
//
// GOOS=windows GOARCH=amd64 go build -ldflags "-H windowsgui -X main.version=1.0.0" ./cmd/ipswap
//
// -H windowsgui is what stops a console window appearing behind the tray icon.
package main
import (
"flag"
"fmt"
"log"
"os"
"runtime"
"gitea.apointless.space/bsncubed/ipswap/internal/applog"
"gitea.apointless.space/bsncubed/ipswap/internal/config"
"gitea.apointless.space/bsncubed/ipswap/internal/desktop"
"gitea.apointless.space/bsncubed/ipswap/internal/elevate"
"gitea.apointless.space/bsncubed/ipswap/internal/netcfg"
"gitea.apointless.space/bsncubed/ipswap/internal/preset"
"gitea.apointless.space/bsncubed/ipswap/internal/server"
"gitea.apointless.space/bsncubed/ipswap/internal/tray"
)
// version is set at link time with -X main.version=...
var version = "dev"
func main() {
showVersion := flag.Bool("version", false, "print the version and exit")
flag.Parse()
if *showVersion {
fmt.Printf("%s %s\n", config.AppName, version)
return
}
if err := run(); err != nil {
// With -H windowsgui there is no stderr to read, so anything fatal has
// to be shown rather than printed.
fatal(err)
}
}
func run() error {
paths, err := config.ResolvePaths()
if err != nil {
return err
}
// The log is the only diagnostic available on a customer site, so it is
// set up before anything that could fail interestingly.
logw, err := applog.Setup(paths.Log, runtime.GOOS != "windows")
if err != nil {
return err
}
defer logw.Close()
log.Printf("--- %s %s starting (elevated=%v) ---", config.AppName, version, elevate.IsElevated())
settings, err := config.Load(paths.Config)
if err != nil {
// Settings are conveniences; a broken config.json must not stop the
// app from starting with defaults.
log.Printf("using default settings: %v", err)
}
store, err := preset.NewStore(paths.Presets)
if err != nil {
return fmt.Errorf("loading presets: %w", err)
}
log.Printf("loaded %d preset(s) from %s", len(store.All()), paths.Presets)
// Keep the Run key in step with the setting: the user may have removed the
// entry by other means, or copied config.json onto a new machine.
if desktop.RunAtLogin() != settings.StartWithWindows {
if err := desktop.SetRunAtLogin(settings.StartWithWindows); err != nil {
log.Printf("could not update the start-with-Windows entry: %v", err)
}
}
mgr := netcfg.New()
srv := server.New(store, mgr, paths, settings)
app := tray.New(store, mgr, srv, paths, settings, version)
// systray.Run takes over this goroutine and does not return until Exit.
app.Run()
return nil
}
func fatal(err error) {
log.Printf("fatal: %v", err)
showFatal(fmt.Sprintf("%s could not start.\n\n%v", config.AppName, err))
os.Exit(1)
}
cmd/ipswap/versioninfo.json
+25
View File
@@ -0,0 +1,25 @@
{
"FixedFileInfo": {
"FileVersion": { "Major": 0, "Minor": 1, "Patch": 0, "Build": 0 },
"ProductVersion": { "Major": 0, "Minor": 1, "Patch": 0, "Build": 0 },
"FileFlagsMask": "3f",
"FileFlags": "00",
"FileOS": "040004",
"FileType": "01",
"FileSubType": "00"
},
"StringFileInfo": {
"CompanyName": "apointless.space",
"FileDescription": "ipswap — network preset switcher",
"InternalName": "ipswap",
"LegalCopyright": "",
"OriginalFilename": "ipswap.exe",
"ProductName": "ipswap",
"ProductVersion": "0.1.0"
},
"VarFileInfo": {
"Translation": { "LangID": "0409", "CharsetID": "04B0" }
},
"IconPath": "../../internal/tray/icon.ico",
"ManifestPath": "ipswap.manifest"
}
examples/preset-pack.json
+72
View File
@@ -0,0 +1,72 @@
{
"version": 1,
"presets": [
{
"id": "0198f2a1c4d07f3b2e5a9c81",
"name": "Artist frame — control",
"group": "Riedel",
"adapter": "Ethernet",
"mode": "static",
"primary": {
"address": "192.168.42.100",
"prefix": 24,
"gateway": "192.168.42.1"
},
"secondary": [
{ "address": "10.0.10.50", "prefix": 24 }
],
"dns": {
"mode": "static",
"servers": ["192.168.42.1", "1.1.1.1"]
},
"notes": "Frame A, rack 3"
},
{
"id": "0198f2a1c4d17a9e4b02d135",
"name": "Artist frame — media",
"group": "Riedel",
"adapter": "Ethernet",
"mode": "static",
"primary": {
"address": "10.20.0.100",
"prefix": 16
},
"dns": { "mode": "dhcp" },
"notes": "No gateway: media VLAN is deliberately non-routed"
},
{
"id": "0198f2a1c4d2b60c7f318ea4",
"name": "Management VLAN",
"group": "Herespace",
"adapter": "Ethernet",
"mode": "static",
"primary": {
"address": "172.16.5.200",
"prefix": 24,
"gateway": "172.16.5.1",
"gateway_metric": 10
},
"dns": {
"mode": "static",
"servers": ["172.16.5.10"]
}
},
{
"id": "0198f2a1c4d3e8175c60ba92",
"name": "DHCP",
"group": "General",
"adapter": "Ethernet",
"mode": "dhcp",
"dns": { "mode": "dhcp" }
},
{
"id": "0198f2a1c4d4fa38096c2d7e",
"name": "Wi-Fi — DHCP",
"group": "General",
"adapter": "Wi-Fi",
"mode": "dhcp",
"dns": { "mode": "dhcp" },
"notes": "Wi-Fi adapters are treated identically to wired ones"
}
]
}
go.mod
+10
View File
@@ -0,0 +1,10 @@
module gitea.apointless.space/bsncubed/ipswap
go 1.26.5
require (
fyne.io/systray v1.12.2
golang.org/x/sys v0.31.0
)
require github.com/godbus/dbus/v5 v5.1.0 // indirect
go.sum
+6
View File
@@ -0,0 +1,6 @@
fyne.io/systray v1.12.2 h1:Y8DZxgLHsVQt6rY9Zrkkg+j67S7vv/1F2viOWKPpVeA=
fyne.io/systray v1.12.2/go.mod h1:RVwqP9nYMo7h5zViCBHri2FgjXF7H2cub7MAq4NSoLs=
github.com/godbus/dbus/v5 v5.1.0 h1:4KLkAxT3aOY8Li4FRJe/KvhoNFFxo0m6fNuFUO8QJUk=
github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
internal/applog/applog.go
+131
View File
@@ -0,0 +1,131 @@
// Package applog gives ipswap a rotating log file. Every netsh invocation and
// its raw output lands here, which is the only forensic trail available when a
// switch misbehaves on a customer site.
package applog
import (
"fmt"
"io"
"log"
"os"
"path/filepath"
"sync"
)
const (
maxBytes = 1 << 20 // 1 MB per file
maxFiles = 5 // ipswap.log plus ipswap.log.1 .. .4
)
// Writer is an io.Writer that rotates at maxBytes and keeps maxFiles files.
// It is small on purpose: a rotation dependency for one log file is not worth
// the supply chain.
type Writer struct {
path string
mu sync.Mutex
f *os.File
size int64
}
// New opens the log at path, creating the directory if needed.
func New(path string) (*Writer, error) {
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
return nil, fmt.Errorf("creating log directory: %w", err)
}
w := &Writer{path: path}
if err := w.open(); err != nil {
return nil, err
}
return w, nil
}
func (w *Writer) open() error {
f, err := os.OpenFile(w.path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644)
if err != nil {
return fmt.Errorf("opening %s: %w", w.path, err)
}
info, err := f.Stat()
if err != nil {
f.Close()
return fmt.Errorf("stat %s: %w", w.path, err)
}
w.f, w.size = f, info.Size()
return nil
}
func (w *Writer) Write(p []byte) (int, error) {
w.mu.Lock()
defer w.mu.Unlock()
if w.f == nil {
return len(p), nil // closed; drop rather than error out a log call
}
if w.size+int64(len(p)) > maxBytes {
if err := w.rotate(); err != nil {
return 0, err
}
}
n, err := w.f.Write(p)
w.size += int64(n)
return n, err
}
// rotate shifts ipswap.log.N to N+1 and starts a fresh ipswap.log. The caller
// holds w.mu.
func (w *Writer) rotate() error {
if err := w.f.Close(); err != nil {
return err
}
w.f = nil
// Walk downwards so nothing is overwritten before it has been moved.
for i := maxFiles - 1; i >= 1; i-- {
older := fmt.Sprintf("%s.%d", w.path, i)
if i == maxFiles-1 {
os.Remove(older) // the oldest file falls off the end
}
var newer string
if i == 1 {
newer = w.path
} else {
newer = fmt.Sprintf("%s.%d", w.path, i-1)
}
if _, err := os.Stat(newer); err == nil {
os.Rename(newer, older)
}
}
return w.open()
}
// Close closes the underlying file.
func (w *Writer) Close() error {
w.mu.Lock()
defer w.mu.Unlock()
if w.f == nil {
return nil
}
err := w.f.Close()
w.f = nil
return err
}
// Setup points the standard logger at the rotating file and returns it so the
// caller can close it on exit.
//
// With -H windowsgui there is no console, so stderr goes nowhere on Windows and
// the file is the only output that survives. During development on Linux the
// log is also echoed to stderr.
func Setup(path string, alsoStderr bool) (*Writer, error) {
w, err := New(path)
if err != nil {
return nil, err
}
var out io.Writer = w
if alsoStderr {
out = io.MultiWriter(w, os.Stderr)
}
log.SetOutput(out)
log.SetFlags(log.LstdFlags | log.Lmsgprefix)
return w, nil
}
internal/config/config.go
+130
View File
@@ -0,0 +1,130 @@
// Package config resolves where ipswap keeps its files and loads the settings
// that are not presets.
package config
import (
"encoding/json"
"fmt"
"os"
"path/filepath"
)
// AppName is the single place the product name appears. It decides the data
// directory, the log file name and the tray tooltip prefix, so renaming the app
// is a one-line change here.
const AppName = "ipswap"
// Paths are the absolute locations of everything ipswap reads or writes.
type Paths struct {
Dir string
Presets string
Config string
Log string
}
// ResolvePaths returns the data locations under %APPDATA%\ipswap on Windows.
//
// os.UserConfigDir maps to %APPDATA% on Windows and to ~/.config elsewhere,
// which keeps development on Linux from scribbling in odd places.
func ResolvePaths() (Paths, error) {
base, err := os.UserConfigDir()
if err != nil {
return Paths{}, fmt.Errorf("locating the application data directory: %w", err)
}
dir := filepath.Join(base, AppName)
return Paths{
Dir: dir,
Presets: filepath.Join(dir, "presets.json"),
Config: filepath.Join(dir, "config.json"),
Log: filepath.Join(dir, AppName+".log"),
}, nil
}
// MaskStyle is how subnet masks are displayed in the editor. Input always
// accepts both spellings; this only controls what is rendered back.
type MaskStyle string
const (
MaskPrefix MaskStyle = "prefix" // /24
MaskDotted MaskStyle = "dotted" // 255.255.255.0
)
// Settings is config.json.
type Settings struct {
// MaskStyle is global rather than per-preset: a per-preset display
// preference would be more state than the feature is worth.
MaskStyle MaskStyle `json:"mask_style"`
// StartWithWindows drives the HKCU Run key. Assumed default off; see the
// open questions at the bottom of claude.md.
StartWithWindows bool `json:"start_with_windows"`
// CheckUpdates gates the startup call to the Gitea releases API.
CheckUpdates bool `json:"check_updates"`
// UpdateRepo is the Gitea repo polled for releases, as
// "https://host/owner/repo". Empty disables the update checker entirely,
// which is the default until the host is confirmed.
UpdateRepo string `json:"update_repo"`
// ActivePollSeconds is how often the live adapter state is re-read to work
// out which preset is currently applied.
ActivePollSeconds int `json:"active_poll_seconds"`
}
// Default is the settings a fresh install starts with.
func Default() Settings {
return Settings{
MaskStyle: MaskPrefix,
StartWithWindows: false,
CheckUpdates: true,
UpdateRepo: "",
ActivePollSeconds: 30,
}
}
// DottedMasks reports whether masks should render as dotted quads.
func (s Settings) DottedMasks() bool { return s.MaskStyle == MaskDotted }
// Load reads config.json, falling back to defaults for a missing file or any
// field left unset. Settings are conveniences, so a corrupt config should not
// stop the app from starting — the caller logs the error and carries on.
func Load(path string) (Settings, error) {
s := Default()
b, err := os.ReadFile(path)
if os.IsNotExist(err) {
return s, nil
}
if err != nil {
return s, fmt.Errorf("reading %s: %w", path, err)
}
if err := json.Unmarshal(b, &s); err != nil {
return Default(), fmt.Errorf("parsing %s: %w", path, err)
}
// Repair anything nonsensical rather than refusing to run.
if s.MaskStyle != MaskPrefix && s.MaskStyle != MaskDotted {
s.MaskStyle = MaskPrefix
}
if s.ActivePollSeconds < 5 {
s.ActivePollSeconds = 30
}
return s, nil
}
// Save writes config.json.
func (s Settings) Save(path string) error {
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
return fmt.Errorf("creating config directory: %w", err)
}
b, err := json.MarshalIndent(s, "", " ")
if err != nil {
return fmt.Errorf("encoding settings: %w", err)
}
if err := os.WriteFile(path, append(b, '\n'), 0o644); err != nil {
return fmt.Errorf("writing %s: %w", path, err)
}
return nil
}
internal/desktop/desktop_other.go
+23
View File
@@ -0,0 +1,23 @@
//go:build !windows
package desktop
import (
"fmt"
"os/exec"
)
// OpenURL shells out to xdg-open so the editor can be exercised during
// development on Linux.
func OpenURL(url string) error {
if err := exec.Command("xdg-open", url).Start(); err != nil {
return fmt.Errorf("opening %s: %w", url, err)
}
return nil
}
// SetRunAtLogin is a no-op: the Run key is a Windows concept.
func SetRunAtLogin(enabled bool) error { return nil }
// RunAtLogin always reports false off Windows.
func RunAtLogin() bool { return false }
internal/desktop/desktop_windows.go
+100
View File
@@ -0,0 +1,100 @@
//go:build windows
// Package desktop holds the small Windows shell integrations that do not
// belong to any one feature: opening a URL in the default browser, and the
// HKCU Run key that starts ipswap with Windows.
package desktop
import (
"fmt"
"os"
"path/filepath"
"syscall"
"unsafe"
"golang.org/x/sys/windows/registry"
"gitea.apointless.space/bsncubed/ipswap/internal/config"
)
var (
shell32 = syscall.NewLazyDLL("shell32.dll")
shellExecuteW = shell32.NewProc("ShellExecuteW")
)
const runKeyPath = `Software\Microsoft\Windows\CurrentVersion\Run`
// OpenURL opens a URL in the default browser.
//
// ShellExecuteW rather than `cmd /c start`: no console window to suppress and
// no quoting rules to get wrong around a URL that already contains "?" and "&".
func OpenURL(url string) error {
verb, err := syscall.UTF16PtrFromString("open")
if err != nil {
return err
}
target, err := syscall.UTF16PtrFromString(url)
if err != nil {
return err
}
ret, _, callErr := shellExecuteW.Call(
0,
uintptr(unsafe.Pointer(verb)),
uintptr(unsafe.Pointer(target)),
0, 0, 1, // no args, no cwd, SW_SHOWNORMAL
)
if ret <= 32 {
return fmt.Errorf("could not open %s (ShellExecuteW returned %d: %v)", url, ret, callErr)
}
return nil
}
// SetRunAtLogin adds or removes ipswap from the current user's Run key.
//
// HKCU rather than HKLM deliberately: HKLM needs elevation, and ipswap is
// designed to run unelevated. It also keeps the setting per-user on a shared
// support laptop.
func SetRunAtLogin(enabled bool) error {
key, _, err := registry.CreateKey(registry.CURRENT_USER, runKeyPath, registry.SET_VALUE)
if err != nil {
return fmt.Errorf("opening the Run key: %w", err)
}
defer key.Close()
if !enabled {
err := key.DeleteValue(config.AppName)
if err != nil && err != registry.ErrNotExist {
return fmt.Errorf("removing the Run key value: %w", err)
}
return nil
}
exe, err := os.Executable()
if err != nil {
return fmt.Errorf("locating the running executable: %w", err)
}
exe, err = filepath.Abs(exe)
if err != nil {
return err
}
// Quoted: the path routinely contains spaces (Program Files, or a user
// profile with a space in the name) and the Run key value is a command
// line, not a path.
if err := key.SetStringValue(config.AppName, `"`+exe+`"`); err != nil {
return fmt.Errorf("writing the Run key value: %w", err)
}
return nil
}
// RunAtLogin reports whether the Run key entry is present.
func RunAtLogin() bool {
key, err := registry.OpenKey(registry.CURRENT_USER, runKeyPath, registry.QUERY_VALUE)
if err != nil {
return false
}
defer key.Close()
v, _, err := key.GetStringValue(config.AppName)
return err == nil && v != ""
}
internal/dialog/dialog_other.go
+22
View File
@@ -0,0 +1,22 @@
//go:build !windows
package dialog
import "log"
// The non-Windows build logs instead of showing a box, so the tray and apply
// paths can be exercised during development on Linux.
// Confirm auto-declines: nothing destructive should run unattended off Windows.
func Confirm(title, text string) bool {
log.Printf("[dialog] confirm %q:\n%s\n(auto-declined on non-Windows build)", title, text)
return false
}
func Info(title, text string) { log.Printf("[dialog] info %q: %s", title, text) }
func Error(title, text string) { log.Printf("[dialog] error %q: %s", title, text) }
func ErrorWithRetryAsAdmin(title, text string) bool {
log.Printf("[dialog] error %q: %s (no elevation off Windows)", title, text)
return false
}
internal/dialog/dialog_windows.go
+80
View File
@@ -0,0 +1,80 @@
//go:build windows
// Package dialog wraps the handful of Win32 message boxes ipswap needs.
//
// This is raw user32 rather than a GUI toolkit on purpose: the fast path must
// stay native and dependency-free, and a confirmation prompt is the only
// blocking UI the tray side has.
package dialog
import (
"syscall"
"unsafe"
)
var (
user32 = syscall.NewLazyDLL("user32.dll")
messageBoxW = user32.NewProc("MessageBoxW")
)
// MessageBoxW uType flags.
const (
mbOK = 0x00000000
mbOKCancel = 0x00000001
mbYesNo = 0x00000004
mbIconError = 0x00000010
mbIconQuestion = 0x00000020
mbIconWarning = 0x00000030
mbIconInformation = 0x00000040
// The tray has no window to own the dialog, so without TOPMOST the box can
// open behind whatever is focused and look like a hang.
mbSetForeground = 0x00010000
mbTopMost = 0x00040000
)
// MessageBoxW return values.
const (
idOK = 1
idYes = 6
)
func show(title, text string, flags uint32) int {
t, err := syscall.UTF16PtrFromString(text)
if err != nil {
return 0
}
c, err := syscall.UTF16PtrFromString(title)
if err != nil {
return 0
}
ret, _, _ := messageBoxW.Call(
0,
uintptr(unsafe.Pointer(t)),
uintptr(unsafe.Pointer(c)),
uintptr(flags|mbSetForeground|mbTopMost),
)
return int(ret)
}
// Confirm asks a yes/no question and reports whether the user said yes.
func Confirm(title, text string) bool {
return show(title, text, mbYesNo|mbIconQuestion) == idYes
}
// Info shows a plain acknowledgement box.
func Info(title, text string) {
show(title, text, mbOK|mbIconInformation)
}
// Error shows a failure. The caller is expected to include the raw netsh
// output — that text is the only diagnostic the user has on site.
func Error(title, text string) {
show(title, text, mbOK|mbIconError)
}
// ErrorWithRetryAsAdmin reports a failure and offers to relaunch elevated.
// It reports whether the user accepted.
func ErrorWithRetryAsAdmin(title, text string) bool {
return show(title, text+"\n\nRelaunch ipswap as administrator and try again?",
mbOKCancel|mbIconWarning) == idOK
}
internal/elevate/elevate_other.go
+14
View File
@@ -0,0 +1,14 @@
//go:build !windows
package elevate
import "errors"
// IsElevated reports true off Windows so development builds do not show the
// "Relaunch as administrator" item that could not work anyway.
func IsElevated() bool { return true }
// RelaunchAsAdmin has no meaning outside Windows.
func RelaunchAsAdmin() error {
return errors.New("elevation is only supported on Windows")
}
internal/elevate/elevate_windows.go
+105
View File
@@ -0,0 +1,105 @@
//go:build windows
// Package elevate answers "is this process actually elevated?" and, if not,
// can re-exec it through the UAC prompt.
//
// The manifest asks for asInvoker rather than requireAdministrator: on a
// machine with UAC relaxed, or when the parent is already elevated, that means
// ipswap starts with zero prompts. The cost is that on a locked-down machine
// we start unprivileged and have to offer the relaunch, which is what this
// package is for.
package elevate
import (
"fmt"
"os"
"path/filepath"
"strings"
"syscall"
"unsafe"
"golang.org/x/sys/windows"
)
var (
shell32 = syscall.NewLazyDLL("shell32.dll")
shellExecuteW = shell32.NewProc("ShellExecuteW")
)
const swShowNormal = 1
// IsElevated reports whether the current process token carries administrator
// rights right now.
//
// Membership of the Administrators group is not the same thing: with UAC on,
// a member's process gets a filtered token, and `netsh interface ipv4 set
// address` then fails with "The requested operation requires elevation."
// Checking the token is the only answer that predicts whether an apply works.
func IsElevated() bool {
return windows.GetCurrentProcessToken().IsElevated()
}
// RelaunchAsAdmin re-execs the current binary through the UAC prompt and
// returns once the new process has been started. The caller is expected to
// exit immediately afterwards so the two copies do not both own a tray icon.
//
// A user who clicks "No" on the UAC prompt produces ERROR_CANCELLED, which is
// reported as an error but is not a failure worth a message box.
func RelaunchAsAdmin() error {
exe, err := os.Executable()
if err != nil {
return fmt.Errorf("locating the running executable: %w", err)
}
exe, err = filepath.Abs(exe)
if err != nil {
return fmt.Errorf("resolving %s: %w", exe, err)
}
verb, err := syscall.UTF16PtrFromString("runas")
if err != nil {
return err
}
file, err := syscall.UTF16PtrFromString(exe)
if err != nil {
return err
}
args, err := syscall.UTF16PtrFromString(strings.Join(quoteArgs(os.Args[1:]), " "))
if err != nil {
return err
}
cwd, err := syscall.UTF16PtrFromString(filepath.Dir(exe))
if err != nil {
return err
}
// ShellExecuteW signals failure with a return value of 32 or less.
ret, _, callErr := shellExecuteW.Call(
0,
uintptr(unsafe.Pointer(verb)),
uintptr(unsafe.Pointer(file)),
uintptr(unsafe.Pointer(args)),
uintptr(unsafe.Pointer(cwd)),
swShowNormal,
)
if ret <= 32 {
if ret == uintptr(windows.ERROR_CANCELLED) {
return fmt.Errorf("the elevation prompt was cancelled")
}
return fmt.Errorf("ShellExecuteW returned %d: %v", ret, callErr)
}
return nil
}
// quoteArgs re-quotes arguments for the single command-line string
// ShellExecuteW takes, since it does not accept an argv.
func quoteArgs(args []string) []string {
out := make([]string, 0, len(args))
for _, a := range args {
if strings.ContainsAny(a, ` "`) {
out = append(out, `"`+strings.ReplaceAll(a, `"`, `\"`)+`"`)
} else {
out = append(out, a)
}
}
return out
}
internal/netcfg/diff.go
+92
View File
@@ -0,0 +1,92 @@
package netcfg
import (
"fmt"
"strings"
"gitea.apointless.space/bsncubed/ipswap/internal/preset"
)
// ConfirmText renders the before/after body of the confirmation MessageBox.
//
// The live side must be read at prompt time rather than taken from the cached
// active-preset poll: the prompt is the only safety net before a destructive
// change, and a 30-second-stale "CURRENT" block would undermine it.
func ConfirmText(p preset.Preset, live LiveConfig) string {
var b strings.Builder
fmt.Fprintf(&b, "Apply preset %q to adapter %q?\n\n", p.Name, p.Adapter)
b.WriteString("CURRENT\n")
writeLive(&b, live)
b.WriteString("\nNEW\n")
writePreset(&b, p)
return b.String()
}
func writeLive(b *strings.Builder, live LiveConfig) {
if len(live.Addresses) == 0 {
b.WriteString(" (no IPv4 address)\n")
}
for i, a := range live.Addresses {
suffix := ""
if live.DHCP {
suffix = " (DHCP)"
}
prefix := " "
if i > 0 {
prefix = " + "
}
fmt.Fprintf(b, "%s%s%s\n", prefix, a.String(), suffix)
}
if len(live.Gateways) > 0 {
fmt.Fprintf(b, " Gateway: %s\n", strings.Join(live.Gateways, ", "))
}
if len(live.DNS) > 0 {
suffix := ""
if live.DNSFromDHCP {
suffix = " (DHCP)"
}
fmt.Fprintf(b, " DNS: %s%s\n", strings.Join(live.DNS, ", "), suffix)
}
}
func writePreset(b *strings.Builder, p preset.Preset) {
if p.Mode == preset.ModeDHCP {
b.WriteString(" DHCP\n")
} else if p.Primary != nil {
fmt.Fprintf(b, " %s\n", p.Primary.String())
for _, s := range p.Secondary {
fmt.Fprintf(b, " + %s\n", s.String())
}
if p.Primary.Gateway != "" {
fmt.Fprintf(b, " Gateway: %s\n", p.Primary.Gateway)
}
}
switch p.DNS.Mode {
case preset.ModeDHCP:
b.WriteString(" DNS: from DHCP\n")
default:
fmt.Fprintf(b, " DNS: %s\n", strings.Join(p.DNS.Servers, ", "))
}
}
// Summary is the one-line description of a live config, used for the editor's
// adapter picker.
func (l LiveConfig) Summary() string {
if len(l.Addresses) == 0 {
return "no IPv4 address"
}
parts := make([]string, 0, len(l.Addresses))
for _, a := range l.Addresses {
parts = append(parts, a.String())
}
s := strings.Join(parts, ", ")
if l.DHCP {
s += " (DHCP)"
}
return s
}
internal/netcfg/netcfg.go
+251
View File
@@ -0,0 +1,251 @@
// Package netcfg reads and writes IPv4 adapter configuration.
//
// Reading and writing deliberately use different mechanisms:
//
// - Reading goes through GetAdaptersAddresses (plus one registry read for
// DNS origin). netsh's "show config" output is localised, so parsing it
// breaks on a German or French Windows; the Win32 API does not.
// - Writing goes through netsh, because the equivalent APIs are a much larger
// surface for no benefit when the whole operation is six shell commands.
//
// The command plan is built in this file, in portable code, so the exact netsh
// sequence can be tested without a Windows box.
package netcfg
import (
"fmt"
"sort"
"strconv"
"strings"
"gitea.apointless.space/bsncubed/ipswap/internal/preset"
)
// Adapter is a network interface as Windows names it.
type Adapter struct {
// Name is the friendly name ("Ethernet", "Wi-Fi 2"). This is what presets
// bind to and what netsh expects.
Name string `json:"name"`
// Description is the hardware description, shown in the adapter picker to
// tell three identically-named USB NICs apart.
Description string `json:"description"`
// GUID is the adapter instance id, used for the registry DNS lookup.
GUID string `json:"-"`
Up bool `json:"up"`
}
// LiveConfig is an adapter's current IPv4 state.
type LiveConfig struct {
Adapter string `json:"adapter"`
DHCP bool `json:"dhcp"`
Addresses []preset.Address `json:"addresses"`
Gateways []string `json:"gateways"`
DNS []string `json:"dns"`
DNSFromDHCP bool `json:"dns_from_dhcp"`
}
// Manager reads and writes adapter configuration.
type Manager interface {
// Adapters lists the IPv4-capable adapters on this machine.
Adapters() ([]Adapter, error)
// Current reads one adapter's live configuration.
Current(adapter string) (LiveConfig, error)
// Apply runs a plan, returning the first command that failed along with
// its raw output.
Apply(plan []Command) error
}
// Command is one netsh invocation. Args excludes the "netsh" itself.
type Command struct {
Args []string
// Desc is what gets written to the log before the command runs.
Desc string
}
func (c Command) String() string { return "netsh " + strings.Join(c.Args, " ") }
// Plan builds the exact netsh sequence that takes an adapter from current to
// the preset's configuration.
//
// The delete step in the middle is the whole reason this is not a one-liner:
// `netsh interface ipv4 set address ... static` replaces the primary address
// but leaves any previously-added secondary addresses attached, so switching
// between presets without deleting first leaks addresses from every preset
// visited so far. Applies are destructive by design — after this runs the
// adapter has exactly what the preset says and nothing else.
func Plan(p preset.Preset, current LiveConfig) []Command {
name := p.Adapter
var cmds []Command
if p.Mode == preset.ModeDHCP {
// Switching the adapter to DHCP clears the static addresses on its
// own, so the explicit deletes are unnecessary here.
cmds = append(cmds, Command{
Args: []string{"interface", "ipv4", "set", "address", nameArg(name), "source=dhcp"},
Desc: "set " + name + " to DHCP",
})
cmds = append(cmds, dnsCommands(name, p.DNS)...)
return cmds
}
// 1. Drop every address currently on the adapter. Addresses handed out by
// DHCP are not deletable this way and do not need to be: the `set
// address ... static` below replaces the lease outright.
if !current.DHCP {
for _, a := range current.Addresses {
cmds = append(cmds, Command{
Args: []string{"interface", "ipv4", "delete", "address", nameArg(name), "addr=" + a.Address},
Desc: "remove existing address " + a.String(),
})
}
}
// 2. Set the primary, with its gateway if the preset carries one.
args := []string{
"interface", "ipv4", "set", "address", nameArg(name), "static",
p.Primary.Address, preset.MaskString(p.Primary.Prefix),
}
if p.Primary.Gateway != "" {
args = append(args, p.Primary.Gateway)
// netsh only accepts a metric once a gateway is present, and 0 means
// "automatic", which is what an unset metric should mean.
if p.Primary.GatewayMetric > 0 {
args = append(args, strconv.Itoa(p.Primary.GatewayMetric))
} else {
args = append(args, "1")
}
}
cmds = append(cmds, Command{Args: args, Desc: "set primary address " + p.Primary.String()})
// 3. Add the secondaries.
for _, s := range p.Secondary {
cmds = append(cmds, Command{
Args: []string{"interface", "ipv4", "add", "address", nameArg(name), s.Address, preset.MaskString(s.Prefix)},
Desc: "add secondary address " + s.String(),
})
}
// 4. DNS.
cmds = append(cmds, dnsCommands(name, p.DNS)...)
return cmds
}
func dnsCommands(adapter string, d preset.DNS) []Command {
if d.Mode == preset.ModeDHCP {
return []Command{{
Args: []string{"interface", "ipv4", "set", "dnsservers", nameArg(adapter), "source=dhcp"},
Desc: "set DNS to DHCP",
}}
}
var cmds []Command
for i, s := range d.Servers {
if i == 0 {
// validate=no skips the several-second reachability probe netsh
// otherwise runs against a server that is often not up yet.
cmds = append(cmds, Command{
Args: []string{"interface", "ipv4", "set", "dnsservers", nameArg(adapter), "static", s, "primary", "validate=no"},
Desc: "set primary DNS " + s,
})
continue
}
cmds = append(cmds, Command{
Args: []string{"interface", "ipv4", "add", "dnsservers", nameArg(adapter), s, "index=" + strconv.Itoa(i+1), "validate=no"},
Desc: "add DNS " + s,
})
}
return cmds
}
// nameArg builds netsh's name= argument. The value is passed as a single
// argv element rather than a quoted shell string: os/exec does not go through
// a shell, so adapter names containing spaces need no quoting here, and adding
// quotes would make them part of the name.
func nameArg(adapter string) string { return "name=" + adapter }
// Matches reports whether a preset is exactly what the adapter currently has.
// Used to put the check mark next to the active preset in the tray menu, so it
// has to be an exact match in both directions — a preset that is a subset of
// the live config is not the active preset.
func Matches(p preset.Preset, live LiveConfig) bool {
if !strings.EqualFold(p.Adapter, live.Adapter) {
return false
}
if p.Mode == preset.ModeDHCP {
if !live.DHCP {
return false
}
} else {
if live.DHCP || p.Primary == nil {
return false
}
want := append([]preset.Address{*p.Primary}, p.Secondary...)
if !sameAddresses(want, live.Addresses) {
return false
}
// A preset with no gateway means "no gateway", so a live default
// route disqualifies it.
if p.Primary.Gateway == "" {
if len(live.Gateways) > 0 {
return false
}
} else if !containsFold(live.Gateways, p.Primary.Gateway) {
return false
}
}
if p.DNS.Mode == preset.ModeDHCP {
return live.DNSFromDHCP
}
if live.DNSFromDHCP {
return false
}
return sameStrings(p.DNS.Servers, live.DNS)
}
func sameAddresses(a, b []preset.Address) bool {
if len(a) != len(b) {
return false
}
key := func(x preset.Address) string { return fmt.Sprintf("%s/%d", x.Address, x.Prefix) }
as := make([]string, len(a))
bs := make([]string, len(b))
for i := range a {
as[i] = key(a[i])
}
for i := range b {
bs[i] = key(b[i])
}
sort.Strings(as)
sort.Strings(bs)
for i := range as {
if as[i] != bs[i] {
return false
}
}
return true
}
// sameStrings compares DNS server lists. Order matters: 1.1.1.1 as the primary
// resolver is a different configuration from 1.1.1.1 as the fallback.
func sameStrings(a, b []string) bool {
if len(a) != len(b) {
return false
}
for i := range a {
if !strings.EqualFold(strings.TrimSpace(a[i]), strings.TrimSpace(b[i])) {
return false
}
}
return true
}
func containsFold(hay []string, needle string) bool {
for _, h := range hay {
if strings.EqualFold(strings.TrimSpace(h), strings.TrimSpace(needle)) {
return true
}
}
return false
}
internal/netcfg/netcfg_other.go
+48
View File
@@ -0,0 +1,48 @@
//go:build !windows
package netcfg
import (
"errors"
"fmt"
"gitea.apointless.space/bsncubed/ipswap/internal/preset"
)
// ErrElevationRequired keeps the non-Windows build type-compatible so the rest
// of the tree compiles and `go vet ./...` is useful during development on
// Linux. Nothing here touches a real adapter.
var ErrElevationRequired = errors.New("this operation requires an elevated process")
// ErrUnsupported is returned by every write path off Windows.
var ErrUnsupported = errors.New("adapter configuration is only supported on Windows")
// Stub is a Manager that reports a plausible fixture instead of touching the
// host. It exists so the tray, the editor server and the confirmation text can
// be exercised on the development machine.
type Stub struct{}
// New returns the platform Manager.
func New() Manager { return Stub{} }
func (Stub) Adapters() ([]Adapter, error) {
return []Adapter{
{Name: "Ethernet", Description: "Stub adapter (non-Windows build)", Up: true},
{Name: "Wi-Fi", Description: "Stub adapter (non-Windows build)", Up: false},
}, nil
}
func (Stub) Current(adapter string) (LiveConfig, error) {
return LiveConfig{
Adapter: adapter,
DHCP: true,
Addresses: []preset.Address{{Address: "192.168.1.87", Prefix: 24}},
Gateways: []string{"192.168.1.1"},
DNS: []string{"192.168.1.1"},
DNSFromDHCP: true,
}, nil
}
func (Stub) Apply(plan []Command) error {
return fmt.Errorf("%w (plan had %d commands)", ErrUnsupported, len(plan))
}
internal/netcfg/netcfg_windows.go
+234
View File
@@ -0,0 +1,234 @@
//go:build windows
package netcfg
import (
"errors"
"fmt"
"log"
"net"
"os/exec"
"strings"
"syscall"
"time"
"unsafe"
"golang.org/x/sys/windows"
"golang.org/x/sys/windows/registry"
"gitea.apointless.space/bsncubed/ipswap/internal/preset"
)
// ErrElevationRequired is returned when netsh refuses because the process token
// is not elevated. The caller turns this into the "Relaunch as administrator"
// offer rather than a bare failure message.
var ErrElevationRequired = errors.New("this operation requires an elevated process")
// ipAdapterDHCPEnabled is IP_ADAPTER_DHCP_ENABLED from iptypes.h.
const ipAdapterDHCPEnabled = 0x00000004
// Interface types we never want in the adapter picker.
const (
ifTypeSoftwareLoopback = 24
ifTypeTunnel = 131
)
// applyTimeout bounds a whole plan. A single netsh call is normally well under
// a second; anything past this is a hung call, not a slow one.
const applyTimeout = 30 * time.Second
// Windows is the real Manager.
type Windows struct{}
// New returns the platform Manager.
func New() Manager { return Windows{} }
// Adapters lists IPv4-capable, non-loopback, non-tunnel adapters.
func (Windows) Adapters() ([]Adapter, error) {
rows, err := adapterRows()
if err != nil {
return nil, err
}
var out []Adapter
for _, a := range rows {
if a.IfType == ifTypeSoftwareLoopback || a.IfType == ifTypeTunnel {
continue
}
out = append(out, Adapter{
Name: windows.UTF16PtrToString(a.FriendlyName),
Description: windows.UTF16PtrToString(a.Description),
GUID: windows.BytePtrToString(a.AdapterName),
Up: a.OperStatus == windows.IfOperStatusUp,
})
}
return out, nil
}
// Current reads one adapter's live IPv4 configuration.
func (Windows) Current(adapter string) (LiveConfig, error) {
rows, err := adapterRows()
if err != nil {
return LiveConfig{}, err
}
for _, a := range rows {
if !strings.EqualFold(windows.UTF16PtrToString(a.FriendlyName), adapter) {
continue
}
cfg := LiveConfig{
Adapter: adapter,
DHCP: a.Flags&ipAdapterDHCPEnabled != 0,
}
for ua := a.FirstUnicastAddress; ua != nil; ua = ua.Next {
ip := ua.Address.IP()
if ip == nil || ip.To4() == nil {
continue // v1 is IPv4 only
}
cfg.Addresses = append(cfg.Addresses, preset.Address{
Address: ip.String(),
Prefix: int(ua.OnLinkPrefixLength),
})
}
for ga := a.FirstGatewayAddress; ga != nil; ga = ga.Next {
if ip := ga.Address.IP(); ip != nil && ip.To4() != nil {
cfg.Gateways = append(cfg.Gateways, ip.String())
}
}
for da := a.FirstDnsServerAddress; da != nil; da = da.Next {
if ip := da.Address.IP(); ip != nil && ip.To4() != nil {
cfg.DNS = append(cfg.DNS, ip.String())
}
}
// GetAdaptersAddresses reports the resolvers in use but not whether
// they were configured or leased, and that distinction decides whether
// a DNS-from-DHCP preset matches. The registry holds it: a non-empty
// NameServer value means statically configured.
cfg.DNSFromDHCP = dnsIsFromDHCP(windows.BytePtrToString(a.AdapterName))
return cfg, nil
}
return LiveConfig{}, fmt.Errorf("adapter %q not found", adapter)
}
// Apply runs each command in order, stopping at the first failure.
func (Windows) Apply(plan []Command) error {
for _, c := range plan {
log.Printf("netsh: %s (%s)", c, c.Desc)
out, err := runNetsh(c)
if out != "" {
log.Printf("netsh output: %s", out)
}
if err != nil {
if isElevationError(out) {
return fmt.Errorf("%w\n\ncommand: %s\n%s", ErrElevationRequired, c, out)
}
return fmt.Errorf("%s failed: %w\n\n%s", c.Desc, err, out)
}
}
return nil
}
func runNetsh(c Command) (string, error) {
cmd := exec.Command("netsh", c.Args...)
// The binary is linked with -H windowsgui and has no console of its own, so
// without this every netsh call flashes a console window on screen.
cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}
done := make(chan struct{})
var out []byte
var err error
go func() {
out, err = cmd.CombinedOutput()
close(done)
}()
select {
case <-done:
case <-time.After(applyTimeout):
if cmd.Process != nil {
_ = cmd.Process.Kill()
}
<-done
return string(out), fmt.Errorf("timed out after %s", applyTimeout)
}
return strings.TrimSpace(string(out)), err
}
// isElevationError sniffs netsh's refusal. netsh exits non-zero with a message
// rather than a distinguishable code, and the message is localised, so this
// also accepts the English text as the common case and falls back to the
// Win32 error number that appears in several translations.
func isElevationError(out string) bool {
l := strings.ToLower(out)
return strings.Contains(l, "requires elevation") ||
strings.Contains(l, "requested operation requires") ||
strings.Contains(l, "access is denied") ||
strings.Contains(l, "740")
}
func dnsIsFromDHCP(guid string) bool {
if guid == "" {
return true
}
key, err := registry.OpenKey(
registry.LOCAL_MACHINE,
`SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces\`+guid,
registry.QUERY_VALUE,
)
if err != nil {
// Not readable without admin on some machines; assume DHCP rather
// than falsely reporting a static configuration.
return true
}
defer key.Close()
ns, _, err := key.GetStringValue("NameServer")
if err != nil {
return true
}
return strings.TrimSpace(ns) == ""
}
// adapterRows walks the GetAdaptersAddresses linked list into a slice.
func adapterRows() ([]*windows.IpAdapterAddresses, error) {
flags := uint32(windows.GAA_FLAG_INCLUDE_GATEWAYS |
windows.GAA_FLAG_SKIP_ANYCAST |
windows.GAA_FLAG_SKIP_MULTICAST)
size := uint32(15 * 1024)
var buf []byte
for attempt := 0; attempt < 4; attempt++ {
buf = make([]byte, size)
err := windows.GetAdaptersAddresses(
windows.AF_INET, flags, 0,
(*windows.IpAdapterAddresses)(unsafe.Pointer(&buf[0])),
&size,
)
if err == nil {
break
}
// The call reports the required size in `size`; retry with it.
if err == windows.ERROR_BUFFER_OVERFLOW {
continue
}
return nil, fmt.Errorf("GetAdaptersAddresses: %w", err)
}
var out []*windows.IpAdapterAddresses
for a := (*windows.IpAdapterAddresses)(unsafe.Pointer(&buf[0])); a != nil; a = a.Next {
out = append(out, a)
}
return out, nil
}
// compile-time assertion that net is used even if the address helpers change.
var _ = net.IP{}
internal/netcfg/plan_test.go
+188
View File
@@ -0,0 +1,188 @@
package netcfg
import (
"strings"
"testing"
"gitea.apointless.space/bsncubed/ipswap/internal/preset"
)
func staticPreset() preset.Preset {
return preset.Preset{
ID: "test",
Name: "Artist frame — control",
Adapter: "Ethernet",
Mode: preset.ModeStatic,
Primary: &preset.Address{
Address: "192.168.42.100",
Prefix: 24,
Gateway: "192.168.42.1",
},
Secondary: []preset.Address{{Address: "10.0.10.50", Prefix: 24}},
DNS: preset.DNS{Mode: preset.ModeStatic, Servers: []string{"192.168.42.1", "1.1.1.1"}},
}
}
func staticLive() LiveConfig {
return LiveConfig{
Adapter: "Ethernet",
Addresses: []preset.Address{{Address: "192.168.1.87", Prefix: 24}, {Address: "172.16.0.5", Prefix: 16}},
Gateways: []string{"192.168.1.1"},
DNS: []string{"192.168.1.1"},
}
}
// The leak this guards against is the reason Plan exists: without a delete for
// every live address, secondaries from the previous preset stay attached.
func TestPlanDeletesEveryExistingAddress(t *testing.T) {
cmds := Plan(staticPreset(), staticLive())
var deletes []string
for _, c := range cmds {
if len(c.Args) > 3 && c.Args[2] == "delete" && c.Args[3] == "address" {
deletes = append(deletes, strings.Join(c.Args, " "))
}
}
if len(deletes) != 2 {
t.Fatalf("expected 2 delete commands, got %d: %v", len(deletes), deletes)
}
for _, want := range []string{"addr=192.168.1.87", "addr=172.16.0.5"} {
found := false
for _, d := range deletes {
if strings.Contains(d, want) {
found = true
}
}
if !found {
t.Errorf("no delete command for %s: %v", want, deletes)
}
}
}
func TestPlanOrdering(t *testing.T) {
cmds := Plan(staticPreset(), staticLive())
// deletes, then set primary, then add secondary, then DNS.
var kinds []string
for _, c := range cmds {
switch {
case c.Args[2] == "delete":
kinds = append(kinds, "delete")
case c.Args[2] == "set" && c.Args[3] == "address":
kinds = append(kinds, "set-addr")
case c.Args[2] == "add" && c.Args[3] == "address":
kinds = append(kinds, "add-addr")
case c.Args[3] == "dnsservers":
kinds = append(kinds, "dns")
}
}
want := []string{"delete", "delete", "set-addr", "add-addr", "dns", "dns"}
if strings.Join(kinds, ",") != strings.Join(want, ",") {
t.Errorf("plan order = %v, want %v", kinds, want)
}
}
func TestPlanUsesDottedMaskNotPrefix(t *testing.T) {
// netsh rejects "/24" outright.
cmds := Plan(staticPreset(), staticLive())
for _, c := range cmds {
for _, a := range c.Args {
if strings.HasPrefix(a, "/") {
t.Errorf("command passes a prefix-notation mask: %v", c.Args)
}
}
}
joined := strings.Join(cmds[2].Args, " ")
if !strings.Contains(joined, "255.255.255.0") {
t.Errorf("set address command lacks a dotted mask: %s", joined)
}
}
func TestPlanDHCPSkipsDeletes(t *testing.T) {
p := preset.Preset{
ID: "d", Name: "DHCP", Adapter: "Ethernet",
Mode: preset.ModeDHCP,
DNS: preset.DNS{Mode: preset.ModeDHCP},
}
cmds := Plan(p, staticLive())
if len(cmds) != 2 {
t.Fatalf("expected 2 commands for a DHCP preset, got %d: %v", len(cmds), cmds)
}
for _, c := range cmds {
if c.Args[2] == "delete" {
t.Errorf("DHCP plan should not delete addresses: %v", c.Args)
}
}
}
// A DHCP lease is not deletable with `netsh delete address`, and the static set
// replaces it anyway, so a live-DHCP adapter gets no delete commands.
func TestPlanSkipsDeletesWhenLiveIsDHCP(t *testing.T) {
live := staticLive()
live.DHCP = true
for _, c := range Plan(staticPreset(), live) {
if c.Args[2] == "delete" {
t.Errorf("should not delete DHCP-assigned addresses: %v", c.Args)
}
}
}
func TestPlanAdapterNameIsNotShellQuoted(t *testing.T) {
p := staticPreset()
p.Adapter = "Ethernet 3"
for _, c := range Plan(p, LiveConfig{Adapter: "Ethernet 3"}) {
for _, a := range c.Args {
if strings.HasPrefix(a, "name=") && strings.Contains(a, `"`) {
t.Errorf("adapter name should not carry quotes through os/exec: %q", a)
}
}
}
}
func TestMatches(t *testing.T) {
p := staticPreset()
live := LiveConfig{
Adapter: "Ethernet",
Addresses: []preset.Address{{Address: "10.0.10.50", Prefix: 24}, {Address: "192.168.42.100", Prefix: 24}},
Gateways: []string{"192.168.42.1"},
DNS: []string{"192.168.42.1", "1.1.1.1"},
}
if !Matches(p, live) {
t.Error("preset should match an adapter carrying exactly its addresses")
}
extra := live
extra.Addresses = append(append([]preset.Address{}, live.Addresses...), preset.Address{Address: "10.9.9.9", Prefix: 24})
if Matches(p, extra) {
t.Error("a preset that is a subset of the live config is not the active preset")
}
reordered := live
reordered.DNS = []string{"1.1.1.1", "192.168.42.1"}
if Matches(p, reordered) {
t.Error("DNS order is significant and should not match")
}
dhcp := live
dhcp.DNSFromDHCP = true
if Matches(p, dhcp) {
t.Error("static-DNS preset should not match a DHCP-DNS adapter")
}
}
func TestConfirmTextShapes(t *testing.T) {
got := ConfirmText(staticPreset(), staticLive())
for _, want := range []string{
`Apply preset "Artist frame — control" to adapter "Ethernet"?`,
"CURRENT", "NEW",
"192.168.1.87/24",
"192.168.42.100/24",
"+ 10.0.10.50/24",
"Gateway: 192.168.42.1",
"DNS: 192.168.42.1, 1.1.1.1",
} {
if !strings.Contains(got, want) {
t.Errorf("confirm text missing %q:\n%s", want, got)
}
}
}
internal/preset/portio.go
+101
View File
@@ -0,0 +1,101 @@
package preset
import (
"encoding/json"
"fmt"
"strings"
)
// ImportMode is what to do with the presets already on disk.
type ImportMode string
const (
// ImportMerge keeps existing presets and adds the incoming ones.
ImportMerge ImportMode = "merge"
// ImportReplace discards everything already saved.
ImportReplace ImportMode = "replace"
)
// Export renders the presets as a shippable preset pack. Passing one or more
// group names filters to just those groups; passing none exports everything.
//
// The output is the same shape as presets.json so a pack can be dropped
// straight in as a starting file, and it stays hand-editable.
func (s *Store) Export(groups ...string) ([]byte, error) {
want := make(map[string]bool, len(groups))
for _, g := range groups {
want[strings.ToLower(strings.TrimSpace(g))] = true
}
out := File{Version: SchemaVersion}
for _, p := range s.All() {
if len(want) > 0 && !want[strings.ToLower(p.GroupOrUngrouped())] {
continue
}
out.Presets = append(out.Presets, p)
}
b, err := json.MarshalIndent(out, "", " ")
if err != nil {
return nil, fmt.Errorf("encoding export: %w", err)
}
return append(b, '\n'), nil
}
// ImportResult reports what an import did, for the summary shown afterwards.
type ImportResult struct {
Added int `json:"added"`
Replaced int `json:"replaced"`
Renamed []string `json:"renamed,omitempty"`
}
// Import validates an incoming preset file in full before touching anything,
// then applies it. A file that fails validation changes nothing on disk.
//
// On merge, an incoming preset whose id already exists is kept alongside the
// existing one: it gets a fresh id and "(imported)" appended to its name, so a
// colleague's pack can never silently overwrite what you already had.
func (s *Store) Import(data []byte, mode ImportMode) (ImportResult, error) {
incoming, err := Decode(data)
if err != nil {
return ImportResult{}, err
}
var res ImportResult
switch mode {
case ImportReplace:
s.mu.Lock()
s.file = File{Version: SchemaVersion, Presets: incoming.Presets}
res.Added = len(incoming.Presets)
s.mu.Unlock()
case ImportMerge:
s.mu.Lock()
existing := make(map[string]bool, len(s.file.Presets))
for _, p := range s.file.Presets {
existing[p.ID] = true
}
for _, p := range incoming.Presets {
if existing[p.ID] {
p.ID = NewID()
p.Name = p.Name + " (imported)"
res.Renamed = append(res.Renamed, p.Name)
}
existing[p.ID] = true
s.file.Presets = append(s.file.Presets, p)
res.Added++
}
s.mu.Unlock()
default:
return ImportResult{}, fmt.Errorf("unknown import mode %q", mode)
}
if err := s.Save(); err != nil {
// Reload so the in-memory copy matches whatever is actually on disk.
_ = s.Load()
return ImportResult{}, err
}
return res, nil
}
internal/preset/prefix.go
+71
View File
@@ -0,0 +1,71 @@
package preset
import (
"fmt"
"net/netip"
"strconv"
"strings"
)
// ParsePrefix accepts every spelling of a subnet mask the editor is required to
// take — "24", "/24" and "255.255.255.0" — and returns the prefix length.
//
// Only contiguous masks are accepted. 255.255.0.255 is a typo, not a netmask,
// and letting it through would produce a netsh call that fails confusingly.
func ParsePrefix(s string) (int, error) {
s = strings.TrimSpace(s)
if s == "" {
return 0, fmt.Errorf("empty mask")
}
s = strings.TrimPrefix(s, "/")
if strings.Contains(s, ".") {
addr, err := netip.ParseAddr(s)
if err != nil || !addr.Is4() {
return 0, fmt.Errorf("%q is not a dotted-quad netmask", s)
}
b := addr.As4()
mask := uint32(b[0])<<24 | uint32(b[1])<<16 | uint32(b[2])<<8 | uint32(b[3])
ones := 0
for ones < 32 && mask&(1<<uint(31-ones)) != 0 {
ones++
}
// Everything below the leading run of ones must be zero.
if ones < 32 && mask<<uint(ones) != 0 {
return 0, fmt.Errorf("%q is not a contiguous netmask", s)
}
return ones, nil
}
n, err := strconv.Atoi(s)
if err != nil {
return 0, fmt.Errorf("%q is not a prefix length", s)
}
if n < 0 || n > 32 {
return 0, fmt.Errorf("prefix /%d out of range", n)
}
return n, nil
}
// MaskString renders a prefix length as the dotted-quad netmask netsh expects
// on the command line. netsh will not take "/24".
func MaskString(prefix int) string {
if prefix < 0 || prefix > 32 {
prefix = 32
}
var mask uint32
if prefix > 0 {
mask = ^uint32(0) << uint(32-prefix)
}
return fmt.Sprintf("%d.%d.%d.%d", mask>>24&0xff, mask>>16&0xff, mask>>8&0xff, mask&0xff)
}
// FormatPrefix renders a prefix in whichever notation the user last chose.
// dotted controls the style; see config.Settings.MaskStyle.
func FormatPrefix(prefix int, dotted bool) string {
if dotted {
return MaskString(prefix)
}
return "/" + strconv.Itoa(prefix)
}
internal/preset/prefix_test.go
+66
View File
@@ -0,0 +1,66 @@
package preset
import "testing"
func TestParsePrefix(t *testing.T) {
ok := []struct {
in string
want int
}{
{"24", 24},
{"/24", 24},
{" /24 ", 24},
{"255.255.255.0", 24},
{"255.255.255.255", 32},
{"0.0.0.0", 0},
{"255.255.254.0", 23},
{"128.0.0.0", 1},
{"32", 32},
{"0", 0},
}
for _, tc := range ok {
got, err := ParsePrefix(tc.in)
if err != nil {
t.Errorf("ParsePrefix(%q) returned error: %v", tc.in, err)
continue
}
if got != tc.want {
t.Errorf("ParsePrefix(%q) = %d, want %d", tc.in, got, tc.want)
}
}
bad := []string{"", "33", "-1", "255.255.0.255", "1.2.3", "abc", "255.0.255.0", "/", "24.5"}
for _, in := range bad {
if got, err := ParsePrefix(in); err == nil {
t.Errorf("ParsePrefix(%q) = %d, want error", in, got)
}
}
}
func TestMaskStringRoundTrip(t *testing.T) {
for p := 0; p <= 32; p++ {
got, err := ParsePrefix(MaskString(p))
if err != nil {
t.Fatalf("ParsePrefix(MaskString(%d)) errored: %v", p, err)
}
if got != p {
t.Errorf("round trip of /%d gave /%d (mask %s)", p, got, MaskString(p))
}
}
}
func TestMaskStringKnown(t *testing.T) {
cases := map[int]string{
0: "0.0.0.0",
8: "255.0.0.0",
16: "255.255.0.0",
24: "255.255.255.0",
30: "255.255.255.252",
32: "255.255.255.255",
}
for prefix, want := range cases {
if got := MaskString(prefix); got != want {
t.Errorf("MaskString(%d) = %s, want %s", prefix, got, want)
}
}
}
internal/preset/preset.go
+162
View File
@@ -0,0 +1,162 @@
// Package preset holds the on-disk preset model and everything that reads or
// writes it. It is deliberately free of Windows-specific code so the whole
// model can be exercised by tests on any platform.
package preset
import (
"fmt"
"net/netip"
"strings"
)
// SchemaVersion is written into every file we save and checked on every file we
// load. Bump it only for a breaking change, and add a migration when you do.
const SchemaVersion = 1
// Mode is how an adapter gets its addresses.
type Mode string
const (
ModeStatic Mode = "static"
ModeDHCP Mode = "dhcp"
)
// File is the top-level shape of presets.json.
type File struct {
Version int `json:"version"`
Presets []Preset `json:"presets"`
}
// Preset is one saved adapter configuration.
type Preset struct {
ID string `json:"id"`
Name string `json:"name"`
// Group drives the tray submenus. Empty means "Ungrouped".
Group string `json:"group,omitempty"`
// Adapter is the Windows friendly name, e.g. "Ethernet" or "Wi-Fi 2".
Adapter string `json:"adapter"`
Mode Mode `json:"mode"`
// Primary is required when Mode is static and ignored when it is dhcp.
Primary *Address `json:"primary,omitempty"`
// Secondary addresses are added after the primary is set.
Secondary []Address `json:"secondary,omitempty"`
DNS DNS `json:"dns"`
Notes string `json:"notes,omitempty"`
}
// Address is a single IPv4 address with its prefix length, and optionally the
// default gateway reached through it.
type Address struct {
Address string `json:"address"`
// Prefix is the mask stored as a prefix length. The editor accepts
// dotted-quad on input and converts here; see ParsePrefix.
Prefix int `json:"prefix"`
Gateway string `json:"gateway,omitempty"`
// GatewayMetric 0 means automatic, which is what netsh wants for "let
// Windows decide".
GatewayMetric int `json:"gateway_metric,omitempty"`
}
// DNS is the resolver configuration for a preset.
type DNS struct {
Mode Mode `json:"mode"`
Servers []string `json:"servers,omitempty"`
}
// GroupOrUngrouped is the submenu a preset belongs under.
func (p Preset) GroupOrUngrouped() string {
if strings.TrimSpace(p.Group) == "" {
return "Ungrouped"
}
return p.Group
}
// Validate reports the first structural problem with a preset. Import rejects
// a whole file rather than partially applying it, so this needs to be strict.
func (p Preset) Validate() error {
if strings.TrimSpace(p.ID) == "" {
return fmt.Errorf("preset has no id")
}
if strings.TrimSpace(p.Name) == "" {
return fmt.Errorf("preset %s has no name", p.ID)
}
if strings.TrimSpace(p.Adapter) == "" {
return fmt.Errorf("preset %q has no adapter", p.Name)
}
switch p.Mode {
case ModeDHCP:
// Nothing else to check: any addresses present are ignored on apply.
case ModeStatic:
if p.Primary == nil {
return fmt.Errorf("preset %q is static but has no primary address", p.Name)
}
if err := p.Primary.validate(); err != nil {
return fmt.Errorf("preset %q primary: %w", p.Name, err)
}
for i, s := range p.Secondary {
if err := s.validate(); err != nil {
return fmt.Errorf("preset %q secondary %d: %w", p.Name, i+1, err)
}
// A gateway on a secondary address is silently dropped by
// `netsh add address`, so reject it rather than pretend.
if s.Gateway != "" {
return fmt.Errorf("preset %q secondary %d: secondary addresses cannot carry a gateway", p.Name, i+1)
}
}
default:
return fmt.Errorf("preset %q has unknown mode %q", p.Name, p.Mode)
}
switch p.DNS.Mode {
case ModeDHCP:
case ModeStatic:
if len(p.DNS.Servers) == 0 {
return fmt.Errorf("preset %q has static DNS but no servers", p.Name)
}
for _, s := range p.DNS.Servers {
if _, err := parseV4(s); err != nil {
return fmt.Errorf("preset %q dns server %q: %w", p.Name, s, err)
}
}
default:
return fmt.Errorf("preset %q has unknown dns mode %q", p.Name, p.DNS.Mode)
}
return nil
}
func (a Address) validate() error {
if _, err := parseV4(a.Address); err != nil {
return fmt.Errorf("address %q: %w", a.Address, err)
}
if a.Prefix < 0 || a.Prefix > 32 {
return fmt.Errorf("prefix /%d out of range", a.Prefix)
}
if a.Gateway != "" {
if _, err := parseV4(a.Gateway); err != nil {
return fmt.Errorf("gateway %q: %w", a.Gateway, err)
}
}
if a.GatewayMetric < 0 {
return fmt.Errorf("gateway metric %d is negative", a.GatewayMetric)
}
return nil
}
// String renders an address the way the confirmation dialog shows it.
func (a Address) String() string { return fmt.Sprintf("%s/%d", a.Address, a.Prefix) }
func parseV4(s string) (netip.Addr, error) {
addr, err := netip.ParseAddr(strings.TrimSpace(s))
if err != nil {
return netip.Addr{}, fmt.Errorf("not an IP address")
}
if !addr.Is4() {
// v1 is IPv4 only; see "Out of scope" in claude.md.
return netip.Addr{}, fmt.Errorf("not an IPv4 address")
}
return addr, nil
}
internal/preset/store.go
+238
View File
@@ -0,0 +1,238 @@
package preset
import (
"crypto/rand"
"encoding/hex"
"encoding/json"
"fmt"
"os"
"path/filepath"
"sort"
"strings"
"sync"
"time"
)
// Store owns presets.json. Every mutation goes through it so the file is
// written atomically and the in-memory copy never drifts from disk.
type Store struct {
path string
mu sync.RWMutex
file File
}
// NewStore opens (or creates) the preset file at path.
func NewStore(path string) (*Store, error) {
s := &Store{path: path, file: File{Version: SchemaVersion}}
if err := s.Load(); err != nil {
return nil, err
}
return s, nil
}
// Load re-reads the file from disk. A missing file is not an error: a fresh
// install has no presets yet and should start with an empty list rather than
// refusing to launch.
func (s *Store) Load() error {
b, err := os.ReadFile(s.path)
if os.IsNotExist(err) {
s.mu.Lock()
s.file = File{Version: SchemaVersion}
s.mu.Unlock()
return nil
}
if err != nil {
return fmt.Errorf("reading %s: %w", s.path, err)
}
f, err := Decode(b)
if err != nil {
return fmt.Errorf("reading %s: %w", s.path, err)
}
s.mu.Lock()
s.file = f
s.mu.Unlock()
return nil
}
// Decode parses and fully validates a preset file. Import uses it too, which is
// why it rejects the whole document on the first bad preset rather than
// dropping the offender and continuing.
func Decode(b []byte) (File, error) {
var f File
dec := json.NewDecoder(strings.NewReader(string(b)))
dec.DisallowUnknownFields()
if err := dec.Decode(&f); err != nil {
return File{}, fmt.Errorf("not a valid preset file: %w", err)
}
if f.Version != SchemaVersion {
return File{}, fmt.Errorf("preset file is version %d, this build understands version %d", f.Version, SchemaVersion)
}
seen := make(map[string]bool, len(f.Presets))
for _, p := range f.Presets {
if err := p.Validate(); err != nil {
return File{}, err
}
if seen[p.ID] {
return File{}, fmt.Errorf("duplicate preset id %q", p.ID)
}
seen[p.ID] = true
}
return f, nil
}
// Save writes the file atomically: a temp file in the same directory, then a
// rename. A half-written presets.json after a crash would lose every preset,
// and this is the user's only copy.
func (s *Store) Save() error {
s.mu.RLock()
b, err := json.MarshalIndent(s.file, "", " ")
s.mu.RUnlock()
if err != nil {
return fmt.Errorf("encoding presets: %w", err)
}
b = append(b, '\n')
if err := os.MkdirAll(filepath.Dir(s.path), 0o755); err != nil {
return fmt.Errorf("creating preset directory: %w", err)
}
tmp, err := os.CreateTemp(filepath.Dir(s.path), ".presets-*.json")
if err != nil {
return fmt.Errorf("creating temp file: %w", err)
}
tmpName := tmp.Name()
defer os.Remove(tmpName) // no-op once the rename below succeeds
if _, err := tmp.Write(b); err != nil {
tmp.Close()
return fmt.Errorf("writing temp file: %w", err)
}
if err := tmp.Sync(); err != nil {
tmp.Close()
return fmt.Errorf("syncing temp file: %w", err)
}
if err := tmp.Close(); err != nil {
return fmt.Errorf("closing temp file: %w", err)
}
if err := os.Rename(tmpName, s.path); err != nil {
return fmt.Errorf("replacing %s: %w", s.path, err)
}
return nil
}
// All returns a copy of the presets, sorted by group then name so the tray menu
// and the editor agree on ordering.
func (s *Store) All() []Preset {
s.mu.RLock()
out := make([]Preset, len(s.file.Presets))
copy(out, s.file.Presets)
s.mu.RUnlock()
sort.SliceStable(out, func(i, j int) bool {
gi, gj := out[i].GroupOrUngrouped(), out[j].GroupOrUngrouped()
if gi != gj {
// Ungrouped sinks to the bottom of the tray menu.
if gi == "Ungrouped" {
return false
}
if gj == "Ungrouped" {
return true
}
return strings.ToLower(gi) < strings.ToLower(gj)
}
return strings.ToLower(out[i].Name) < strings.ToLower(out[j].Name)
})
return out
}
// Get returns the preset with the given id.
func (s *Store) Get(id string) (Preset, bool) {
s.mu.RLock()
defer s.mu.RUnlock()
for _, p := range s.file.Presets {
if p.ID == id {
return p, true
}
}
return Preset{}, false
}
// Put inserts or replaces a preset and saves. An empty ID means "new".
func (s *Store) Put(p Preset) (Preset, error) {
if strings.TrimSpace(p.ID) == "" {
p.ID = NewID()
}
if err := p.Validate(); err != nil {
return Preset{}, err
}
s.mu.Lock()
replaced := false
for i := range s.file.Presets {
if s.file.Presets[i].ID == p.ID {
s.file.Presets[i] = p
replaced = true
break
}
}
if !replaced {
s.file.Presets = append(s.file.Presets, p)
}
s.mu.Unlock()
return p, s.Save()
}
// Delete removes a preset by id and saves.
func (s *Store) Delete(id string) error {
s.mu.Lock()
kept := s.file.Presets[:0]
found := false
for _, p := range s.file.Presets {
if p.ID == id {
found = true
continue
}
kept = append(kept, p)
}
s.file.Presets = kept
s.mu.Unlock()
if !found {
return fmt.Errorf("no preset with id %q", id)
}
return s.Save()
}
// Groups lists the distinct groups in tray-menu order.
func (s *Store) Groups() []string {
seen := map[string]bool{}
var out []string
for _, p := range s.All() {
g := p.GroupOrUngrouped()
if !seen[g] {
seen[g] = true
out = append(out, g)
}
}
return out
}
// NewID mints a preset id. claude.md shows ULID-shaped ids in the example file,
// but nothing depends on them being sortable or on their length — an id only
// has to be unique and stable — so this stays dependency-free: a millisecond
// timestamp for rough ordering plus 64 bits of randomness.
func NewID() string {
var b [8]byte
if _, err := rand.Read(b[:]); err != nil {
// crypto/rand does not fail in practice on Windows; if it somehow
// does, a timestamp-only id is still unique enough to save with.
return fmt.Sprintf("%013x", time.Now().UnixMilli())
}
return fmt.Sprintf("%013x%s", time.Now().UnixMilli(), hex.EncodeToString(b[:]))
}
internal/preset/store_test.go
+228
View File
@@ -0,0 +1,228 @@
package preset
import (
"os"
"path/filepath"
"strings"
"testing"
)
func newTestStore(t *testing.T) *Store {
t.Helper()
s, err := NewStore(filepath.Join(t.TempDir(), "presets.json"))
if err != nil {
t.Fatal(err)
}
return s
}
func sample() Preset {
return Preset{
Name: "Artist frame — control",
Group: "Riedel",
Adapter: "Ethernet",
Mode: ModeStatic,
Primary: &Address{Address: "192.168.42.100", Prefix: 24, Gateway: "192.168.42.1"},
DNS: DNS{Mode: ModeStatic, Servers: []string{"192.168.42.1"}},
}
}
// The shipped example doubles as the documented export format, so a change
// that breaks it breaks every preset pack already in circulation.
func TestExamplePackDecodes(t *testing.T) {
b, err := os.ReadFile(filepath.Join("..", "..", "examples", "preset-pack.json"))
if err != nil {
t.Skipf("example pack not present: %v", err)
}
f, err := Decode(b)
if err != nil {
t.Fatalf("examples/preset-pack.json does not validate: %v", err)
}
if len(f.Presets) == 0 {
t.Fatal("example pack is empty")
}
}
func TestMissingFileStartsEmpty(t *testing.T) {
s := newTestStore(t)
if len(s.All()) != 0 {
t.Errorf("a fresh store should have no presets, got %d", len(s.All()))
}
}
func TestPutAssignsIDAndPersists(t *testing.T) {
path := filepath.Join(t.TempDir(), "presets.json")
s, err := NewStore(path)
if err != nil {
t.Fatal(err)
}
saved, err := s.Put(sample())
if err != nil {
t.Fatal(err)
}
if saved.ID == "" {
t.Fatal("Put should have assigned an id")
}
reopened, err := NewStore(path)
if err != nil {
t.Fatalf("saved file did not reload: %v", err)
}
if got, ok := reopened.Get(saved.ID); !ok || got.Name != saved.Name {
t.Errorf("preset did not survive a reload: %+v", got)
}
}
func TestPutRejectsInvalid(t *testing.T) {
s := newTestStore(t)
bad := sample()
bad.Primary.Address = "not-an-ip"
if _, err := s.Put(bad); err == nil {
t.Error("expected a validation error for a bad address")
}
// A secondary carrying a gateway is silently dropped by netsh, so it is
// rejected rather than saved as a lie.
withGW := sample()
withGW.Secondary = []Address{{Address: "10.0.0.5", Prefix: 24, Gateway: "10.0.0.1"}}
if _, err := s.Put(withGW); err == nil {
t.Error("expected a validation error for a secondary with a gateway")
}
}
func TestDecodeRejectsWrongVersion(t *testing.T) {
_, err := Decode([]byte(`{"version": 99, "presets": []}`))
if err == nil || !strings.Contains(err.Error(), "version") {
t.Errorf("expected a version error, got %v", err)
}
}
func TestDecodeRejectsDuplicateIDs(t *testing.T) {
doc := `{"version":1,"presets":[
{"id":"a","name":"one","adapter":"Ethernet","mode":"dhcp","dns":{"mode":"dhcp"}},
{"id":"a","name":"two","adapter":"Ethernet","mode":"dhcp","dns":{"mode":"dhcp"}}]}`
if _, err := Decode([]byte(doc)); err == nil {
t.Error("expected a duplicate-id error")
}
}
func TestImportMergeKeepsBothOnIDCollision(t *testing.T) {
s := newTestStore(t)
saved, err := s.Put(sample())
if err != nil {
t.Fatal(err)
}
pack, err := s.Export()
if err != nil {
t.Fatal(err)
}
res, err := s.Import(pack, ImportMerge)
if err != nil {
t.Fatal(err)
}
if res.Added != 1 || len(res.Renamed) != 1 {
t.Fatalf("expected 1 added and 1 renamed, got %+v", res)
}
if len(s.All()) != 2 {
t.Fatalf("merge should keep both, got %d presets", len(s.All()))
}
// The original must be untouched: a colleague's pack silently overwriting
// a working preset is the failure this guards against.
orig, ok := s.Get(saved.ID)
if !ok || orig.Name != saved.Name {
t.Errorf("original preset was modified: %+v", orig)
}
var found bool
for _, p := range s.All() {
if strings.HasSuffix(p.Name, "(imported)") {
found = true
}
}
if !found {
t.Error("the colliding import should have been suffixed with (imported)")
}
}
func TestImportReplaceDiscardsExisting(t *testing.T) {
s := newTestStore(t)
if _, err := s.Put(sample()); err != nil {
t.Fatal(err)
}
doc := `{"version":1,"presets":[{"id":"z","name":"only","adapter":"Ethernet","mode":"dhcp","dns":{"mode":"dhcp"}}]}`
if _, err := s.Import([]byte(doc), ImportReplace); err != nil {
t.Fatal(err)
}
all := s.All()
if len(all) != 1 || all[0].ID != "z" {
t.Errorf("replace should leave exactly the incoming presets, got %+v", all)
}
}
// A rejected import must change nothing: partial application would leave the
// user with a half-imported pack and no way to tell what landed.
func TestImportRejectsWithoutMutating(t *testing.T) {
s := newTestStore(t)
if _, err := s.Put(sample()); err != nil {
t.Fatal(err)
}
before := len(s.All())
bad := `{"version":1,"presets":[{"id":"x","name":"broken","adapter":"Ethernet","mode":"static","dns":{"mode":"dhcp"}}]}`
if _, err := s.Import([]byte(bad), ImportMerge); err == nil {
t.Fatal("expected the import to be rejected")
}
if len(s.All()) != before {
t.Errorf("a rejected import changed the store: %d -> %d", before, len(s.All()))
}
}
func TestExportFiltersByGroup(t *testing.T) {
s := newTestStore(t)
if _, err := s.Put(sample()); err != nil {
t.Fatal(err)
}
other := sample()
other.Name = "Management"
other.Group = "Herespace"
if _, err := s.Put(other); err != nil {
t.Fatal(err)
}
b, err := s.Export("Riedel")
if err != nil {
t.Fatal(err)
}
f, err := Decode(b)
if err != nil {
t.Fatalf("a filtered export must still be a valid pack: %v", err)
}
if len(f.Presets) != 1 || f.Presets[0].Group != "Riedel" {
t.Errorf("group filter returned %+v", f.Presets)
}
}
func TestUngroupedSortsLast(t *testing.T) {
s := newTestStore(t)
loose := sample()
loose.Name = "Loose"
loose.Group = ""
if _, err := s.Put(loose); err != nil {
t.Fatal(err)
}
if _, err := s.Put(sample()); err != nil {
t.Fatal(err)
}
groups := s.Groups()
if len(groups) != 2 || groups[len(groups)-1] != "Ungrouped" {
t.Errorf("Ungrouped should sort last, got %v", groups)
}
}
internal/server/server.go
+439
View File
@@ -0,0 +1,439 @@
// Package server is the "slow path": a local HTTP server hosting the preset
// editor, opened in the user's default browser.
//
// It exists because the fast path must not involve a browser and the editor
// must not involve a MessageBox. Switching a preset is two clicks in the tray;
// managing fifty of them needs a real UI, and an embedded web app is the only
// way to get one without linking a GUI toolkit and giving up cross-compilation.
//
// The server is not running most of the time. The tray starts it on demand and
// it shuts itself down once the browser stops sending heartbeats.
package server
import (
"context"
"crypto/rand"
"crypto/subtle"
"embed"
"encoding/hex"
"encoding/json"
"fmt"
"io"
"io/fs"
"log"
"net"
"net/http"
"strings"
"sync"
"time"
"gitea.apointless.space/bsncubed/ipswap/internal/config"
"gitea.apointless.space/bsncubed/ipswap/internal/netcfg"
"gitea.apointless.space/bsncubed/ipswap/internal/preset"
)
//go:embed web
var webFS embed.FS
const (
// idleTimeout is how long the server survives without a heartbeat. The
// browser beats every 30s, so this tolerates a few missed beats before
// concluding the tab is gone.
idleTimeout = 5 * time.Minute
// tokenHeader carries the session token on mutating requests.
tokenHeader = "X-Ipswap-Token"
)
// Server hosts the editor.
type Server struct {
store *preset.Store
mgr netcfg.Manager
paths config.Paths
// onSettingsChange lets the tray react to a settings save, e.g. to
// rewrite the Run key when start-with-Windows is toggled.
onSettingsChange func(config.Settings)
// onPresetsChange asks the tray to rebuild its menu.
onPresetsChange func()
mu sync.Mutex
settings config.Settings
token string
srv *http.Server
ln net.Listener
lastBeat time.Time
stop chan struct{}
}
// New builds a server. It does not listen until Start is called.
func New(store *preset.Store, mgr netcfg.Manager, paths config.Paths, settings config.Settings) *Server {
return &Server{store: store, mgr: mgr, paths: paths, settings: settings}
}
// OnSettingsChange registers a callback fired after settings are saved.
func (s *Server) OnSettingsChange(f func(config.Settings)) { s.onSettingsChange = f }
// OnPresetsChange registers a callback fired after any preset mutation.
func (s *Server) OnPresetsChange(f func()) { s.onPresetsChange = f }
// URL returns the address to open, including the session token. It is empty
// when the server is not running.
func (s *Server) URL() string {
s.mu.Lock()
defer s.mu.Unlock()
if s.ln == nil {
return ""
}
return fmt.Sprintf("http://127.0.0.1:%d/?t=%s", s.ln.Addr().(*net.TCPAddr).Port, s.token)
}
// Start binds a random loopback port and serves until Stop or an idle timeout.
// Calling it while already running just returns the existing URL, so clicking
// "Manage presets…" twice reuses the one session.
func (s *Server) Start() (string, error) {
s.mu.Lock()
if s.ln != nil {
url := fmt.Sprintf("http://127.0.0.1:%d/?t=%s", s.ln.Addr().(*net.TCPAddr).Port, s.token)
s.lastBeat = time.Now()
s.mu.Unlock()
return url, nil
}
// Loopback only. This binds no external interface at any point, which
// matters given the app spends its life on customer networks.
ln, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
s.mu.Unlock()
return "", fmt.Errorf("binding a local port: %w", err)
}
token, err := newToken()
if err != nil {
ln.Close()
s.mu.Unlock()
return "", err
}
s.ln = ln
s.token = token
s.lastBeat = time.Now()
s.stop = make(chan struct{})
s.srv = &http.Server{
Handler: s.routes(),
ReadHeaderTimeout: 10 * time.Second,
}
stop := s.stop
srv := s.srv
port := ln.Addr().(*net.TCPAddr).Port
s.mu.Unlock()
go func() {
if err := srv.Serve(ln); err != nil && err != http.ErrServerClosed {
log.Printf("editor server stopped: %v", err)
}
}()
go s.watchIdle(stop)
log.Printf("editor server listening on 127.0.0.1:%d", port)
return fmt.Sprintf("http://127.0.0.1:%d/?t=%s", port, token), nil
}
// Stop shuts the server down. It is safe to call when not running.
func (s *Server) Stop() {
s.mu.Lock()
srv, stop := s.srv, s.stop
s.srv, s.ln, s.stop, s.token = nil, nil, nil, ""
s.mu.Unlock()
if stop != nil {
close(stop)
}
if srv == nil {
return
}
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
_ = srv.Shutdown(ctx)
log.Printf("editor server shut down")
}
func (s *Server) watchIdle(stop <-chan struct{}) {
t := time.NewTicker(30 * time.Second)
defer t.Stop()
for {
select {
case <-stop:
return
case <-t.C:
s.mu.Lock()
idle := time.Since(s.lastBeat)
s.mu.Unlock()
if idle > idleTimeout {
log.Printf("editor server idle for %s, shutting down", idle.Round(time.Second))
s.Stop()
return
}
}
}
}
func newToken() (string, error) {
var b [32]byte
if _, err := rand.Read(b[:]); err != nil {
return "", fmt.Errorf("generating a session token: %w", err)
}
return hex.EncodeToString(b[:]), nil
}
// Settings returns the current settings.
func (s *Server) Settings() config.Settings {
s.mu.Lock()
defer s.mu.Unlock()
return s.settings
}
// SetSettings replaces the settings the server serves, for when something
// outside the editor changes them.
func (s *Server) SetSettings(c config.Settings) {
s.mu.Lock()
s.settings = c
s.mu.Unlock()
}
func (s *Server) beat() {
s.mu.Lock()
s.lastBeat = time.Now()
s.mu.Unlock()
}
// --- routing ---
func (s *Server) routes() http.Handler {
mux := http.NewServeMux()
assets, err := fs.Sub(webFS, "web")
if err != nil {
// Only reachable if the embed directive and the directory disagree,
// which is a build-time mistake, not a runtime condition.
panic(err)
}
mux.Handle("GET /", http.FileServer(http.FS(assets)))
mux.HandleFunc("POST /api/heartbeat", func(w http.ResponseWriter, r *http.Request) {
writeJSON(w, http.StatusOK, map[string]any{"ok": true})
})
mux.HandleFunc("GET /api/presets", s.handleListPresets)
mux.HandleFunc("POST /api/presets", s.handlePutPreset)
mux.HandleFunc("PUT /api/presets/{id}", s.handlePutPreset)
mux.HandleFunc("DELETE /api/presets/{id}", s.handleDeletePreset)
mux.HandleFunc("GET /api/adapters", s.handleAdapters)
mux.HandleFunc("GET /api/settings", s.handleGetSettings)
mux.HandleFunc("PUT /api/settings", s.handlePutSettings)
mux.HandleFunc("GET /api/export", s.handleExport)
mux.HandleFunc("POST /api/import", s.handleImport)
return s.withAuth(mux)
}
// withAuth gates every request on the session token and refreshes the idle
// timer.
//
// The token arrives once in the URL and is then stored in a SameSite=Strict
// cookie. Mutating requests additionally require the token in a header, which
// a cross-site page cannot set: a cookie alone would let any website in the
// browser POST to this port and rewrite the user's presets.
func (s *Server) withAuth(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
s.mu.Lock()
token := s.token
s.mu.Unlock()
if token == "" {
http.Error(w, "server is shutting down", http.StatusServiceUnavailable)
return
}
if q := r.URL.Query().Get("t"); q != "" && tokenEqual(q, token) {
http.SetCookie(w, &http.Cookie{
Name: "ipswap_session",
Value: token,
Path: "/",
HttpOnly: true,
SameSite: http.SameSiteStrictMode,
})
s.beat()
next.ServeHTTP(w, r)
return
}
c, err := r.Cookie("ipswap_session")
if err != nil || !tokenEqual(c.Value, token) {
http.Error(w, "unauthorised: reopen the editor from the tray menu", http.StatusUnauthorized)
return
}
if r.Method != http.MethodGet && r.Method != http.MethodHead {
if !tokenEqual(r.Header.Get(tokenHeader), token) {
http.Error(w, "missing session header", http.StatusForbidden)
return
}
}
s.beat()
next.ServeHTTP(w, r)
})
}
func tokenEqual(got, want string) bool {
return subtle.ConstantTimeCompare([]byte(got), []byte(want)) == 1
}
// --- handlers ---
func (s *Server) handleListPresets(w http.ResponseWriter, r *http.Request) {
writeJSON(w, http.StatusOK, map[string]any{
"presets": s.store.All(),
"groups": s.store.Groups(),
})
}
func (s *Server) handlePutPreset(w http.ResponseWriter, r *http.Request) {
var p preset.Preset
if err := readJSON(r, &p); err != nil {
writeErr(w, http.StatusBadRequest, err)
return
}
if id := r.PathValue("id"); id != "" {
p.ID = id
}
saved, err := s.store.Put(p)
if err != nil {
writeErr(w, http.StatusBadRequest, err)
return
}
s.notifyPresets()
writeJSON(w, http.StatusOK, saved)
}
func (s *Server) handleDeletePreset(w http.ResponseWriter, r *http.Request) {
if err := s.store.Delete(r.PathValue("id")); err != nil {
writeErr(w, http.StatusNotFound, err)
return
}
s.notifyPresets()
writeJSON(w, http.StatusOK, map[string]any{"ok": true})
}
func (s *Server) handleAdapters(w http.ResponseWriter, r *http.Request) {
adapters, err := s.mgr.Adapters()
if err != nil {
writeErr(w, http.StatusInternalServerError, err)
return
}
type row struct {
netcfg.Adapter
Current string `json:"current"`
}
out := make([]row, 0, len(adapters))
for _, a := range adapters {
r := row{Adapter: a}
if live, err := s.mgr.Current(a.Name); err == nil {
r.Current = live.Summary()
}
out = append(out, r)
}
writeJSON(w, http.StatusOK, map[string]any{"adapters": out})
}
func (s *Server) handleGetSettings(w http.ResponseWriter, r *http.Request) {
writeJSON(w, http.StatusOK, s.Settings())
}
func (s *Server) handlePutSettings(w http.ResponseWriter, r *http.Request) {
c := s.Settings()
if err := readJSON(r, &c); err != nil {
writeErr(w, http.StatusBadRequest, err)
return
}
if err := c.Save(s.paths.Config); err != nil {
writeErr(w, http.StatusInternalServerError, err)
return
}
s.SetSettings(c)
if s.onSettingsChange != nil {
s.onSettingsChange(c)
}
writeJSON(w, http.StatusOK, c)
}
func (s *Server) handleExport(w http.ResponseWriter, r *http.Request) {
var groups []string
if g := strings.TrimSpace(r.URL.Query().Get("groups")); g != "" {
groups = strings.Split(g, ",")
}
b, err := s.store.Export(groups...)
if err != nil {
writeErr(w, http.StatusInternalServerError, err)
return
}
w.Header().Set("Content-Type", "application/json")
w.Header().Set("Content-Disposition", `attachment; filename="ipswap-presets.json"`)
w.Write(b)
}
func (s *Server) handleImport(w http.ResponseWriter, r *http.Request) {
mode := preset.ImportMode(r.URL.Query().Get("mode"))
if mode == "" {
mode = preset.ImportMerge
}
body, err := io.ReadAll(io.LimitReader(r.Body, 8<<20))
if err != nil {
writeErr(w, http.StatusBadRequest, err)
return
}
res, err := s.store.Import(body, mode)
if err != nil {
// Import validates the whole file first, so a rejection here means
// nothing on disk changed.
writeErr(w, http.StatusBadRequest, err)
return
}
s.notifyPresets()
writeJSON(w, http.StatusOK, res)
}
func (s *Server) notifyPresets() {
if s.onPresetsChange != nil {
s.onPresetsChange()
}
}
// --- helpers ---
func writeJSON(w http.ResponseWriter, status int, v any) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(status)
if err := json.NewEncoder(w).Encode(v); err != nil {
log.Printf("writing response: %v", err)
}
}
func writeErr(w http.ResponseWriter, status int, err error) {
writeJSON(w, status, map[string]string{"error": err.Error()})
}
func readJSON(r *http.Request, v any) error {
dec := json.NewDecoder(io.LimitReader(r.Body, 1<<20))
if err := dec.Decode(v); err != nil {
return fmt.Errorf("invalid request body: %w", err)
}
return nil
}
internal/server/server_test.go
+214
View File
@@ -0,0 +1,214 @@
package server
import (
"encoding/json"
"io"
"net/http"
"net/url"
"path/filepath"
"strings"
"testing"
"gitea.apointless.space/bsncubed/ipswap/internal/config"
"gitea.apointless.space/bsncubed/ipswap/internal/netcfg"
"gitea.apointless.space/bsncubed/ipswap/internal/preset"
)
func newTestServer(t *testing.T) (*Server, string, string) {
t.Helper()
dir := t.TempDir()
store, err := preset.NewStore(filepath.Join(dir, "presets.json"))
if err != nil {
t.Fatal(err)
}
paths := config.Paths{Dir: dir, Presets: filepath.Join(dir, "presets.json"), Config: filepath.Join(dir, "config.json")}
s := New(store, netcfg.New(), paths, config.Default())
raw, err := s.Start()
if err != nil {
t.Fatal(err)
}
t.Cleanup(s.Stop)
u, err := url.Parse(raw)
if err != nil {
t.Fatal(err)
}
return s, "http://" + u.Host, u.Query().Get("t")
}
// do issues a request with no cookie jar, so each call is judged purely on
// what it carries.
func do(t *testing.T, method, url, token, header, body string) *http.Response {
t.Helper()
var r io.Reader
if body != "" {
r = strings.NewReader(body)
}
req, err := http.NewRequest(method, url, r)
if err != nil {
t.Fatal(err)
}
if token != "" {
req.AddCookie(&http.Cookie{Name: "ipswap_session", Value: token})
}
if header != "" {
req.Header.Set(tokenHeader, header)
}
resp, err := http.DefaultClient.Do(req)
if err != nil {
t.Fatal(err)
}
return resp
}
func TestServesOnLoopbackOnly(t *testing.T) {
_, base, _ := newTestServer(t)
if !strings.HasPrefix(base, "http://127.0.0.1:") {
t.Errorf("editor must bind loopback only, got %s", base)
}
}
func TestRejectsMissingToken(t *testing.T) {
_, base, _ := newTestServer(t)
resp := do(t, "GET", base+"/api/presets", "", "", "")
defer resp.Body.Close()
if resp.StatusCode != http.StatusUnauthorized {
t.Errorf("no token should be 401, got %d", resp.StatusCode)
}
}
func TestRejectsWrongToken(t *testing.T) {
_, base, _ := newTestServer(t)
resp := do(t, "GET", base+"/api/presets", strings.Repeat("a", 64), "", "")
defer resp.Body.Close()
if resp.StatusCode != http.StatusUnauthorized {
t.Errorf("a wrong token should be 401, got %d", resp.StatusCode)
}
}
func TestQueryTokenSetsCookie(t *testing.T) {
_, base, token := newTestServer(t)
resp := do(t, "GET", base+"/api/presets?t="+token, "", "", "")
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
t.Fatalf("query token should authenticate, got %d", resp.StatusCode)
}
var found bool
for _, c := range resp.Cookies() {
if c.Name == "ipswap_session" {
found = true
if c.SameSite != http.SameSiteStrictMode {
t.Error("session cookie must be SameSite=Strict")
}
if !c.HttpOnly {
t.Error("session cookie must be HttpOnly")
}
}
}
if !found {
t.Error("expected a session cookie to be set")
}
}
// A cookie alone must not be enough to mutate: any page in the browser can
// make the browser send this cookie to 127.0.0.1, but it cannot set a header.
func TestMutationRequiresHeaderNotJustCookie(t *testing.T) {
_, base, token := newTestServer(t)
body := `{"name":"x","adapter":"Ethernet","mode":"dhcp","dns":{"mode":"dhcp"}}`
resp := do(t, "POST", base+"/api/presets", token, "", body)
defer resp.Body.Close()
if resp.StatusCode != http.StatusForbidden {
t.Errorf("cookie-only mutation should be 403, got %d", resp.StatusCode)
}
resp2 := do(t, "POST", base+"/api/presets", token, token, body)
defer resp2.Body.Close()
if resp2.StatusCode != http.StatusOK {
b, _ := io.ReadAll(resp2.Body)
t.Errorf("cookie plus header should succeed, got %d: %s", resp2.StatusCode, b)
}
}
func TestPresetCRUD(t *testing.T) {
_, base, token := newTestServer(t)
body := `{"name":"Control","group":"Riedel","adapter":"Ethernet","mode":"static",
"primary":{"address":"192.168.42.100","prefix":24,"gateway":"192.168.42.1"},
"dns":{"mode":"static","servers":["192.168.42.1"]}}`
resp := do(t, "POST", base+"/api/presets", token, token, body)
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
b, _ := io.ReadAll(resp.Body)
t.Fatalf("create failed: %d %s", resp.StatusCode, b)
}
var created preset.Preset
if err := json.NewDecoder(resp.Body).Decode(&created); err != nil {
t.Fatal(err)
}
if created.ID == "" {
t.Fatal("server should assign an id")
}
list := do(t, "GET", base+"/api/presets", token, "", "")
defer list.Body.Close()
var got struct {
Presets []preset.Preset `json:"presets"`
Groups []string `json:"groups"`
}
if err := json.NewDecoder(list.Body).Decode(&got); err != nil {
t.Fatal(err)
}
if len(got.Presets) != 1 || got.Presets[0].Name != "Control" {
t.Fatalf("list returned %+v", got.Presets)
}
del := do(t, "DELETE", base+"/api/presets/"+created.ID, token, token, "")
defer del.Body.Close()
if del.StatusCode != http.StatusOK {
t.Errorf("delete failed: %d", del.StatusCode)
}
}
func TestInvalidPresetIsRejected(t *testing.T) {
_, base, token := newTestServer(t)
body := `{"name":"bad","adapter":"Ethernet","mode":"static","dns":{"mode":"dhcp"}}`
resp := do(t, "POST", base+"/api/presets", token, token, body)
defer resp.Body.Close()
if resp.StatusCode != http.StatusBadRequest {
t.Errorf("a static preset with no primary should be 400, got %d", resp.StatusCode)
}
}
func TestStopRejectsSubsequentRequests(t *testing.T) {
s, base, token := newTestServer(t)
s.Stop()
if _, err := http.Get(base + "/api/presets?t=" + token); err == nil {
t.Error("expected the listener to be closed after Stop")
}
}
func TestIndexIsServed(t *testing.T) {
_, base, token := newTestServer(t)
resp := do(t, "GET", base+"/?t="+token, "", "", "")
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
t.Fatalf("index should be served, got %d", resp.StatusCode)
}
b, _ := io.ReadAll(resp.Body)
if !strings.Contains(string(b), "ipswap") {
t.Error("index.html does not look like the editor")
}
}
internal/server/web/app.css
+333
View File
@@ -0,0 +1,333 @@
/*
* apointless.css — reconstructed from the description in claude.md.
*
* If you have the canonical apointless.css, drop it in over this file: the
* markup below only uses the components the spec lists (cards, stat cards,
* badges, pills, buttons, inputs, tables, alerts, code blocks, spinners), so a
* real copy should be a straight swap.
*
* Fonts are declared as stacks with system fallbacks rather than pulled from a
* CDN: ipswap runs on laptops sitting on customer networks with no route to
* the internet, and a webfont that 404s would leave the editor unstyled.
*/
:root {
--bg: #0b0d11;
--surface-1: #12151b;
--surface-2: #1a1e28;
--surface-3: #232838;
--text: #e6e9ef;
--text-muted: #9aa3b2;
--text-dim: #6b7382;
--accent: #3b82f6;
--accent-hover: #60a5fa;
--accent-dim: rgba(59, 130, 246, 0.15);
--ok: #22c55e;
--warn: #f59e0b;
--danger: #ef4444;
--info: #38bdf8;
--border: #232838;
--border-strong: #2f3648;
--mono: "JetBrains Mono", ui-monospace, "Cascadia Mono", "Consolas", monospace;
--sans: "DM Sans", ui-sans-serif, system-ui, "Segoe UI", sans-serif;
--radius: 10px;
--radius-sm: 6px;
--gap: 16px;
}
html.light {
--bg: #f6f7f9;
--surface-1: #ffffff;
--surface-2: #f0f2f5;
--surface-3: #e4e7ec;
--text: #12151b;
--text-muted: #4b5563;
--text-dim: #6b7382;
--accent-dim: rgba(59, 130, 246, 0.12);
--border: #dfe3e9;
--border-strong: #c8ced8;
}
* { box-sizing: border-box; }
body {
margin: 0;
background: var(--bg);
color: var(--text);
font-family: var(--sans);
font-size: 15px;
line-height: 1.55;
min-height: 100vh;
position: relative;
}
/* Subtle blue grid behind everything. */
body::before {
content: "";
position: fixed;
inset: 0;
pointer-events: none;
z-index: 0;
background-image:
linear-gradient(to right, rgba(59, 130, 246, 0.05) 1px, transparent 1px),
linear-gradient(to bottom, rgba(59, 130, 246, 0.05) 1px, transparent 1px);
background-size: 40px 40px;
}
.wrap {
position: relative;
z-index: 1;
max-width: 1100px;
margin: 0 auto;
padding: 28px 20px 64px;
}
/* --- typography --- */
h1, h2, h3 { font-weight: 600; line-height: 1.25; margin: 0 0 8px; }
h1 { font-size: 24px; letter-spacing: -0.02em; }
h2 { font-size: 18px; }
h3 { font-size: 15px; color: var(--text-muted); }
.mono { font-family: var(--mono); }
.muted { color: var(--text-muted); }
.dim { color: var(--text-dim); font-size: 13px; }
header.top {
display: flex;
align-items: center;
justify-content: space-between;
gap: var(--gap);
margin-bottom: 24px;
flex-wrap: wrap;
}
/* --- cards --- */
.card {
background: var(--surface-1);
border: 1px solid var(--border);
border-radius: var(--radius);
padding: 18px;
margin-bottom: var(--gap);
}
.card > h2 { margin-bottom: 12px; }
.stat-row {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
gap: 12px;
margin-bottom: var(--gap);
}
.stat-card {
background: var(--surface-1);
border: 1px solid var(--border);
border-radius: var(--radius);
padding: 14px 16px;
}
.stat-card .label {
font-size: 12px;
text-transform: uppercase;
letter-spacing: 0.08em;
color: var(--text-dim);
}
.stat-card .value {
font-family: var(--mono);
font-size: 18px;
margin-top: 4px;
word-break: break-all;
}
/* --- badges and pills --- */
.badge, .pill {
display: inline-block;
font-size: 12px;
font-family: var(--mono);
padding: 2px 8px;
border-radius: 999px;
border: 1px solid var(--border-strong);
color: var(--text-muted);
white-space: nowrap;
}
.badge.accent { background: var(--accent-dim); border-color: var(--accent); color: var(--accent-hover); }
.badge.ok { background: rgba(34, 197, 94, 0.12); border-color: var(--ok); color: var(--ok); }
.badge.warn { background: rgba(245, 158, 11, 0.12); border-color: var(--warn); color: var(--warn); }
.badge.danger { background: rgba(239, 68, 68, 0.12); border-color: var(--danger); color: var(--danger); }
.pill { background: var(--surface-2); }
/* --- buttons --- */
button, .btn {
font-family: var(--sans);
font-size: 14px;
font-weight: 500;
padding: 7px 14px;
border-radius: var(--radius-sm);
border: 1px solid var(--border-strong);
background: var(--surface-2);
color: var(--text);
cursor: pointer;
transition: background 0.12s ease, border-color 0.12s ease;
}
button:hover, .btn:hover { background: var(--surface-3); border-color: var(--accent); }
button:disabled { opacity: 0.5; cursor: not-allowed; }
button:disabled:hover { background: var(--surface-2); border-color: var(--border-strong); }
button.primary { background: var(--accent); border-color: var(--accent); color: #fff; }
button.primary:hover { background: var(--accent-hover); border-color: var(--accent-hover); }
button.danger { border-color: var(--danger); color: var(--danger); }
button.danger:hover { background: rgba(239, 68, 68, 0.12); }
button.ghost { background: transparent; border-color: transparent; color: var(--text-muted); }
button.ghost:hover { background: var(--surface-2); border-color: var(--border); }
button.small { font-size: 12px; padding: 4px 9px; }
.btn-row { display: flex; gap: 8px; flex-wrap: wrap; align-items: center; }
/* --- inputs --- */
label { display: block; font-size: 13px; color: var(--text-muted); margin-bottom: 4px; }
input, select, textarea {
width: 100%;
font-family: var(--mono);
font-size: 14px;
padding: 7px 10px;
border-radius: var(--radius-sm);
border: 1px solid var(--border-strong);
background: var(--surface-2);
color: var(--text);
}
input:focus, select:focus, textarea:focus {
outline: none;
border-color: var(--accent);
box-shadow: 0 0 0 3px var(--accent-dim);
}
input[type="checkbox"] { width: auto; accent-color: var(--accent); }
.field { margin-bottom: 12px; }
.field-row {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
gap: 12px;
}
.check { display: flex; align-items: center; gap: 8px; }
.check label { margin: 0; }
/* --- tables --- */
table { width: 100%; border-collapse: collapse; font-size: 14px; }
th {
text-align: left;
font-size: 12px;
text-transform: uppercase;
letter-spacing: 0.06em;
color: var(--text-dim);
font-weight: 500;
padding: 8px 10px;
border-bottom: 1px solid var(--border-strong);
}
td { padding: 9px 10px; border-bottom: 1px solid var(--border); vertical-align: middle; }
tbody tr:hover { background: var(--surface-2); }
td.mono, .table-scroll td.addr { font-family: var(--mono); font-size: 13px; }
.table-scroll { overflow-x: auto; }
/* --- alerts --- */
.alert {
border-radius: var(--radius-sm);
border: 1px solid var(--border-strong);
background: var(--surface-2);
padding: 10px 14px;
margin-bottom: 12px;
font-size: 14px;
}
.alert.ok { border-color: var(--ok); background: rgba(34, 197, 94, 0.10); }
.alert.warn { border-color: var(--warn); background: rgba(245, 158, 11, 0.10); }
.alert.danger { border-color: var(--danger); background: rgba(239, 68, 68, 0.10); }
.alert.info { border-color: var(--info); background: rgba(56, 189, 248, 0.10); }
/* --- code --- */
pre, code {
font-family: var(--mono);
font-size: 13px;
}
pre {
background: var(--surface-2);
border: 1px solid var(--border);
border-radius: var(--radius-sm);
padding: 12px;
overflow-x: auto;
}
/* --- spinner --- */
.spinner {
display: inline-block;
width: 14px;
height: 14px;
border: 2px solid var(--border-strong);
border-top-color: var(--accent);
border-radius: 50%;
animation: spin 0.7s linear infinite;
vertical-align: -2px;
}
@keyframes spin { to { transform: rotate(360deg); } }
/* --- layout odds and ends --- */
.group-head {
display: flex;
align-items: center;
gap: 10px;
margin: 20px 0 8px;
}
.group-head h2 { margin: 0; }
.empty {
text-align: center;
color: var(--text-dim);
padding: 32px 16px;
}
dialog {
background: var(--surface-1);
color: var(--text);
border: 1px solid var(--border-strong);
border-radius: var(--radius);
padding: 20px;
width: min(680px, 92vw);
}
dialog::backdrop { background: rgba(0, 0, 0, 0.6); }
.sec-list { display: flex; flex-direction: column; gap: 8px; }
.sec-row { display: flex; gap: 8px; align-items: center; }
.sec-row input { flex: 1; }
.hidden { display: none !important; }
internal/server/web/app.js
+435
View File
@@ -0,0 +1,435 @@
/*
* ipswap preset editor.
*
* Plain ES modules-free JavaScript on purpose: the whole app is served from an
* embed.FS inside a single .exe, and a build step for the front end would mean
* a Node toolchain in CI for a few hundred lines of DOM code.
*/
// The token arrives once in the query string. The server also sets it as a
// SameSite=Strict cookie, but mutations additionally require it as a header —
// a cookie alone would let any page in the browser POST to this port.
const TOKEN = new URLSearchParams(location.search).get("t") || "";
const state = {
presets: [],
groups: [],
adapters: [],
settings: null,
editing: null,
};
// --- theme ---
const themeToggle = document.getElementById("theme-toggle");
function applyTheme(light) {
document.documentElement.classList.toggle("light", light);
themeToggle.textContent = light ? "Dark" : "Light";
localStorage.setItem("ipswap-theme", light ? "light" : "dark");
}
applyTheme(localStorage.getItem("ipswap-theme") === "light");
themeToggle.addEventListener("click", () =>
applyTheme(!document.documentElement.classList.contains("light"))
);
// --- api ---
async function api(path, opts = {}) {
const headers = Object.assign({}, opts.headers);
if (opts.method && opts.method !== "GET") {
headers["X-Ipswap-Token"] = TOKEN;
if (opts.body && !headers["Content-Type"]) {
headers["Content-Type"] = "application/json";
}
}
const res = await fetch(path, Object.assign({}, opts, { headers }));
const text = await res.text();
let data = null;
try {
data = text ? JSON.parse(text) : null;
} catch {
// Non-JSON bodies come from the auth middleware, which writes plain text.
if (!res.ok) throw new Error(text || res.statusText);
}
if (!res.ok) throw new Error((data && data.error) || text || res.statusText);
return data;
}
// The server shuts down after five minutes without one of these.
setInterval(() => {
api("/api/heartbeat", { method: "POST" }).catch(() => {});
}, 30_000);
// --- alerts ---
function alertBox(kind, message, container = "alerts") {
const host = document.getElementById(container);
host.innerHTML = `<div class="alert ${kind}">${escapeHTML(message)}</div>`;
if (kind === "ok") setTimeout(() => (host.innerHTML = ""), 4000);
}
function escapeHTML(s) {
return String(s).replace(/[&<>"']/g, (c) =>
({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]
);
}
// --- rendering ---
function maskOf(prefix) {
if (state.settings && state.settings.mask_style === "dotted") {
let m = prefix === 0 ? 0 : (0xffffffff << (32 - prefix)) >>> 0;
return [m >>> 24, (m >>> 16) & 255, (m >>> 8) & 255, m & 255].join(".");
}
return "/" + prefix;
}
function addrText(a) {
return a.address + maskOf(a.prefix).replace(/^(?!\/)/, " ");
}
function renderStats() {
const adapters = new Set(state.presets.map((p) => p.adapter));
document.getElementById("stats").innerHTML = `
<div class="stat-card"><div class="label">Presets</div><div class="value">${state.presets.length}</div></div>
<div class="stat-card"><div class="label">Groups</div><div class="value">${state.groups.length}</div></div>
<div class="stat-card"><div class="label">Adapters in use</div><div class="value">${adapters.size}</div></div>
`;
}
function renderPresets() {
const host = document.getElementById("groups");
if (!state.presets.length) {
host.innerHTML = `<div class="card"><div class="empty">No presets yet. Create one, or import a pack from a colleague.</div></div>`;
return;
}
const byGroup = new Map();
for (const p of state.presets) {
const g = p.group && p.group.trim() ? p.group : "Ungrouped";
if (!byGroup.has(g)) byGroup.set(g, []);
byGroup.get(g).push(p);
}
let html = "";
for (const [group, presets] of byGroup) {
html += `
<div class="group-head">
<h2>${escapeHTML(group)}</h2>
<span class="pill">${presets.length}</span>
</div>
<div class="card" style="padding:0">
<div class="table-scroll">
<table>
<thead><tr>
<th>Name</th><th>Adapter</th><th>Address</th><th>Gateway</th><th>DNS</th><th></th>
</tr></thead>
<tbody>`;
for (const p of presets) {
const isDHCP = p.mode === "dhcp";
const addr = isDHCP
? `<span class="badge accent">DHCP</span>`
: escapeHTML(addrText(p.primary)) +
(p.secondary && p.secondary.length
? ` <span class="pill">+${p.secondary.length}</span>`
: "");
const dns =
p.dns.mode === "dhcp"
? `<span class="badge">from DHCP</span>`
: escapeHTML((p.dns.servers || []).join(", "));
html += `<tr>
<td>${escapeHTML(p.name)}${p.notes ? `<div class="dim">${escapeHTML(p.notes)}</div>` : ""}</td>
<td class="mono">${escapeHTML(p.adapter)}</td>
<td class="addr">${addr}</td>
<td class="addr">${isDHCP ? "" : escapeHTML(p.primary.gateway || "—")}</td>
<td class="addr">${dns}</td>
<td style="text-align:right; white-space:nowrap">
<button class="small" data-edit="${escapeHTML(p.id)}">Edit</button>
<button class="small danger" data-del="${escapeHTML(p.id)}">Delete</button>
</td>
</tr>`;
}
html += `</tbody></table></div></div>`;
}
host.innerHTML = html;
host.querySelectorAll("[data-edit]").forEach((b) =>
b.addEventListener("click", () => openEditor(b.dataset.edit))
);
host.querySelectorAll("[data-del]").forEach((b) =>
b.addEventListener("click", () => deletePreset(b.dataset.del))
);
}
function renderAdapters() {
const body = document.getElementById("adapters");
if (!state.adapters.length) {
body.innerHTML = `<tr><td colspan="4" class="dim">No adapters found.</td></tr>`;
return;
}
body.innerHTML = state.adapters
.map(
(a) => `<tr>
<td class="mono">${escapeHTML(a.name)}</td>
<td class="dim">${escapeHTML(a.description || "")}</td>
<td class="addr">${escapeHTML(a.current || "—")}</td>
<td>${a.up ? '<span class="badge ok">up</span>' : '<span class="badge">down</span>'}</td>
</tr>`
)
.join("");
}
// --- loading ---
async function loadAll() {
const [presets, adapters, settings] = await Promise.all([
api("/api/presets"),
api("/api/adapters"),
api("/api/settings"),
]);
state.presets = presets.presets || [];
state.groups = presets.groups || [];
state.adapters = adapters.adapters || [];
state.settings = settings;
renderStats();
renderPresets();
renderAdapters();
document.getElementById("group-list").innerHTML = state.groups
.map((g) => `<option value="${escapeHTML(g)}">`)
.join("");
document.getElementById("f-adapter").innerHTML = state.adapters
.map((a) => `<option value="${escapeHTML(a.name)}">${escapeHTML(a.name)}</option>`)
.join("");
}
// --- editor ---
const editor = document.getElementById("editor");
function secondaryRow(addr = "", prefix = "") {
const div = document.createElement("div");
div.className = "sec-row";
div.innerHTML = `
<input class="sec-addr" placeholder="10.0.10.50" value="${escapeHTML(addr)}">
<input class="sec-prefix" placeholder="/24" value="${escapeHTML(prefix)}" style="max-width:150px">
<button type="button" class="small ghost sec-del">✕</button>`;
div.querySelector(".sec-del").addEventListener("click", () => div.remove());
return div;
}
function openEditor(id) {
const p = id ? state.presets.find((x) => x.id === id) : null;
state.editing = p ? p.id : null;
document.getElementById("editor-title").textContent = p ? "Edit preset" : "New preset";
document.getElementById("editor-error").innerHTML = "";
document.getElementById("f-name").value = p ? p.name : "";
document.getElementById("f-group").value = p ? p.group || "" : "";
document.getElementById("f-adapter").value = p ? p.adapter : (state.adapters[0] || {}).name || "";
document.getElementById("f-mode").value = p ? p.mode : "static";
document.getElementById("f-notes").value = p ? p.notes || "" : "";
const prim = (p && p.primary) || {};
document.getElementById("f-address").value = prim.address || "";
document.getElementById("f-prefix").value = prim.prefix !== undefined ? maskOf(prim.prefix) : "";
document.getElementById("f-gateway").value = prim.gateway || "";
document.getElementById("f-metric").value = prim.gateway_metric || 0;
const secs = document.getElementById("secondaries");
secs.innerHTML = "";
for (const s of (p && p.secondary) || []) secs.appendChild(secondaryRow(s.address, maskOf(s.prefix)));
document.getElementById("f-dns-mode").value = p ? p.dns.mode : "static";
document.getElementById("f-dns").value = p ? (p.dns.servers || []).join(", ") : "";
syncModeVisibility();
editor.showModal();
}
function syncModeVisibility() {
const isDHCP = document.getElementById("f-mode").value === "dhcp";
document.getElementById("static-fields").classList.toggle("hidden", isDHCP);
const dnsStatic = document.getElementById("f-dns-mode").value === "static";
document.getElementById("dns-servers-field").classList.toggle("hidden", !dnsStatic);
}
document.getElementById("f-mode").addEventListener("change", syncModeVisibility);
document.getElementById("f-dns-mode").addEventListener("change", syncModeVisibility);
document.getElementById("btn-add-sec").addEventListener("click", () =>
document.getElementById("secondaries").appendChild(secondaryRow())
);
document.getElementById("btn-new").addEventListener("click", () => openEditor(null));
document.getElementById("btn-cancel").addEventListener("click", () => editor.close());
// Masks are parsed here so the editor accepts both spellings, matching the Go
// side's ParsePrefix. Anything malformed is reported before the request goes
// out rather than coming back as a server-side validation error.
function parsePrefix(s) {
s = (s || "").trim().replace(/^\//, "");
if (!s) throw new Error("mask is required");
if (s.includes(".")) {
const parts = s.split(".").map(Number);
if (parts.length !== 4 || parts.some((n) => !Number.isInteger(n) || n < 0 || n > 255)) {
throw new Error(`"${s}" is not a dotted-quad netmask`);
}
const m = ((parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8) | parts[3]) >>> 0;
let ones = 0;
while (ones < 32 && m & (1 << (31 - ones))) ones++;
if (ones < 32 && (m << ones) >>> 0) throw new Error(`"${s}" is not a contiguous netmask`);
return ones;
}
const n = Number(s);
if (!Number.isInteger(n) || n < 0 || n > 32) throw new Error(`"${s}" is not a prefix length`);
return n;
}
async function savePreset() {
const mode = document.getElementById("f-mode").value;
const dnsMode = document.getElementById("f-dns-mode").value;
let body;
try {
body = {
id: state.editing || "",
name: document.getElementById("f-name").value.trim(),
group: document.getElementById("f-group").value.trim(),
adapter: document.getElementById("f-adapter").value,
mode,
notes: document.getElementById("f-notes").value.trim(),
dns: {
mode: dnsMode,
servers:
dnsMode === "static"
? document.getElementById("f-dns").value.split(",").map((s) => s.trim()).filter(Boolean)
: undefined,
},
};
if (mode === "static") {
body.primary = {
address: document.getElementById("f-address").value.trim(),
prefix: parsePrefix(document.getElementById("f-prefix").value),
gateway: document.getElementById("f-gateway").value.trim() || undefined,
gateway_metric: Number(document.getElementById("f-metric").value) || undefined,
};
const secs = [];
for (const row of document.querySelectorAll("#secondaries .sec-row")) {
const a = row.querySelector(".sec-addr").value.trim();
if (!a) continue;
secs.push({ address: a, prefix: parsePrefix(row.querySelector(".sec-prefix").value) });
}
if (secs.length) body.secondary = secs;
}
} catch (e) {
alertBox("danger", e.message, "editor-error");
return;
}
try {
const path = state.editing ? `/api/presets/${encodeURIComponent(state.editing)}` : "/api/presets";
await api(path, { method: state.editing ? "PUT" : "POST", body: JSON.stringify(body) });
editor.close();
await loadAll();
alertBox("ok", "Preset saved.");
} catch (e) {
alertBox("danger", e.message, "editor-error");
}
}
document.getElementById("btn-save").addEventListener("click", savePreset);
async function deletePreset(id) {
const p = state.presets.find((x) => x.id === id);
if (!confirm(`Delete preset "${p ? p.name : id}"?`)) return;
try {
await api(`/api/presets/${encodeURIComponent(id)}`, { method: "DELETE" });
await loadAll();
alertBox("ok", "Preset deleted.");
} catch (e) {
alertBox("danger", e.message);
}
}
// --- settings ---
const settingsDlg = document.getElementById("settings");
document.getElementById("btn-settings").addEventListener("click", () => {
const s = state.settings || {};
document.getElementById("s-mask").value = s.mask_style || "prefix";
document.getElementById("s-startup").checked = !!s.start_with_windows;
document.getElementById("s-updates").checked = !!s.check_updates;
document.getElementById("s-repo").value = s.update_repo || "";
settingsDlg.showModal();
});
document.getElementById("btn-settings-cancel").addEventListener("click", () => settingsDlg.close());
document.getElementById("btn-settings-save").addEventListener("click", async () => {
try {
await api("/api/settings", {
method: "PUT",
body: JSON.stringify({
mask_style: document.getElementById("s-mask").value,
start_with_windows: document.getElementById("s-startup").checked,
check_updates: document.getElementById("s-updates").checked,
update_repo: document.getElementById("s-repo").value.trim(),
}),
});
settingsDlg.close();
await loadAll();
alertBox("ok", "Settings saved.");
} catch (e) {
alertBox("danger", e.message);
}
});
// --- import / export ---
document.getElementById("btn-export").addEventListener("click", () => {
// A plain navigation, so the browser's own download UI picks the location.
location.href = "/api/export";
});
const importDlg = document.getElementById("import");
document.getElementById("btn-import").addEventListener("click", () => {
document.getElementById("import-error").innerHTML = "";
importDlg.showModal();
});
document.getElementById("btn-import-cancel").addEventListener("click", () => importDlg.close());
document.getElementById("btn-import-go").addEventListener("click", async () => {
const file = document.getElementById("i-file").files[0];
if (!file) {
alertBox("danger", "Choose a file first.", "import-error");
return;
}
const mode = document.getElementById("i-mode").value;
if (mode === "replace" && !confirm("Replace discards every preset you currently have. Continue?")) {
return;
}
try {
const res = await api(`/api/import?mode=${mode}`, { method: "POST", body: await file.text() });
importDlg.close();
await loadAll();
let msg = `Imported ${res.added} preset${res.added === 1 ? "" : "s"}.`;
if (res.renamed && res.renamed.length) {
msg += ` ${res.renamed.length} had an id collision and were kept alongside the originals.`;
}
alertBox("ok", msg);
} catch (e) {
alertBox("danger", e.message, "import-error");
}
});
// --- go ---
loadAll().catch((e) => alertBox("danger", `Could not load: ${e.message}`));
internal/server/web/index.html
+193
View File
@@ -0,0 +1,193 @@
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>ipswap — presets</title>
<link rel="stylesheet" href="/app.css">
</head>
<body>
<div class="wrap">
<header class="top">
<div>
<h1>ipswap</h1>
<div class="dim">Preset editor · this page closes itself when you stop using it</div>
</div>
<div class="btn-row">
<button id="theme-toggle" class="ghost small">Light</button>
<button id="btn-settings" class="ghost small">Settings</button>
</div>
</header>
<div id="alerts"></div>
<div class="stat-row" id="stats"></div>
<div class="card">
<div class="btn-row" style="justify-content: space-between;">
<h2 style="margin:0">Presets</h2>
<div class="btn-row">
<button id="btn-import">Import…</button>
<button id="btn-export">Export</button>
<button id="btn-new" class="primary">New preset</button>
</div>
</div>
</div>
<div id="groups"></div>
<div class="card">
<h2>Adapters on this machine</h2>
<div class="table-scroll">
<table>
<thead>
<tr><th>Name</th><th>Description</th><th>Current IPv4</th><th>State</th></tr>
</thead>
<tbody id="adapters"><tr><td colspan="4"><span class="spinner"></span></td></tr></tbody>
</table>
</div>
</div>
</div>
<!-- preset editor -->
<dialog id="editor">
<form method="dialog" id="editor-form">
<h2 id="editor-title">New preset</h2>
<div id="editor-error"></div>
<div class="field-row">
<div class="field">
<label for="f-name">Name</label>
<input id="f-name" required placeholder="Artist frame — control">
</div>
<div class="field">
<label for="f-group">Group</label>
<input id="f-group" list="group-list" placeholder="Riedel">
<datalist id="group-list"></datalist>
</div>
</div>
<div class="field-row">
<div class="field">
<label for="f-adapter">Adapter</label>
<select id="f-adapter"></select>
</div>
<div class="field">
<label for="f-mode">Mode</label>
<select id="f-mode">
<option value="static">Static</option>
<option value="dhcp">DHCP</option>
</select>
</div>
</div>
<div id="static-fields">
<div class="field-row">
<div class="field">
<label for="f-address">Address</label>
<input id="f-address" placeholder="192.168.42.100">
</div>
<div class="field">
<label for="f-prefix">Mask <span class="dim">(/24 or 255.255.255.0)</span></label>
<input id="f-prefix" placeholder="/24">
</div>
</div>
<div class="field-row">
<div class="field">
<label for="f-gateway">Gateway <span class="dim">(optional)</span></label>
<input id="f-gateway" placeholder="192.168.42.1">
</div>
<div class="field">
<label for="f-metric">Gateway metric <span class="dim">(0 = automatic)</span></label>
<input id="f-metric" type="number" min="0" value="0">
</div>
</div>
<div class="field">
<label>Secondary addresses</label>
<div class="sec-list" id="secondaries"></div>
<button type="button" id="btn-add-sec" class="small" style="margin-top:8px">Add secondary</button>
</div>
</div>
<div class="field">
<label for="f-dns-mode">DNS</label>
<select id="f-dns-mode">
<option value="static">Static</option>
<option value="dhcp">From DHCP</option>
</select>
</div>
<div class="field" id="dns-servers-field">
<label for="f-dns">DNS servers <span class="dim">(comma separated, order matters)</span></label>
<input id="f-dns" placeholder="192.168.42.1, 1.1.1.1">
</div>
<div class="field">
<label for="f-notes">Notes</label>
<input id="f-notes" placeholder="Frame A, rack 3">
</div>
<div class="btn-row" style="justify-content: flex-end; margin-top: 16px;">
<button type="button" id="btn-cancel" class="ghost">Cancel</button>
<button type="button" id="btn-save" class="primary">Save</button>
</div>
</form>
</dialog>
<!-- settings -->
<dialog id="settings">
<h2>Settings</h2>
<div class="field">
<label for="s-mask">Mask display</label>
<select id="s-mask">
<option value="prefix">Prefix (/24)</option>
<option value="dotted">Dotted (255.255.255.0)</option>
</select>
</div>
<div class="field check">
<input type="checkbox" id="s-startup">
<label for="s-startup">Start ipswap when Windows starts</label>
</div>
<div class="field check">
<input type="checkbox" id="s-updates">
<label for="s-updates">Check for updates on startup</label>
</div>
<div class="field">
<label for="s-repo">Update repository <span class="dim">(https://host/owner/repo — blank disables)</span></label>
<input id="s-repo" placeholder="https://gitea.apointless.space/bsncubed/ipswap">
</div>
<div class="btn-row" style="justify-content: flex-end; margin-top: 16px;">
<button type="button" id="btn-settings-cancel" class="ghost">Cancel</button>
<button type="button" id="btn-settings-save" class="primary">Save</button>
</div>
</dialog>
<!-- import -->
<dialog id="import">
<h2>Import presets</h2>
<div class="alert info">
The file is validated in full before anything is written. If it is rejected, nothing changes.
</div>
<div class="field">
<label for="i-file">Preset pack (.json)</label>
<input type="file" id="i-file" accept="application/json,.json">
</div>
<div class="field">
<label for="i-mode">Mode</label>
<select id="i-mode">
<option value="merge">Merge — keep what I have, add these</option>
<option value="replace">Replace — discard my existing presets</option>
</select>
</div>
<div id="import-error"></div>
<div class="btn-row" style="justify-content: flex-end; margin-top: 16px;">
<button type="button" id="btn-import-cancel" class="ghost">Cancel</button>
<button type="button" id="btn-import-go" class="primary">Import</button>
</div>
</dialog>
<script src="/app.js"></script>
</body>
</html>
internal/tray/helpers.go
+21
View File
@@ -0,0 +1,21 @@
package tray
import (
"errors"
"os"
"path/filepath"
"gitea.apointless.space/bsncubed/ipswap/internal/config"
"gitea.apointless.space/bsncubed/ipswap/internal/netcfg"
)
// isElevationErr reports whether a failed apply was refused for lack of
// administrator rights, which is the one failure that has a useful next step.
func isElevationErr(err error) bool {
return errors.Is(err, netcfg.ErrElevationRequired)
}
// tempDir is where update downloads land.
func tempDir() string {
return filepath.Join(os.TempDir(), config.AppName)
}
internal/tray/icon.ico
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.5 KiB

internal/tray/tray.go
+430
View File
@@ -0,0 +1,430 @@
// Package tray is the fast path: the tray icon, its grouped preset menu, and
// the confirm-then-apply flow.
//
// Everything here is driven by systray's callbacks, which run on the UI
// goroutine. Nothing slow may happen inline — a netsh apply takes one to three
// seconds and would freeze the menu — so every click handler hands off to a
// goroutine immediately.
package tray
import (
"context"
_ "embed"
"fmt"
"log"
"sync"
"time"
"fyne.io/systray"
"gitea.apointless.space/bsncubed/ipswap/internal/config"
"gitea.apointless.space/bsncubed/ipswap/internal/desktop"
"gitea.apointless.space/bsncubed/ipswap/internal/dialog"
"gitea.apointless.space/bsncubed/ipswap/internal/elevate"
"gitea.apointless.space/bsncubed/ipswap/internal/netcfg"
"gitea.apointless.space/bsncubed/ipswap/internal/preset"
"gitea.apointless.space/bsncubed/ipswap/internal/server"
"gitea.apointless.space/bsncubed/ipswap/internal/updater"
)
//go:embed icon.ico
var iconICO []byte
// App owns the tray and everything it talks to.
type App struct {
Store *preset.Store
Manager netcfg.Manager
Server *server.Server
Paths config.Paths
Version string
mu sync.Mutex
settings config.Settings
// activeID is the preset currently matching the live adapter state, empty
// when nothing matches.
activeID string
// pendingUpdate is set once the update check finds a newer release.
pendingUpdate *updater.Update
// menuGen is closed and replaced on every menu rebuild, so the click
// listeners attached to the previous set of items exit instead of leaking
// a goroutine per rebuild.
menuGen chan struct{}
titleItem *systray.MenuItem
updateItem *systray.MenuItem
// presetItems maps preset id to its menu entry, for the check marks.
presetItems map[string]*systray.MenuItem
elevated bool
}
// New builds the tray application.
func New(store *preset.Store, mgr netcfg.Manager, srv *server.Server, paths config.Paths, settings config.Settings, version string) *App {
return &App{
Store: store,
Manager: mgr,
Server: srv,
Paths: paths,
Version: version,
settings: settings,
elevated: elevate.IsElevated(),
}
}
// Run blocks until the user exits. It must be called from the main goroutine.
func (a *App) Run() {
a.Server.OnPresetsChange(func() {
// The editor changed something; rebuild on the UI goroutine.
go a.rebuild()
})
a.Server.OnSettingsChange(a.applySettings)
systray.Run(a.onReady, a.onExit)
}
func (a *App) onReady() {
systray.SetIcon(iconICO)
systray.SetTitle(config.AppName)
systray.SetTooltip(config.AppName)
a.build()
go a.pollActive()
go a.checkUpdatesOnStartup()
}
func (a *App) onExit() {
a.Server.Stop()
log.Printf("%s exiting", config.AppName)
}
// --- menu construction ---
func (a *App) rebuild() {
systray.ResetMenu()
a.build()
a.refreshActive()
}
func (a *App) build() {
a.mu.Lock()
if a.menuGen != nil {
close(a.menuGen) // retire the previous generation's listeners
}
gen := make(chan struct{})
a.menuGen = gen
pending := a.pendingUpdate
a.mu.Unlock()
// Update offer sits at the very top when there is one.
updateItem := systray.AddMenuItem("", "A newer release is available")
updateItem.Hide()
if pending != nil {
updateItem.SetTitle(fmt.Sprintf("Update available — v%s", pending.Version))
updateItem.Show()
}
a.onClick(gen, updateItem, a.doUpdate)
titleItem := systray.AddMenuItem(config.AppName, "The preset currently applied")
titleItem.Disable()
systray.AddSeparator()
// Groups become submenus. A flat list of fifty presets is unusable, so
// this is not optional even when there are only a handful.
presets := a.Store.All()
if len(presets) == 0 {
empty := systray.AddMenuItem("No presets yet — use Manage presets…", "")
empty.Disable()
}
items := make(map[string]*systray.MenuItem, len(presets))
var currentGroup string
var sub *systray.MenuItem
for _, p := range presets {
g := p.GroupOrUngrouped()
if g != currentGroup || sub == nil {
currentGroup = g
sub = systray.AddMenuItem(g, "")
}
item := sub.AddSubMenuItemCheckbox(p.Name, p.Notes, false)
items[p.ID] = item
id := p.ID
a.onClick(gen, item, func() { a.applyPreset(id) })
}
// The menu is built on the UI goroutine but read by the active-preset
// poller, so every handle it touches is published under the lock.
a.mu.Lock()
a.presetItems = items
a.titleItem = titleItem
a.updateItem = updateItem
a.mu.Unlock()
systray.AddSeparator()
manage := systray.AddMenuItem("Manage presets…", "Open the preset editor in your browser")
a.onClick(gen, manage, a.openEditor)
check := systray.AddMenuItem("Check for updates", "")
a.onClick(gen, check, a.checkUpdatesNow)
if !a.elevated {
systray.AddSeparator()
relaunch := systray.AddMenuItem("Relaunch as administrator", "Applying a preset needs an elevated process")
a.onClick(gen, relaunch, a.relaunch)
}
systray.AddSeparator()
quit := systray.AddMenuItem("Exit", "")
a.onClick(gen, quit, func() { systray.Quit() })
}
// onClick runs fn on its own goroutine for every click, until this menu
// generation is retired.
func (a *App) onClick(gen <-chan struct{}, item *systray.MenuItem, fn func()) {
go func() {
for {
select {
case <-gen:
return
case _, ok := <-item.ClickedCh:
if !ok {
return
}
go fn()
}
}
}()
}
// --- actions ---
// applyPreset is the whole fast path: read the live config, show the diff,
// and on a Yes run the netsh plan.
func (a *App) applyPreset(id string) {
p, ok := a.Store.Get(id)
if !ok {
dialog.Error(config.AppName, "That preset no longer exists.")
return
}
// Read live rather than reusing the poll's cached view: this text is the
// only safety net before a destructive change and it must not be stale.
live, err := a.Manager.Current(p.Adapter)
if err != nil {
dialog.Error(config.AppName, fmt.Sprintf(
"Could not read the current configuration of adapter %q.\n\n%v", p.Adapter, err))
return
}
if !dialog.Confirm(config.AppName, netcfg.ConfirmText(p, live)) {
log.Printf("apply of %q cancelled at the prompt", p.Name)
return
}
log.Printf("applying preset %q to %q", p.Name, p.Adapter)
plan := netcfg.Plan(p, live)
if err := a.Manager.Apply(plan); err != nil {
log.Printf("apply of %q failed: %v", p.Name, err)
if isElevationErr(err) && !a.elevated {
if dialog.ErrorWithRetryAsAdmin(config.AppName,
fmt.Sprintf("Applying %q needs administrator rights.", p.Name)) {
a.relaunch()
}
return
}
dialog.Error(config.AppName, fmt.Sprintf("Applying %q failed.\n\n%v", p.Name, err))
return
}
log.Printf("applied preset %q", p.Name)
a.refreshActive()
}
func (a *App) openEditor() {
url, err := a.Server.Start()
if err != nil {
dialog.Error(config.AppName, fmt.Sprintf("Could not start the preset editor.\n\n%v", err))
return
}
if err := desktop.OpenURL(url); err != nil {
// The server is up, so give the user the address rather than just failing.
dialog.Error(config.AppName, fmt.Sprintf(
"Could not open your browser. Paste this address into it:\n\n%s\n\n%v", url, err))
}
}
func (a *App) relaunch() {
if err := elevate.RelaunchAsAdmin(); err != nil {
log.Printf("relaunch as admin failed: %v", err)
return
}
systray.Quit()
}
func (a *App) applySettings(c config.Settings) {
a.mu.Lock()
a.settings = c
a.mu.Unlock()
if err := desktop.SetRunAtLogin(c.StartWithWindows); err != nil {
log.Printf("updating the start-with-Windows setting: %v", err)
}
}
func (a *App) currentSettings() config.Settings {
a.mu.Lock()
defer a.mu.Unlock()
return a.settings
}
// --- active preset detection ---
// pollActive re-reads the live adapter state on a timer so the check mark and
// tooltip stay right when something outside ipswap changes the network.
func (a *App) pollActive() {
a.refreshActive()
interval := time.Duration(a.currentSettings().ActivePollSeconds) * time.Second
t := time.NewTicker(interval)
defer t.Stop()
for range t.C {
a.refreshActive()
}
}
func (a *App) refreshActive() {
presets := a.Store.All()
// One read per distinct adapter rather than one per preset: fifty presets
// across three adapters is three reads, not fifty.
live := map[string]netcfg.LiveConfig{}
for _, p := range presets {
if _, done := live[p.Adapter]; done {
continue
}
cfg, err := a.Manager.Current(p.Adapter)
if err != nil {
continue
}
live[p.Adapter] = cfg
}
activeID, activeName := "", ""
for _, p := range presets {
cfg, ok := live[p.Adapter]
if ok && netcfg.Matches(p, cfg) {
activeID, activeName = p.ID, p.Name
break
}
}
a.mu.Lock()
a.activeID = activeID
items := a.presetItems
title := a.titleItem
a.mu.Unlock()
for id, item := range items {
if id == activeID {
item.Check()
} else {
item.Uncheck()
}
}
label := config.AppName + " — unmatched"
if activeName != "" {
label = config.AppName + " — " + activeName
}
systray.SetTooltip(label)
if title != nil {
title.SetTitle(label)
}
}
// --- updates ---
func (a *App) checkUpdatesOnStartup() {
if !a.currentSettings().CheckUpdates {
return
}
// Never block startup on the network, and never surface a failure: a
// laptop on a customer site usually cannot reach the Gitea host.
if _, err := a.checkUpdates(); err != nil {
log.Printf("startup update check failed (ignored): %v", err)
}
}
// checkUpdatesNow is the menu-driven check, which does report its result.
func (a *App) checkUpdatesNow() {
up, err := a.checkUpdates()
switch {
case err != nil:
dialog.Error(config.AppName, fmt.Sprintf("Could not check for updates.\n\n%v", err))
case up == nil:
dialog.Info(config.AppName, fmt.Sprintf("%s v%s is up to date.", config.AppName, a.Version))
default:
dialog.Info(config.AppName, fmt.Sprintf(
"%s v%s is available.\n\nChoose \"Update available\" in the tray menu to install it.", config.AppName, up.Version))
}
}
func (a *App) checkUpdates() (*updater.Update, error) {
s := a.currentSettings()
if s.UpdateRepo == "" {
return nil, fmt.Errorf("no update repository is configured (set one in Settings)")
}
c := &updater.Checker{Repo: s.UpdateRepo, Current: a.Version}
up, err := c.Check(context.Background())
if err != nil {
return nil, err
}
a.mu.Lock()
a.pendingUpdate = up
item := a.updateItem
a.mu.Unlock()
if up != nil && item != nil {
item.SetTitle(fmt.Sprintf("Update available — v%s", up.Version))
item.Show()
}
return up, nil
}
// doUpdate downloads, verifies and installs. Nothing here happens without the
// user having clicked the update item first.
func (a *App) doUpdate() {
a.mu.Lock()
up := a.pendingUpdate
repo := a.settings.UpdateRepo
a.mu.Unlock()
if up == nil {
return
}
if !dialog.Confirm(config.AppName, fmt.Sprintf(
"Download and install %s v%s?\n\n%s will close and reopen once the update is in place.",
config.AppName, up.Version, config.AppName)) {
return
}
c := &updater.Checker{Repo: repo, Current: a.Version}
path, err := c.Download(context.Background(), up, tempDir())
if err != nil {
dialog.Error(config.AppName, fmt.Sprintf("The update could not be downloaded.\n\n%v", err))
return
}
if err := updater.InstallAndRestart(path); err != nil {
dialog.Error(config.AppName, fmt.Sprintf("The update could not be installed.\n\n%v", err))
return
}
systray.Quit()
}
internal/updater/install_other.go
+11
View File
@@ -0,0 +1,11 @@
//go:build !windows
package updater
import "errors"
// InstallAndRestart is Windows-only: the swap helper is a batch file and the
// thing being replaced is an .exe.
func InstallAndRestart(downloadedExe string) error {
return errors.New("in-place update is only supported on Windows")
}
internal/updater/install_windows.go
+95
View File
@@ -0,0 +1,95 @@
//go:build windows
package updater
import (
"fmt"
"os"
"os/exec"
"path/filepath"
"strconv"
"syscall"
)
// swapScript waits for ipswap to exit, replaces the binary, restarts it and
// deletes itself.
//
// A running .exe on Windows is locked against overwriting, so the swap cannot
// be done by the process being replaced — it has to outlive it. A tiny batch
// file is the least machinery that does this without shipping a second binary.
//
// %1 is the PID to wait for, %2 the freshly downloaded exe, %3 the exe to
// replace. The tasklist/find pair is the standard "is this PID still alive"
// idiom; `timeout` rather than `ping -n` keeps it readable.
const swapScript = `@echo off
setlocal
set PID=%~1
set NEWEXE=%~2
set TARGET=%~3
rem Give up after ~30s rather than spinning forever if the old process hangs.
set /a TRIES=0
:wait
tasklist /FI "PID eq %PID%" 2>nul | find "%PID%" >nul
if errorlevel 1 goto swap
set /a TRIES+=1
if %TRIES% GEQ 30 goto giveup
timeout /t 1 /nobreak >nul
goto wait
:swap
copy /y "%NEWEXE%" "%TARGET%" >nul
if errorlevel 1 goto giveup
del /q "%NEWEXE%" >nul 2>&1
start "" "%TARGET%"
goto done
:giveup
rem Leave the download in place so the user can swap it in by hand.
exit /b 1
:done
endlocal
rem Delete this script last; cmd tolerates a batch file removing itself.
del /q "%~f0" >nul 2>&1
`
// InstallAndRestart writes the swap helper, launches it detached, and returns.
// The caller must exit promptly afterwards — the helper is already waiting on
// this process to go away.
//
// This is only ever reached from an explicit click on "Update available": the
// updater never installs on its own.
func InstallAndRestart(downloadedExe string) error {
target, err := os.Executable()
if err != nil {
return fmt.Errorf("locating the running executable: %w", err)
}
target, err = filepath.Abs(target)
if err != nil {
return err
}
script := filepath.Join(os.TempDir(), "ipswap-update.cmd")
if err := os.WriteFile(script, []byte(swapScript), 0o755); err != nil {
return fmt.Errorf("writing the update helper: %w", err)
}
cmd := exec.Command("cmd.exe", "/c", script,
strconv.Itoa(os.Getpid()), downloadedExe, target)
// Detach: the helper has to survive this process exiting, and it must not
// flash a console window while it waits.
cmd.SysProcAttr = &syscall.SysProcAttr{
HideWindow: true,
CreationFlags: windowsCreateNoWindow | windowsDetachedProcess,
}
if err := cmd.Start(); err != nil {
return fmt.Errorf("starting the update helper: %w", err)
}
return cmd.Process.Release()
}
const (
windowsDetachedProcess = 0x00000008
windowsCreateNoWindow = 0x08000000
)
internal/updater/semver.go
+102
View File
@@ -0,0 +1,102 @@
package updater
import (
"fmt"
"strconv"
"strings"
)
// Version is a parsed semantic version. Only what a release-tag comparison
// needs is modelled: major.minor.patch plus an optional pre-release, which
// sorts before the same version without one.
type Version struct {
Major, Minor, Patch int
Pre string
}
// ParseVersion accepts "v1.2.0", "1.2.0", "1.2", "1" and "1.2.0-rc1". Build
// metadata after "+" is ignored, as semver says it must be for ordering.
func ParseVersion(s string) (Version, error) {
s = strings.TrimSpace(s)
s = strings.TrimPrefix(s, "v")
if s == "" {
return Version{}, fmt.Errorf("empty version")
}
if i := strings.IndexByte(s, '+'); i >= 0 {
s = s[:i]
}
var v Version
if i := strings.IndexByte(s, '-'); i >= 0 {
v.Pre = s[i+1:]
s = s[:i]
}
parts := strings.Split(s, ".")
if len(parts) > 3 {
return Version{}, fmt.Errorf("%q has too many components", s)
}
dst := []*int{&v.Major, &v.Minor, &v.Patch}
for i, p := range parts {
n, err := strconv.Atoi(p)
if err != nil || n < 0 {
return Version{}, fmt.Errorf("%q is not a version number", s)
}
*dst[i] = n
}
return v, nil
}
// Compare returns -1, 0 or 1 as v sorts before, equal to, or after other.
func (v Version) Compare(other Version) int {
for _, pair := range [][2]int{
{v.Major, other.Major},
{v.Minor, other.Minor},
{v.Patch, other.Patch},
} {
if pair[0] != pair[1] {
if pair[0] < pair[1] {
return -1
}
return 1
}
}
// A pre-release sorts before the release it leads up to.
switch {
case v.Pre == "" && other.Pre == "":
return 0
case v.Pre == "":
return 1
case other.Pre == "":
return -1
case v.Pre < other.Pre:
return -1
case v.Pre > other.Pre:
return 1
}
return 0
}
func (v Version) String() string {
s := fmt.Sprintf("%d.%d.%d", v.Major, v.Minor, v.Patch)
if v.Pre != "" {
s += "-" + v.Pre
}
return s
}
// IsNewer reports whether candidate is a strictly later version than current.
// An unparseable version on either side means "no update", because offering a
// download on the strength of a tag we could not read is worse than silence.
func IsNewer(candidate, current string) bool {
c, err := ParseVersion(candidate)
if err != nil {
return false
}
cur, err := ParseVersion(current)
if err != nil {
return false
}
return c.Compare(cur) > 0
}
internal/updater/semver_test.go
+63
View File
@@ -0,0 +1,63 @@
package updater
import "testing"
func TestParseVersion(t *testing.T) {
cases := []struct {
in string
want Version
}{
{"v1.2.0", Version{1, 2, 0, ""}},
{"1.2.0", Version{1, 2, 0, ""}},
{"1.2", Version{1, 2, 0, ""}},
{"1", Version{1, 0, 0, ""}},
{"v1.2.0-rc1", Version{1, 2, 0, "rc1"}},
{"1.2.0+build7", Version{1, 2, 0, ""}},
{" v0.1.0 ", Version{0, 1, 0, ""}},
}
for _, tc := range cases {
got, err := ParseVersion(tc.in)
if err != nil {
t.Errorf("ParseVersion(%q) errored: %v", tc.in, err)
continue
}
if got != tc.want {
t.Errorf("ParseVersion(%q) = %+v, want %+v", tc.in, got, tc.want)
}
}
for _, in := range []string{"", "v", "abc", "1.2.3.4", "1.x", "-1.0.0"} {
if got, err := ParseVersion(in); err == nil {
t.Errorf("ParseVersion(%q) = %+v, want error", in, got)
}
}
}
func TestIsNewer(t *testing.T) {
yes := [][2]string{
{"v1.2.1", "v1.2.0"},
{"v1.3.0", "v1.2.9"},
{"v2.0.0", "v1.99.99"},
{"v1.2.0", "v1.2.0-rc1"},
}
for _, tc := range yes {
if !IsNewer(tc[0], tc[1]) {
t.Errorf("IsNewer(%q, %q) = false, want true", tc[0], tc[1])
}
}
no := [][2]string{
{"v1.2.0", "v1.2.0"},
{"v1.2.0", "v1.2.1"},
{"v1.2.0-rc1", "v1.2.0"},
// An unreadable tag must never trigger an update offer.
{"garbage", "v1.2.0"},
{"v1.2.0", "garbage"},
{"", "v1.0.0"},
}
for _, tc := range no {
if IsNewer(tc[0], tc[1]) {
t.Errorf("IsNewer(%q, %q) = true, want false", tc[0], tc[1])
}
}
}
internal/updater/updater.go
+266
View File
@@ -0,0 +1,266 @@
// Package updater checks a Gitea repository for a newer release and, on
// request, downloads and verifies the new binary.
//
// Two rules shape the whole package: it never installs on its own, and it never
// blocks startup. The check runs in a goroutine behind a short timeout and
// fails silently into the log, because a laptop on a customer site frequently
// has no route to the Gitea host and that must not be a visible error.
package updater
import (
"context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"fmt"
"io"
"net/http"
"net/url"
"os"
"path"
"path/filepath"
"regexp"
"strings"
"time"
)
// checkTimeout bounds the startup release check.
const checkTimeout = 8 * time.Second
// maxAssetBytes caps a download. The binary is a few MB; anything near this is
// a wrong URL or a captive portal serving a login page.
const maxAssetBytes = 128 << 20
// Release is the subset of Gitea's release JSON that matters here.
type Release struct {
TagName string `json:"tag_name"`
Name string `json:"name"`
Body string `json:"body"`
Assets []Asset `json:"assets"`
HTMLURL string `json:"html_url"`
}
// Asset is one file attached to a release.
type Asset struct {
Name string `json:"name"`
Size int64 `json:"size"`
BrowserDownloadURL string `json:"browser_download_url"`
}
// Checker polls one repository.
type Checker struct {
// Repo is the repository as "https://gitea.example.com/owner/repo".
Repo string
// Current is the compiled-in version, from -X main.version.
Current string
HTTP *http.Client
}
// Update describes an available newer release.
type Update struct {
Version string
Release Release
Asset Asset
// SHA256 is the expected checksum, empty if the release published none.
SHA256 string
}
// apiURL turns a repo browse URL into its releases/latest API endpoint.
func apiURL(repo string) (string, error) {
repo = strings.TrimSuffix(strings.TrimSpace(repo), "/")
if repo == "" {
return "", fmt.Errorf("no update repository configured")
}
u, err := url.Parse(repo)
if err != nil {
return "", fmt.Errorf("update repo %q is not a URL: %w", repo, err)
}
if u.Scheme != "https" && u.Scheme != "http" {
return "", fmt.Errorf("update repo %q must be an http(s) URL", repo)
}
parts := strings.Split(strings.Trim(u.Path, "/"), "/")
if len(parts) != 2 || parts[0] == "" || parts[1] == "" {
return "", fmt.Errorf("update repo %q should look like https://host/owner/repo", repo)
}
u.Path = path.Join("/api/v1/repos", parts[0], parts[1], "releases/latest")
return u.String(), nil
}
func (c *Checker) client() *http.Client {
if c.HTTP != nil {
return c.HTTP
}
return &http.Client{Timeout: checkTimeout}
}
// Check asks for the latest release and returns an Update if it is newer than
// the running build. A nil Update with a nil error means "up to date".
func (c *Checker) Check(ctx context.Context) (*Update, error) {
endpoint, err := apiURL(c.Repo)
if err != nil {
return nil, err
}
ctx, cancel := context.WithTimeout(ctx, checkTimeout)
defer cancel()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
if err != nil {
return nil, err
}
req.Header.Set("Accept", "application/json")
resp, err := c.client().Do(req)
if err != nil {
return nil, fmt.Errorf("contacting %s: %w", endpoint, err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("%s returned %s", endpoint, resp.Status)
}
var rel Release
if err := json.NewDecoder(io.LimitReader(resp.Body, 4<<20)).Decode(&rel); err != nil {
return nil, fmt.Errorf("parsing the release response: %w", err)
}
if !IsNewer(rel.TagName, c.Current) {
return nil, nil
}
asset, ok := pickExe(rel.Assets)
if !ok {
return nil, fmt.Errorf("release %s has no .exe asset", rel.TagName)
}
return &Update{
Version: strings.TrimPrefix(rel.TagName, "v"),
Release: rel,
Asset: asset,
SHA256: findChecksum(rel, asset.Name),
}, nil
}
func pickExe(assets []Asset) (Asset, bool) {
for _, a := range assets {
if strings.HasSuffix(strings.ToLower(a.Name), ".exe") {
return a, true
}
}
return Asset{}, false
}
var sha256Re = regexp.MustCompile(`\b([a-fA-F0-9]{64})\b`)
// findChecksum digs the expected SHA256 out of the release body. The body is
// scanned for a line naming the asset; a bare 64-hex string anywhere is
// accepted as a fallback for a release that publishes only the one checksum.
//
// A SHA256SUMS sibling asset is handled by the caller, which can fetch it — it
// is not available from the release JSON alone.
func findChecksum(rel Release, assetName string) string {
for _, line := range strings.Split(rel.Body, "\n") {
if strings.Contains(line, assetName) {
if m := sha256Re.FindStringSubmatch(line); m != nil {
return strings.ToLower(m[1])
}
}
}
if m := sha256Re.FindStringSubmatch(rel.Body); m != nil {
return strings.ToLower(m[1])
}
return ""
}
// SumsAsset finds a SHA256SUMS-style asset in the release, if there is one.
func (u *Update) SumsAsset() (Asset, bool) {
for _, a := range u.Release.Assets {
n := strings.ToUpper(a.Name)
if strings.Contains(n, "SHA256") {
return a, true
}
}
return Asset{}, false
}
// Download fetches the update's .exe into dir and verifies its SHA256 before
// returning the path. A release with no published checksum is refused: an
// unverified binary that we are about to swap in and run is not worth the
// convenience.
func (c *Checker) Download(ctx context.Context, u *Update, dir string) (string, error) {
want := u.SHA256
if want == "" {
// Try the sibling SHA256SUMS asset before giving up.
if sums, ok := u.SumsAsset(); ok {
body, err := c.fetch(ctx, sums.BrowserDownloadURL, 1<<20)
if err != nil {
return "", fmt.Errorf("fetching %s: %w", sums.Name, err)
}
want = checksumFor(string(body), u.Asset.Name)
}
}
if want == "" {
return "", fmt.Errorf("release %s publishes no SHA256 for %s; refusing to install an unverified binary", u.Release.TagName, u.Asset.Name)
}
body, err := c.fetch(ctx, u.Asset.BrowserDownloadURL, maxAssetBytes)
if err != nil {
return "", fmt.Errorf("downloading %s: %w", u.Asset.Name, err)
}
sum := sha256.Sum256(body)
got := hex.EncodeToString(sum[:])
if !strings.EqualFold(got, want) {
return "", fmt.Errorf("checksum mismatch for %s:\n expected %s\n got %s", u.Asset.Name, want, got)
}
if err := os.MkdirAll(dir, 0o755); err != nil {
return "", err
}
dest := filepath.Join(dir, u.Asset.Name)
if err := os.WriteFile(dest, body, 0o755); err != nil {
return "", fmt.Errorf("writing %s: %w", dest, err)
}
return dest, nil
}
func (c *Checker) fetch(ctx context.Context, rawURL string, limit int64) ([]byte, error) {
ctx, cancel := context.WithTimeout(ctx, 5*time.Minute)
defer cancel()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, rawURL, nil)
if err != nil {
return nil, err
}
resp, err := c.client().Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("server returned %s", resp.Status)
}
return io.ReadAll(io.LimitReader(resp.Body, limit))
}
// checksumFor pulls one file's hash out of a `sha256sum` style listing.
func checksumFor(sums, name string) string {
for _, line := range strings.Split(sums, "\n") {
fields := strings.Fields(line)
if len(fields) < 2 {
continue
}
// The name may carry sha256sum's binary-mode "*" prefix.
if strings.TrimPrefix(fields[len(fields)-1], "*") == name {
if sha256Re.MatchString(fields[0]) {
return strings.ToLower(fields[0])
}
}
}
return ""
}
internal/updater/updater_test.go
+94
View File
@@ -0,0 +1,94 @@
package updater
import (
"context"
"encoding/json"
"net/http"
"net/http/httptest"
"testing"
)
func TestAPIURL(t *testing.T) {
got, err := apiURL("https://gitea.apointless.space/bsncubed/ipswap")
if err != nil {
t.Fatal(err)
}
want := "https://gitea.apointless.space/api/v1/repos/bsncubed/ipswap/releases/latest"
if got != want {
t.Errorf("apiURL = %q, want %q", got, want)
}
if _, err := apiURL("https://gitea.apointless.space/bsncubed/ipswap/"); err != nil {
t.Errorf("a trailing slash should be tolerated: %v", err)
}
for _, bad := range []string{"", "not a url", "https://host", "https://host/a/b/c"} {
if _, err := apiURL(bad); err == nil {
t.Errorf("apiURL(%q) should have failed", bad)
}
}
}
func TestCheckFindsNewerRelease(t *testing.T) {
rel := Release{
TagName: "v1.2.0",
Body: "ipswap.exe e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\n",
Assets: []Asset{
{Name: "SHA256SUMS", BrowserDownloadURL: "http://x/sums"},
{Name: "ipswap.exe", BrowserDownloadURL: "http://x/ipswap.exe"},
},
}
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
json.NewEncoder(w).Encode(rel)
}))
defer srv.Close()
c := &Checker{Repo: srv.URL + "/owner/repo", Current: "v1.1.0"}
up, err := c.Check(context.Background())
if err != nil {
t.Fatal(err)
}
if up == nil {
t.Fatal("expected an update, got nil")
}
if up.Version != "1.2.0" {
t.Errorf("version = %q, want 1.2.0", up.Version)
}
if up.Asset.Name != "ipswap.exe" {
t.Errorf("picked asset %q, want ipswap.exe", up.Asset.Name)
}
if up.SHA256 != "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" {
t.Errorf("checksum = %q", up.SHA256)
}
}
func TestCheckIgnoresOlderRelease(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
json.NewEncoder(w).Encode(Release{TagName: "v1.0.0"})
}))
defer srv.Close()
c := &Checker{Repo: srv.URL + "/owner/repo", Current: "v1.2.0"}
up, err := c.Check(context.Background())
if err != nil {
t.Fatal(err)
}
if up != nil {
t.Errorf("expected no update, got %+v", up)
}
}
func TestChecksumFor(t *testing.T) {
sums := "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 ipswap.exe\n" +
"aaaabbbbccccddddeeeeffff00001111222233334444555566667777888899990 other.zip\n"
got := checksumFor(sums, "ipswap.exe")
if got != "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" {
t.Errorf("checksumFor = %q", got)
}
if checksumFor(sums, "missing.exe") != "" {
t.Error("expected empty checksum for an absent file")
}
// sha256sum's binary-mode marker must not defeat the lookup.
if checksumFor("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 *ipswap.exe", "ipswap.exe") == "" {
t.Error("binary-mode '*' prefix should be tolerated")
}
}