...
Run Format

Source file src/net/nss.go

Documentation: net

  // 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.
  
  // +build darwin dragonfly freebsd linux netbsd openbsd solaris
  
  package net
  
  import (
  	"errors"
  	"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 := bytesIndexByte(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 := bytesIndexByte(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 := bytesIndexByte(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 := bytesIndexByte(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
  }
  

View as plain text