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

+576
View File
@@ -0,0 +1,576 @@
// Package health is Health's checks, as dawnline.health health() makes them: each named for the healthy
// state ("Clock is set"), a failed one also with the problem in words for notices, in the reader's
// language. Pure: Inputs is everything read on the router, gathered by the caller, so every check can be
// made up in a test. A check whose input is not given yet (nil) is left out.
package health
import (
"fmt"
"strconv"
"strings"
"github.com/tickcount/luci-app-dawnline/backend/endpoint"
"github.com/tickcount/luci-app-dawnline/backend/i18n"
"github.com/tickcount/luci-app-dawnline/backend/ipnet"
"github.com/tickcount/luci-app-dawnline/backend/model"
"github.com/tickcount/luci-app-dawnline/backend/uci"
)
// Check is one result. Fix names an action (apply, sync, restart, netrestart, ifup:<name>, install:<feature>,
// updates) or is nil; Problem is the failed check in words, nil for one that passed.
type Check struct {
ID string `json:"id"`
Title string `json:"title"`
Status string `json:"status"`
Detail string `json:"detail"`
Fix *string `json:"fix"`
Problem *string `json:"problem"`
}
func check(id, title, status, detail, fix, problem string) Check {
c := Check{ID: id, Title: title, Status: status, Detail: detail}
if fix != "" {
c.Fix = &fix
}
if status == "warn" || status == "error" {
if problem == "" {
problem = title
}
c.Problem = &problem
}
return c
}
// Iface is what netifd says of an interface.
type Iface struct {
Exists, Up bool
// Errors is its error codes (INVALID_PROTO).
Errors []string
}
// Peers is how a tunnel's loaded devices stand against those it should hold.
type Peers struct {
Expected, Missing, Extra, Loaded int
}
// Replies: whether answers from our ports go straight out, and the proxies' diverts that would swallow them.
type Replies struct {
OK bool
Diverts []string
}
// Subnet is an IPv4 network of a netifd interface.
type Subnet struct {
Iface, CIDR string
}
// Portal is what was read for the portal's checks.
type Portal struct {
Owners []string
Listening bool
// IPs is where its address points; WAN the router's.
IPs []string
WAN string
// Cert is the certificate in use; Valid: for more than 14 days; Names: the DNS names it covers.
Cert string
SelfSigned bool
Valid bool
Names []string
}
// Inputs is everything the checks are made from.
type Inputs struct {
M *model.Model
T *i18n.Catalog
// AmneziaWG: its state after trying to load the module (missing packages, loaded, handler), the firmware
// the installed build was for when that is not this one, why the module does not load, an update that
// waits for a reboot.
Missing []string
Loaded, Handler bool
KernelWas, KernelIs string
WhyNotLoaded string
WaitsForReboot bool
Year int
AgentRunning bool
// FreeKB is the overlay's free space (nil: unknown).
FreeKB *int64
NftLoaded bool
PolicyRouting []string
// ModelErrors is what is wrong with people and devices (nil: not checked yet).
ModelErrors func() []string
Firewall, Network *uci.Config
Iface func(ifname string) Iface
// Unread tells a tunnel that could not be read; Peers how its devices stand (nil: not checked yet).
Unread func(ifname string) bool
Peers func(srv *model.Server) Peers
Replies *Replies
// Subnets is the router's networks; HomeNets a server's home networks; Endpoint what its public address reads as.
Subnets []Subnet
HomeNets func(srv *model.Server) []string
Endpoint func(srv *model.Server, host string) endpoint.Reads
// LikeHome is the home-like path's state (dawnline.loop status); Needs the packages each feature misses.
LikeHome map[string]any
Needs map[string][]string
// The resolver for Home-only devices: its configuration's age in seconds (nil: none), whether it runs.
ResolverConfAge *int64
ResolverRunning bool
Portal func() Portal
// The networks behind people's routers: Behind, those in effect on this router by device (nil: not
// checked); Own, the router's own networks, to name what a network shares addresses with; RouteError,
// what the last sync said of a route that would not go in ("": none).
Behind map[string][]string
Own []string
RouteError string
}
// The /24s home routers come with out of the box: a home network on one of them is very likely the same as
// the network a person connects from.
var commonHome = []string{"192.168.0.0/24", "192.168.1.0/24", "192.168.2.0/24", "192.168.3.0/24", "192.168.8.0/24", "192.168.10.0/24", "192.168.31.0/24",
"192.168.50.0/24", "192.168.88.0/24", "192.168.100.0/24", "192.168.178.0/24", "10.0.0.0/24", "10.1.1.0/24"}
func overlap(a, b ipnet.Net) bool {
return uint64(a.Base) < uint64(b.Base)+b.Size() && uint64(b.Base) < uint64(a.Base)+a.Size()
}
// CommonHome is the home networks that overlap a common out-of-the-box subnet.
func CommonHome(nets []string) []string {
out := []string{}
for _, n := range nets {
a, ok := ipnet.Subnet(n)
if !ok {
continue
}
for _, c := range commonHome {
if b, _ := ipnet.Subnet(c); overlap(a, b) {
out = append(out, n)
break
}
}
}
return out
}
func has(list []string, v string) bool {
for _, x := range list {
if x == v {
return true
}
}
return false
}
func (in *Inputs) noProto() string {
return in.T.T("netifd doesn't know the amneziawg protocol (AmneziaWG missing, or the network wasn't restarted after installing it).")
}
func (in *Inputs) awg() Check {
t := in.T
title := t.T("AmneziaWG installed")
if n := len(in.Missing); n > 0 {
// the module was built for the kernel of the firmware it was installed on
if in.KernelWas != "" && has(in.Missing, "kmod-amneziawg") {
return check("awg", title, "error",
fmt.Sprintf(t.T("The firmware changed (kernel %s → %s): the AmneziaWG build installed for it is gone. Install the build for this firmware."), in.KernelWas, in.KernelIs),
"install:awg", t.T("AmneziaWG needs a build for the new firmware"))
}
return check("awg", title, "error", fmt.Sprintf(t.N(int64(n), "%s is missing.", "%s are missing."), strings.Join(in.Missing, ", ")), "install:awg", t.T("AmneziaWG isn’t installed"))
}
if !in.Loaded {
detail := t.T("The kernel module doesn't load. Reinstall a build for this kernel in Components.")
if in.WhyNotLoaded != "" {
detail = fmt.Sprintf(t.T("The kernel module doesn't load: %s Reinstall a build for this kernel in Components."), in.WhyNotLoaded)
}
return check("awg", title, "error", detail, "updates", t.T("AmneziaWG’s kernel module doesn’t load"))
}
if !in.Handler {
return check("awg", title, "error", in.noProto(), "netrestart", t.T("The network doesn’t know AmneziaWG yet"))
}
if in.WaitsForReboot {
return check("awg", title, "warn", t.T("The AmneziaWG update is installed and starts after a reboot."), "", t.T("The AmneziaWG update waits for a reboot"))
}
return check("awg", title, "ok", t.T("Kernel module, awg tool and the netifd protocol are present."), "", "")
}
func (in *Inputs) reply(id, title, problem, proto string, port int) (Check, bool) {
r := in.Replies
if r == nil {
return Check{}, false
}
t := in.T
via, from := strings.Join(r.Diverts, ", "), strings.ToUpper(proto)+" "+strconv.Itoa(port)
switch {
case !r.OK:
return check(id, title, "error", fmt.Sprintf(t.T("Answers from %s are swallowed by a proxy on the router (%s): clients get no reply."), from, via), "apply", problem), true
case len(r.Diverts) > 0:
return check(id, title, "ok", fmt.Sprintf(t.T("Answers from %s go straight out. A proxy on the router diverts its own traffic (%s); these answers skip it."), from, via), "", problem), true
}
return check(id, title, "ok", fmt.Sprintf(t.T("Answers from %s go straight out."), from), "", problem), true
}
func sectionIs(c *uci.Config, name, kind string) bool {
if c == nil {
return false
}
s := c.Section(name)
return s != nil && s.Type == kind
}
// server is the checks of one server's tunnel.
func (in *Inputs) server(id string, srv *model.Server, label string) []Check {
t, m := in.T, in.M
out := []Check{}
st := in.Iface(srv.Ifname)
running, down := t.T("Tunnel running")+label, t.T("AmneziaWG is down")+label
switch {
case !st.Up && has(st.Errors, "INVALID_PROTO"):
out = append(out, check("up_"+id, running, "error", in.noProto(), "netrestart", down))
case st.Up:
out = append(out, check("up_"+id, running, "ok", fmt.Sprintf(t.T("%s is up, listening on UDP %d."), srv.Ifname, srv.Port), "", down))
case !st.Exists:
out = append(out, check("up_"+id, running, "error", fmt.Sprintf(t.T("%s does not exist."), srv.Ifname), "apply", down))
case len(st.Errors) > 0:
out = append(out, check("up_"+id, running, "error", fmt.Sprintf(t.T("%s is down: %s."), srv.Ifname, strings.Join(st.Errors, ", ")), "ifup:"+srv.Ifname, down))
default:
out = append(out, check("up_"+id, running, "error", fmt.Sprintf(t.T("%s is down."), srv.Ifname), "ifup:"+srv.Ifname, down))
}
// the devices the sync loads, by the same choice the agent compares with every minute
loaded := t.T("Devices loaded") + label
if st.Up && in.Unread != nil && in.Unread(srv.Ifname) {
out = append(out, check("peers_"+id, loaded, "warn", t.T("The tunnel could not be read, so its devices could not be checked."), "",
t.T("The devices in AmneziaWG could not be checked")+label))
} else if st.Up && in.Peers != nil {
p := in.Peers(srv)
bad := t.T("Not every device is loaded into AmneziaWG") + label
switch {
case p.Missing == 0 && p.Extra == 0:
out = append(out, check("peers_"+id, loaded, "ok", fmt.Sprintf(t.N(int64(p.Loaded), "%d device is loaded in the tunnel.", "%d devices are loaded in the tunnel."), p.Loaded), "", bad))
case p.Extra != 0:
out = append(out, check("peers_"+id, loaded, "warn", fmt.Sprintf(t.N(int64(p.Expected), "%d of %d device missing, %d loaded that should not be.",
"%d of %d devices missing, %d loaded that should not be."), p.Missing, p.Expected, p.Extra), "sync", bad))
default:
out = append(out, check("peers_"+id, loaded, "warn", fmt.Sprintf(t.N(int64(p.Expected), "%d of %d device missing.", "%d of %d devices missing."), p.Missing, p.Expected), "sync", bad))
}
}
rules := sectionIs(in.Firewall, "dawnline_"+id+"_port", "rule") && sectionIs(in.Firewall, "dawnline_"+id+"_zone", "zone")
if rules {
out = append(out, check("fw_"+id, t.T("Firewall rules")+label, "ok", fmt.Sprintf(t.T("Zone %s and the WAN rule for UDP %d exist."), srv.Ifname, srv.Port), "", ""))
} else {
out = append(out, check("fw_"+id, t.T("Firewall rules")+label, "error", t.T("Firewall zone or WAN rule is missing."), "apply", t.T("AmneziaWG firewall rules are missing")+label))
}
if c, ok := in.reply("reply_"+id, t.T("Answers reach devices")+label, t.T("AmneziaWG answers may not reach devices")+label, "udp", srv.Port); ok {
out = append(out, c)
}
// port collisions with other tunnels
var clash []string
if in.Network != nil {
for _, s := range in.Network.OfType("interface") {
proto, _ := s.Get("proto")
lp, _ := s.Get("listen_port")
if n, _ := strconv.Atoi(strings.TrimSpace(lp)); s.Name != srv.Ifname && (proto == "amneziawg" || proto == "wireguard") && n == srv.Port {
clash = append(clash, s.Name)
}
}
}
if len(clash) > 0 {
out = append(out, check("port_"+id, t.T("Port is free")+label, "error", fmt.Sprintf(t.T("UDP %d is also used by %s."), srv.Port, strings.Join(clash, ", ")), "", t.T("AmneziaWG port is taken")+label))
}
var overlaps []string
if sc, ok := ipnet.Subnet(srv.Subnet); ok {
for _, o := range in.Subnets {
// every network of the router but this server's own tunnel's
if o.Iface == srv.Ifname {
continue
}
if oc, ok := ipnet.Subnet(o.CIDR); ok && overlap(sc, oc) {
overlaps = append(overlaps, o.Iface+" ("+o.CIDR+")")
}
}
}
if len(overlaps) > 0 {
out = append(out, check("subnet_"+id, t.T("Subnet is unique")+label, "error", fmt.Sprintf(t.T("%s overlaps %s."), srv.Subnet, strings.Join(overlaps, ", ")), "", t.T("AmneziaWG subnet overlaps another network")+label))
} else {
out = append(out, check("subnet_"+id, t.T("Subnet is unique")+label, "ok", fmt.Sprintf(t.T("%s does not overlap other networks."), srv.Subnet), "", ""))
}
// whether the home networks are on a common subnet, while anyone on the server has home access
reach := false
for _, p := range m.People {
reach = reach || (p.Server == id && (p.Access == "lan" || p.Access == "both"))
}
if nets := in.HomeNets(srv); reach && len(nets) > 0 {
c := check("homenet_"+id, t.T("Home network addresses")+label, "ok",
fmt.Sprintf(t.T("%s is not a common home subnet: the networks people connect from rarely use the same addresses."), strings.Join(nets, ", ")), "", "")
if bad := CommonHome(nets); len(bad) > 0 {
c.Status = "warn"
c.Detail = fmt.Sprintf(t.T("%s is one of the most common home subnets. On a network with the same addresses, people with home access reach your home instead of their own: their printer or TV there is out of reach while connected, with LAN Bypass too. A rarer subnet for your home network avoids it, for example 10.37.12.0/24."), strings.Join(bad, ", "))
}
// advice, not a fault: no notice elsewhere
out = append(out, c)
}
if c, has := in.behind(id, label); has {
out = append(out, c)
}
return out
}
// behind is the check of the networks behind a server's routers, when any router has one written: each is
// in effect (a peer of the tunnel, a route, a place in the access table), or the check says which is not
// and what it shares addresses with; a route the router would not take is said in its own words.
func (in *Inputs) behind(id, label string) (Check, bool) {
m, t := in.M, in.T
if in.Behind == nil {
return Check{}, false
}
title := t.T("Networks behind routers") + label
var bad []string
written, routed := 0, 0
for _, did := range m.DeviceIDs() {
d := m.Devices[did]
p := m.People[d.Person]
if p == nil || p.Server != id || d.Kind != "router" || d.Waiting || len(d.Behind) == 0 {
continue
}
written += len(d.Behind)
routed += len(in.Behind[did])
who := p.Name + " · " + d.Name
for _, s := range d.Behind {
n, why := model.BehindNet(s)
switch {
case why != "":
bad = append(bad, fmt.Sprintf(t.T("%s behind %s is not a network a router may have behind it."), s, who))
case has(in.Behind[did], n.String()):
default:
c := m.BehindClash(n, did, in.Own)
switch {
case c == nil:
bad = append(bad, fmt.Sprintf(t.T("%s behind %s is written twice, or is one more than a router may have."), n.String(), who))
case c.Server != "":
bad = append(bad, fmt.Sprintf(t.T("%s behind %s shares addresses with the tunnel network of %s (%s)."), n.String(), who, m.Servers[c.Server].Name, c.Net))
case c.Device != "":
bad = append(bad, fmt.Sprintf(t.T("%s behind %s shares addresses with %s behind %s."), n.String(), who, c.Net, m.Devices[c.Device].Name))
default:
bad = append(bad, fmt.Sprintf(t.T("%s behind %s shares addresses with %s, which the router has itself."), n.String(), who, c.Net))
}
}
}
}
switch {
case written == 0:
return Check{}, false
case len(bad) > 0:
return check("sites_"+id, title, "warn", strings.Join(bad, " ")+" "+t.T("Such a network is not in effect: change it in the server's Network settings."), "",
t.T("A network behind a router isn’t in effect")+label), true
case in.RouteError != "":
return check("sites_"+id, title, "error", fmt.Sprintf(t.T("A route to a network behind a router couldn't be set: %s."), in.RouteError), "sync",
t.T("A network behind a router has no route")+label), true
}
return check("sites_"+id, title, "ok",
fmt.Sprintf(t.N(int64(routed), "%d network behind routers is carried by the tunnel.", "%d networks behind routers are carried by the tunnel."), routed), "", ""), true
}
func (in *Inputs) portal() []Check {
t, s := in.T, in.M.Settings
portal, bad := t.T("Personal portal"), t.T("Personal portal isn’t working")
if need := in.Needs["https"]; len(need) > 0 {
return []Check{check("portal", portal, "error", fmt.Sprintf(t.T("HTTPS isn't available on this router: install %s."), strings.Join(need, ", ")), "install:https", bad)}
}
p := in.Portal()
out := []Check{}
switch {
case len(p.Owners) > 0:
out = append(out, check("portal", portal, "error", fmt.Sprintf(t.T("TCP %d is already used by %s. Choose another port in Settings."), s.PortalPort, strings.Join(p.Owners, ", ")), "", bad))
case p.Listening:
out = append(out, check("portal", portal, "ok", fmt.Sprintf(t.T("Listening on TCP %d."), s.PortalPort), "", bad))
default:
out = append(out, check("portal", portal, "error", fmt.Sprintf(t.T("Nothing listens on TCP %d."), s.PortalPort), "restart", bad))
}
if h := s.PortalHost; h == "" {
out = append(out, check("portal_host", t.T("Portal address"), "error", t.T("Set the public hostname in Settings so links can be generated."), "", t.T("Portal address isn’t set")))
} else {
cf := false
for _, ip := range p.IPs {
cf = cf || endpoint.Cloudflare(ip)
}
ips := strings.Join(p.IPs, ", ")
title, problem := t.T("Portal address points here"), t.T("Portal address doesn’t point here")
switch {
case len(p.IPs) == 0:
out = append(out, check("portal_dns", title, "error", fmt.Sprintf(t.T("%s does not resolve."), h), "", problem))
case cf:
out = append(out, check("portal_dns", title, "ok", fmt.Sprintf(t.T("%s goes through Cloudflare; in Russia such connections often stall after ~16 KB."), h), "", problem))
case p.WAN != "" && !has(p.IPs, p.WAN):
out = append(out, check("portal_dns", title, "warn", fmt.Sprintf(t.T("%s points at %s, not this router (%s)."), h, ips, p.WAN), "", problem))
case p.WAN != "":
out = append(out, check("portal_dns", title, "ok", fmt.Sprintf(t.T("%s → %s (this router)."), h, ips), "", problem))
default:
out = append(out, check("portal_dns", title, "ok", h+" → "+ips+".", "", problem))
}
}
if c, ok := in.reply("portal_reply", t.T("Portal answers reach visitors"), t.T("Portal answers may not reach visitors"), "tcp", s.PortalPort); ok {
out = append(out, c)
}
// IP addresses have no certificate: the portal also answers plain HTTP for them
var plain []string
hosts := append([]string{s.PortalHost}, s.PortalAlt...)
for i, h := range hosts {
if _, ip := ipnet.IP(h); ip && h != "" && !has(hosts[:i], h) {
plain = append(plain, h)
}
}
if len(plain) > 0 {
out = append(out, check("portal_http", t.T("Plain HTTP links"), "warn",
fmt.Sprintf(t.T("Links on %s use plain HTTP: the link and the VPN keys in configurations travel unencrypted."), strings.Join(plain, ", ")), "", t.T("Portal links use plain HTTP")))
}
title := t.T("Portal certificate")
if _, ip := ipnet.IP(s.PortalHost); ip {
return append(out, check("cert", title, "skip", t.T("The main address is an IP: its links use plain HTTP."), "", ""))
}
covers := s.PortalHost == "" || p.SelfSigned
for _, n := range p.Names {
covers = covers || endpoint.Covers(n, s.PortalHost)
}
problem := t.T("Portal certificate needs attention")
switch {
case p.SelfSigned && len(in.Needs["acme"]) > 0:
out = append(out, check("cert", title, "warn", t.T("Using a self-signed certificate: browsers will show a warning. ACME can get a free Let’s Encrypt one."), "", problem))
case p.SelfSigned:
out = append(out, check("cert", title, "warn", t.T("Using a self-signed certificate: browsers will show a warning."), "", problem))
case !covers:
out = append(out, check("cert", title, "warn", fmt.Sprintf(t.T("%s does not cover %s (it has %s): browsers will warn."), p.Cert, s.PortalHost, strings.Join(p.Names, ", ")), "", problem))
case p.Valid:
out = append(out, check("cert", title, "ok", fmt.Sprintf(t.T("%s covers %s and is valid for more than 14 days."), p.Cert, s.PortalHost), "", problem))
default:
out = append(out, check("cert", title, "warn", fmt.Sprintf(t.T("%s expires within 14 days."), p.Cert), "", problem))
}
return out
}
// Run makes every check.
func Run(in Inputs) []Check {
t, m := in.T, in.M
out := []Check{}
ids := m.ServerIDs()
if len(ids) > 0 {
out = append(out, in.awg())
}
if in.Year >= 2025 {
out = append(out, check("clock", t.T("Clock is set"), "ok", t.T("End dates and quotas use the router clock."), "", ""))
} else {
out = append(out, check("clock", t.T("Clock is set"), "error", t.T("The router clock looks wrong; end dates will misbehave. Check NTP."), "", t.T("Clock isn’t set")))
}
fix := "restart"
status := "error"
if in.AgentRunning {
fix, status = "", "ok"
}
out = append(out, check("agent", t.T("Background agent running"), status, t.T("Counts traffic and enforces end dates and quotas."), fix, t.T("Background agent isn’t running")))
// a full overlay fails every config write on the router
if in.FreeKB != nil {
free := *in.FreeKB
problem := t.T("The router is running out of flash")
switch {
case free < 2048:
status := "warn"
if free < 512 {
status = "error"
}
mb := strconv.FormatFloat(float64(int64(float64(free)/1024*10))/10, 'g', -1, 64)
out = append(out, check("flash", t.T("Free space on the router"), status,
fmt.Sprintf(t.T("%s MB free: settings may stop saving. Remove old backups (Settings → Backups) or shorten the history."), mb), "", problem))
default:
out = append(out, check("flash", t.T("Free space on the router"), "ok", fmt.Sprintf(t.T("%d MB free on the overlay."), free/1024), "", problem))
}
}
if len(ids) == 0 {
return append(out, check("server", t.T("Server configured"), "warn", t.T("Set a server up in Settings."), "", t.T("No server yet")))
}
if in.NftLoaded {
out = append(out, check("nft", t.T("Access rules loaded"), "ok", t.T("Table inet dawnline enforces who may reach LAN and the internet."), "", ""))
} else {
out = append(out, check("nft", t.T("Access rules loaded"), "error", t.T("Table inet dawnline is missing: no device is loaded into the tunnels until it is back."), "apply", t.T("Access rules aren’t loaded")))
}
likeHome := false
for _, id := range ids {
likeHome = likeHome || (m.Servers[id].LanLike && m.Servers[id].Enabled)
}
if likeHome {
if pr := in.PolicyRouting; len(pr) > 0 {
out = append(out, check("policy", t.T("Internet like a home device not bypassed"), "warn",
fmt.Sprintf(t.T("Policy routing on the router (%s) sends marked traffic straight out, past the home-device path: tunnel traffic it matches skips your LAN's proxies and filters."), strings.Join(pr, "; ")),
"", t.T("Other policy routing bypasses the home-device path")))
} else {
out = append(out, check("policy", t.T("Internet like a home device not bypassed"), "ok", t.T("No other policy routing ahead of the tunnel rules."), "", ""))
}
}
// a device the sync has to leave out: its sentences, how many more, then what it means
if in.ModelErrors != nil {
if data := in.ModelErrors(); len(data) > 0 {
parts := []string{strings.Join(data[:min(len(data), 4)], " ")}
if len(data) > 4 {
parts = append(parts, fmt.Sprintf(t.T("(%d more)"), len(data)-4))
}
parts = append(parts, t.T("Such devices are left out of the tunnels: fix or remove them."))
out = append(out, check("data", t.T("People and devices consistent"), "error", strings.Join(parts, " "), "", t.T("People and devices are inconsistent")))
} else {
out = append(out, check("data", t.T("People and devices consistent"), "ok", t.T("Every device has a key and an address of its own inside its server."), "", ""))
}
}
keyed := false
for _, id := range ids {
srv := m.Servers[id]
keyed = keyed || (srv.Enabled && srv.PrivateKey != "")
label := ""
if len(ids) > 1 {
label = " (" + srv.Name + ")"
}
if !srv.Enabled {
out = append(out, check("srv_"+id, t.T("Server")+label, "skip", t.T("Server is disabled."), "", ""))
continue
}
out = append(out, in.server(id, srv, label)...)
host := m.EndpointHost(srv)
status, text := endpoint.Words(endpoint.Of(host, in.Endpoint(srv, host)), "UDP "+strconv.Itoa(srv.Port), t)
out = append(out, check("ep_"+id, t.T("Public address")+label, status, text, "", t.T("Public address needs attention")+label))
if srv.LanLike {
ls := in.LikeHome
active, bridged := ls["active"] == true, ls["bridged"] == true
title, problem := t.T("Internet like a home device")+label, t.T("Internet like a home device isn’t working")+label
nh := in.Needs["home"]
switch {
case active && bridged:
out = append(out, check("home_"+id, title, "ok", fmt.Sprintf(t.T("Traffic enters %s as %s, so it is handled like any device on your LAN."), ls["dev"], ls["address"]), "", problem))
case len(nh) > 0:
out = append(out, check("home_"+id, title, "warn", fmt.Sprintf(t.T("Needs %s. Internet traffic leaves through WAN directly until then."), strings.Join(nh, ", ")), "install:home", problem))
case active:
out = append(out, check("home_"+id, title, "warn", fmt.Sprintf(t.T("The link is up but not attached to %s."), ls["dev"]), "apply", problem))
default:
// the path's own sentence, then what it means
why, _ := ls["error"].(string)
if ls["error"] == nil {
why = t.T("Not set up.")
}
out = append(out, check("home_"+id, title, "warn", why+" "+t.T("Internet traffic leaves through WAN directly."), "apply", problem))
}
}
}
// while every server is off the resolver only idles on loopback: nothing to check
if keyed {
running := in.ResolverConfAge != nil && in.ResolverRunning
// a new config (a server turned on, the home link up) restarts it: give it a few seconds
restarting := !running && in.ResolverConfAge != nil && *in.ResolverConfAge < 10
title, problem := t.T("DNS for Home-only devices"), t.T("DNS for Home-only devices isn’t working")
switch {
case restarting:
out = append(out, check("resolver", title, "ok", t.T("Restarting with the new settings."), "", problem))
case running && in.LikeHome["active"] == true && in.LikeHome["transit"] != nil && in.LikeHome["transit"] != "":
out = append(out, check("resolver", title, "ok", fmt.Sprintf(t.T("Plain resolver running next to the LAN (%s)."), in.LikeHome["transit"]), "", problem))
case running:
out = append(out, check("resolver", title, "ok", fmt.Sprintf(t.T("Plain resolver on port %d."), 5354), "", problem))
default:
out = append(out, check("resolver", title, "warn", t.T("The resolver is not running; Home-only devices cannot resolve names."), "apply", problem))
}
}
if m.Settings.PortalEnabled {
out = append(out, in.portal()...)
}
return out
}