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

+551
View File
@@ -0,0 +1,551 @@
// Package access is "Check access": it walks the same rules the access table and a device's configuration
// apply, and says in words where a connection stops, each step a whole sentence in the reader's language
// (dawnline.access). Held to ucode's own output on a made-up household (testdata, scripts/ucode-golden.sh).
package access
import (
"errors"
"fmt"
"regexp"
"strconv"
"strings"
"github.com/tickcount/luci-app-dawnline/backend/awg"
"github.com/tickcount/luci-app-dawnline/backend/handout"
"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/netview"
)
// Step is one step of the walk.
type Step struct {
OK bool `json:"ok"`
Title string `json:"title"`
Detail string `json:"detail"`
}
// Ctx is what the walk reads besides the settings: each person's state, the tunnels' peers, who is online
// and the router's interfaces.
type Ctx struct {
States map[string]string
Peers map[string]awg.Peer
Online func(d *model.Device, peer awg.Peer) bool
Snap *netview.Snapshot
T *i18n.Catalog
}
// Said is a refusal to check at all, as a sentence to translate and what goes into it.
type Said struct {
Msg string
Args []any
}
func (s Said) Error() string { return fmt.Sprintf(s.Msg, s.Args...) }
type walk struct {
Ctx
m *model.Model
}
func (w *walk) f(msg string, args ...any) string { return fmt.Sprintf(w.T.T(msg), args...) }
// inNets is the first of nets that holds ip, or "".
func inNets(ip string, nets []string) string {
n, ok := ipnet.IP(ip)
if !ok {
return ""
}
for _, s := range nets {
if c, ok := ipnet.Any(s); ok && c.Holds(n) {
return s
}
}
return ""
}
func (w *walk) cantConnect(name, st string) string {
switch st {
case "no_server":
return w.f("%s can't connect: they have no server", name)
case "server_off":
return w.f("%s can't connect: their server is turned off", name)
case "paused":
return w.f("%s can't connect: they are paused", name)
case "expired":
return w.f("%s can't connect: their access has ended", name)
case "quota":
return w.f("%s can't connect: they used up their data", name)
}
return w.f("%s can't connect: %s", name, st)
}
func (w *walk) cantReach(who string, disabled bool, st string) string {
switch {
case disabled:
return w.f("%s can't be reached: it is turned off", who)
case st == "no_server":
return w.f("%s can't be reached: they have no server", who)
case st == "server_off":
return w.f("%s can't be reached: their server is turned off", who)
case st == "paused":
return w.f("%s can't be reached: they are paused", who)
case st == "expired":
return w.f("%s can't be reached: their access has ended", who)
case st == "quota":
return w.f("%s can't be reached: they used up their data", who)
}
return w.f("%s can't be reached: %s", who, st)
}
func (w *walk) accessText(a string) string {
switch a {
case "lan":
return w.T.T("Home only")
case "internet":
return w.T.T("Internet only")
case "both":
return w.T.T("Home and Internet")
}
return a
}
func (w *walk) hasAccess(name, a string) string {
switch a {
case "lan":
return w.f("%s has Home only", name)
case "internet":
return w.f("%s has Internet only", name)
}
return w.f("%s has Home and Internet", name)
}
func (w *walk) reaches(name string, devs []string) string {
if len(devs) > 0 {
return w.f("%s reaches %s.", name, strings.Join(devs, ", "))
}
return w.f("%s reaches no home network.", name)
}
// tunnelOf is a server's tunnel network when it runs one of Dawnline's own, else "".
func tunnelOf(srv *model.Server) string {
if srv == nil || srv.PrivateKey == "" || srv.Blocked != nil || !model.ValidIfname(srv.Ifname) {
return ""
}
if _, ok := ipnet.Subnet(srv.Subnet); !ok {
return ""
}
return srv.Subnet
}
// inTunnels is the tunnel network (of any server) that holds ip: never home, whatever routes cover it.
func (w *walk) inTunnels(ip string) string {
var nets []string
for _, id := range w.m.ServerIDs() {
if t := tunnelOf(w.m.Servers[id]); t != "" {
nets = append(nets, t)
}
}
return inNets(ip, nets)
}
type target struct {
dev *model.Device
ip string
port int // 0: none
// net: the address is a host in this network behind dev (a router): the rules see it as they see the router
net string
}
var address = regexp.MustCompile(`^([0-9.]+)(:([0-9]{1,5}))?$`)
// parse reads "10.0.1.20:445" or a device id.
func (w *walk) parse(s string) (target, bool) {
s = strings.Trim(s, " \t\r\n\v\f")
if d := w.m.Devices[s]; d != nil {
return target{dev: d, ip: d.Address}, true
}
mm := address.FindStringSubmatch(s)
if mm == nil {
return target{}, false
}
if _, ok := ipnet.IP(mm[1]); !ok {
return target{}, false
}
t := target{ip: mm[1]}
if mm[3] != "" {
t.port, _ = strconv.Atoi(mm[3])
}
for _, id := range w.m.DeviceIDs() {
if d := w.m.Devices[id]; d.Address == t.ip {
t.dev = d
break
}
}
// a host behind someone's router: the networks in effect on this router, as the access table has them
if t.dev == nil {
behind := w.Snap.Behind(w.m)
for _, id := range w.m.DeviceIDs() {
if n := inNets(t.ip, behind[id]); n != "" {
t.dev, t.net = w.m.Devices[id], n
break
}
}
}
return t, true
}
// behindStep says that an address is a host behind a router, which the rest of the walk is then about.
func (w *walk) behindStep(t target) Step {
who := t.dev.Name
if p := w.m.People[t.dev.Person]; p != nil {
who = p.Name + " · " + t.dev.Name
}
return Step{true, w.f("%s is behind %s", t.ip, who), w.f("%s: the tunnel carries this network, and the rules see a host there as they see the router.", t.net)}
}
// personHome is the home networks a person reaches: all of the server's, or the interfaces ticked on their page.
func (w *walk) personHome(srv *model.Server, p *model.Person) (all bool, nets, devs []string) {
_, home, every, _ := w.Snap.ServerNet(srv)
if len(p.HomeNets) == 0 {
for _, h := range home {
devs = append(devs, h.Dev)
}
return true, every, devs
}
var picked []string
for _, h := range home {
for _, want := range p.HomeNets {
if want == h.Dev {
picked = append(picked, h.Nets...)
devs = append(devs, h.Dev)
break
}
}
}
return false, ipnet.Collapse(picked), devs
}
// homeDevOf is the home network (interface) of a server that holds an address.
func (w *walk) homeDevOf(srv *model.Server, ip string) string {
_, home, _, _ := w.Snap.ServerNet(srv)
for _, h := range home {
if inNets(ip, h.Nets) != "" {
return h.Dev
}
}
return ""
}
func (w *walk) routerHas(ip string) bool {
for _, d := range w.Snap.Devices {
for _, a := range d.Addrs {
if strings.SplitN(a, "/", 2)[0] == ip {
return true
}
}
}
return false
}
func (w *walk) state(p *model.Person) string {
if st := w.States[p.ID]; st != "" {
return st
}
return "active"
}
func (w *walk) personOK(p *model.Person, d *model.Device) Step {
if d.Disabled {
return Step{false, w.f("%s is turned off", d.Name), w.T.T("Turn the device on again on its page.")}
}
if st := w.state(p); st != "active" {
return Step{false, w.cantConnect(p.Name, st), ""}
}
return Step{true, w.f("%s is active", p.Name), w.accessText(p.Access)}
}
func (w *walk) connected(d *model.Device, who string) Step {
peer, has := w.Peers[d.PublicKey]
if !has || peer.Handshake <= 0 {
return Step{false, w.f("%s has never connected", who), w.T.T("There is no session the router could reach.")}
}
if w.Online == nil || !w.Online(d, peer) {
return Step{false, w.f("%s isn't connected right now", who), w.T.T("The router reaches it only while its VPN is on.")}
}
return Step{true, w.f("%s is connected", who), ""}
}
func (w *walk) circle(p *model.Person) *model.Circle {
if c := w.m.Circles[p.Circle]; c != nil && c.Server == p.Server {
return c
}
return nil
}
// fromDevice: a device to somewhere, the router, home, another device or the internet.
func (w *walk) fromDevice(d *model.Device, t target) []Step {
m, T := w.m, w.T
p := m.People[d.Person]
var srv *model.Server
if p != nil {
srv = m.Servers[p.Server]
}
if p == nil || srv == nil {
return []Step{{false, w.f("%s has no server", d.Name), ""}}
}
steps := []Step{w.personOK(p, d)}
if !steps[0].OK {
return steps
}
all, homeNets, homeDevs := w.personHome(srv, p)
allowed := handout.AllowedIPs(m, srv, p, d, homeNets)
via := func(ip string) Step {
// the configuration's own words: the option and its value
var v4 []string
for _, x := range allowed {
if !strings.Contains(x, ":") {
v4 = append(v4, x)
}
}
what := "AllowedIPs " + strings.Join(v4, ", ")
if inNets(ip, allowed) != "" {
return Step{true, T.T("Its configuration sends it to the router"), what}
}
return Step{false, T.T("Its configuration doesn't send it to the router"), w.f("%s: the device's own network handles it.", what)}
}
// another device
if t.dev != nil {
q := m.People[t.dev.Person]
qname := "?"
if q != nil {
qname = q.Name
}
who := qname + " · " + t.dev.Name
if t.dev.ID == d.ID {
// its own network: a router reaches what is behind it without the tunnel
if t.net != "" {
return []Step{{false, w.f("%s is behind this device", t.ip), T.T("A router reaches its own network without the tunnel.")}}
}
return []Step{{false, T.T("That is the same device"), ""}}
}
if q == nil || q.Server != p.Server {
return append(steps, Step{false, w.f("%s is on another server", who), T.T("Devices of different servers never reach each other.")})
}
if !p.HomeAccess() {
return append(steps, Step{false, w.hasAccess(p.Name, p.Access), T.T("Only people with home access reach other devices.")})
}
if !q.HomeAccess() {
return append(steps, Step{false, w.hasAccess(q.Name, q.Access), T.T("Only devices of people with home access can be reached.")})
}
if srv.Mesh == "off" {
return append(steps, Step{false, w.f(`"Devices reach each other" is off on %s`, srv.Name), T.T("Server → Access → Home network.")})
}
if srv.Mesh == "circles" && q.ID != p.ID {
a, b := w.circle(p), w.circle(q)
if a == nil || b == nil || a.ID != b.ID {
name := func(c *model.Circle) string {
if c == nil {
return T.T("no circle")
}
return c.Name
}
return append(steps, Step{false, w.f("%s and %s are not in one circle", p.Name, q.Name), p.Name + ": " + name(a) + " · " + q.Name + ": " + name(b)})
}
steps = append(steps, Step{true, w.f("Both are in %s", a.Name), T.T("Devices in one circle reach each other.")})
} else if q.ID == p.ID {
steps = append(steps, Step{true, w.f("Both are %s's devices", p.Name), ""})
} else {
steps = append(steps, Step{true, T.T("Devices reach each other on this server"), ""})
}
if st := w.state(q); st != "active" || t.dev.Disabled {
return append(steps, Step{false, w.cantReach(who, t.dev.Disabled, st), ""})
}
return append(steps, via(t.ip), w.connected(t.dev, who))
}
// a device that keeps its own local network out of the tunnel sends a private address there, router or
// home address alike: it never reaches this router's rules
if d.LanBypass && p.Access != "lan" && inNets(t.ip, allowed) == "" {
return append(steps, via(t.ip))
}
// the router itself
if w.routerHas(t.ip) {
s := m.Settings
plain := false
for _, h := range append([]string{s.PortalHost}, s.PortalAlt...) {
if _, ip := ipnet.IP(h); ip {
plain = true
}
}
portal := s.PortalEnabled && t.port != 0 && (t.port == s.PortalPort || (plain && t.port == s.PortalPort+1))
switch {
case t.port == 53:
steps = append(steps, Step{true, w.f("%s is this router: DNS is open to everyone", t.ip), ""})
case portal:
steps = append(steps, Step{true, w.f("%s is this router: the personal portal is open to everyone", t.ip), ""})
case !p.HomeAccess():
detail := w.f("%s has Internet only: only DNS and the portal on the router.", p.Name)
if p.Access == "lan" {
detail = w.f("%s has Home only: only DNS and the portal on the router.", p.Name)
}
return append(steps, Step{false, w.f("%s is this router", t.ip), detail})
default:
// like any home address: only on the networks the person reaches
if !all && inNets(t.ip, homeNets) == "" {
return append(steps, Step{false, w.f("%s is this router on a network %s doesn't reach", t.ip, p.Name), w.reaches(p.Name, homeDevs)})
}
detail := w.f("On one of the networks %s reaches.", p.Name)
if all {
detail = T.T("Home access includes the router.")
}
steps = append(steps, Step{true, w.f("%s is this router", t.ip), detail})
}
return append(steps, via(t.ip))
}
// a tunnel address no device has
if tn := w.inTunnels(t.ip); tn != "" {
return append(steps, Step{false, w.f("No device uses %s", t.ip), w.f("It is in the tunnel network %s.", tn)})
}
// home
wan, _, _, zones := w.Snap.ServerNet(srv)
if hdev := w.homeDevOf(srv, t.ip); hdev != "" {
if p.Access == "internet" {
return append(steps, Step{false, w.f("%s is at home (%s)", t.ip, hdev), w.f("%s has Internet only.", p.Name)})
}
if p.Access == "lan" && len(p.Services) > 0 {
var hit *model.Service
var names []string
for _, sid := range p.Services {
s := m.Services[sid]
if s == nil {
continue
}
names = append(names, s.Name)
open := len(s.Ports) == 0 || t.port == 0
for _, port := range s.Ports {
open = open || port == strconv.Itoa(t.port)
}
if s.Address == t.ip && open {
hit = s
}
}
if hit == nil {
what := t.ip
if t.port != 0 {
what += ":" + strconv.Itoa(t.port)
}
return append(steps, Step{false, w.f("%s is not one of %s's home services", what, p.Name), w.f("Allowed: %s", strings.Join(names, ", "))})
}
detail := T.T("All ports")
if len(hit.Ports) > 0 {
detail = w.f("Ports %s", strings.Join(hit.Ports, ", "))
}
steps = append(steps, Step{true, w.f("%s is %s, one of %s's home services", t.ip, hit.Name, p.Name), detail})
} else {
if inNets(t.ip, homeNets) == "" {
return append(steps, Step{false, w.f("%s is in %s, which %s doesn't reach", t.ip, hdev, p.Name), w.reaches(p.Name, homeDevs)})
}
detail := w.f("One of the networks %s reaches.", p.Name)
if all {
detail = T.T("Home access reaches every home network.")
}
steps = append(steps, Step{true, w.f("%s is in home network %s", t.ip, hdev), detail})
}
to := strings.Join(zones, ", ")
if to == "" {
to = T.T("home")
}
return append(steps, via(t.ip), Step{true, T.T("The firewall lets it through"), srv.Ifname + " → " + to})
}
// another private address, or the internet
if inNets(t.ip, []string{"10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "100.64.0.0/10", "169.254.0.0/16"}) != "" {
return append(steps, Step{false, w.f("%s isn't in %s's home network", t.ip, srv.Name), T.T("Private addresses outside the home network are blocked.")})
}
if p.Access == "lan" {
return append(steps, Step{true, w.f("%s is on the internet", t.ip), w.f("%s has Home only: their device's own internet reaches it, not the tunnel.", p.Name)})
}
leaves := T.T("It leaves through the WAN.")
if srv.LanLike {
leaves = T.T("It leaves like a home device would.")
} else if wan.Dev != "" {
leaves = w.f("It leaves through %s.", wan.Dev)
}
return append(steps, via(t.ip), Step{true, w.f("%s is on the internet", t.ip), leaves})
}
// toDevice: a home address to a device.
func (w *walk) toDevice(ip string, d *model.Device) []Step {
m, T := w.m, w.T
p := m.People[d.Person]
var srv *model.Server
if p != nil {
srv = m.Servers[p.Server]
}
if p == nil || srv == nil {
return []Step{{false, w.f("%s has no server", d.Name), ""}}
}
who := p.Name + " · " + d.Name
hdev := ""
if w.inTunnels(ip) == "" {
hdev = w.homeDevOf(srv, ip)
}
if hdev == "" {
return []Step{{false, w.f("%s isn't in %s's home network", ip, srv.Name), T.T("Only home devices reach people's devices.")}}
}
steps := []Step{{true, w.f("%s is at home (%s)", ip, hdev), ""}}
if !p.HomeAccess() {
title := w.hasAccess(p.Name, p.Access)
if p.Access == "lan" {
title = w.f("%s has only some home services", p.Name)
}
return append(steps, Step{false, title, T.T("Home devices reach only people with home access.")})
}
if _, nets, _ := w.personHome(srv, p); inNets(ip, nets) == "" {
return append(steps, Step{false, w.f("%s doesn't reach %s", p.Name, hdev), T.T("Networks a person does not reach cannot reach them either.")})
}
steps = append(steps, w.personOK(p, d))
if !steps[len(steps)-1].OK {
return steps
}
_, _, _, zones := w.Snap.ServerNet(srv)
from := strings.Join(zones, ", ")
if from == "" {
from = T.T("home")
}
return append(steps, Step{true, T.T("The firewall lets it through"), from + " → " + srv.Ifname}, w.connected(d, who))
}
// Check walks from one side to the other: each a device's id, or an IPv4 address (with a port when given).
// ok tells whether every step passed.
func Check(m *model.Model, from, to string, ctx Ctx) (ok bool, steps []Step, err error) {
w := &walk{ctx, m}
a, aok := w.parse(from)
if !aok {
return false, nil, Said{`"%s" is not a device or an IPv4 address.`, []any{from}}
}
b, bok := w.parse(to)
if !bok {
return false, nil, Said{`"%s" is not a device or an IPv4 address.`, []any{to}}
}
switch {
case a.dev != nil:
steps = w.fromDevice(a.dev, b)
case b.dev != nil:
steps = w.toDevice(a.ip, b.dev)
default:
return false, nil, errors.New("Choose a device on at least one side.")
}
// a side that is a host behind a router: said first, for each such side
var lead []Step
for _, t := range []target{a, b} {
if t.net != "" {
lead = append(lead, w.behindStep(t))
}
}
steps = append(lead, steps...)
ok = true
for _, s := range steps {
ok = ok && s.OK
}
return ok, steps, nil
}