mirror of
https://github.com/autc04/Retro68.git
synced 2024-08-31 09:29:37 +00:00
161 lines
3.7 KiB
Go
161 lines
3.7 KiB
Go
// Copyright 2015 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
//go:build aix || darwin || dragonfly || freebsd || hurd || linux || netbsd || openbsd || solaris
|
|
|
|
package net
|
|
|
|
import (
|
|
"errors"
|
|
"internal/bytealg"
|
|
"io"
|
|
"os"
|
|
)
|
|
|
|
// nssConf represents the state of the machine's /etc/nsswitch.conf file.
|
|
type nssConf struct {
|
|
err error // any error encountered opening or parsing the file
|
|
sources map[string][]nssSource // keyed by database (e.g. "hosts")
|
|
}
|
|
|
|
type nssSource struct {
|
|
source string // e.g. "compat", "files", "mdns4_minimal"
|
|
criteria []nssCriterion
|
|
}
|
|
|
|
// standardCriteria reports all specified criteria have the default
|
|
// status actions.
|
|
func (s nssSource) standardCriteria() bool {
|
|
for i, crit := range s.criteria {
|
|
if !crit.standardStatusAction(i == len(s.criteria)-1) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// nssCriterion is the parsed structure of one of the criteria in brackets
|
|
// after an NSS source name.
|
|
type nssCriterion struct {
|
|
negate bool // if "!" was present
|
|
status string // e.g. "success", "unavail" (lowercase)
|
|
action string // e.g. "return", "continue" (lowercase)
|
|
}
|
|
|
|
// standardStatusAction reports whether c is equivalent to not
|
|
// specifying the criterion at all. last is whether this criteria is the
|
|
// last in the list.
|
|
func (c nssCriterion) standardStatusAction(last bool) bool {
|
|
if c.negate {
|
|
return false
|
|
}
|
|
var def string
|
|
switch c.status {
|
|
case "success":
|
|
def = "return"
|
|
case "notfound", "unavail", "tryagain":
|
|
def = "continue"
|
|
default:
|
|
// Unknown status
|
|
return false
|
|
}
|
|
if last && c.action == "return" {
|
|
return true
|
|
}
|
|
return c.action == def
|
|
}
|
|
|
|
func parseNSSConfFile(file string) *nssConf {
|
|
f, err := os.Open(file)
|
|
if err != nil {
|
|
return &nssConf{err: err}
|
|
}
|
|
defer f.Close()
|
|
return parseNSSConf(f)
|
|
}
|
|
|
|
func parseNSSConf(r io.Reader) *nssConf {
|
|
slurp, err := readFull(r)
|
|
if err != nil {
|
|
return &nssConf{err: err}
|
|
}
|
|
conf := new(nssConf)
|
|
conf.err = foreachLine(slurp, func(line []byte) error {
|
|
line = trimSpace(removeComment(line))
|
|
if len(line) == 0 {
|
|
return nil
|
|
}
|
|
colon := bytealg.IndexByte(line, ':')
|
|
if colon == -1 {
|
|
return errors.New("no colon on line")
|
|
}
|
|
db := string(trimSpace(line[:colon]))
|
|
srcs := line[colon+1:]
|
|
for {
|
|
srcs = trimSpace(srcs)
|
|
if len(srcs) == 0 {
|
|
break
|
|
}
|
|
sp := bytealg.IndexByte(srcs, ' ')
|
|
var src string
|
|
if sp == -1 {
|
|
src = string(srcs)
|
|
srcs = nil // done
|
|
} else {
|
|
src = string(srcs[:sp])
|
|
srcs = trimSpace(srcs[sp+1:])
|
|
}
|
|
var criteria []nssCriterion
|
|
// See if there's a criteria block in brackets.
|
|
if len(srcs) > 0 && srcs[0] == '[' {
|
|
bclose := bytealg.IndexByte(srcs, ']')
|
|
if bclose == -1 {
|
|
return errors.New("unclosed criterion bracket")
|
|
}
|
|
var err error
|
|
criteria, err = parseCriteria(srcs[1:bclose])
|
|
if err != nil {
|
|
return errors.New("invalid criteria: " + string(srcs[1:bclose]))
|
|
}
|
|
srcs = srcs[bclose+1:]
|
|
}
|
|
if conf.sources == nil {
|
|
conf.sources = make(map[string][]nssSource)
|
|
}
|
|
conf.sources[db] = append(conf.sources[db], nssSource{
|
|
source: src,
|
|
criteria: criteria,
|
|
})
|
|
}
|
|
return nil
|
|
})
|
|
return conf
|
|
}
|
|
|
|
// parses "foo=bar !foo=bar"
|
|
func parseCriteria(x []byte) (c []nssCriterion, err error) {
|
|
err = foreachField(x, func(f []byte) error {
|
|
not := false
|
|
if len(f) > 0 && f[0] == '!' {
|
|
not = true
|
|
f = f[1:]
|
|
}
|
|
if len(f) < 3 {
|
|
return errors.New("criterion too short")
|
|
}
|
|
eq := bytealg.IndexByte(f, '=')
|
|
if eq == -1 {
|
|
return errors.New("criterion lacks equal sign")
|
|
}
|
|
lowerASCIIBytes(f)
|
|
c = append(c, nssCriterion{
|
|
negate: not,
|
|
status: string(f[:eq]),
|
|
action: string(f[eq+1:]),
|
|
})
|
|
return nil
|
|
})
|
|
return
|
|
}
|