Files
dawnline/backend/model/settings.go
T
Aemeath ac90575b0b
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
Dawnline 0.20.0
- **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.
2026-11-13 09:43:50 +03:00

180 lines
5.1 KiB
Go

// The `settings` section read by its schema (dawnline.schema SETTINGS and get()): each setting has a type,
// a default and, for a number, a range; a value that is missing or not of its type reads as the default.
// The words the admin is told about a bad value stay with whoever saves settings; this only reads.
package model
import (
"net/netip"
"regexp"
"strconv"
"strings"
"github.com/tickcount/luci-app-dawnline/backend/uci"
)
// The update policy's choices (dawnline.updates).
var (
updateIntervals = []string{"6h", "12h", "1d", "7d"}
updateTargets = []string{"app", "amneziawg", "packages"}
)
func settings(s *uci.Section) Settings {
return Settings{
PortalEnabled: flag(s, "portal_enabled", false),
PortalPort: ranged(s, "portal_port", 8443, 1, 65535),
PortalHost: word(s, "portal_host", ""),
PortalAlt: words(s, "portal_alt", []string{}),
PortalCert: word(s, "portal_cert", ""),
PortalKey: word(s, "portal_key", ""),
PortalRedirect: word(s, "portal_redirect", ""),
DefaultDeviceLimit: ranged(s, "default_device_limit", 3, 1, 32),
// Off until the admin turns it on: lookups send people's addresses to a third party.
GeoEnabled: flag(s, "geo_enabled", false),
GeoProvider: choice(s, "geo_provider", "ipwho.is", []string{"ipwho.is", "ipapi.co"}),
Hostnames: flag(s, "hostnames", true),
Domain: word(s, "domain", "lan"),
LogConnections: flag(s, "log_connections", true),
LogLevel: choice(s, "log_level", "info", []string{"error", "warn", "info", "debug"}),
Watchdog: flag(s, "watchdog", true),
// Written as "none" for no fallback; not set means the default.
HomeDNSFallback: fallbackDNS(s),
Updates: updates(s),
Retention: Retention{
LogKeepDays: raw(s, "log_keep_days"), LogMax: raw(s, "log_max"), LogCategory: raw(s, "log_category"),
LogConnections: raw(s, "log_connections"), LogPersist: raw(s, "log_persist"),
UsageKeepDays: raw(s, "usage_keep_days"), UsageKeepMonths: raw(s, "usage_keep_months"),
},
}
}
// raw is a value as it is written: a string, a list, or nil.
func raw(s *uci.Section, key string) any {
v, ok := s.Values[key]
switch {
case !ok:
return nil
case v.IsList:
return append([]string{}, v.List...)
}
return v.Str
}
// flag is a yes or no (schema's: 1 on true yes enabled, 0 off false no disabled, any case; else the default).
func flag(s *uci.Section, key string, dflt bool) bool {
v, _ := s.Get(key)
switch strings.ToLower(strings.TrimSpace(v)) {
case "1", "on", "true", "yes", "enabled":
return true
case "0", "off", "false", "no", "disabled":
return false
}
return dflt
}
var wholeNumber = regexp.MustCompile(`^-?[0-9]{1,9}$`)
// ranged is a whole number within its range, or the default.
func ranged(s *uci.Section, key string, dflt, lo, hi int) int {
v, _ := s.Get(key)
v = strings.TrimSpace(v)
if !wholeNumber.MatchString(v) {
return dflt
}
n, _ := strconv.Atoi(v)
if n < lo || n > hi {
return dflt
}
return n
}
// word is a string setting, or the default when it is not set or empty.
func word(s *uci.Section, key, dflt string) string {
if v, ok := s.Get(key); ok && v != "" {
return v
}
return dflt
}
// words is a list setting without its empty entries (one written as an option is a list of one).
func words(s *uci.Section, key string, dflt []string) []string {
v, ok := s.Values[key]
if !ok {
return dflt
}
in := v.List
if !v.IsList {
in = []string{v.Str}
}
out := []string{}
for _, x := range in {
if x != "" {
out = append(out, x)
}
}
return out
}
func choice(s *uci.Section, key, dflt string, values []string) string {
if v, ok := s.Get(key); ok && has(values, v) {
return v
}
return dflt
}
func fallbackDNS(s *uci.Section) string {
v, ok := s.Get("home_dns_fallback")
switch {
case !ok || v == "":
return "1.1.1.1"
case v == "none":
return ""
}
if a, err := netip.ParseAddr(v); err == nil && a.Is4() {
return v
}
return "1.1.1.1"
}
// on is the update policy's yes or no (dawnline.updates: 1 true on yes; anything else written is no).
func on(s *uci.Section, key string, dflt bool) bool {
v, ok := s.Get(key)
if !ok || v == "" {
return dflt
}
return v == "1" || v == "true" || v == "on" || v == "yes"
}
var clock = regexp.MustCompile(`^([01]?[0-9]|2[0-3]):[0-5][0-9]$`)
func updates(s *uci.Section) Updates {
u := Updates{
Check: on(s, "update_check", true), Interval: "1d", Auto: on(s, "update_auto", true), Mode: "scheduled",
Time: "04:00", Keep: on(s, "update_keep", false), Mirrors: on(s, "update_mirrors", true),
// AmneziaWG is left out by default: a new kernel module restarts every tunnel.
Targets: []string{"app", "packages"},
}
if v, _ := s.Get("update_interval"); has(updateIntervals, v) {
u.Interval = v
}
if v, _ := s.Get("update_mode"); v == "immediate" {
u.Mode = "immediate"
}
if v, _ := s.Get("update_time"); clock.MatchString(v) {
u.Time = v
}
if v, ok := s.Values["update_targets"]; ok && (v.IsList || v.Str != "") {
in := v.List
if !v.IsList {
in = []string{v.Str}
}
u.Targets = []string{}
for _, x := range in {
if has(updateTargets, x) {
u.Targets = append(u.Targets, x)
}
}
}
return u
}