Files
dawnline/backend/methods/server.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

875 lines
25 KiB
Go
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package methods
import (
"errors"
"fmt"
"net"
"os"
"os/exec"
"regexp"
"strconv"
"strings"
"github.com/tickcount/luci-app-dawnline/backend/awg"
"github.com/tickcount/luci-app-dawnline/backend/disguise"
"github.com/tickcount/luci-app-dawnline/backend/endpoint"
"github.com/tickcount/luci-app-dawnline/backend/files"
"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/servicelog"
"github.com/tickcount/luci-app-dawnline/backend/uci"
"github.com/tickcount/luci-app-dawnline/backend/view"
)
var (
meshWords = map[string]string{"off": "devices kept apart", "all": "devices reach each other", "circles": "devices reach each other in circles"}
keepaliveArg = regexp.MustCompile(`^[0-9]{1,3}$`)
mtuArg = regexp.MustCompile(`^[0-9]{1,4}$`)
)
// on tells a switch as a page sends it: true or "1".
func on(v any) bool { return v == true || v == "1" || num(v) == 1 }
// asString is a value as ucode writes it into a string, trimmed.
func asString(v any) string {
switch x := v.(type) {
case string:
return strings.Trim(x, blank)
case nil:
return ""
case bool:
if x {
return "true"
}
return "false"
}
return str(num(v))
}
// dnsList is a list of DNS servers as typed (a list, or "a, b"): each an IPv4 or IPv6 address.
func dnsList(v any) ([]string, error) {
var parts []string
if list, isList := v.([]any); isList {
for _, x := range list {
parts = append(parts, asString(x))
}
} else {
parts = regexp.MustCompile(`[ ,]+`).Split(asString(v), -1)
}
out := []string{}
for _, d := range parts {
if d == "" {
continue
}
if _, v4 := ipnet.IP(d); !v4 && (net.ParseIP(d) == nil || !strings.Contains(d, ":")) {
return nil, said{"%s is not an IP address.", []any{d}}
}
out = append(out, d)
}
return out, nil
}
// privateNet tells a network that lies inside one of the private ranges.
func privateNet(n ipnet.Net) bool {
for _, p := range []string{"10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16"} {
r, _ := ipnet.Any(p)
if uint64(n.Base) >= uint64(r.Base) && uint64(n.Base)+n.Size() <= uint64(r.Base)+r.Size() {
return true
}
}
return false
}
// udpHeld is the UDP ports a server cannot take, read on the router.
func udpHeld(m *model.Model, srv *model.Server, t *i18n.Catalog) []map[string]any {
udp, _ := os.ReadFile("/proc/net/udp")
udp6, _ := os.ReadFile("/proc/net/udp6")
return udpTaken(m, srv, t, parseFile("/etc/config/network"), parseFile("/etc/config/firewall"), udpBound(string(udp), string(udp6)), listening("udp"))
}
// serverUpdate saves a server's settings from the General and Network tabs and applies them at once
// (dawnline.rpc.servers server_update). It answers what the apply came to.
func serverUpdate(d Deps, a map[string]any) (map[string]any, error) {
id := text(a["id"])
v, _ := a["values"].(map[string]any)
if v == nil {
v = map[string]any{}
}
if v["device_mesh"] != nil && v["mesh"] == nil {
v["mesh"] = "off"
if on(v["device_mesh"]) {
v["mesh"] = "all"
}
}
t := i18n.Use(d.Catalogs, text(a["lang"]))
var was model.Server
var newDNS []string
err := write(d, func(c *uci.Config, m *model.Model) error {
srv := m.Servers[id]
if srv == nil {
return errors.New("Unknown server.")
}
was = *srv
set := func(k, val string) {
if val == "" {
c.Delete(id, k)
} else {
c.Set(id, k, val)
}
}
if v["name"] != nil {
if !ValidName(asString(v["name"])) {
return errors.New(`Server: Enter a name: up to 48 characters, without < > " or \.`)
}
set("name", asString(v["name"]))
}
// empty: the portal's address, as at creation
if v["endpoint"] != nil {
if e := asString(v["endpoint"]); e != "" && !endpoint.ValidHost(e) {
return errors.New("Public address must be a hostname or IP address.")
}
set("endpoint", asString(v["endpoint"]))
}
if v["port"] != nil {
if !ValidPort(asString(v["port"])) {
return errors.New("UDP port must be 1-65535.")
}
n, _ := strconv.Atoi(asString(v["port"]))
if n != srv.Port {
for _, h := range udpHeld(m, srv, t) {
if h["from"].(int) <= n && n <= h["to"].(int) {
return said{"UDP %d is used by %s. Choose another port.", []any{n, h["who"]}}
}
}
}
set("port", strconv.Itoa(n))
}
if v["enabled"] != nil {
if on(v["enabled"]) {
set("enabled", "1")
} else {
set("enabled", "0")
}
}
if v["mesh"] != nil {
mesh := text(v["mesh"])
if _, known := meshWords[mesh]; !known {
return errors.New("Unknown choice for devices reaching each other.")
}
set("mesh", mesh)
set("device_mesh", "")
}
// what people may do about routers on their own pages; "ask" is what an unset one means
for k, choices := range map[string][]string{"portal_routers": model.PortalRouters, "portal_nets": model.PortalNets} {
if v[k] == nil {
continue
}
pick, known := text(v[k]), false
for _, x := range choices {
known = known || x == pick
}
if !known {
return errors.New("Unknown choice for routers on people's pages.")
}
if pick == "ask" {
pick = ""
}
set(k, pick)
}
if v["mtu"] != nil {
s := asString(v["mtu"])
if n, _ := strconv.Atoi(s); s != "" && (!mtuArg.MatchString(s) || n < 1280 || n > 1500) {
return errors.New("MTU must be 1280-1500.")
}
set("mtu", s)
}
if v["keepalive"] != nil {
s := asString(v["keepalive"])
if n, _ := strconv.Atoi(s); s != "" && (!keepaliveArg.MatchString(s) || n > 600) {
return errors.New("Keep-alive must be 0-600 seconds.")
}
set("keepalive", s)
}
if v["dns"] != nil {
list, err := dnsList(v["dns"])
if err != nil {
return err
}
newDNS = list
if len(list) > 0 {
c.SetList(id, "dns", list)
} else {
c.Delete(id, "dns")
}
}
// a new tunnel network: private, free, and every device renumbered into it
if sub := asString(v["subnet"]); v["subnet"] != nil && sub != "" && sub != srv.Subnet {
pc, ok := ipnet.Subnet(sub)
if !ok {
return errors.New("Subnet must look like 10.77.0.0/24.")
}
if !privateNet(pc) {
return errors.New("Use a private range: 10.x.x.x, 172.16–31.x.x or 192.168.x.x.")
}
var addrs []Address
if d.Addresses != nil {
addrs = d.Addresses()
}
for _, n := range takenNetworks(m, addrs) {
if n["cidr"] == srv.Subnet || n["name"] == srv.Name {
continue
}
if o, ok := ipnet.Subnet(n["cidr"].(string)); ok && uint64(pc.Base) < uint64(o.Base)+o.Size() && uint64(o.Base) < uint64(pc.Base)+pc.Size() {
return said{"Subnet overlaps %s.", []any{n["cidr"]}}
}
}
// every device on the server gets an address in it, lowest first
moved := map[string]string{}
here := map[string]bool{}
for _, pid := range m.PersonIDs() {
if p := m.People[pid]; p.Server == id {
for _, did := range p.Devices {
here[did] = true
}
}
}
to := *srv
to.Subnet = pc.String()
for _, pid := range m.PersonIDs() {
p := m.People[pid]
if p.Server != id {
continue
}
for _, did := range p.Devices {
addr := allocAddress(m, &to, func(q *model.Person) string { return q.Server }, func(x *model.Device) string {
if here[x.ID] {
return moved[x.ID]
}
return x.Address
})
if addr == "" {
return said{"%s has no room for every device on %s.", []any{pc.String(), srv.Name}}
}
moved[did] = addr
c.Set(did, "address", addr)
}
}
c.Set(id, "subnet", pc.String())
}
return nil
})
if err != nil {
return nil, err
}
// for the log: what changed, in words; turning on or off is its own line
var what []string
for _, k := range []struct{ key, label string }{{"name", "name"}, {"endpoint", "public address"}, {"port", "AmneziaWG port"}, {"mtu", "MTU"},
{"keepalive", "keep-alive"}, {"dns", "DNS"}, {"subnet", "tunnel network"}} {
if v[k.key] == nil {
continue
}
before, now := "", asString(v[k.key])
switch k.key {
case "name":
before = was.Name
case "endpoint":
before = was.Endpoint
case "port":
before = strconv.Itoa(was.Port)
case "mtu":
if was.MTU != 0 {
before = strconv.Itoa(was.MTU)
}
case "keepalive":
before = strconv.Itoa(was.Keepalive)
case "dns":
before, now = strings.Join(was.DNS, " "), strings.Join(newDNS, " ")
case "subnet":
before = was.Subnet
}
if strings.Trim(before, blank) != strings.Trim(now, blank) {
what = append(what, k.label)
}
}
name := was.Name
if v["name"] != nil {
name = asString(v["name"])
}
var applied map[string]any
if d.Apply != nil {
applied = d.Apply(text(a["lang"]))
}
if d.Log != nil {
line := func(msg, note string) {
d.Log.Write("dawnline", "info", msg, "", name, servicelog.Extra{By: "admin", Kind: "server", Note: note, SID: id})
}
if v["enabled"] != nil && on(v["enabled"]) != was.Enabled {
if on(v["enabled"]) {
line("turned on", "")
} else {
line("turned off", "")
}
}
if len(what) > 0 {
line("changed", strings.Join(what, ", "))
}
if v["mesh"] != nil && text(v["mesh"]) != was.Mesh {
line("changed", meshWords[text(v["mesh"])])
}
if v["portal_routers"] != nil && text(v["portal_routers"]) != was.PortalRouters {
line("changed", "routers on people's pages: "+text(v["portal_routers"]))
}
if v["portal_nets"] != nil && text(v["portal_nets"]) != was.PortalNets {
line("changed", "networks behind routers on people's pages: "+text(v["portal_nets"]))
}
}
if d.Told != nil {
d.Told()
}
if applied == nil {
applied = map[string]any{}
}
return applied, nil
}
// serverDelete removes a server with its people, their devices and its circles; a backup is made first.
func serverDelete(d Deps, id, lang string) (map[string]any, error) {
if d.Store == nil {
return nil, errors.New("The router is still starting. Try again in a moment.")
}
if _, m, err := d.Store.Read(); err != nil || m.Servers[id] == nil {
return nil, errors.New("Unknown server.")
}
if _, err := backupCreate(d, "pre-delete"); err != nil {
return nil, err
}
name, gone := "", 0
err := write(d, func(c *uci.Config, m *model.Model) error {
srv := m.Servers[id]
if srv == nil {
return errors.New("Unknown server.")
}
for _, pid := range m.PersonIDs() {
if p := m.People[pid]; p.Server == id {
for _, dev := range p.Devices {
c.DeleteSection(dev)
}
c.DeleteSection(pid)
gone++
}
}
for _, cid := range m.CircleIDs() {
if m.Circles[cid].Server == id {
c.DeleteSection(cid)
}
}
c.DeleteSection(id)
name = srv.Name
return nil
})
if err != nil {
return nil, err
}
var applied map[string]any
if d.Apply != nil {
applied = d.Apply(lang)
}
if d.Log != nil {
note := ""
if gone == 1 {
note = "with 1 person"
} else if gone > 1 {
note = "with " + strconv.Itoa(gone) + " people"
}
d.Log.Write("awg", "info", "removed", "", name, servicelog.Extra{By: "admin", Kind: "server", Note: note, SID: id})
}
if d.Told != nil {
d.Told()
}
if applied == nil {
applied = map[string]any{}
}
return applied, nil
}
// off tells a switch a page turned off: false or "0".
func off(v any) bool { return v == false || v == "0" }
// serverInterfaces saves which interfaces a server uses (its WAN, its home networks), whether its traffic
// leaves like a home device's and who reaches whom, and applies it (dawnline.rpc.servers server_interfaces).
// It answers the interfaces as the page shows them, and whether the home networks changed.
func serverInterfaces(d Deps, a map[string]any) (map[string]any, error) {
if d.Snapshot == nil {
return nil, errors.New("The router is still starting. Try again in a moment.")
}
id := text(a["id"])
snap := d.Snapshot()
autoWan, autoLan := !off(a["auto_wan"]), !off(a["auto_lan"])
wanDev := asString(a["wan_device"])
var was, now model.Server
mesh := ""
err := write(d, func(c *uci.Config, m *model.Model) error {
srv := m.Servers[id]
if srv == nil {
return errors.New("Unknown server.")
}
was = *srv
if !autoWan {
dev := snap.Devices[wanDev]
if dev == nil {
return errors.New("Choose the interface that leads to the internet.")
}
if dev.Zone == "" {
return said{"%s is not in a firewall zone, so the server port cannot be opened on it.", []any{wanDev}}
}
}
wan := wanDev
if autoWan {
wan = snap.WAN
}
var lans []string
list, _ := a["lan_devices"].([]any)
for _, x := range list {
name := asString(x)
saved := false
for _, o := range srv.LanDevices {
saved = saved || o == name
}
dev := snap.Devices[name]
// unknown names are kept only if they were saved before (an interface down right now)
if name == "" || name == srv.Ifname || (dev == nil && !saved) {
continue
}
if dev != nil && dev.Master != "" {
return said{"%s is part of %s; choose %s instead.", []any{name, dev.Master, dev.Master}}
}
if name == wan {
return said{"%s is the WAN.", []any{name}}
}
dup := false
for _, o := range lans {
dup = dup || o == name
}
if !dup {
lans = append(lans, name)
}
}
if a["lan_like"] != nil {
if off(a["lan_like"]) {
c.Set(id, "lan_like", "0")
} else {
c.Set(id, "lan_like", "1")
}
}
mesh = srv.Mesh
if _, known := meshWords[text(a["mesh"])]; known {
mesh = text(a["mesh"])
} else if a["device_mesh"] != nil {
mesh = "all"
if off(a["device_mesh"]) {
mesh = "off"
}
}
c.Set(id, "mesh", mesh)
c.Delete(id, "device_mesh")
flag := func(k string, v bool) {
if v {
c.Set(id, k, "1")
} else {
c.Set(id, k, "0")
}
}
flag("auto_wan", autoWan)
flag("auto_lan", autoLan)
if autoWan || wanDev == "" {
c.Delete(id, "wan_device")
} else {
c.Set(id, "wan_device", wanDev)
}
if len(lans) > 0 {
c.SetList(id, "lan_device", lans)
} else {
c.Delete(id, "lan_device")
}
// what was detected, as the fallback while an interface is down
if snap.WAN != "" {
c.Set(id, "detected_wan", snap.WAN)
}
if snap.LAN != "" {
c.Set(id, "detected_lan", snap.LAN)
}
// the older zone options kept in step
var blocked map[string]any
files.ReadJSON(d.RunDir+"/netifd-blocked.json", &blocked)
wanNet, _, _, zones := snap.ServerNet(model.Load(c, blocked).Servers[id])
if wanNet.Zone != "" {
c.Set(id, "wan_zone", wanNet.Zone)
}
if len(zones) > 0 {
c.Set(id, "lan_zone", zones[0])
}
now = *model.Load(c, blocked).Servers[id]
return nil
})
if err != nil {
return nil, err
}
sig := func(x model.Server) (string, string) {
wan, _, nets, _ := snap.ServerNet(&x)
return strings.Join(nets, ","), strings.Join(nets, ",") + "|" + wan.Dev + "|" + strconv.FormatBool(x.LanLike)
}
before, sigWas := sig(was)
_, sigNow := sig(now)
var what []string
if sigNow != sigWas {
what = append(what, "home network and internet path")
}
if mesh != was.Mesh {
what = append(what, meshWords[mesh])
}
if len(what) > 0 && d.Log != nil {
d.Log.Write("awg", "info", "changed", "", was.Name, servicelog.Extra{By: "admin", Kind: "server", Note: strings.Join(what, ", "), SID: id})
}
if d.Apply != nil {
d.Apply(text(a["lang"]))
}
if d.Told != nil {
d.Told()
}
w := d.World()
if w == nil || w.M == nil {
_, m, _ := d.Store.Read()
w = &view.World{M: m}
}
out, err := interfaces(w, d, id)
if err != nil {
return nil, err
}
eff, _ := out["effective"].(map[string]any)
nets, _ := eff["nets"].([]string)
out["nets_changed"] = before != strings.Join(nets, ",")
return out, nil
}
// caps is what the installed AmneziaWG can do.
func caps(d Deps) awg.Caps {
if d.Caps != nil {
return d.Caps()
}
return awg.SystemCaps(d.DataDir)
}
// defaultMethod is the disguise a new server gets: the strongest this router can run.
func defaultMethod(d Deps) string {
switch c := caps(d); {
case c.V3:
return "max"
case c.V2:
return "balanced"
}
return "off"
}
// checkMethod refuses a disguise the installed AmneziaWG cannot run, in the admin's words.
func checkMethod(d Deps, name string) error {
if name != "off" && name != "balanced" && name != "max" {
return errors.New("Unknown disguise method.")
}
c := caps(d)
installed := true
if d.AWG != nil {
st := d.AWG()
installed = st["tools"] == true && st["kmod"] == true
}
if name == "max" && !c.V3 {
if installed {
return errors.New("Maximum needs AmneziaWG 3.1 on the router (kmod-amneziawg, amneziawg-tools 3.1): install a 3.1 build in Dawnline → Components.")
}
return errors.New("AmneziaWG is not installed: install it in Dawnline → Components, then choose Maximum.")
}
if name == "balanced" && !c.V2 {
if installed {
return errors.New("Balanced needs AmneziaWG 2.0 or newer on the router: install a current build in Dawnline → Components.")
}
return errors.New("AmneziaWG is not installed: install it in Dawnline → Components, then choose Balanced.")
}
return nil
}
// serverObfuscation gives a server a new disguise of a method (the strongest the router runs when none is
// named): its old values go, the new ones are made here, and it is applied.
func serverObfuscation(d Deps, id, preset, lang string) (map[string]any, error) {
if preset == "" {
preset = defaultMethod(d)
}
if err := checkMethod(d, preset); err != nil {
return nil, err
}
values := disguise.Preset(preset)
// a cheap self-check: new values pass what a restore would be held to
o := map[string]string{}
for _, p := range values {
o[p.Key] = p.Value
}
if errs := disguise.Errors(o); len(errs) > 0 {
return nil, errors.New(strings.Join(errs, " "))
}
name := ""
err := write(d, func(c *uci.Config, m *model.Model) error {
srv := m.Servers[id]
if srv == nil {
return errors.New("Unknown server.")
}
name = srv.Name
for _, k := range model.ObfKeys {
c.Delete(id, k)
}
for _, p := range values {
c.Set(id, p.Key, p.Value)
}
c.Set(id, "preset", preset)
return nil
})
if err != nil {
return nil, err
}
var applied map[string]any
if d.Apply != nil {
applied = d.Apply(lang)
}
if d.Log != nil {
d.Log.Write("awg", "info", "changed", "", name, servicelog.Extra{By: "admin", Kind: "server", Note: "disguise: " + preset, SID: id})
}
if d.Told != nil {
d.Told()
}
if applied == nil {
applied = map[string]any{}
}
return applied, nil
}
// needLoaded: a server is made only where AmneziaWG is installed and its module loads. The golden's test
// turns it off, as the copy of ucode its golden ran on has that one check taken out.
var needLoaded = true
var serverID = regexp.MustCompile(`^[a-z][a-z0-9_]{0,23}$`)
// serverCreate sets a server up (the wizard's last step): its section with keys made here and the disguise
// of its method, the portal as asked, then ucode's full apply and the service turned on and restarted.
func serverCreate(d Deps, a map[string]any) (map[string]any, error) {
if needLoaded {
if err := needAWG(d); err != nil {
return nil, err
}
}
// an installed module that is not loaded yet is loaded: nothing loads it before the first tunnel comes up
if needLoaded && d.AWG != nil && d.AWG()["loaded"] != true {
exec.Command("modprobe", "amneziawg").Run()
if d.AWG()["loaded"] != true {
return nil, errors.New("AmneziaWG's kernel module doesn't load on this firmware: reinstall a build for this kernel in Components.")
}
}
if d.Snapshot == nil {
return nil, errors.New("The router is still starting. Try again in a moment.")
}
snap := d.Snapshot()
var routerNets []string
if d.Addresses != nil {
for _, x := range d.Addresses() {
routerNets = append(routerNets, x.CIDR)
}
}
t := i18n.Use(d.Catalogs, text(a["lang"]))
id, name, port := asString(a["id"]), "", 0
if id == "" {
id = "home"
}
err := write(d, func(c *uci.Config, m *model.Model) error {
// a section's name: a dash would make uci drop it silently
if !serverID.MatchString(id) {
return errors.New("Server ID may use lowercase letters, digits and underscores.")
}
if idTaken(m, id) {
return said{`"%s" is already taken.`, []any{id}}
}
network := parseFile("/etc/config/network")
ifname := asString(a["ifname"])
if ifname == "" {
ifname = freeIfname(m, network)
}
free := (network == nil || network.Section(ifname) == nil) && ifname != "dlx0" && ifname != "dll0"
for _, s := range m.Servers {
free = free && s.Ifname != ifname
}
if !free {
return said{"Network interface %s already exists.", []any{ifname}}
}
wanZone := asString(a["wan_zone"])
if wanZone == "" {
wanZone = "wan"
}
udp := udpHeld(m, &model.Server{WanZone: wanZone}, t)
port = freePort(udp)
if p := asString(a["port"]); a["port"] != nil && p != "" && p != "0" {
if !ValidPort(p) {
return errors.New("UDP port must be 1-65535.")
}
port, _ = strconv.Atoi(p)
}
for _, h := range udp {
if h["from"].(int) <= port && port <= h["to"].(int) {
return said{"UDP %d is used by %s. Choose another port.", []any{port, h["who"]}}
}
}
mtu := asString(a["mtu"])
if mtu == "0" {
mtu = ""
}
if n, _ := strconv.Atoi(mtu); mtu != "" && (!mtuArg.MatchString(mtu) || n < 1280 || n > 1500) {
return errors.New("MTU must be 1280-1500.")
}
preset := asString(a["preset"])
if preset == "" {
preset = defaultMethod(d)
}
if err := checkMethod(d, preset); err != nil {
return err
}
values := disguise.Preset(preset)
subnet := asString(a["subnet"])
pc, isNet := ipnet.Subnet(subnet)
if isNet {
subnet = pc.String()
// public addresses inside the tunnel would hide the real hosts behind them
if !privateNet(pc) {
return errors.New("Use a private range: 10.x.x.x, 172.16–31.x.x or 192.168.x.x.")
}
}
endpointHost := asString(a["endpoint"])
// the definition against the rest of the router, every fault at once
var errs []string
if !model.ValidIfname(ifname) {
errs = append(errs, t.T("Interface name: 1-12 lowercase letters, digits or _."))
}
if port < 1 || port > 65535 {
errs = append(errs, t.T("Port must be 1-65535."))
}
if !isNet {
errs = append(errs, t.T("Subnet must look like 10.77.0.0/24."))
} else {
taken := append([]string{}, routerNets...)
for _, sid := range m.ServerIDs() {
taken = append(taken, m.Servers[sid].Subnet)
}
for _, o := range taken {
if oc, ok := ipnet.Subnet(o); ok && uint64(pc.Base) < uint64(oc.Base)+oc.Size() && uint64(oc.Base) < uint64(pc.Base)+pc.Size() {
errs = append(errs, fmt.Sprintf(t.T("Subnet overlaps %s."), o))
}
}
}
if endpointHost != "" && !endpoint.ValidHost(endpointHost) {
errs = append(errs, t.T("Endpoint must be a hostname or IP address."))
}
o := map[string]string{}
for _, p := range values {
o[p.Key] = p.Value
}
errs = append(errs, disguise.Errors(o)...)
if len(errs) > 0 {
return said{"%s", []any{strings.Join(errs, " ")}}
}
name = asString(a["name"])
if name == "" {
name = "Home"
}
if !ValidName(name) {
return errors.New(`Server: Enter a name: up to 48 characters, without < > " or \.`)
}
keys := newKeys()
if !awg.ValidKey(keys.Public) || keys.Private == "" {
return errors.New("Key generation failed (is amneziawg-tools installed?).")
}
c.Add("settings", "settings")
c.Add("server", id)
set := func(k, v string) { c.Set(id, k, v) }
set("name", name)
set("ifname", ifname)
set("port", strconv.Itoa(port))
set("subnet", subnet)
set("endpoint", endpointHost)
set("mtu", mtu)
set("keepalive", "25")
set("private_key", keys.Private)
set("public_key", keys.Public)
set("preset", preset)
for _, p := range values {
set(p.Key, p.Value)
}
zone := func(k string) {
z := asString(a[k])
if z == "" {
z = strings.TrimSuffix(k, "_zone")
}
set(k, z)
}
zone("lan_zone")
zone("wan_zone")
set("auto_wan", "1")
set("auto_lan", "1")
set("detected_wan", snap.WAN)
set("detected_lan", snap.LAN)
// off unless asked for: the loop through the LAN costs speed
if on(a["lan_like"]) {
set("lan_like", "1")
} else {
set("lan_like", "0")
}
set("enabled", "1")
if a["portal_enabled"] != nil {
if on(a["portal_enabled"]) {
c.Set("settings", "portal_enabled", "1")
} else {
c.Set("settings", "portal_enabled", "0")
}
if p := asString(a["portal_port"]); a["portal_port"] != nil && p != "" && p != "0" {
if !ValidPort(p) {
return errors.New("Portal port must be 1-65535.")
}
n, _ := strconv.Atoi(p)
c.Set("settings", "portal_port", strconv.Itoa(n))
}
}
if host, _ := c.Section("settings").Get("portal_host"); endpointHost != "" && host == "" && endpoint.ValidHost(endpointHost) {
c.Set("settings", "portal_host", endpointHost)
}
// the portal as it will be, whatever this call changed
var blocked map[string]any
files.ReadJSON(d.RunDir+"/netifd-blocked.json", &blocked)
return checkPortal(model.Load(c, blocked), m, listening("tcp"), parseFile("/etc/config/firewall"))
})
if err != nil {
return nil, err
}
var applied map[string]any
if d.Apply != nil {
applied = d.Apply(text(a["lang"]))
}
if d.Log != nil {
d.Log.Write("dawnline", "info", "created", "", name, servicelog.Extra{By: "admin", Kind: "server", Note: "UDP " + strconv.Itoa(port), SID: id})
}
// netifd reads its protocol handlers when it starts: AmneziaWG installed after that needs a network restart
networkRestart := d.AWG != nil && d.AWG()["handler"] != true
if d.Restart != nil {
d.Restart(networkRestart)
}
if d.Told != nil {
d.Told()
}
if applied == nil {
applied = map[string]any{}
}
return map[string]any{"id": id, "applied": applied, "network_restart": networkRestart, "warning": applied["warning"]}, nil
}