package wireguard import ( "io/fs" "strconv" "asciigoat.org/ini/basic" "darvaza.org/core" ) var sectionMap = map[string]func(*Config, *basic.Section) error{ "Interface": loadInterfaceConfSection, "Peer": loadPeerConfSection, } func loadConfSection(out *Config, src *basic.Section) error { h, ok := sectionMap[src.Key] if !ok { return core.Wrap(fs.ErrInvalid, "unknown section %q", src.Key) } return h(out, src) } func loadInterfaceConfSection(out *Config, src *basic.Section) error { var cfg InterfaceConfig for _, field := range src.Fields { if err := loadInterfaceConfField(&cfg, field); err != nil { return core.Wrap(err, "Interface") } } out.Interface = cfg return nil } func loadPeerConfSection(out *Config, src *basic.Section) error { var cfg PeerConfig for _, field := range src.Fields { if err := loadPeerConfField(&cfg, field); err != nil { return core.Wrap(err, "Peer[%v]", len(out.Peer)) } } out.Peer = append(out.Peer, cfg) return nil } // revive:disable:cyclomatic // revive:disable:cognitive-complexity func loadInterfaceConfField(cfg *InterfaceConfig, field basic.Field) error { // revive:enable:cyclomatic // revive:enable:cognitive-complexity // TODO: refactor when asciigoat's ini parser learns to do reflection switch field.Key { case "Address": if !core.IsZero(cfg.Address) { return core.Wrap(fs.ErrInvalid, "duplicate field %q", field.Key) } err := cfg.Address.UnmarshalText([]byte(field.Value)) switch { case err != nil: return core.Wrap(err, field.Key) default: return nil } case "PrivateKey": if !core.IsZero(cfg.PrivateKey) { return core.Wrap(fs.ErrInvalid, "duplicate field %q", field.Key) } err := cfg.PrivateKey.UnmarshalText([]byte(field.Value)) switch { case err != nil: return core.Wrap(err, field.Key) default: return nil } case "ListenPort": if cfg.ListenPort > 0 { return core.Wrap(fs.ErrInvalid, "duplicate field %q", field.Key) } u64, err := strconv.ParseUint(field.Value, 10, 16) switch { case err != nil: return core.Wrap(err, field.Key) case u64 == 0: return core.Wrap(fs.ErrInvalid, "invalid %q value", field.Key) default: cfg.ListenPort = uint16(u64) return nil } default: return core.Wrap(fs.ErrInvalid, "unknown field %q", field.Key) } } // revive:disable:cyclomatic // revive:disable:cognitive-complexity func loadPeerConfField(cfg *PeerConfig, field basic.Field) error { // revive:enable:cyclomatic // revive:enable:cognitive-complexity switch field.Key { case "PublicKey": if !core.IsZero(cfg.PublicKey) { return core.Wrap(fs.ErrInvalid, "duplicate field %q", field.Key) } err := cfg.PublicKey.UnmarshalText([]byte(field.Value)) switch { case err != nil: return core.Wrap(err, field.Key) default: return nil } case "Endpoint": if cfg.Endpoint.String() != "" { return core.Wrap(fs.ErrInvalid, "duplicate field %q", field.Key) } err := cfg.Endpoint.UnmarshalText([]byte(field.Value)) switch { case err != nil: return core.Wrap(err, field.Key) default: return nil } case "AllowedIPs": s, err := parseAllowedIPs(field.Value) switch { case err != nil: return core.Wrap(err, field.Key) case len(s) > 0: cfg.AllowedIPs = append(cfg.AllowedIPs, s...) return nil } default: return core.Wrap(fs.ErrInvalid, "unknown field %q", field.Key) } return nil } func newConfigFromDocument(doc *basic.Document) (*Config, error) { var out Config if len(doc.Global) > 0 { err := core.Wrap(fs.ErrInvalid, "fields before the first section") return nil, err } for i := range doc.Sections { src := &doc.Sections[i] if err := loadConfSection(&out, src); err != nil { return nil, err } } return &out, nil }