Dawnline 0.20.0
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.
This commit is contained in:
Aemeath committed 2026-11-13 09:43:50 +03:00
1 parent f8130e39a8
commit ac90575b0b
788 files changed
+139244 -41720

No files matched your search

+430
View File
@@ -0,0 +1,430 @@
package apply
import (
"crypto/rand"
"encoding/hex"
"encoding/json"
"fmt"
"os"
"path/filepath"
"strconv"
"strings"
"time"
"github.com/tickcount/luci-app-dawnline/backend/awg"
"github.com/tickcount/luci-app-dawnline/backend/disguise"
"github.com/tickcount/luci-app-dawnline/backend/files"
"github.com/tickcount/luci-app-dawnline/backend/model"
"github.com/tickcount/luci-app-dawnline/backend/servicelog"
"github.com/tickcount/luci-app-dawnline/backend/uci"
)
// netifd: one AmneziaWG interface a server, named after its ifname and marked `_dawnline` = the server's
// id (dawnline.netifd). Only interfaces Dawnline made are changed or removed: a name another interface has
// is left alone, and the server is kept down and said so (netifd-blocked.json: a code with its values).
// opt is one option of an interface: a string, a list, or nothing (the option goes).
type opt struct {
key string
val string
list []string
}
// put sets an option only when it differs (nothing deletes it); true when something changed.
func put(c *uci.Config, sec string, o opt) bool {
cur, has := c.Section(sec).Values[o.key]
if o.val == "" && len(o.list) == 0 {
if has {
c.Delete(sec, o.key)
return true
}
return false
}
if o.list != nil {
if has && cur.IsList && strings.Join(cur.List, "\n") == strings.Join(o.list, "\n") {
return false
}
c.SetList(sec, o.key, o.list)
return true
}
if has && !cur.IsList && cur.Str == o.val {
return false
}
c.Set(sec, o.key, o.val)
return true
}
// options is what is written into network.<ifname> apart from the markers: what netifd sets the tunnel up from.
func options(srv *model.Server) []opt {
prefix := ""
if i := strings.Index(srv.Subnet, "/"); i >= 0 {
prefix = srv.Subnet[i+1:]
}
o := []opt{{key: "proto", val: "amneziawg"}, {key: "private_key", val: srv.PrivateKey}, {key: "listen_port", val: strconv.Itoa(srv.Port)},
{key: "addresses", list: []string{model.ServerAddress(srv) + "/" + prefix}}, {key: "mtu", val: strconv.Itoa(model.TunnelMTU(srv))}}
for _, k := range model.ObfKeys {
v := srv.Obf[k]
// DisableCookies is the devices' alone: on the server it would turn off WireGuard's own defence
// against a flood of handshakes. Nothing takes it off an interface that had it.
if k == "disable_cookies" {
v = ""
}
o = append(o, opt{key: "awg_" + k, val: v})
}
off := opt{key: "disabled"}
auto := opt{key: "auto"}
if !srv.Enabled {
off.val, auto.val = "1", "0"
}
return append(o, off, auto)
}
// optsText is options as a log line's words (secrets masked, nothing as "-").
func optsText(list []opt) string {
var out []string
for _, o := range list {
s := "-"
if o.list != nil {
s = strings.Join(o.list, " ")
} else if o.val != "" {
s = o.val
}
if strings.Contains(o.key, "private_key") || strings.Contains(o.key, "preshared_key") || strings.Contains(o.key, "protection_key") ||
strings.Contains(o.key, "privatekey") || strings.Contains(o.key, "presharedkey") || strings.Contains(o.key, "protectionkey") {
s = "***"
}
out = append(out, o.key+"="+s)
}
return strings.Join(out, ", ")
}
// unsupported is why this AmneziaWG cannot run a server's disguise values, or nil when it can
// (dawnline.awg obf_unsupported).
func unsupported(o map[string]string, c awg.Caps) map[string]any {
has := func(keys ...string) bool {
for _, k := range keys {
if o[k] != "" {
return true
}
}
return false
}
installed := c.Kmod
if installed == nil {
installed = c.Tools
}
ranged := false
for _, k := range []string{"h1", "h2", "h3", "h4"} {
ranged = ranged || strings.Contains(o[k], "-")
}
switch {
case has("header_protection_key", "content_padding_addition", "rekey_after_time", "rekey_timeout", "reject_after_time", "keepalive_timeout",
"max_handshake_attempts", "random_trailers", "disable_cookies") && !c.V3:
return map[string]any{"code": "disguise", "need": "3.1", "installed": installed}
case (has("s3", "s4", "i1", "i2", "i3", "i4", "i5") || ranged) && !c.V2:
return map[string]any{"code": "disguise", "need": "2.0", "installed": installed}
}
return nil
}
// blockedNote is why a server is kept down, for the service log (dawnline.awg blocked_note).
func blockedNote(why map[string]any) string {
switch why["code"] {
case "ifname":
return fmt.Sprintf(`has an invalid interface name "%v"`, why["ifname"])
case "taken":
return fmt.Sprintf("can't use the network interface %v: it exists and isn't Dawnline's", why["ifname"])
case "disguise":
if in, _ := why["installed"].(string); in != "" {
return fmt.Sprintf("is kept down: its disguise needs AmneziaWG %v (installed: %s)", why["need"], in)
}
return fmt.Sprintf("is kept down: its disguise needs AmneziaWG %v (installed: none)", why["need"])
case "disguise_invalid":
return "is kept down: its disguise has values AmneziaWG cannot take"
}
return "is kept down"
}
func blockedFix(why map[string]any) string {
switch why["code"] {
case "disguise":
return "Install that AmneziaWG build in Settings → Updates, or switch the disguise in Settings → Disguise."
case "disguise_invalid":
return "Choose a disguise in Settings → Disguise: it replaces the values set by hand."
}
return "Choose another interface name in the server settings."
}
// intent notes why Dawnline itself is about to take a tunnel down, so the hotplug log can tell that from
// a tunnel that stopped on its own. reason: settings | off | removed. Kept for two minutes.
func (r *Router) intent(ifname, reason, name string) {
path := r.RunDir + "/iface-intent.json"
all := map[string]map[string]any{}
files.ReadJSON(path, &all)
now := time.Now().Unix()
for k, v := range all {
if ts, _ := v["ts"].(float64); float64(now)-ts >= 120 {
delete(all, k)
}
}
all[ifname] = map[string]any{"reason": reason, "name": name, "ts": now}
os.MkdirAll(r.RunDir, 0o755)
files.WriteJSON(path, all, 0o600)
}
// commit writes a configuration file in place whole, under a hidden name first.
func commit(path string, c *uci.Config) error {
var b [4]byte
rand.Read(b[:])
tmp := filepath.Join(filepath.Dir(path), "."+filepath.Base(path)+".dl-"+hex.EncodeToString(b[:]))
mode := os.FileMode(0o644)
if st, err := os.Stat(path); err == nil {
mode = st.Mode().Perm()
}
if err := os.WriteFile(tmp, []byte(c.Format()), mode); err != nil {
os.Remove(tmp)
return err
}
os.Chmod(tmp, mode)
if err := os.Rename(tmp, path); err != nil {
os.Remove(tmp)
return err
}
return nil
}
// ack records a configuration's new checksum after Dawnline committed and applied it itself, so a later
// `reload_config` does not treat it as changed and restart services that reload on any network change.
func (r *Router) ack(conf string) {
const md5f = "/var/run/config.md5"
if r.dry {
return
}
raw, err := os.ReadFile(md5f)
if err != nil {
return
}
sum, _ := r.Exec("sh", "-c", "uci show "+conf+" | md5sum | cut -d' ' -f1")
sum = strings.TrimSpace(sum)
if sum == "" {
return
}
path := "/var/run/config.check/" + conf
lines := strings.Split(strings.Trim(string(raw), " \t\r\n\v\f"), "\n")
found := false
for i, l := range lines {
if strings.HasSuffix(l, " "+path) {
lines[i], found = sum+" "+path, true
}
}
if !found {
lines = append(lines, sum+" "+path)
}
os.WriteFile(md5f, []byte(strings.Join(lines, "\n")+"\n"), 0o644)
}
// Netifd brings the router's network configuration in line with the servers; true when it changed. tools
// tells whether amneziawg-tools is there (without its protocol script, changing or bringing up an
// interface would only stop a tunnel that still runs); caps what this AmneziaWG can run. Each server that
// cannot have its interface is marked Blocked in m, as the rest of an apply works from the same model.
func (r *Router) Netifd(m *model.Model, tools bool, caps awg.Caps) bool {
text, _ := os.ReadFile(r.Network)
c, err := uci.Parse(string(text))
if err != nil {
r.say("error", "network", r.Network+" does not parse: nothing was changed · "+err.Error())
return false
}
changed := false
var touched []string
want := map[string]bool{}
was := map[string]any{}
files.ReadJSON(r.RunDir+"/netifd-blocked.json", &was)
blocked := map[string]any{}
block := func(srv *model.Server, why map[string]any, detail string) {
blocked[srv.ID] = why
srv.Blocked = why
a, _ := json.Marshal(was[srv.ID])
b, _ := json.Marshal(why)
if string(a) != string(b) && r.Log != nil {
r.Log.Write("dawnline", "error", blockedNote(why), detail, srv.Name, servicelog.Extra{})
}
}
flag := r.RunDir + "/netifd-no-awg"
_, flagged := os.Stat(flag)
keyed := false
for _, s := range m.Servers {
keyed = keyed || s.PrivateKey != ""
}
if tools && flagged == nil {
os.Remove(flag)
} else if !tools && keyed && flagged != nil {
if r.Log != nil {
r.Log.Write("dawnline", "error", "isn't installed: tunnels were left as they are", "Install it in Dawnline → Components.", "AmneziaWG", servicelog.Extra{})
}
os.MkdirAll(r.RunDir, 0o755)
os.WriteFile(flag, []byte(strconv.FormatInt(time.Now().Unix(), 10)), 0o644)
}
for _, id := range m.ServerIDs() {
srv := m.Servers[id]
if srv.PrivateKey == "" {
continue
}
ifn := srv.Ifname
if !model.ValidIfname(ifn) {
block(srv, map[string]any{"code": "ifname", "ifname": ifn}, "Interface name: 1-12 lowercase letters, digits or _.")
continue
}
// whose the section is: nobody's, this server's, or someone else's
if s := c.Section(ifn); s != nil {
if owner := s.Values["_dawnline"].Str; owner != id {
block(srv, map[string]any{"code": "taken", "ifname": ifn}, "Dawnline never changes interfaces it did not create. Choose another interface name for this server.")
continue
}
}
// disguise values AmneziaWG refuses or crashes on never reach the kernel, and a disguise this build
// cannot run would come up as a tunnel no device reaches: down, and said so
var why map[string]any
if tools {
if len(disguise.Unsafe(srv.Obf)) > 0 {
why = map[string]any{"code": "disguise_invalid"}
} else {
why = unsupported(srv.Obf, caps)
}
}
if why != nil {
block(srv, why, blockedFix(why))
continue
}
srv.Blocked = nil
want[ifn] = true
if !tools {
continue
}
created := false
if s := c.Section(ifn); s == nil || s.Type != "interface" {
c.DeleteSection(ifn)
c.Add("interface", ifn)
created = true
}
mine := created
var diff []opt
for _, o := range options(srv) {
if put(c, ifn, o) {
mine = true
diff = append(diff, o)
}
}
if mine {
how := "updated"
if created {
how = "created"
}
r.say("info", "network", fmt.Sprintf("interface %s (%s): %s · %s", ifn, srv.Name, how, optsText(diff)))
} else {
r.say("debug", "network", fmt.Sprintf("interface %s (%s): unchanged · %s", ifn, srv.Name, optsText(options(srv))))
}
// the markers are saved, but netifd does not read them: a renamed server keeps its tunnel and every session in it
if put(c, ifn, opt{key: "_dawnline", val: id}) {
changed = true
}
if put(c, ifn, opt{key: "_dawnline_name", val: srv.Name}) {
changed = true
}
if mine {
changed = true
touched = append(touched, ifn)
reason := "settings"
if !srv.Enabled {
reason = "off"
}
r.intent(ifn, reason, srv.Name)
}
}
a, _ := json.Marshal(blocked)
b, _ := json.Marshal(was)
if string(a) != string(b) {
os.MkdirAll(r.RunDir, 0o755)
files.WriteJSON(r.RunDir+"/netifd-blocked.json", blocked, 0o644)
}
// interfaces Dawnline made for servers that are no more
var stale []string
for _, s := range c.OfType("interface") {
if s.Values["_dawnline"].Str != "" && !want[s.Name] {
stale = append(stale, s.Name)
}
}
for _, ifn := range stale {
name := c.Section(ifn).Values["_dawnline_name"].Str
shown := name
if name == "" {
name, shown = ifn, "a removed server"
}
r.intent(ifn, "removed", name)
r.say("info", "network", fmt.Sprintf("interface %s (%s): removed, ifdown %s", ifn, shown, ifn))
r.Exec("ifdown", ifn)
c.DeleteSection(ifn)
changed = true
}
if changed {
if err := commit(r.Network, c); err != nil {
r.say("error", "network", r.Network+" could not be written · "+err.Error())
return false
}
r.ack("network")
}
// only the markers changed: nothing for netifd to read
if len(touched) > 0 || len(stale) > 0 {
r.say("info", "network", "ubus call network reload")
r.Exec("ubus", "call", "network", "reload")
for _, ifn := range touched {
if srv := m.Servers[c.Section(ifn).Values["_dawnline"].Str]; srv != nil && srv.Enabled {
r.say("info", "network", "ifup "+ifn)
r.Exec("ifup", ifn)
}
}
}
return changed
}
// NetifdOwner is whose an interface of the network configuration is: has false when there is none, id ""
// when it is not Dawnline's.
func (r *Router) NetifdOwner(ifname string) (id string, has bool) {
text, _ := os.ReadFile(r.Network)
c, err := uci.Parse(string(text))
if err != nil || c.Section(ifname) == nil {
return "", false
}
return c.Section(ifname).Values["_dawnline"].Str, true
}
// NetifdDrift is what of each running server's interface differs from what Netifd writes, by option name
// (a LuCI or uci edit of network.<ifname>, which would otherwise last until the next apply): an empty list
// when it is as Dawnline set it. Only enabled servers whose section exists and is theirs (a missing one is
// the tunnel probe's); the markers are not compared, netifd does not read them. Nothing is saved.
func (r *Router) NetifdDrift(m *model.Model) map[string][]string {
out := map[string][]string{}
text, _ := os.ReadFile(r.Network)
c, err := uci.Parse(string(text))
if err != nil {
return out
}
for _, id := range m.ServerIDs() {
srv := m.Servers[id]
s := c.Section(srv.Ifname)
if !srv.Enabled || !tunnelOK(srv) || s == nil || s.Values["_dawnline"].Str != id || s.Type != "interface" {
continue
}
diff := []string{}
for _, o := range options(srv) {
if put(c, srv.Ifname, o) {
diff = append(diff, o.key)
}
}
out[id] = diff
}
return out
}
// BlockedNote and BlockedFix word why a server is kept down, for the service log.
func BlockedNote(why map[string]any) string { return blockedNote(why) }
func BlockedFix(why map[string]any) string { return blockedFix(why) }