mirror of
https://github.com/kiddin9/op-packages.git
synced 2026-11-17 05:53:03 +08:00
228 lines
6.7 KiB
Go
228 lines
6.7 KiB
Go
package presets
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"io"
|
|
"regexp"
|
|
"strings"
|
|
|
|
"github.com/matthewlu070111/smart-srun/core/internal/domain"
|
|
)
|
|
|
|
const (
|
|
UserSchemaVersion = 2
|
|
MaxUserBytes = 256 << 10
|
|
// The frozen LuCI store accepts at most 50 entries in each list.
|
|
MaxUserItems = 50
|
|
)
|
|
|
|
// UserPreset keeps the local interface choice separate from public school
|
|
// defaults: a publisher must never choose the user's logical WAN interface.
|
|
type UserPreset struct {
|
|
School School
|
|
WiredIface string
|
|
}
|
|
|
|
// UserDocument keeps the original JSON alongside a normalized runtime view.
|
|
// Unknown fields, missing optional fields and formatting remain in the file.
|
|
// Operators is a shortcut view deduplicated by both suffix and label.
|
|
type UserDocument struct {
|
|
Revision uint64
|
|
Presets []UserPreset
|
|
Operators []Operator
|
|
raw []byte
|
|
revision jsonField
|
|
}
|
|
|
|
func (d UserDocument) Document() []byte { return bytes.Clone(d.raw) }
|
|
|
|
type jsonField struct {
|
|
raw json.RawMessage
|
|
start, end int
|
|
}
|
|
|
|
// objectFields also records byte spans, allowing Set to change only revision.
|
|
// Duplicate keys are rejected before any value can silently replace another.
|
|
func objectFields(data []byte) (map[string]jsonField, error) {
|
|
decoder := json.NewDecoder(bytes.NewReader(data))
|
|
token, err := decoder.Token()
|
|
if err != nil || token != json.Delim('{') {
|
|
return nil, userError("需要 JSON 对象")
|
|
}
|
|
fields := make(map[string]jsonField)
|
|
for decoder.More() {
|
|
token, err := decoder.Token()
|
|
if err != nil {
|
|
return nil, userError("JSON 字段无效")
|
|
}
|
|
key, ok := token.(string)
|
|
if !ok {
|
|
return nil, userError("JSON 字段名无效")
|
|
}
|
|
if _, duplicate := fields[key]; duplicate {
|
|
return nil, userError("JSON 字段重复")
|
|
}
|
|
var raw json.RawMessage
|
|
if err := decoder.Decode(&raw); err != nil {
|
|
return nil, userError("JSON 字段内容无效")
|
|
}
|
|
end := int(decoder.InputOffset())
|
|
fields[key] = jsonField{raw: raw, start: end - len(raw), end: end}
|
|
}
|
|
if _, err := decoder.Token(); err != nil {
|
|
return nil, userError("JSON 对象不完整")
|
|
}
|
|
if _, err := decoder.Token(); !errors.Is(err, io.EOF) {
|
|
return nil, userError("JSON 对象后还有内容")
|
|
}
|
|
return fields, nil
|
|
}
|
|
|
|
func userError(message string) error {
|
|
return domain.Errorf(domain.CodeInvalidArgument, "用户预设:%s", message)
|
|
}
|
|
|
|
func userArray(field jsonField) ([]json.RawMessage, error) {
|
|
var values []json.RawMessage
|
|
if len(field.raw) == 0 || field.raw[0] != '[' || json.Unmarshal(field.raw, &values) != nil {
|
|
return nil, userError("presets 和 operators 必须是数组")
|
|
}
|
|
if len(values) > MaxUserItems {
|
|
return nil, userError("每个列表最多保存 50 项")
|
|
}
|
|
return values, nil
|
|
}
|
|
|
|
func userString(field jsonField) (string, error) {
|
|
var value string
|
|
if len(field.raw) == 0 || field.raw[0] != '"' || json.Unmarshal(field.raw, &value) != nil {
|
|
return "", userError("字段必须是字符串")
|
|
}
|
|
return value, nil
|
|
}
|
|
|
|
// ParseUsers reads schema v2 only. User data is never silently upgraded or
|
|
// repaired into an empty document; the old file must remain available.
|
|
func ParseUsers(data []byte) (UserDocument, error) {
|
|
if len(data) > MaxUserBytes {
|
|
return UserDocument{}, userError("文件超过 256 KiB 上限")
|
|
}
|
|
fields, err := objectFields(data)
|
|
if err != nil {
|
|
return UserDocument{}, err
|
|
}
|
|
var version *int
|
|
var revision *uint64
|
|
if json.Unmarshal(fields["schema_version"].raw, &version) != nil || version == nil || *version != UserSchemaVersion {
|
|
return UserDocument{}, userError("schema_version 必须为 2,不读取旧版用户预设")
|
|
}
|
|
if json.Unmarshal(fields["revision"].raw, &revision) != nil || revision == nil {
|
|
return UserDocument{}, userError("revision 必须是非负整数")
|
|
}
|
|
entries, err := userArray(fields["presets"])
|
|
if err != nil {
|
|
return UserDocument{}, err
|
|
}
|
|
operators, err := userOperators(fields["operators"])
|
|
if err != nil {
|
|
return UserDocument{}, err
|
|
}
|
|
document := UserDocument{Revision: *revision, Operators: operators,
|
|
raw: bytes.Clone(data), revision: fields["revision"]}
|
|
seen := make(map[string]bool)
|
|
for _, entry := range entries {
|
|
preset, err := parseUserPreset(entry)
|
|
if err != nil {
|
|
return UserDocument{}, err
|
|
}
|
|
id := SafeID(preset.School.ShortName)
|
|
if seen[id] {
|
|
return UserDocument{}, userError("自定义预设标识重复")
|
|
}
|
|
seen[id] = true
|
|
document.Presets = append(document.Presets, preset)
|
|
}
|
|
return document, nil
|
|
}
|
|
|
|
var customID = regexp.MustCompile(`^custom-[A-Za-z0-9_-]+$`)
|
|
|
|
func parseUserPreset(data []byte) (UserPreset, error) {
|
|
fields, err := objectFields(data)
|
|
if err != nil {
|
|
return UserPreset{}, err
|
|
}
|
|
id, err := userString(fields["short_name"])
|
|
if err != nil || !customID.MatchString(id) {
|
|
return UserPreset{}, userError("自定义预设标识必须使用 custom- 前缀及字母、数字、下划线或连字符")
|
|
}
|
|
name, err := userString(fields["name"])
|
|
if err != nil || strings.TrimSpace(name) == "" {
|
|
return UserPreset{}, userError("自定义预设名称不能为空")
|
|
}
|
|
var raw rawSchool
|
|
if err := json.Unmarshal(data, &raw); err != nil {
|
|
return UserPreset{}, userError("自定义预设格式无效")
|
|
}
|
|
// The user's short_name is authoritative; an unrelated future id field
|
|
// must not override it through the public catalogue's legacy ID alias.
|
|
raw.ID = flexString{Value: id, Present: true}
|
|
school, _ := normalizeSchool(raw)
|
|
school.ShortName = id
|
|
// Local metadata must not turn legacy school defaults into account choices.
|
|
school.Operators = nil
|
|
if field, exists := fields["operators"]; exists {
|
|
school.Operators, err = userOperators(field)
|
|
if err != nil {
|
|
return UserPreset{}, err
|
|
}
|
|
}
|
|
preset := UserPreset{School: school}
|
|
for _, key := range []string{"defaults", "observed_login_shape"} {
|
|
if field, exists := fields[key]; exists {
|
|
values, err := objectFields(field.raw)
|
|
if err != nil {
|
|
return UserPreset{}, err
|
|
}
|
|
if iface, exists := values["wired_iface"]; key == "defaults" && exists {
|
|
preset.WiredIface, err = userString(iface)
|
|
if err != nil {
|
|
return UserPreset{}, err
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return preset, nil
|
|
}
|
|
|
|
func userOperators(field jsonField) ([]Operator, error) {
|
|
entries, err := userArray(field)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
operators := make([]Operator, 0, len(entries))
|
|
seen := make(map[Operator]bool)
|
|
for _, entry := range entries {
|
|
fields, err := objectFields(entry)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
suffix, err := userString(fields["suffix"])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
label, err := userString(fields["label"])
|
|
if err != nil || strings.TrimSpace(label) == "" {
|
|
return nil, userError("运营商名称不能为空")
|
|
}
|
|
operator := Operator{Suffix: suffix, Label: label}
|
|
if !seen[operator] {
|
|
operators = append(operators, operator)
|
|
seen[operator] = true
|
|
}
|
|
}
|
|
return operators, nil
|
|
}
|