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

+524
View File
@@ -0,0 +1,524 @@
// Package netview is the router's own networks: which interfaces there are, which is the WAN, which the
// LAN, and what a server's and a person's "home" reaches. As dawnline.net (snapshot, server_net) and
// dawnline.core (person_home) work them out: a device's configuration lists these networks, so the two
// backends must name the same ones.
//
// What it reads of the system comes through Sources, so a test hands in what a router said.
package netview
import (
"encoding/json"
"os"
"os/exec"
"path/filepath"
"regexp"
"sort"
"strconv"
"strings"
"github.com/tickcount/luci-app-dawnline/backend/ipnet"
"github.com/tickcount/luci-app-dawnline/backend/model"
"github.com/tickcount/luci-app-dawnline/backend/uci"
)
// Links Dawnline makes itself: never interfaces to offer.
const transit, inner = "dlx0", "dll0"
var (
vpnProtos = []string{"amneziawg", "wireguard", "openvpn", "openconnect", "vpnc", "pptp", "l2tp", "gre", "gretap", "vti", "xfrm"}
vpnNames = regexp.MustCompile(`^(wg|awg|tun|tap|ovpn|ipsec|vti|xfrm)`)
notWanProto = []string{"amneziawg", "wireguard", "openvpn", "openconnect", "vpnc"}
notWanNames = regexp.MustCompile(`^(wg|awg|tun|tap|ovpn)`)
noise = regexp.MustCompile(`^(ifb|teql|sit|ip6tnl|gre|gretap|erspan|ip6gre|ip6gretap|ip_vti|ip6_vti|tunl|bond)[0-9]*$`)
private = []string{"10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "100.64.0.0/10"}
)
// Link is what the system says of one interface.
type Link struct {
Flags int64 `json:"flags"`
Type int `json:"type"`
Master string `json:"master"`
Bridge bool `json:"bridge"`
Wifi bool `json:"wifi"`
}
// Logical is a netifd interface on a device.
type Logical struct {
Name string `json:"name"`
Proto string `json:"proto"`
}
// Sources is where a snapshot reads the system.
type Sources struct {
// Routes is `ip -j -4 route show table main`'s answer.
Routes func() []byte
// Addrs is `ip -j -4 addr show`'s answer (nil: no addresses are read).
Addrs func() []byte
// Links is every interface by name; Logical the netifd interface on each device.
Links func() map[string]Link
Logical func() map[string]Logical
// Zones is the firewall's zones (nil: none are read).
Zones func() Zones
}
// Device is an interface as Dawnline sees it.
type Device struct {
Name string `json:"name"`
// Category is what it is to the admin: wan (the one the default route leaves by), wifi, vpn, ethernet,
// other. Kind is the same but for a bridge, which is "bridge", and for the WAN, which keeps its own.
Category string `json:"category"`
Kind string `json:"kind"`
Up bool `json:"up"`
// Master is the bridge it is a port of; Members a bridge's ports.
Master string `json:"master"`
Members []string `json:"members"`
Nets []string `json:"nets"`
// Addrs is its IPv4 addresses ("192.0.2.7/24"), when they were read.
Addrs []string `json:"addrs"`
// Logical is the netifd interface on it and Proto that one's protocol; Zone its firewall zone ("": none).
Logical string `json:"logical"`
Proto string `json:"proto"`
Zone string `json:"zone"`
}
// Zones is the firewall's zones: every name, and the zone of each network and each device named in one.
type Zones struct {
Names []string
ByNet, ByDev map[string]string
}
// ZonesOf reads the zones of a firewall configuration, the first zone that names a network or device winning.
func ZonesOf(fw *uci.Config) Zones {
z := Zones{ByNet: map[string]string{}, ByDev: map[string]string{}}
if fw == nil {
return z
}
for _, s := range fw.OfType("zone") {
name, _ := s.Get("name")
if name == "" {
continue
}
z.Names = append(z.Names, name)
for key, into := range map[string]map[string]string{"network": z.ByNet, "device": z.ByDev} {
v := s.Values[key]
list := v.List
if !v.IsList {
list = strings.Fields(v.Str)
}
for _, n := range list {
if _, has := into[n]; n != "" && !has {
into[n] = name
}
}
}
}
return z
}
// Snapshot is one consistent look at the router's interfaces.
type Snapshot struct {
Devices map[string]*Device
WAN string
LAN string
// Zones is every firewall zone's name.
Zones []string
}
// Names is the interfaces' names, sorted: the order ucode lists them in.
func (s *Snapshot) Names() []string {
out := make([]string, 0, len(s.Devices))
for n := range s.Devices {
out = append(out, n)
}
sort.Strings(out)
return out
}
func has(list []string, v string) bool {
for _, x := range list {
if x == v {
return true
}
}
return false
}
func isPrivate(cidr string) bool {
n, ok := ipnet.Any(cidr)
if !ok || n.Prefix < 1 {
return false
}
for _, p := range private {
if r, _ := ipnet.Any(p); r.Holds(n.Base) {
return true
}
}
return false
}
// Take looks at the router.
func Take(src Sources) *Snapshot {
var routes []struct {
Dst string `json:"dst"`
Dev string `json:"dev"`
Metric *int `json:"metric"`
}
json.Unmarshal(src.Routes(), &routes)
logical := map[string]Logical{}
if src.Logical != nil {
logical = src.Logical()
}
byDev := map[string][]string{}
vpn := func(dev string) bool { return has(notWanProto, logical[dev].Proto) || notWanNames.MatchString(dev) }
// The WAN: the default route with the lowest metric that does not go into a VPN client; only VPN
// routes: the lowest of them.
wan, wanMetric, wanVPN := "", 0, true
for _, r := range routes {
if r.Dev == "" {
continue
}
if r.Dst != "default" {
byDev[r.Dev] = append(byDev[r.Dev], r.Dst)
continue
}
v, metric := vpn(r.Dev), 0
if r.Metric != nil {
metric = *r.Metric
}
if wan == "" || (wanVPN && !v) || (wanVPN == v && metric < wanMetric) {
wan, wanMetric, wanVPN = r.Dev, metric, v
}
}
addrs := map[string][]string{}
if src.Addrs != nil {
var list []struct {
Ifname string `json:"ifname"`
Info []struct {
Family string `json:"family"`
Local string `json:"local"`
Prefix int `json:"prefixlen"`
} `json:"addr_info"`
}
json.Unmarshal(src.Addrs(), &list)
for _, l := range list {
for _, a := range l.Info {
if a.Family == "inet" {
addrs[l.Ifname] = append(addrs[l.Ifname], a.Local+"/"+strconv.Itoa(a.Prefix))
}
}
}
}
links := src.Links()
names := make([]string, 0, len(links))
for n := range links {
names = append(names, n)
}
sort.Strings(names)
zones := Zones{}
if src.Zones != nil {
zones = src.Zones()
}
s := &Snapshot{Devices: map[string]*Device{}, WAN: wan, Zones: zones.Names}
if s.Zones == nil {
s.Zones = []string{}
}
var order []string
for _, dev := range names {
if dev == "lo" || dev == transit || dev == inner {
continue
}
l := links[dev]
nets := []string{}
if byDev[dev] != nil {
nets = ipnet.Collapse(byDev[dev])
}
if noise.MatchString(dev) && len(nets) == 0 {
continue
}
lg, known := logical[dev]
cat := "other"
switch {
case l.Wifi:
cat = "wifi"
case (known && has(vpnProtos, lg.Proto)) || l.Type == 65534 || (l.Flags&0x10 != 0 && l.Type != 1) || vpnNames.MatchString(dev):
cat = "vpn"
case l.Type == 1 || l.Bridge:
cat = "ethernet"
}
d := &Device{Name: dev, Category: cat, Kind: cat, Up: l.Flags&1 != 0, Master: l.Master, Members: []string{}, Nets: nets, Addrs: addrs[dev],
Logical: lg.Name, Proto: lg.Proto, Zone: zones.ByDev[dev]}
if l.Bridge {
d.Kind = "bridge"
}
if dev == wan {
d.Category = "wan"
}
if d.Addrs == nil {
d.Addrs = []string{}
}
if d.Zone == "" && known {
d.Zone = zones.ByNet[lg.Name]
}
s.Devices[dev] = d
order = append(order, dev)
}
for _, dev := range order {
if m := s.Devices[s.Devices[dev].Master]; m != nil {
m.Members = append(m.Members, dev)
}
}
// The LAN: netifd's "lan" if present, otherwise the first bridge (then ethernet device) carrying a
// private network.
for dev, lg := range logical {
if lg.Name == "lan" && s.Devices[dev] != nil {
s.LAN = dev
}
}
for _, pass := range []string{"bridge", "ethernet"} {
for _, dev := range order {
d := s.Devices[dev]
if s.LAN != "" || dev == wan || d.Kind != pass || d.Master != "" {
continue
}
for _, n := range d.Nets {
if isPrivate(n) {
s.LAN = dev
break
}
}
}
}
return s
}
// WanAddress is the address of the interface a server's devices come in on, or "".
func (s *Snapshot) WanAddress(srv *model.Server) string {
wan := srv.WanDevice
if srv.AutoWan {
wan = s.WAN
if wan == "" {
wan = srv.DetectedWan
}
}
if d := s.Devices[wan]; d != nil && len(d.Addrs) > 0 {
return strings.SplitN(d.Addrs[0], "/", 2)[0]
}
return ""
}
// Home is one interface of a server's home network.
type Home struct {
Dev string
Nets []string
}
// ServerHome is the interfaces that make up a server's home network and what they reach together.
func (s *Snapshot) ServerHome(srv *model.Server) (home []Home, nets []string) {
wan := srv.WanDevice
if srv.AutoWan {
wan = s.WAN
if wan == "" {
wan = srv.DetectedWan
}
}
var picked []string
auto := ""
if srv.AutoLan {
auto = s.LAN
if auto == "" {
auto = srv.DetectedLan
}
}
if auto != "" {
picked = append(picked, auto)
}
for _, d := range srv.LanDevices {
if d != auto {
picked = append(picked, d)
}
}
var all []string
for _, dev := range picked {
d := s.Devices[dev]
// Never the WAN, the tunnel itself, or a bridge port (routing only sees the bridge).
if dev == wan || dev == srv.Ifname || (d != nil && d.Master != "") {
continue
}
h := Home{Dev: dev, Nets: []string{}}
if d != nil {
h.Nets = d.Nets
}
home = append(home, h)
all = append(all, h.Nets...)
}
return home, ipnet.Collapse(all)
}
// PersonHome is the home networks a person reaches: all of the server's, or only the interfaces ticked on
// their page.
func (s *Snapshot) PersonHome(srv *model.Server, p *model.Person) []string {
home, nets := s.ServerHome(srv)
if p == nil || len(p.HomeNets) == 0 {
return nets
}
var picked []string
for _, h := range home {
if has(p.HomeNets, h.Dev) {
picked = append(picked, h.Nets...)
}
}
return ipnet.Collapse(picked)
}
// System reads the router itself: `ip` for the routes, /sys/class/net for the interfaces. logical is asked
// of netifd by the caller (it holds the bus).
func System(logical func() map[string]Logical) Sources {
const sys = "/sys/class/net"
read := func(dev, f string) string {
b, _ := os.ReadFile(filepath.Join(sys, dev, f))
return strings.TrimSpace(string(b))
}
return Sources{
Routes: func() []byte {
out, _ := exec.Command("ip", "-j", "-4", "route", "show", "table", "main").Output()
return out
},
Addrs: func() []byte {
out, _ := exec.Command("ip", "-j", "-4", "addr", "show").Output()
return out
},
Links: func() map[string]Link {
out := map[string]Link{}
entries, _ := os.ReadDir(sys)
for _, e := range entries {
dev := e.Name()
l := Link{}
l.Flags, _ = strconv.ParseInt(strings.TrimPrefix(read(dev, "flags"), "0x"), 16, 64)
l.Type, _ = strconv.Atoi(read(dev, "type"))
if m, err := os.Readlink(filepath.Join(sys, dev, "master")); err == nil {
l.Master = filepath.Base(m)
}
_, err := os.Stat(filepath.Join(sys, dev, "bridge"))
l.Bridge = err == nil
_, e1 := os.Stat(filepath.Join(sys, dev, "phy80211"))
_, e2 := os.Stat(filepath.Join(sys, dev, "wireless"))
l.Wifi = e1 == nil || e2 == nil
out[dev] = l
}
return out
},
Logical: logical,
Zones: func() Zones {
raw, err := os.ReadFile("/etc/config/firewall")
if err != nil {
return Zones{}
}
fw, _ := uci.Parse(string(raw))
return ZonesOf(fw)
},
}
}
// Wan is the interface a server's devices come in on; HomeOf one interface of its home network.
type Wan struct {
Dev string
Auto bool
Zone string
Missing bool
}
type HomeOf struct {
Dev string
Auto bool
Nets []string
Zone string
Missing bool
}
// ServerNet is what a server uses right now (dawnline.net server_net): its WAN, the interfaces of its home
// Own is the router's own networks: every route of its main table but the ones through Dawnline's own
// tunnels, which Dawnline puts there itself (a tunnel's subnet, the networks behind people's routers).
func (s *Snapshot) Own(m *model.Model) []string {
ours := map[string]bool{}
for _, srv := range m.Servers {
ours[srv.Ifname] = true
}
var nets []string
for _, name := range s.Names() {
if !ours[name] {
nets = append(nets, s.Devices[name].Nets...)
}
}
return ipnet.Collapse(nets)
}
// Behind is the networks behind each router that are in effect on this router, by the device's id: none
// that shares addresses with a network the router has itself.
func (s *Snapshot) Behind(m *model.Model) map[string][]string { return m.BehindOf(s.Own(m)) }
// network, what those reach together, and their firewall zones.
func (s *Snapshot) ServerNet(srv *model.Server) (wan Wan, home []HomeOf, nets, zones []string) {
wan = Wan{Dev: srv.WanDevice, Auto: srv.AutoWan}
if srv.AutoWan {
if wan.Dev = s.WAN; wan.Dev == "" {
wan.Dev = srv.DetectedWan
}
}
wan.Zone = srv.WanZone
if d := s.Devices[wan.Dev]; d != nil && d.Zone != "" {
wan.Zone = d.Zone
}
if wan.Zone == "" {
wan.Zone = "wan"
}
wan.Missing = wan.Dev != "" && s.Devices[wan.Dev] == nil
type pick struct {
dev string
auto bool
}
var picked []pick
auto := ""
if srv.AutoLan {
if auto = s.LAN; auto == "" {
auto = srv.DetectedLan
}
}
if auto != "" {
picked = append(picked, pick{auto, true})
}
for _, d := range srv.LanDevices {
if d != auto {
picked = append(picked, pick{d, false})
}
}
home, zones = []HomeOf{}, []string{}
var all []string
zone := func(z string) {
if z != "" && !has(zones, z) {
zones = append(zones, z)
}
}
for _, p := range picked {
d := s.Devices[p.dev]
// Never the WAN, the tunnel itself, or a bridge port (routing only sees the bridge).
if p.dev == wan.Dev || p.dev == srv.Ifname || (d != nil && d.Master != "") {
continue
}
// The detected LAN missing for a moment (bridge recreated) keeps its zone.
h := HomeOf{Dev: p.dev, Auto: p.auto, Nets: []string{}, Missing: d == nil}
if d != nil {
h.Nets, h.Zone = d.Nets, d.Zone
}
if h.Zone == "" && p.auto {
h.Zone = srv.LanZone
}
home = append(home, h)
all = append(all, h.Nets...)
zone(h.Zone)
}
// Older configs and routers where nothing could be resolved: the zone set at setup.
if len(home) == 0 && srv.AutoLan {
zone(srv.LanZone)
}
return wan, home, ipnet.Collapse(all), zones
}