package config import ( "fmt" "net" "os" "strconv" "strings" "time" "git.sr.ht/~emersion/go-scfg" ) type IPSet []*net.IPNet func (set IPSet) Contains(ip net.IP) bool { for _, n := range set { if n.Contains(ip) { return true } } return false } // loopbackIPs contains the loopback networks 127.0.0.0/8 and ::1/128. var loopbackIPs = IPSet{ &net.IPNet{ IP: net.IP{127, 0, 0, 0}, Mask: net.CIDRMask(8, 32), }, &net.IPNet{ IP: net.IPv6loopback, Mask: net.CIDRMask(128, 128), }, } func parseDuration(s string) (time.Duration, error) { if !strings.HasSuffix(s, "d") { return 0, fmt.Errorf("missing 'd' suffix in duration") } s = strings.TrimSuffix(s, "d") v, err := strconv.ParseFloat(s, 64) if err != nil { return 0, fmt.Errorf("invalid duration: %v", err) } return time.Duration(v * 24 * float64(time.Hour)), nil } type TLS struct { CertPath, KeyPath string } type DB struct { Driver, Source string } type MsgStore struct { Driver, Source string } type Auth struct { Driver, Source string } type Server struct { Listen []string TLS *TLS Hostname string Title string MOTDPath string DB DB MsgStore MsgStore Auth Auth HTTPOrigins []string AcceptProxyIPs IPSet MaxUserNetworks int UpstreamUserIPs []*net.IPNet DisableInactiveUsersDelay time.Duration EnableUsersOnAuth bool } func Defaults() *Server { hostname, err := os.Hostname() if err != nil { hostname = "localhost" } return &Server{ Hostname: hostname, DB: DB{ Driver: "sqlite3", Source: "soju.db", }, MsgStore: MsgStore{ Driver: "memory", }, Auth: Auth{ Driver: "internal", }, MaxUserNetworks: -1, } } func Load(path string) (*Server, error) { cfg, err := scfg.Load(path) if err != nil { return nil, err } return parse(cfg) } func parse(cfg scfg.Block) (*Server, error) { srv := Defaults() for _, d := range cfg { switch d.Name { case "listen": var uri string if err := d.ParseParams(&uri); err != nil { return nil, err } srv.Listen = append(srv.Listen, uri) case "hostname": if err := d.ParseParams(&srv.Hostname); err != nil { return nil, err } case "title": if err := d.ParseParams(&srv.Title); err != nil { return nil, err } case "motd": if err := d.ParseParams(&srv.MOTDPath); err != nil { return nil, err } case "tls": tls := &TLS{} if err := d.ParseParams(&tls.CertPath, &tls.KeyPath); err != nil { return nil, err } srv.TLS = tls case "db": if err := d.ParseParams(&srv.DB.Driver, &srv.DB.Source); err != nil { return nil, err } case "message-store", "log": if err := d.ParseParams(&srv.MsgStore.Driver); err != nil { return nil, err } switch srv.MsgStore.Driver { case "memory": srv.MsgStore.Source = "" case "fs": if err := d.ParseParams(nil, &srv.MsgStore.Source); err != nil { return nil, err } default: return nil, fmt.Errorf("directive %q: unknown driver %q", d.Name, srv.MsgStore.Driver) } case "auth": if err := d.ParseParams(&srv.Auth.Driver); err != nil { return nil, err } switch srv.Auth.Driver { case "internal", "pam": srv.Auth.Source = "" case "oauth2": if err := d.ParseParams(nil, &srv.Auth.Source); err != nil { return nil, err } default: return nil, fmt.Errorf("directive %q: unknown driver %q", d.Name, srv.Auth.Driver) } case "http-origin": srv.HTTPOrigins = d.Params case "accept-proxy-ip": srv.AcceptProxyIPs = nil for _, s := range d.Params { if s == "localhost" { srv.AcceptProxyIPs = append(srv.AcceptProxyIPs, loopbackIPs...) continue } _, n, err := net.ParseCIDR(s) if err != nil { return nil, fmt.Errorf("directive %q: failed to parse CIDR: %v", d.Name, err) } srv.AcceptProxyIPs = append(srv.AcceptProxyIPs, n) } case "max-user-networks": var max string if err := d.ParseParams(&max); err != nil { return nil, err } var err error if srv.MaxUserNetworks, err = strconv.Atoi(max); err != nil { return nil, fmt.Errorf("directive %q: %v", d.Name, err) } case "upstream-user-ip": if len(srv.UpstreamUserIPs) > 0 { return nil, fmt.Errorf("directive %q: can only be specified once", d.Name) } var hasIPv4, hasIPv6 bool for _, s := range d.Params { _, n, err := net.ParseCIDR(s) if err != nil { return nil, fmt.Errorf("directive %q: failed to parse CIDR: %v", d.Name, err) } if n.IP.To4() == nil { if hasIPv6 { return nil, fmt.Errorf("directive %q: found two IPv6 CIDRs", d.Name) } hasIPv6 = true } else { if hasIPv4 { return nil, fmt.Errorf("directive %q: found two IPv4 CIDRs", d.Name) } hasIPv4 = true } srv.UpstreamUserIPs = append(srv.UpstreamUserIPs, n) } case "disable-inactive-user": var durStr string if err := d.ParseParams(&durStr); err != nil { return nil, err } dur, err := parseDuration(durStr) if err != nil { return nil, fmt.Errorf("directive %q: %v", d.Name, err) } else if dur < 0 { return nil, fmt.Errorf("directive %q: duration must be positive", d.Name) } srv.DisableInactiveUsersDelay = dur case "enable-user-on-auth": var s string if err := d.ParseParams(&s); err != nil { return nil, err } b, err := strconv.ParseBool(s) if err != nil { return nil, fmt.Errorf("directive %q: %v", d.Name, err) } srv.EnableUsersOnAuth = b default: return nil, fmt.Errorf("unknown directive %q", d.Name) } } return srv, nil }