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

+807
View File
@@ -0,0 +1,807 @@
package apply
import (
"encoding/json"
"fmt"
"os"
"path/filepath"
"reflect"
"strconv"
"strings"
"time"
"github.com/tickcount/luci-app-dawnline/backend/files"
"github.com/tickcount/luci-app-dawnline/backend/ipnet"
"github.com/tickcount/luci-app-dawnline/backend/model"
"github.com/tickcount/luci-app-dawnline/backend/servicelog"
"github.com/tickcount/luci-app-dawnline/backend/uci"
)
// "Like a home device" (dawnline.loop): tunnel clients' internet traffic enters the router from the LAN,
// so whatever handles LAN traffic there (proxies, DPI bypass, DNS filters, fw4's lan zone) handles it too.
//
// dawn0 ──policy route──▶ dlx0 ═veth═ dlx1 ┐ netns "dawnline" ┌ dll1 ═veth═ dll0 ── br-lan
// └── NAT to a LAN address ┘
//
// The netns is one more device on the LAN bridge with its own address (picked from the LAN's network above
// the DHCP pool) and its own MAC (hashed from the bridge's), the same each time it is made. Everything is
// derived from the router at run time. If the LAN is not a bridge or setup fails, the direct path stays and
// loop.json says why, as a code with its values.
const (
loopNS = "dawnline"
txRoot, txNS, lanRoot, lanNS = "dlx0", "dlx1", "dll0", "dll1"
prefLoopDNS, prefMain, prefLoop = 5205, 5210, 5290
loopWho = "Internet like a home device"
)
// LoopServer is one tunnel on the path: its networks that keep their direct route, and of those the ones
// behind people's routers (nil when there are none: the plan is compared with the one kept in loop.json),
// which the netns answers through the tunnel as it does the tunnel's own subnet.
type LoopServer struct {
Ifname string `json:"ifname"`
Subnet string `json:"subnet"`
Direct []string `json:"direct"`
Behind []string `json:"behind,omitempty"`
}
// LoopPlan is what should exist (dawnline.loop plan), kept in loop.json in ucode's own order of keys.
type LoopPlan struct {
Dev string `json:"dev"`
Gateway string `json:"gateway"`
Address string `json:"address"`
MAC string `json:"mac"`
Prefix int `json:"prefix"`
DNS string `json:"dns"`
Transit uint32 `json:"transit"`
TxRoot string `json:"tx_root"`
TxNS string `json:"tx_ns"`
Table int `json:"table"`
Servers []LoopServer `json:"servers"`
}
// Loop is what bringing the path to the settings came to: off (nobody wants it), a reason it cannot be
// (a code with its values), or the plan that is in place.
type Loop struct {
Off bool
Error map[string]any
Plan *LoopPlan
}
func (r *Router) sysNet() string {
if r.SysNet != "" {
return r.SysNet
}
return "/sys/class/net"
}
func (r *Router) netnsFile() string {
if r.NetnsDir != "" {
return r.NetnsDir + "/" + loopNS
}
return "/var/run/netns/" + loopNS
}
func (r *Router) linkThere(dev string) bool {
_, err := os.Stat(r.sysNet() + "/" + dev)
return err == nil
}
func (r *Router) nsThere() bool {
_, err := os.Stat(r.netnsFile())
return err == nil
}
// sh runs a shell command as ucode's sh(): what it said (both streams) and its exit code.
func (r *Router) sh(cmd string) (string, int) { return r.Exec("sh", "-c", cmd) }
// q quotes a word for the shell.
func q(s string) string { return "'" + strings.ReplaceAll(s, "'", `'\''`) + "'" }
func trimmed(s string) string { return strings.Trim(s, " \t\r\n\v\f") }
// run gives the commands that set the path up or take it down, each in the log as it is given; what failed,
// each with what it said.
func (r *Router) run(cmds []string) []string {
var errs []string
for _, c := range cmds {
r.say("info", "loop", "$ "+c)
}
for _, c := range cmds {
if out, code := r.sh(c); code != 0 {
errs = append(errs, c+": "+trimmed(out))
r.say("error", "loop", "failed: "+c+" · "+trimmed(out))
}
}
return errs
}
func (r *Router) loopLog(level, msg, detail string) {
if r.Log != nil {
r.Log.Write("dawnline", level, msg, detail, loopWho, servicelog.Extra{})
}
}
/* ---------- facts about the LAN ---------- */
type dhcpFacts struct {
pool *[2]uint32
dns string
statics []uint32
}
// dhcpOf is the DHCP pool, static leases and the DNS handed to LAN clients, for one netifd interface.
func (r *Router) dhcpOf(logical string, lan ipnet.Net) dhcpFacts {
var f dhcpFacts
raw, err := os.ReadFile(r.DHCP)
if err != nil {
return f
}
c, err := uci.Parse(string(raw))
if err != nil {
return f
}
for _, s := range c.OfType("dhcp") {
iface, _ := s.Get("interface")
if ignore, _ := s.Get("ignore"); iface != logical || ignore == "1" {
continue
}
num := func(key string, dflt float64) (float64, bool) {
v, has := s.Get(key)
if !has {
return dflt, true
}
return model.Number(v)
}
start, ok1 := num("start", 100)
limit, ok2 := num("limit", 150)
f.pool = nil
if ok1 && ok2 {
f.pool = &[2]uint32{lan.Base + uint32(int64(start)), lan.Base + uint32(int64(start)+int64(limit)) - 1}
}
v := s.Values["dhcp_option"]
opts := v.List
if !v.IsList && v.Str != "" {
opts = []string{v.Str}
}
for _, o := range opts {
if m := dnsOption.FindStringSubmatch(o); m != nil && f.dns == "" {
f.dns = m[2]
}
}
}
for _, s := range c.OfType("host") {
v, _ := s.Get("ip")
if ip, ok := ipnet.IP(v); ok {
f.statics = append(f.statics, ip)
}
}
return f
}
// usedAddresses is the addresses other devices are using right now (neighbour table and leases): each
// with the MAC that holds it ("": one is not known).
func (r *Router) usedAddresses(dev string) map[string]string {
used := map[string]string{}
if out, code := r.sh("ip -j -4 neigh show dev " + q(dev)); code == 0 {
var list []struct {
Dst string `json:"dst"`
Lladdr string `json:"lladdr"`
State []string `json:"state"`
}
if json.Unmarshal([]byte(trimmed(out)), &list) == nil {
for _, n := range list {
if n.Dst != "" && !has(n.State, "FAILED") && !has(n.State, "INCOMPLETE") {
used[n.Dst] = n.Lladdr
}
}
}
}
leases := r.Leases
if leases == "" {
leases = "/tmp/dhcp.leases"
}
raw, _ := os.ReadFile(leases)
for _, l := range strings.Split(string(raw), "\n") {
if f := strings.Split(l, " "); len(f) >= 3 {
used[f[2]] = f[1]
}
}
return used
}
func has(list []string, v string) bool {
for _, x := range list {
if x == v {
return true
}
}
return false
}
// ourMAC is the MAC the netns's LAN link has now; "" without the link.
func (r *Router) ourMAC() string {
out, code := r.sh("ip -n " + loopNS + " -j link show " + lanNS + " 2>/dev/null")
if code != 0 {
return ""
}
var list []struct {
Address string `json:"address"`
}
if json.Unmarshal([]byte(trimmed(out)), &list) != nil || len(list) == 0 {
return ""
}
return list[0].Address
}
func fnv1a(s string, h uint32) uint32 {
for i := 0; i < len(s); i++ {
h = (h ^ uint32(s[i])) * 16777619
}
return h
}
// LanMAC is the MAC for the netns's LAN link, from the bridge's: a locally administered unicast address
// hashed from it, so it is the same every time and differs between routers. Not the bridge's MAC with a
// bit flipped: radios and ports often get those.
func LanMAC(bridge string) string {
s := strings.ToLower(trimmed(bridge))
h1 := fnv1a("dawnline lan "+s, 0x811c9dc5)
h2 := fnv1a(s, h1)
return fmt.Sprintf("%02x:%02x:%02x:%02x:%02x:%02x", ((h1>>24)&0xfc)|0x02, (h1>>16)&0xff, (h1>>8)&0xff, h1&0xff, (h2>>24)&0xff, (h2>>16)&0xff)
}
// addressFree tells whether the netns may use a LAN address: a host of the network, not the router's, not
// a static lease, outside the DHCP pool and not held by another device (an entry with one of the MACs in
// mine is the netns itself, also from before it was made again).
func addressFree(ip, router uint32, lan ipnet.Net, f dhcpFacts, used map[string]string, mine []string) bool {
if ip <= lan.Base || uint64(ip) >= uint64(lan.Base)+lan.Size()-1 || ip == router {
return false
}
for _, s := range f.statics {
if s == ip {
return false
}
}
if f.pool != nil && ip >= f.pool[0] && ip <= f.pool[1] {
return false
}
u, held := used[ipnet.String(ip)]
return !held || (u != "" && has(mine, u))
}
// pickAddress is a LAN address for the netns: the saved one while it is free, otherwise the highest free
// host that does not answer.
func (r *Router) pickAddress(lan ipnet.Net, router uint32, f dhcpFacts, saved, dev string, mine []string) string {
used := r.usedAddresses(dev)
if sv, ok := ipnet.IP(saved); ok && addressFree(sv, router, lan, f, used, mine) {
return ipnet.String(sv)
}
for ip := lan.Base + uint32(lan.Size()) - 2; ip > lan.Base; ip-- {
if !addressFree(ip, router, lan, f, used, mine) {
continue
}
// last check: nobody answers on it
r.sh("ping -c 1 -W 1 -I " + q(dev) + " " + ipnet.String(ip))
if addressFree(ip, router, lan, f, r.usedAddresses(dev), mine) {
return ipnet.String(ip)
}
}
return ""
}
// pickTransit is a /30 in 169.254.0.0/16 that no route or address on the router overlaps.
func (r *Router) pickTransit() (uint32, bool) {
var busy []ipnet.Net
snap := r.Snapshot()
for _, d := range snap.Devices {
for _, n := range append(append([]string{}, d.Nets...), d.Addrs...) {
if c, ok := ipnet.Any(n); ok {
busy = append(busy, c)
}
}
}
for k := 77; k < 77+256; k++ {
base, _ := ipnet.IP(fmt.Sprintf("169.254.%d.0", k%256))
free := true
for _, c := range busy {
if uint64(base) < uint64(c.Base)+c.Size() && uint64(c.Base) < uint64(base)+4 {
free = false
break
}
}
if free {
return base, true
}
}
return 0, false
}
// pickTable is a routing table nobody else uses (ours holds a single route via the transit link).
func (r *Router) pickTable(saved int) (int, bool) {
free := func(t int) bool {
out, code := r.sh("ip -4 route show table " + strconv.Itoa(t))
said := trimmed(out)
if code != 0 || said == "" {
return true
}
return !strings.Contains(said, "\n") && strings.Contains(said, " dev "+txRoot)
}
if saved != 0 && free(saved) {
return saved, true
}
for t := 2077; t < 2177; t++ {
if free(t) {
return t, true
}
}
return 0, false
}
// LoopErrorNote is a reason the path is off, for the service log and syslog: English, like every log line.
func LoopErrorNote(e map[string]any) string {
switch e["code"] {
case "no_lan":
return "No LAN detected."
case "not_bridge":
return fmt.Sprintf("%v is not a bridge, so Dawnline cannot join the LAN as a device.", e["dev"])
case "no_ipv4":
return fmt.Sprintf("%v has no IPv4 address.", e["dev"])
case "no_address":
return fmt.Sprintf("No free address on %v.", e["net"])
case "no_transit":
return "No free link-local range for the internal link."
}
return "No free routing table."
}
/* ---------- plan ---------- */
type loopState struct {
Applied int64 `json:"applied"`
Plan *LoopPlan `json:"plan"`
Transit uint32 `json:"transit"`
Fast *bool `json:"fast"`
Error any `json:"error"`
Off bool `json:"off"`
}
func (r *Router) loopState() loopState {
var s loopState
files.ReadJSON(r.RunDir+"/loop.json", &s)
return s
}
// LoopPlanFor is what should exist for these settings; saved is the LAN address kept from before
// (settings.lan_address). Pure apart from reading the router (and one ping a candidate address).
func (r *Router) LoopPlanFor(m *model.Model, saved string) Loop {
var wanted []*model.Server
for _, id := range m.ServerIDs() {
if s := m.Servers[id]; tunnelOK(s) && s.Enabled && s.LanLike {
wanted = append(wanted, s)
}
}
if len(wanted) == 0 {
return Loop{Off: true}
}
snap := r.Snapshot()
dev := snap.LAN
d := snap.Devices[dev]
if dev == "" || d == nil {
return Loop{Error: map[string]any{"code": "no_lan"}}
}
if d.Kind != "bridge" {
return Loop{Error: map[string]any{"code": "not_bridge", "dev": dev}}
}
var lan ipnet.Net
var router uint32
ok := len(d.Addrs) > 0
if ok {
if lan, ok = ipnet.Subnet(d.Addrs[0]); ok {
router, ok = ipnet.IP(strings.SplitN(d.Addrs[0], "/", 2)[0])
}
}
if !ok {
return Loop{Error: map[string]any{"code": "no_ipv4", "dev": dev}}
}
facts := r.dhcpOf(d.Logical, lan)
bridge, _ := os.ReadFile(r.sysNet() + "/" + dev + "/address")
mac := LanMAC(string(bridge))
// the netns's MACs: the one it gets, and the one it has (a random one from an older version)
addr := r.pickAddress(lan, router, facts, saved, dev, []string{mac, r.ourMAC()})
if addr == "" {
return Loop{Error: map[string]any{"code": "no_address", "net": lan.String()}}
}
last := r.loopState()
tx, ok := r.pickTransit()
if !ok {
return Loop{Error: map[string]any{"code": "no_transit"}}
}
saw := 0
if last.Plan != nil {
saw = last.Plan.Table
}
table, ok := r.pickTable(saw)
if !ok {
return Loop{Error: map[string]any{"code": "no_table"}}
}
p := &LoopPlan{Dev: dev, Gateway: ipnet.String(router), Address: addr, MAC: mac, Prefix: lan.Prefix, DNS: facts.dns, Transit: tx,
TxRoot: ipnet.String(tx + 1), TxNS: ipnet.String(tx + 2), Table: table, Servers: []LoopServer{}}
if p.DNS == "" {
p.DNS = p.Gateway
}
// by the settings alone, whoever is loaded now: the path does not move with people's states
behind := snap.Behind(m)
for _, srv := range wanted {
_, _, nets, _ := snap.ServerNet(srv)
var sites []string
for _, id := range m.DeviceIDs() {
if p := m.People[m.Devices[id].Person]; p != nil && p.Server == srv.ID {
sites = append(sites, behind[id]...)
}
}
if sites != nil {
sites = ipnet.Collapse(sites)
}
p.Servers = append(p.Servers, LoopServer{Ifname: srv.Ifname, Subnet: srv.Subnet,
Direct: ipnet.Collapse(append(append([]string{srv.Subnet}, nets...), sites...)), Behind: sites})
}
return Loop{Plan: p}
}
/* ---------- apply ---------- */
// NSRules is the netns's nft script as text. With fast, a flowtable on the netns's own two links takes
// established TCP and UDP flows past conntrack and the forward hook here. Only dlx1 and dll1: the root
// namespace's links stay out, the guard there sees every packet.
func NSRules(p *LoopPlan, fast bool) string {
ft, add := "", ""
if fast {
ft = "\n\tflowtable ft {\n\t\thook ingress priority 0;\n\t\tdevices = { \"" + txNS + "\", \"" + lanNS + "\" };\n\t}"
add = "\n\t\tct state established meta l4proto { tcp, udp } flow add @ft"
}
return "table inet dawnline\ndelete table inet dawnline\ntable inet dawnline {" + ft + `
chain nat_pre {
type nat hook prerouting priority dstnat; policy accept;
iifname "` + txNS + `" ip daddr ` + p.Address + ` meta l4proto { tcp, udp } th dport 53 dnat ip to ` + p.DNS + `:53
}
chain nat_post {
type nat hook postrouting priority srcnat; policy accept;
oifname "` + lanNS + `" masquerade
}
chain filter_forward {
type filter hook forward priority filter; policy drop;` + add + `
ct state established,related accept
iifname "` + txNS + `" oifname "` + lanNS + `" accept
}
chain filter_input {
type filter hook input priority filter; policy drop;
ct state established,related accept
iifname "lo" accept
icmp type echo-request accept
iifname "` + txNS + `" meta l4proto { tcp, udp } th dport 53 accept
}
}
`
}
// loadNSRules loads the netns's rules, with the flowtable when the kernel takes it, else without (the path
// works either way): slow is why the flowtable failed, err why the rules without it failed too.
func (r *Router) loadNSRules(p *LoopPlan) (fast bool, slow, err string) {
os.MkdirAll(r.varEtc(), 0o755)
path := r.varEtc() + "/dawnline-ns.nft"
load := func(fast bool) string {
os.WriteFile(path, []byte(NSRules(p, fast)), 0o644)
if errs := r.run([]string{"ip netns exec " + loopNS + " nft -f " + path}); len(errs) > 0 {
return errs[0]
}
return ""
}
if slow = load(true); slow == "" {
return true, "", ""
}
return false, slow, load(false)
}
// LoopRule is one policy rule of the path (To "": all).
type LoopRule struct {
Pref int
Iif string
To string
Table string
}
// LoopRules is the policy rules a plan wants, in order. A server interface: DNS to the netns address
// through the netns, home networks and the tunnel network by main, the rest into the netns.
func LoopRules(p *LoopPlan) []LoopRule {
var out []LoopRule
if p == nil {
return out
}
table := strconv.Itoa(p.Table)
for _, s := range p.Servers {
out = append(out, LoopRule{prefLoopDNS, s.Ifname, p.Address + "/32", table})
for _, n := range s.Direct {
out = append(out, LoopRule{prefMain, s.Ifname, n, "main"})
}
out = append(out, LoopRule{prefLoop, s.Ifname, "", table})
}
return out
}
// IPRule is a policy rule as `ip -j -4 rule show` prints it.
type IPRule struct {
Priority int `json:"priority"`
Src string `json:"src"`
Srclen *int `json:"srclen"`
Dst string `json:"dst"`
Dstlen *int `json:"dstlen"`
Iif string `json:"iif"`
Table string `json:"table"`
Detached json.RawMessage `json:"iif_detached"`
}
// currentRules is our policy rules: in our priority band and bound to a Dawnline tunnel interface, or left
// behind by a removed tunnel (its interface is gone).
func (r *Router) currentRules(ifnames []string) []IPRule {
var out []IPRule
said, code := r.sh("ip -j -4 rule show")
if code != 0 {
return out
}
var all []IPRule
if json.Unmarshal([]byte(trimmed(said)), &all) != nil {
return out
}
for _, x := range all {
if x.Priority >= 5200 && x.Priority < 5300 && x.Iif != "" && (has(ifnames, x.Iif) || x.Detached != nil) {
out = append(out, x)
}
}
return out
}
// ruleNet is a source or destination as `ip -j rule` has it, or "" for all.
func ruleNet(addr string, n *int) string {
if addr == "" || addr == "all" {
return ""
}
if n != nil {
return addr + "/" + strconv.Itoa(*n)
}
return addr
}
func ruleKey(pref int, from, iif, to, table string) string {
// `ip -j rule` shows a /32 source or destination without its length
full := func(n string) string {
switch {
case n == "":
return "all"
case !strings.Contains(n, "/"):
return n + "/32"
}
return n
}
return fmt.Sprintf("%d %s %s %s %s", pref, full(from), iif, full(to), table)
}
func ruleDel(x IPRule) string {
cmd := "ip -4 rule del priority " + strconv.Itoa(x.Priority)
if from := ruleNet(x.Src, x.Srclen); from != "" {
cmd += " from " + from
}
cmd += " iif " + q(x.Iif)
if to := ruleNet(x.Dst, x.Dstlen); to != "" {
cmd += " to " + to
}
return cmd + " lookup " + x.Table
}
// RuleCmds is the commands that turn the rules there are into the ones a plan wants: the missing ones
// added first, then the ones no longer wanted removed, so a device's traffic never falls between two
// rules while others change. None when they are as wanted.
func RuleCmds(p *LoopPlan, current []IPRule) []string {
have, want := map[string]IPRule{}, map[string]bool{}
var order, cmds, twice []string
for _, x := range current {
k := ruleKey(x.Priority, ruleNet(x.Src, x.Srclen), x.Iif, ruleNet(x.Dst, x.Dstlen), x.Table)
if _, seen := have[k]; seen {
twice = append(twice, ruleDel(x))
} else {
order = append(order, k)
}
have[k] = x
}
for _, w := range LoopRules(p) {
k := ruleKey(w.Pref, "", w.Iif, w.To, w.Table)
if _, there := have[k]; !there && !want[k] {
cmd := "ip -4 rule add priority " + strconv.Itoa(w.Pref) + " iif " + q(w.Iif)
if w.To != "" {
cmd += " to " + w.To
}
cmds = append(cmds, cmd+" lookup "+w.Table)
}
want[k] = true
}
for _, k := range order {
if !want[k] {
cmds = append(cmds, ruleDel(have[k]))
}
}
// the same rule twice (one deletion removes one of them)
return append(cmds, twice...)
}
// LoopRemove takes away the netns, links and rules, and the router's neighbour entry for the netns.
func (r *Router) LoopRemove(ifnames []string) {
last := r.loopState().Plan
// read while the link is there: the entry is ours when it carries the netns's MAC
stale := false
if last != nil && last.Dev != "" {
held := r.usedAddresses(last.Dev)[last.Address]
stale = held != "" && (held == last.MAC || held == r.ourMAC())
}
var cmds []string
for _, x := range r.currentRules(ifnames) {
cmds = append(cmds, ruleDel(x))
}
if last != nil && last.Table != 0 {
cmds = append(cmds, "ip -4 route flush table "+strconv.Itoa(last.Table))
}
if r.linkThere(txRoot) {
cmds = append(cmds, "ip link del "+txRoot)
}
if r.linkThere(lanRoot) {
cmds = append(cmds, "ip link del "+lanRoot)
}
if r.nsThere() {
cmds = append(cmds, "ip netns del "+loopNS)
}
// left there, it would hold the address for a MAC nobody has
if stale {
cmds = append(cmds, "ip -4 neigh del "+q(last.Address)+" dev "+q(last.Dev))
}
r.run(cmds)
os.Remove(r.RunDir + "/loop.json")
}
func sameJSON(a, b any) bool {
x, _ := json.Marshal(a)
y, _ := json.Marshal(b)
return string(x) == string(y)
}
// LoopEnsure brings the path to the plan. Cheap when nothing changed: it compares with the last applied
// plan and only checks that links, bridge port and rules exist. saved is the LAN address kept from before.
func (r *Router) LoopEnsure(m *model.Model, saved string, force bool) Loop {
state := r.RunDir + "/loop.json"
var ifnames []string
for _, id := range m.ServerIDs() {
ifnames = append(ifnames, m.Servers[id].Ifname)
}
res := r.LoopPlanFor(m, saved)
if res.Plan == nil {
// read before the removal, which deletes it: the error is logged once, not every tick
was := r.loopState()
if was.Plan != nil || r.linkThere(txRoot) || r.linkThere(lanRoot) || len(r.currentRules(ifnames)) > 0 {
r.LoopRemove(ifnames)
}
os.MkdirAll(r.RunDir, 0o755)
var why any
if res.Error != nil {
why = res.Error
}
files.WriteJSON(state, map[string]any{"error": why, "off": res.Off}, 0o644)
if res.Error != nil && !sameJSON(res.Error, was.Error) {
r.loopLog("error", "is off", LoopErrorNote(res.Error))
}
return res
}
p := res.Plan
last := r.loopState()
same := !force && last.Applied != 0 && last.Plan != nil && reflect.DeepEqual(last.Plan, p)
master, _ := os.Readlink(r.sysNet() + "/" + lanRoot + "/master")
healthy := r.linkThere(txRoot) && r.linkThere(lanRoot) && r.nsThere() && master != "" && filepath.Base(master) == p.Dev
if same && healthy && len(RuleCmds(p, r.currentRules(ifnames))) == 0 {
return res
}
// A link made by an older version has a random MAC (its plan had none, so this runs once after an
// update): it gets the stable one.
remac := r.linkThere(lanRoot) && r.ourMAC() != p.MAC
var cmds []string
if !r.nsThere() {
cmds = append(cmds, "ip netns add "+loopNS)
}
if !r.linkThere(txRoot) {
cmds = append(cmds, "ip link add "+txRoot+" type veth peer name "+txNS+" netns "+loopNS)
}
if !r.linkThere(lanRoot) {
cmds = append(cmds, "ip link add "+lanRoot+" type veth peer name "+lanNS+" address "+p.MAC+" netns "+loopNS)
}
if remac {
cmds = append(cmds, "ip -n "+loopNS+" link set "+lanNS+" down", "ip -n "+loopNS+" link set "+lanNS+" address "+p.MAC)
}
errs := r.run(cmds)
n := "ip -n " + loopNS + " "
cmds = []string{
"ip addr flush dev " + txRoot,
"ip addr add " + p.TxRoot + "/30 dev " + txRoot,
"ip link set " + txRoot + " up",
"ip link set " + lanRoot + " master " + q(p.Dev),
"ip link set " + lanRoot + " up",
n + "link set lo up",
n + "addr flush dev " + txNS,
n + "addr add " + p.TxNS + "/30 dev " + txNS,
n + "link set " + txNS + " up",
n + "addr flush dev " + lanNS,
n + "addr add " + p.Address + "/" + strconv.Itoa(p.Prefix) + " dev " + lanNS,
n + "link set " + lanNS + " up",
n + "route replace default via " + p.Gateway + " dev " + lanNS,
// the resolver's own queries (from the transit address) go back out the transit link
n + "route replace default via " + p.TxRoot + " dev " + txNS + " table 100",
n + "rule del from " + p.TxNS + " lookup 100 2>/dev/null; " + n + "rule add from " + p.TxNS + " lookup 100",
"ip netns exec " + loopNS + " sh -c 'echo 1 > /proc/sys/net/ipv4/ip_forward; echo 0 > /proc/sys/net/ipv4/conf/all/rp_filter; echo 0 > /proc/sys/net/ipv4/conf/default/rp_filter'",
"ip -4 route replace default via " + p.TxNS + " dev " + txRoot + " table " + strconv.Itoa(p.Table),
}
// the networks behind routers are answered through the tunnel too; the ones of the plan before go first
sites := false
for _, s := range p.Servers {
sites = sites || len(s.Behind) > 0
}
if last.Plan != nil {
for _, s := range last.Plan.Servers {
sites = sites || len(s.Behind) > 0
}
}
if sites {
cmds = append(cmds, n+"route flush proto "+routeProto+" 2>/dev/null || true")
}
for _, s := range p.Servers {
cmds = append(cmds, n+"route replace "+q(s.Subnet)+" via "+q(p.TxRoot)+" dev "+txNS)
for _, b := range s.Behind {
cmds = append(cmds, n+"route replace "+q(b)+" via "+q(p.TxRoot)+" dev "+txNS+" proto "+routeProto)
}
}
// the router knows the address by the old MAC: ask again now, not when the entry expires
if remac {
cmds = append(cmds, "ip -4 neigh flush to "+p.Address+" dev "+q(p.Dev))
}
errs = append(errs, r.run(cmds)...)
fast, slow, err := r.loadNSRules(p)
if err != "" {
errs = append(errs, err)
}
errs = append(errs, r.run(RuleCmds(p, r.currentRules(ifnames)))...)
if len(errs) > 0 {
why := map[string]any{"code": "setup", "detail": errs[0]}
if !sameJSON(r.loopState().Error, why) {
r.loopLog("error", "failed - internet goes out directly for now", errs[0])
}
r.LoopRemove(ifnames)
files.WriteJSON(state, map[string]any{"error": why}, 0o644)
return Loop{Error: why}
}
os.MkdirAll(r.RunDir, 0o755)
files.WriteJSON(state, loopState2{Applied: time.Now().Unix(), Plan: p, Transit: p.Transit, Fast: fast}, 0o644)
switch {
case last.Applied == 0 || last.Plan == nil || last.Plan.Dev != p.Dev || last.Plan.Address != p.Address:
r.loopLog("up", fmt.Sprintf("is on · traffic enters %s as %s", p.Dev, p.Address), "")
case !healthy:
r.loopLog("repair", fmt.Sprintf("was broken - set up again (%s as %s)", p.Dev, p.Address), "")
}
// once, not again on every apply while the module is still missing
if !fast && (last.Fast == nil || *last.Fast) {
r.loopLog("info", "runs without its fast path",
"Without kmod-nft-offload every packet on this path passes the firewall twice. Install it and restart Dawnline.\n"+slow)
}
return res
}
// loopState2 is loop.json while the path is up, in ucode's own order of keys.
type loopState2 struct {
Applied int64 `json:"applied"`
Plan *LoopPlan `json:"plan"`
Transit uint32 `json:"transit"`
Fast bool `json:"fast"`
}