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.
243 lines
5.9 KiB
Go
243 lines
5.9 KiB
Go
// Package uci reads a configuration file of OpenWrt's UCI the way libuci does, without the uci program:
|
|
// the backend reads /etc/config/dawnline on every change, and a test reads fixtures on any system.
|
|
//
|
|
// Reading only. Whoever writes the file (the ucode backend's store, until the model's writer is ported)
|
|
// replaces it whole; this package never holds it open.
|
|
//
|
|
// The syntax, as libuci's parser takes it: one command a line (or several parted by `;`), `package`,
|
|
// `config <type> [<name>]`, `option <name> <value>`, `list <name> <value>`; a word is bare, in single
|
|
// quotes (taken as written) or in double quotes (a backslash takes the next character), and pieces that
|
|
// touch are one word; `#` begins a comment where a word could begin.
|
|
package uci
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
)
|
|
|
|
// Value is what an option holds: one string (`option`), or a list (`list`, one entry a line).
|
|
type Value struct {
|
|
Str string
|
|
List []string
|
|
IsList bool
|
|
}
|
|
|
|
// Section is one `config` block.
|
|
type Section struct {
|
|
Type string
|
|
Name string
|
|
// Anonymous: the file gave it no name. libuci names such a section by its place and a hash of its
|
|
// content; here it gets its place only (Dawnline's own file names every section).
|
|
Anonymous bool
|
|
Values map[string]Value
|
|
// Order is the options' names in the order they stand in the file: what is written keeps it.
|
|
Order []string
|
|
}
|
|
|
|
// Config is a parsed file: its sections in the order they stand.
|
|
type Config struct {
|
|
Sections []*Section
|
|
}
|
|
|
|
// Get returns an option's string. A list has none (ok is false): its entries are List's.
|
|
func (s *Section) Get(name string) (string, bool) {
|
|
v, ok := s.Values[name]
|
|
if !ok || v.IsList {
|
|
return "", false
|
|
}
|
|
return v.Str, true
|
|
}
|
|
|
|
// Section returns the section of that name, or nil.
|
|
func (c *Config) Section(name string) *Section {
|
|
for _, s := range c.Sections {
|
|
if s.Name == name {
|
|
return s
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// OfType returns the sections of a type, in the file's order.
|
|
func (c *Config) OfType(kind string) []*Section {
|
|
var out []*Section
|
|
for _, s := range c.Sections {
|
|
if s.Type == kind {
|
|
out = append(out, s)
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
// Parse reads a file's text.
|
|
func Parse(text string) (*Config, error) {
|
|
cmds, err := commands(text)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
c := &Config{}
|
|
var cur *Section
|
|
for _, cmd := range cmds {
|
|
w := cmd.words
|
|
switch w[0] {
|
|
case "package":
|
|
// one package a file; its name is the file's
|
|
case "config":
|
|
if len(w) < 2 {
|
|
return nil, fmt.Errorf("uci: line %d: config without a type", cmd.line)
|
|
}
|
|
name := ""
|
|
if len(w) > 2 {
|
|
name = w[2]
|
|
}
|
|
cur = c.open(w[1], name)
|
|
case "option", "list":
|
|
if cur == nil {
|
|
return nil, fmt.Errorf("uci: line %d: %s outside a section", cmd.line, w[0])
|
|
}
|
|
if len(w) < 3 {
|
|
return nil, fmt.Errorf("uci: line %d: %s needs a name and a value", cmd.line, w[0])
|
|
}
|
|
cur.set(w[1], w[2], w[0] == "list")
|
|
default:
|
|
return nil, fmt.Errorf("uci: line %d: unknown command %q", cmd.line, w[0])
|
|
}
|
|
}
|
|
return c, nil
|
|
}
|
|
|
|
// open starts a section. A name the file used before goes on with that section (its type becomes the new
|
|
// one), as libuci merges them.
|
|
func (c *Config) open(kind, name string) *Section {
|
|
if name != "" {
|
|
if s := c.Section(name); s != nil {
|
|
s.Type = kind
|
|
return s
|
|
}
|
|
}
|
|
s := &Section{Type: kind, Name: name, Values: map[string]Value{}}
|
|
if name == "" {
|
|
s.Anonymous = true
|
|
s.Name = fmt.Sprintf("cfg%02x", len(c.Sections)+1)
|
|
}
|
|
c.Sections = append(c.Sections, s)
|
|
return s
|
|
}
|
|
|
|
// set stores a value: an option replaces what was there; a list entry is added to a list, and turns an
|
|
// option of that name into a list that begins with it.
|
|
func (s *Section) set(name, value string, list bool) {
|
|
if _, had := s.Values[name]; !had {
|
|
s.Order = append(s.Order, name)
|
|
}
|
|
if !list {
|
|
s.Values[name] = Value{Str: value}
|
|
return
|
|
}
|
|
old, had := s.Values[name]
|
|
switch {
|
|
case !had:
|
|
s.Values[name] = Value{IsList: true, List: []string{value}}
|
|
case old.IsList:
|
|
old.List = append(old.List, value)
|
|
s.Values[name] = old
|
|
default:
|
|
s.Values[name] = Value{IsList: true, List: []string{old.Str, value}}
|
|
}
|
|
}
|
|
|
|
type command struct {
|
|
words []string
|
|
// line is where the command begins, for an error.
|
|
line int
|
|
}
|
|
|
|
// commands cuts a file into commands: a line, or a part of one up to a `;`. A quoted word may run over
|
|
// several lines (a value with line breaks in it).
|
|
func commands(text string) ([]command, error) {
|
|
var out []command
|
|
var cur []string
|
|
line, began := 1, 1
|
|
flush := func() {
|
|
if len(cur) > 0 {
|
|
out = append(out, command{words: cur, line: began})
|
|
}
|
|
cur = nil
|
|
}
|
|
i := 0
|
|
for i < len(text) {
|
|
switch c := text[i]; {
|
|
case c == '\n':
|
|
flush()
|
|
line++
|
|
i++
|
|
case c == ' ' || c == '\t' || c == '\r':
|
|
i++
|
|
case c == ';':
|
|
flush()
|
|
i++
|
|
case c == '#':
|
|
for i < len(text) && text[i] != '\n' {
|
|
i++
|
|
}
|
|
default:
|
|
if len(cur) == 0 {
|
|
began = line
|
|
}
|
|
var b strings.Builder
|
|
piece:
|
|
for i < len(text) {
|
|
switch c := text[i]; c {
|
|
case ' ', '\t', '\r', '\n', ';':
|
|
break piece
|
|
case '\'':
|
|
end := strings.IndexByte(text[i+1:], '\'')
|
|
if end < 0 {
|
|
return nil, fmt.Errorf("uci: line %d: a single quote is not closed", line)
|
|
}
|
|
quoted := text[i+1 : i+1+end]
|
|
line += strings.Count(quoted, "\n")
|
|
b.WriteString(quoted)
|
|
i += end + 2
|
|
case '"':
|
|
i++
|
|
closed := false
|
|
for i < len(text) {
|
|
if text[i] == '\\' && i+1 < len(text) {
|
|
b.WriteByte(text[i+1])
|
|
i += 2
|
|
continue
|
|
}
|
|
if text[i] == '"' {
|
|
i++
|
|
closed = true
|
|
break
|
|
}
|
|
if text[i] == '\n' {
|
|
line++
|
|
}
|
|
b.WriteByte(text[i])
|
|
i++
|
|
}
|
|
if !closed {
|
|
return nil, fmt.Errorf("uci: line %d: a double quote is not closed", line)
|
|
}
|
|
case '\\':
|
|
if i+1 < len(text) {
|
|
b.WriteByte(text[i+1])
|
|
i += 2
|
|
} else {
|
|
i++
|
|
}
|
|
default:
|
|
b.WriteByte(c)
|
|
i++
|
|
}
|
|
}
|
|
cur = append(cur, b.String())
|
|
}
|
|
}
|
|
flush()
|
|
return out, nil
|
|
}
|