Build packages / CI (push) Blocked by required conditions
Build packages / Version (push) Waiting to run
CI / Web (format, types, tests, bundles) (push) Blocked by required conditions
CI / ShellCheck (push) Blocked by required conditions
CI / Backend (Go: vet, tests, a real ubusd and uhttpd) (push) Blocked by required conditions
CI / Package files (push) Blocked by required conditions
- **Backend rewritten in Go.** One daemon, `dawnlined`, replaces the whole ucode backend: the rpcd plugin, the agent, the CLI and the updater. The package no longer depends on ucode. - **Per-architecture builds.** The release carries the backend for arm64, ARMv7, mips, mipsle and amd64; the router fetches its own after the package is installed and checks its sha256. Dawnline does not run on other architectures (older ARM, 32-bit x86, RISC-V). - **Faster on the router.** A firewall sync takes 0.06 s instead of 0.9 s; a full apply takes about 300 ms. The portal is served by the daemon itself, without a CGI process per request. - **Live pages.** The admin and the portal follow a live stream from the router instead of re-fetching the whole state every 30 seconds. - **Admin redesigned in the portal's style.** Three sections (Overview · Log · Settings); a server is a page of its own with People, Places and Settings; a device opens as a dialog over its person. - **Changes wait for «Apply».** Every setting, and a person's access, is staged in one dock before it reaches the router. - **Configuration rollout.** After a change that makes devices fetch their configuration again, the admin shows how many have fetched it and who has not. Every setting shows beforehand (⟳N) how many devices it will touch. - **Waiting for a decision.** Overview and People put first the people who need one (access ended, limit reached, a device that does not connect), each with its one action a tap away. - **Bulk actions on people.** «Select» (or a long press on a card) picks several people to extend by a month, pause or resume at once. - **Undo.** An action done from a card or a request is undone from its toast. - **Update dialogs redesigned.** An update is one view from its question to its result; Dawnline's own update runs in it like every other, and the page reloads itself once the new version answers. Other versions are a list, each with its notes and Install on a page of its own. - **Site to site: networks behind a router.** A router connected as a device can have networks behind it (up to eight, /16 to /30): the server routes them and applies the router's access to them. A network that shares addresses with a tunnel, the router's own networks or another site is refused by name. - **Routers from the portal.** People can add a router and name its networks on their own page; the admin accepts or declines with a reason, or lets them through without asking. - **Check access and Health know the networks behind routers.** - **Usage limits reworked.** A monthly limit no longer follows the calendar. A person's month starts with their first traffic and ends a month later; the next one starts only when they connect again, so time away uses up none of it. Before, everyone's limit reset on the 1st. - Extra data lasts until that person's month ends; «Reset usage» starts the month anew. - A limit is for a month or for the whole term; the admin and the portal show when it resets. - Charts that said «this month» show the last 30 days. - After the update nobody loses what was counted: the month that was running becomes the person's first and ends on the 1st. - **Access by time of day removed.** The Hours limit is gone from the admin, the portal and the backend; saved hours are dropped. - **Expiry simplified.** An end date always stops access, with a heads-up three days before; the per-person choice is gone. - **No false disconnects from sleeping phones.** A phone or a tablet stays online through ten minutes of silence. - **Mobile Safari fixes.** Pressing a control no longer sends the page to its top; tab tracks that do not fit scroll; switches animate after a press.
722 lines
23 KiB
Go
722 lines
23 KiB
Go
package updater
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"regexp"
|
|
"sort"
|
|
"strings"
|
|
|
|
"github.com/tickcount/luci-app-dawnline/backend/files"
|
|
"github.com/tickcount/luci-app-dawnline/backend/github"
|
|
"github.com/tickcount/luci-app-dawnline/backend/uci"
|
|
)
|
|
|
|
func (w *worker) must(ok bool, err error, format string, args ...any) {
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
if !ok {
|
|
w.die(format, args...)
|
|
}
|
|
}
|
|
|
|
func (w *worker) download(url, dest, want string) bool {
|
|
return github.Download(w.e.Fetch, url, dest, want, w.e.Policy.Mirrors, w.log, w.t) != ""
|
|
}
|
|
|
|
/* ---------- Dawnline itself ---------- */
|
|
|
|
func (w *worker) checkApp() map[string]any {
|
|
v := w.e.Version
|
|
r := w.e.GH.Latest(Repo)
|
|
if r == nil {
|
|
return map[string]any{"installed": v, "latest": nil, "update": false, "repo": Repo, "status": "", "note": fmt.Sprintf(w.t("Cannot reach github.com/%s"), Repo)}
|
|
}
|
|
tag := str(r["tag"])
|
|
latest := strings.TrimPrefix(tag, "v")
|
|
st := appStatus(v, latest)
|
|
switch st {
|
|
case "outdated":
|
|
w.logf("Dawnline update is available: %s → %s", v, latest)
|
|
case "dev":
|
|
w.logf("Installed Dawnline %s is newer than the release %s", v, latest)
|
|
default:
|
|
w.logf("Dawnline is up to date (%s)", v)
|
|
}
|
|
return map[string]any{"installed": v, "latest": latest, "tag": tag, "repo": Repo, "url": r["url"], "published": r["published"], "update": st == "outdated", "status": st}
|
|
}
|
|
|
|
var (
|
|
unsafeTag = regexp.MustCompile(`[^A-Za-z0-9.-]`)
|
|
sumLine = regexp.MustCompile(`^([0-9a-f]{64})[ \t]+\*?(\S+)$`)
|
|
)
|
|
|
|
// wantSHA is the sha256 a release publishes for a file: GitHub's own (API), else the release's
|
|
// sha256sums.txt fetched straight from GitHub (never a mirror).
|
|
func (w *worker) wantSHA(tag, asset, dir string) string {
|
|
if want := w.e.GH.AssetSHA256(Repo, tag, asset); want != "" {
|
|
return want
|
|
}
|
|
sums := dir + "/sha256sums-" + unsafeTag.ReplaceAllString(tag, "_") + ".txt"
|
|
if github.Download(w.e.Fetch, "https://github.com/"+Repo+"/releases/download/"+tag+"/sha256sums.txt", sums, "", false, w.log, w.t) == "" {
|
|
return ""
|
|
}
|
|
raw, _ := os.ReadFile(sums)
|
|
for _, line := range strings.Split(string(raw), "\n") {
|
|
if m := sumLine.FindStringSubmatch(strings.Trim(line, " \t\r\n\v\f")); m != nil && m[2] == asset {
|
|
return m[1]
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// fetchFile downloads one file of a release, verified against its sha256. optional: a release without it
|
|
// (one from before the translations) gives "".
|
|
func (w *worker) fetchFile(tag, asset, dir string, optional bool) string {
|
|
w.phase("Downloading %s", asset)
|
|
want := w.wantSHA(tag, asset, dir)
|
|
if want == "" && optional {
|
|
w.logf("Release %s has no %s: it stays as it is", tag, asset)
|
|
return ""
|
|
}
|
|
if want == "" {
|
|
w.die("Release %s publishes no checksum for %s: not installing an unverified package", tag, asset)
|
|
}
|
|
f := dir + "/" + asset
|
|
if !w.download("https://github.com/"+Repo+"/releases/download/"+tag+"/"+asset, f, want) {
|
|
w.die("Download failed: %s", asset)
|
|
}
|
|
w.logf("sha256 matches the release (%s…)", want[:12])
|
|
return f
|
|
}
|
|
|
|
func (w *worker) langs() []string {
|
|
if w.e.Langs == nil {
|
|
return nil
|
|
}
|
|
return w.e.Langs()
|
|
}
|
|
|
|
// fetchRelease is a release's package and the translations installed here, verified.
|
|
func (w *worker) fetchRelease(tag, dir string) []string {
|
|
ver := strings.TrimPrefix(tag, "v")
|
|
out := []string{w.fetchFile(tag, "luci-app-dawnline-"+ver+"."+w.e.Pkg.Ext(), dir, false)}
|
|
for _, l := range w.langs() {
|
|
if f := w.fetchFile(tag, "luci-i18n-dawnline-"+l+"-"+ver+"."+w.e.Pkg.Ext(), dir, true); f != "" {
|
|
out = append(out, f)
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
// tagOf is the release tag of a version: tags may or may not carry the v.
|
|
func (w *worker) tagOf(ver string) string {
|
|
for _, t := range []string{"v" + ver, ver} {
|
|
if r, _ := w.e.GH.Release(Repo, t); r != nil {
|
|
return t
|
|
}
|
|
}
|
|
return "v" + ver
|
|
}
|
|
|
|
func (w *worker) backup() {
|
|
w.phase("Backing up configuration")
|
|
w.e.Run("/usr/bin/dawnline backup --reason pre-update >/dev/null 2>&1")
|
|
}
|
|
|
|
// setLang adds the translation `lang` of the installed version from its release, or (lang "") removes the
|
|
// installed ones. LuCI reads its catalogs once per web server process: it restarts after the job.
|
|
func (w *worker) setLang(lang string) map[string]any {
|
|
v := w.e.Version
|
|
if lang == "" {
|
|
var have []string
|
|
for _, l := range w.langs() {
|
|
have = append(have, "luci-i18n-dawnline-"+l)
|
|
}
|
|
if len(have) > 0 {
|
|
w.phase("Removing the translation")
|
|
if !w.e.Pkg.Remove(have, w.log) {
|
|
w.die("The translation could not be removed")
|
|
}
|
|
}
|
|
} else {
|
|
tag := w.tagOf(v)
|
|
f := w.fetchFile(tag, "luci-i18n-dawnline-"+lang+"-"+v+"."+w.e.Pkg.Ext(), w.work, true)
|
|
if f == "" {
|
|
w.die("Release %s has no translation into %s: install a release that has one", tag, lang)
|
|
}
|
|
w.phase("Installing the translation")
|
|
ok, err := w.e.Pkg.InstallFiles([]string{f}, false, w.log)
|
|
w.must(ok, err, "Installation failed")
|
|
}
|
|
w.after["luci"] = true
|
|
return map[string]any{"from": v, "to": v, "lang": orNil(lang)}
|
|
}
|
|
|
|
// installApp: arg "" (latest) | @<tag> | reinstall | rollback | lang:<code> | nolang
|
|
func (w *worker) installApp(arg string) map[string]any {
|
|
v := w.e.Version
|
|
if arg == "nolang" {
|
|
return w.setLang("")
|
|
}
|
|
if l, is := strings.CutPrefix(arg, "lang:"); is {
|
|
return w.setLang(l)
|
|
}
|
|
out := map[string]any{"from": v, "to": nil}
|
|
if arg == "rollback" {
|
|
k := kept(w.e.DataDir, "app")
|
|
if k == nil {
|
|
w.die("No previous Dawnline version is kept on the router")
|
|
}
|
|
out["to"] = k.Version
|
|
w.versions(v, k.Version)
|
|
w.backup()
|
|
w.phase("Rolling back to %s", k.Version)
|
|
ok, err := w.e.Pkg.InstallFiles(k.Files, true, w.log)
|
|
w.must(ok, err, "Installation failed")
|
|
forget(w.e.DataDir, "app")
|
|
w.after["app"] = true
|
|
return out
|
|
}
|
|
tag, force := "", false
|
|
switch {
|
|
case arg == "reinstall":
|
|
tag, force = w.tagOf(v), true
|
|
case strings.HasPrefix(arg, "@"):
|
|
tag = arg[1:]
|
|
force = VersionCmp(strings.TrimPrefix(tag, "v"), v) <= 0
|
|
default:
|
|
c := w.checkApp()
|
|
if c["latest"] == nil {
|
|
panic(failure{str(c["note"])})
|
|
}
|
|
if c["update"] != true {
|
|
out["to"] = v
|
|
return out
|
|
}
|
|
tag = str(c["tag"])
|
|
}
|
|
to := strings.TrimPrefix(tag, "v")
|
|
out["to"] = to
|
|
w.versions(v, to)
|
|
paths := w.fetchRelease(tag, w.work)
|
|
// The version being replaced, for Roll back (downloaded again: the package manager keeps no package
|
|
// files). Always for an automatic run: nobody is there to recover a router whose new version does not
|
|
// come up (postupdate rolls back to it on its own).
|
|
if k := kept(w.e.DataDir, "app"); (w.e.Policy.Keep || w.job.Auto) && to != v && (k == nil || k.Version != v) {
|
|
w.phase("Keeping Dawnline %s for rollback", v)
|
|
func() {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
msg := fmt.Sprint(r)
|
|
if f, is := r.(failure); is {
|
|
msg = f.msg
|
|
}
|
|
w.logf("Warning: could not keep %s: %s", v, msg)
|
|
}
|
|
}()
|
|
os.MkdirAll(w.work+"/keep", 0o700)
|
|
keep(w.e.DataDir, "app", v, w.fetchRelease(w.tagOf(v), w.work+"/keep"), nil, nil)
|
|
}()
|
|
}
|
|
w.backup()
|
|
w.phase("Installing package")
|
|
ok, err := w.e.Pkg.InstallFiles(paths, force, w.log)
|
|
w.must(ok, err, "Installation failed")
|
|
w.after["app"] = true
|
|
return out
|
|
}
|
|
|
|
/* ---------- system packages ---------- */
|
|
|
|
// PkgNames is what Dawnline itself adds to OpenWrt (the rest of LuCI, rpcd and uhttpd is the stock system).
|
|
var PkgNames = []string{"ip-full", "kmod-veth", "libustream-openssl", "openssl-util", "acme", "acme-acmesh-dnsapi", "luci-app-acme"}
|
|
|
|
// Packages released together with each of the above, updated as a set so OpenSSL never ends up half old
|
|
// and half new.
|
|
var families = [][2]*regexp.Regexp{
|
|
{regexp.MustCompile(`^ip-full$`), regexp.MustCompile(`^ip-`)},
|
|
{regexp.MustCompile(`^(libustream-openssl|openssl-util)$`), regexp.MustCompile(`^(libustream-openssl|libopenssl|openssl-util$)`)},
|
|
{regexp.MustCompile(`^(acme|luci-app-acme$)`), regexp.MustCompile(`^acme`)},
|
|
}
|
|
|
|
// WithFamily is the packages to update for these names: each one plus its upgradable family. Pure.
|
|
func WithFamily(names []string, up map[string]string) []string {
|
|
set := map[string]bool{}
|
|
for _, n := range names {
|
|
if _, has := up[n]; has {
|
|
set[n] = true
|
|
}
|
|
for _, f := range families {
|
|
if f[0].MatchString(n) {
|
|
for u := range up {
|
|
if f[1].MatchString(u) {
|
|
set[u] = true
|
|
}
|
|
}
|
|
break
|
|
}
|
|
}
|
|
}
|
|
out := make([]string, 0, len(set))
|
|
for k := range set {
|
|
out = append(out, k)
|
|
}
|
|
sort.Strings(out)
|
|
return out
|
|
}
|
|
|
|
// checkPkgs; refresh: update the package lists first (a check by hand or on schedule).
|
|
func (w *worker) checkPkgs(refresh bool) map[string]any {
|
|
if refresh {
|
|
w.phase("Refreshing package lists")
|
|
w.e.Pkg.Refresh(nil)
|
|
}
|
|
up := w.e.Pkg.Upgradable()
|
|
res := map[string]any{}
|
|
all := map[string]bool{}
|
|
for _, p := range PkgNames {
|
|
v := w.e.Pkg.Version(p)
|
|
set := []string{}
|
|
if v != "" {
|
|
set = WithFamily([]string{p}, up)
|
|
}
|
|
with := []string{}
|
|
for _, x := range set {
|
|
all[x] = true
|
|
if x != p {
|
|
with = append(with, x)
|
|
}
|
|
}
|
|
var latest any
|
|
if l, has := up[p]; has && v != "" {
|
|
latest = l
|
|
}
|
|
res[p] = map[string]any{"installed": orNil(v), "latest": latest, "with": with}
|
|
}
|
|
names := make([]string, 0, len(all))
|
|
for k := range all {
|
|
names = append(names, k)
|
|
}
|
|
sort.Strings(names)
|
|
n := len(names)
|
|
status := "latest"
|
|
if n > 0 {
|
|
status = "outdated"
|
|
w.log(fmt.Sprintf(w.e.T.N(int64(n), "%d package update in the feeds: %s", "%d package updates in the feeds: %s"), n, strings.Join(names, ", ")))
|
|
} else {
|
|
w.logf("System packages are up to date")
|
|
}
|
|
return map[string]any{"pkgs": res, "updates": n, "status": status}
|
|
}
|
|
|
|
var (
|
|
needsApply = regexp.MustCompile(`^(openssl-util|libustream|ip-full|kmod-veth)`)
|
|
needsUhttpd = regexp.MustCompile(`^(libustream|libopenssl)`)
|
|
)
|
|
|
|
// installPkgs: arg name,name,… (only names Dawnline manages): missing ones are installed, present ones
|
|
// updated with their family.
|
|
func (w *worker) installPkgs(arg string) map[string]any {
|
|
var names []string
|
|
for _, n := range strings.Split(arg, ",") {
|
|
if n != "" {
|
|
names = append(names, n)
|
|
}
|
|
}
|
|
for _, n := range names {
|
|
if !has(PkgNames, n) {
|
|
w.die("%s is not a package Dawnline manages", n)
|
|
}
|
|
}
|
|
if len(names) == 0 {
|
|
w.die("Nothing to install")
|
|
}
|
|
w.phase("Refreshing package lists")
|
|
w.e.Pkg.Refresh(w.log)
|
|
var missing, present []string
|
|
for _, n := range names {
|
|
if w.e.Pkg.Version(n) == "" {
|
|
missing = append(missing, n)
|
|
} else {
|
|
present = append(present, n)
|
|
}
|
|
}
|
|
have := WithFamily(present, w.e.Pkg.Upgradable())
|
|
if len(have) > 0 {
|
|
w.phase("Updating %s", strings.Join(have, ", "))
|
|
ok, err := w.e.Pkg.Upgrade(have, w.log)
|
|
w.must(ok, err, "Update failed")
|
|
}
|
|
if len(missing) > 0 {
|
|
w.phase("Installing %s", strings.Join(missing, ", "))
|
|
ok, err := w.e.Pkg.Add(missing, w.log)
|
|
w.must(ok, err, "Installation failed")
|
|
}
|
|
// the portal's HTTPS and the home-like link: a piece that just arrived lets them start
|
|
arrived, touched := false, false
|
|
for _, n := range missing {
|
|
arrived = arrived || needsApply.MatchString(n)
|
|
}
|
|
for _, n := range append(append([]string{}, missing...), have...) {
|
|
touched = touched || needsUhttpd.MatchString(n)
|
|
}
|
|
if arrived {
|
|
w.after["apply"], w.after["uhttpd"] = true, true
|
|
} else if touched {
|
|
w.after["uhttpd"] = true
|
|
}
|
|
if have == nil {
|
|
have = []string{}
|
|
}
|
|
if missing == nil {
|
|
missing = []string{}
|
|
}
|
|
return map[string]any{"updated": have, "installed": missing, "check": w.checkPkgs(false)}
|
|
}
|
|
|
|
/* ---------- AmneziaWG ---------- */
|
|
|
|
func (w *worker) firmware() (Firmware, bool) {
|
|
version, target, arch := "", "", ""
|
|
if w.e.Board != nil {
|
|
version, target, arch = w.e.Board()
|
|
}
|
|
release, _ := os.ReadFile("/etc/openwrt_release")
|
|
return FirmwareOf(version, target, arch, string(release), w.e.Pkg.Ext())
|
|
}
|
|
|
|
func (w *worker) awgInstalled() map[string]any {
|
|
out := map[string]any{}
|
|
for _, p := range AwgPackages {
|
|
out[p] = orNil(w.e.Pkg.Version(p))
|
|
}
|
|
return out
|
|
}
|
|
|
|
// fetchBuild downloads one package of a build to dir, verified when GitHub publishes its sha256 (then
|
|
// mirrors may serve it); without a sha256 only github.com itself. The path, or "".
|
|
func (w *worker) fetchBuild(fw Firmware, name, src, dir string) string {
|
|
file := fw.Asset(name)
|
|
dest := dir + "/" + src + "_" + file
|
|
repo := Sources[src].Repo
|
|
if w.download("https://github.com/"+repo+"/releases/download/"+fw.Tag+"/"+file, dest, w.e.GH.AssetSHA256(repo, fw.Tag, file)) {
|
|
return dest
|
|
}
|
|
return ""
|
|
}
|
|
|
|
var series = regexp.MustCompile(`^v([0-9]+\.[0-9]+)\.`)
|
|
|
|
// newerSeriesTag is the newest tag of the same OpenWrt series (24.10.x) in a repository, if newer than ours.
|
|
func (w *worker) newerSeriesTag(repo, tag string) string {
|
|
m := series.FindStringSubmatch(tag)
|
|
if m == nil {
|
|
return ""
|
|
}
|
|
best := ""
|
|
list, _ := w.e.GH.Releases(repo, 1)
|
|
for _, x := range list {
|
|
r, _ := x.(map[string]any)
|
|
t := str(r["tag"])
|
|
if !strings.HasPrefix(t, "v"+m[1]+".") {
|
|
continue
|
|
}
|
|
if c, ok := w.e.Pkg.Cmp(t[1:], tag[1:]); !ok || c <= 0 {
|
|
continue
|
|
}
|
|
if best != "" {
|
|
if c, ok := w.e.Pkg.Cmp(t[1:], best[1:]); !ok || c <= 0 {
|
|
continue
|
|
}
|
|
}
|
|
best = t
|
|
}
|
|
return best
|
|
}
|
|
|
|
func (w *worker) checkAwg() map[string]any {
|
|
installed := w.awgInstalled()
|
|
ru := w.e.Pkg.Version(AwgRU) != ""
|
|
cur := str(installed["amneziawg-tools"])
|
|
base := func(note string) map[string]any {
|
|
return map[string]any{"installed": orNil(cur), "gen": orNil(Gen(cur)), "packages": installed, "current": nil, "ru": ru, "sources": map[string]any{},
|
|
"update": false, "status": "", "note": w.t(note)}
|
|
}
|
|
fw, ok := w.firmware()
|
|
if !ok {
|
|
return base("Cannot detect the firmware target")
|
|
}
|
|
if fw.Snapshot {
|
|
return base("This is a SNAPSHOT firmware: the AmneziaWG projects publish builds for releases only")
|
|
}
|
|
dir := w.work + "/check"
|
|
os.MkdirAll(dir, 0o700)
|
|
sources := map[string]any{}
|
|
versions := map[string]string{}
|
|
found := false
|
|
for _, id := range Order {
|
|
src := Sources[id]
|
|
w.logf("Looking for the %s build for OpenWrt %s", src.Label, fw.Tag[1:])
|
|
v := ""
|
|
var date any
|
|
if f := w.fetchBuild(fw, "amneziawg-tools", id, dir); f != "" {
|
|
v = w.e.Pkg.FileVersion(f)
|
|
if r, _ := w.e.GH.Release(src.Repo, fw.Tag); r != nil {
|
|
date = r["published"]
|
|
}
|
|
}
|
|
s := map[string]any{"label": src.Label, "repo": src.Repo, "tag": fw.Tag, "version": orNil(v), "gen": orNil(Gen(v)), "date": date}
|
|
// a newer firmware may already get 3.1 from this source
|
|
if Gen(v) != "3.1" {
|
|
if nt := w.newerSeriesTag(src.Repo, fw.Tag); nt != "" {
|
|
if nf := w.fetchBuild(fw.ForTag(nt), "amneziawg-tools", id, dir); nf != "" && Gen(w.e.Pkg.FileVersion(nf)) == "3.1" {
|
|
s["newer"] = map[string]any{"tag": nt, "gen": "3.1"}
|
|
}
|
|
}
|
|
}
|
|
sources[id], versions[id] = s, v
|
|
found = found || v != ""
|
|
}
|
|
// The installed build: the source whose package matches. Unknown stays unknown (an automatic update
|
|
// never switches a build it could not identify).
|
|
current := ""
|
|
for _, id := range Order {
|
|
if current == "" && cur != "" && versions[id] == cur {
|
|
current = id
|
|
}
|
|
}
|
|
mine := versions[current]
|
|
st := ""
|
|
if cur != "" && mine != "" {
|
|
if c, known := w.e.Pkg.Cmp(cur, mine); known {
|
|
st = map[int]string{-1: "outdated", 0: "latest", 1: "dev"}[c]
|
|
}
|
|
}
|
|
// an update that waits for a reboot: Components says so after a check
|
|
pending := Pending(record(w.e.DataDir), bootID(), moduleCore())
|
|
switch {
|
|
case cur == "":
|
|
w.logf("AmneziaWG is not installed")
|
|
case current == "":
|
|
w.logf("AmneziaWG %s: no source publishes this build for this firmware any more", cur)
|
|
case st == "outdated":
|
|
w.logf("AmneziaWG update is available: %s → %s", cur, mine)
|
|
default:
|
|
w.logf("AmneziaWG is up to date (%s)", cur)
|
|
}
|
|
var note any
|
|
switch {
|
|
case !found:
|
|
note = fmt.Sprintf(w.t("No AmneziaWG build for OpenWrt %s yet"), fw.Tag[1:])
|
|
case pending:
|
|
note = w.t("The AmneziaWG update is installed and starts after a reboot.")
|
|
}
|
|
return map[string]any{"installed": orNil(cur), "gen": orNil(Gen(cur)), "packages": installed, "current": orNil(current), "ru": ru, "release": fw.Tag,
|
|
"sources": sources, "latest": orNil(mine), "status": st, "update": cur == "" || st == "outdated",
|
|
// an update that changes the generation (2.0 → 3.1) breaks older apps: never automatic
|
|
"gen_change": cur != "" && mine != "" && Gen(cur) != Gen(mine), "pending": pending, "note": note}
|
|
}
|
|
|
|
func exists(path string) bool { _, err := os.Stat(path); return err == nil }
|
|
|
|
// reloadModule: every AmneziaWG interface is brought down, the module swapped and the interfaces brought
|
|
// up again. False when the old module stays loaded: the tunnels come back on it and the installed one
|
|
// starts with the next boot.
|
|
func (w *worker) reloadModule() bool {
|
|
var ifaces []string
|
|
names := map[string]string{}
|
|
if raw, err := os.ReadFile("/etc/config/network"); err == nil {
|
|
if c, err := uci.Parse(string(raw)); err == nil {
|
|
for _, s := range c.OfType("interface") {
|
|
proto, _ := s.Get("proto")
|
|
if off, _ := s.Get("disabled"); proto == "amneziawg" && off != "1" && s.Name != "" {
|
|
ifaces = append(ifaces, s.Name)
|
|
names[s.Name], _ = s.Get("_dawnline_name")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
n := len(ifaces)
|
|
w.job.Phase = fmt.Sprintf(w.e.T.N(int64(n), "Reloading the kernel module (%d tunnel restarts)", "Reloading the kernel module (%d tunnels restart)"), n)
|
|
w.log(w.job.Phase)
|
|
// why each goes down, so the log does not call it unexpected
|
|
path := w.e.RunDir + "/iface-intent.json"
|
|
all := map[string]map[string]any{}
|
|
files.ReadJSON(path, &all)
|
|
for _, i := range ifaces {
|
|
name := names[i]
|
|
if name == "" {
|
|
name = i
|
|
}
|
|
all[i] = map[string]any{"reason": "update", "name": name, "ts": w.now()}
|
|
}
|
|
files.WriteJSON(path, all, 0o600)
|
|
for _, i := range ifaces {
|
|
w.e.Run("ifdown '" + i + "' >/dev/null 2>&1")
|
|
}
|
|
if exists("/sys/module/amneziawg") {
|
|
w.run("rmmod amneziawg")
|
|
}
|
|
swapped := !exists("/sys/module/amneziawg")
|
|
if swapped {
|
|
w.run("modprobe amneziawg")
|
|
if !exists("/sys/module/amneziawg") {
|
|
w.die("The new AmneziaWG kernel module doesn't load on this firmware: the tunnels stay down until it does (see the log above)")
|
|
}
|
|
}
|
|
for _, i := range ifaces {
|
|
w.e.Run("ifup '" + i + "' >/dev/null 2>&1")
|
|
}
|
|
return swapped
|
|
}
|
|
|
|
// settle, after packages changed: the module loaded, netifd knowing the protocol, Dawnline set up again.
|
|
// It returns whether the module that runs is the installed one.
|
|
func (w *worker) settle(before, after map[string]any, was Module) bool {
|
|
b, a := str(before["kmod-amneziawg"]), str(after["kmod-amneziawg"])
|
|
fresh := true
|
|
switch {
|
|
// a new module package, one over a module loaded by hand, or an earlier update that still waits for a boot
|
|
case a != "" && (a != b || was.Pending) && (b != "" || was.Core != 0):
|
|
fresh = w.reloadModule()
|
|
case a != "" && b == "":
|
|
w.phase("Loading the kernel module")
|
|
if _, code := w.run("modprobe amneziawg"); code != 0 && !exists("/sys/module/amneziawg") {
|
|
w.die("AmneziaWG is installed, but its kernel module doesn't load on this firmware")
|
|
}
|
|
}
|
|
// netifd reads its protocol handlers when it starts
|
|
if out, _ := w.run("ubus call network get_proto_handlers"); !strings.Contains(out, `"amneziawg"`) {
|
|
w.phase("Restarting the network so it knows AmneziaWG (connections drop for a few seconds)")
|
|
w.run("/etc/init.d/network restart")
|
|
}
|
|
w.after["apply"] = true
|
|
return fresh
|
|
}
|
|
|
|
func (w *worker) finishAwg(out map[string]any, source, tag any, was Module) map[string]any {
|
|
after := w.awgInstalled()
|
|
out["after"] = after
|
|
reloaded := w.settle(out["before"].(map[string]any), after, was)
|
|
out["reloaded"] = reloaded
|
|
writeRecord(w.e.DataDir, source, tag, after, was, reloaded)
|
|
if !reloaded {
|
|
w.logf("The old kernel module stays loaded (another AmneziaWG interface may use it): the AmneziaWG update is installed and starts after a reboot.")
|
|
}
|
|
return out
|
|
}
|
|
|
|
// pick is the first source that publishes every package for this firmware.
|
|
func (w *worker) pick(fw Firmware) string {
|
|
for _, id := range Order {
|
|
assets := w.e.GH.Assets(Sources[id].Repo, fw.Tag)
|
|
all := assets != nil
|
|
for _, p := range AwgPackages {
|
|
all = all && has(assets, fw.Asset(p))
|
|
}
|
|
if all {
|
|
return id
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// installAwg: arg [auto|slava|grey][:ru] | rollback
|
|
func (w *worker) installAwg(arg string) map[string]any {
|
|
before := w.awgInstalled()
|
|
was := moduleNow(w.e.DataDir, str(before["kmod-amneziawg"]))
|
|
from := str(before["amneziawg-tools"])
|
|
out := map[string]any{"from": orNil(from), "to": nil, "before": before}
|
|
fw, ok := w.firmware()
|
|
if !ok {
|
|
w.die("Cannot detect the firmware target")
|
|
}
|
|
if arg == "rollback" {
|
|
k := kept(w.e.DataDir, "amneziawg")
|
|
if k == nil {
|
|
w.die("No previous AmneziaWG build is kept on the router")
|
|
}
|
|
if f := str(k.Firmware); f != "" && f != fw.Postfix {
|
|
w.die("The kept AmneziaWG build was made for another firmware: it would not load on this one")
|
|
}
|
|
out["to"], out["build"] = k.Version, k.Build
|
|
w.versions(from, k.Version)
|
|
w.phase("Rolling back to %s", k.Version)
|
|
ok, err := w.e.Pkg.InstallFiles(k.Files, true, w.log)
|
|
w.must(ok, err, "Package installation failed")
|
|
forget(w.e.DataDir, "amneziawg")
|
|
return w.finishAwg(out, k.Build, fw.Tag, was)
|
|
}
|
|
parts := strings.Split(arg, ":")
|
|
id := parts[0]
|
|
if id == "" {
|
|
id = "auto"
|
|
}
|
|
wantRU := len(parts) > 1 && parts[1] == "ru"
|
|
if id == "auto" {
|
|
if id = w.pick(fw); id == "" {
|
|
w.die("No AmneziaWG build for OpenWrt %s (%s) yet", fw.Tag[1:], fw.Postfix)
|
|
}
|
|
}
|
|
src, known := Sources[id]
|
|
if !known {
|
|
w.die("Unknown AmneziaWG build %s", id)
|
|
}
|
|
out["build"] = id
|
|
names := append([]string{}, AwgPackages...)
|
|
if wantRU {
|
|
names = append(names, AwgRU)
|
|
}
|
|
var paths []string
|
|
for _, p := range names {
|
|
w.phase("Downloading %s from %s", p, src.Repo)
|
|
f := w.fetchBuild(fw, p, id, w.work)
|
|
if f == "" {
|
|
w.die("No %s build for OpenWrt %s in %s, or it could not be verified", p, fw.Tag[1:], src.Repo)
|
|
}
|
|
paths = append(paths, f)
|
|
}
|
|
to := w.e.Pkg.FileVersion(paths[1])
|
|
out["to"] = orNil(to)
|
|
w.versions(from, to)
|
|
// the build being replaced, for Roll back: from another source that still publishes it
|
|
if w.e.Policy.Keep && from != "" && to != from {
|
|
dir := w.work + "/keep"
|
|
os.MkdirAll(dir, 0o700)
|
|
other := ""
|
|
for _, sid := range Order {
|
|
if sid == id || other != "" {
|
|
continue
|
|
}
|
|
if f := w.fetchBuild(fw, "amneziawg-tools", sid, dir); f != "" && w.e.Pkg.FileVersion(f) == from {
|
|
other = sid
|
|
}
|
|
}
|
|
if other != "" {
|
|
w.phase("Keeping AmneziaWG %s for rollback", from)
|
|
var keepf []string
|
|
for _, p := range AwgPackages {
|
|
if f := w.fetchBuild(fw, p, other, dir); f != "" {
|
|
keepf = append(keepf, f)
|
|
}
|
|
}
|
|
if len(keepf) == len(AwgPackages) {
|
|
keep(w.e.DataDir, "amneziawg", from, keepf, other, fw.Postfix)
|
|
}
|
|
} else {
|
|
w.logf("Warning: the installed build is no longer published, nothing to keep for rollback")
|
|
}
|
|
}
|
|
w.phase("Refreshing package lists")
|
|
w.e.Pkg.Refresh(w.log)
|
|
w.phase("Installing the %s build", src.Label)
|
|
ok2, err := w.e.Pkg.InstallFiles(paths, true, w.log)
|
|
w.must(ok2, err, "Package installation failed")
|
|
if !wantRU && w.e.Pkg.Version(AwgRU) != "" {
|
|
w.e.Pkg.Remove([]string{AwgRU}, w.log)
|
|
}
|
|
return w.finishAwg(out, id, fw.Tag, was)
|
|
}
|