2015-05-06 22:23:01 +00:00
|
|
|
// Package resolvconf provides utility code to query and update DNS configuration in /etc/resolv.conf
|
|
|
|
package resolvconf
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
|
|
|
"io/ioutil"
|
|
|
|
"regexp"
|
|
|
|
"strings"
|
|
|
|
"sync"
|
|
|
|
|
|
|
|
"github.com/Sirupsen/logrus"
|
|
|
|
"github.com/docker/docker/pkg/ioutils"
|
2015-05-16 23:02:51 +00:00
|
|
|
"github.com/docker/libnetwork/resolvconf/dns"
|
2015-05-06 22:23:01 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
var (
|
|
|
|
// Note: the default IPv4 & IPv6 resolvers are set to Google's Public DNS
|
|
|
|
defaultIPv4Dns = []string{"nameserver 8.8.8.8", "nameserver 8.8.4.4"}
|
|
|
|
defaultIPv6Dns = []string{"nameserver 2001:4860:4860::8888", "nameserver 2001:4860:4860::8844"}
|
|
|
|
ipv4NumBlock = `(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)`
|
|
|
|
ipv4Address = `(` + ipv4NumBlock + `\.){3}` + ipv4NumBlock
|
|
|
|
// This is not an IPv6 address verifier as it will accept a super-set of IPv6, and also
|
|
|
|
// will *not match* IPv4-Embedded IPv6 Addresses (RFC6052), but that and other variants
|
|
|
|
// -- e.g. other link-local types -- either won't work in containers or are unnecessary.
|
|
|
|
// For readability and sufficiency for Docker purposes this seemed more reasonable than a
|
|
|
|
// 1000+ character regexp with exact and complete IPv6 validation
|
|
|
|
ipv6Address = `([0-9A-Fa-f]{0,4}:){2,7}([0-9A-Fa-f]{0,4})`
|
|
|
|
|
2015-05-13 03:27:22 +00:00
|
|
|
localhostNSRegexp = regexp.MustCompile(`(?m)^nameserver\s+` + dns.IPLocalhost + `\s*\n*`)
|
2015-05-06 22:23:01 +00:00
|
|
|
nsIPv6Regexp = regexp.MustCompile(`(?m)^nameserver\s+` + ipv6Address + `\s*\n*`)
|
|
|
|
nsRegexp = regexp.MustCompile(`^\s*nameserver\s*((` + ipv4Address + `)|(` + ipv6Address + `))\s*$`)
|
|
|
|
searchRegexp = regexp.MustCompile(`^\s*search\s*(([^\s]+\s*)*)$`)
|
2015-08-22 00:31:31 +00:00
|
|
|
optionsRegexp = regexp.MustCompile(`^\s*options\s*(([^\s]+\s*)*)$`)
|
2015-05-06 22:23:01 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
var lastModified struct {
|
|
|
|
sync.Mutex
|
|
|
|
sha256 string
|
|
|
|
contents []byte
|
|
|
|
}
|
|
|
|
|
2015-08-31 22:17:24 +00:00
|
|
|
// File contains the resolv.conf content and its hash
|
|
|
|
type File struct {
|
|
|
|
Content []byte
|
|
|
|
Hash string
|
|
|
|
}
|
|
|
|
|
|
|
|
// Get returns the contents of /etc/resolv.conf and its hash
|
|
|
|
func Get() (*File, error) {
|
2015-05-06 22:23:01 +00:00
|
|
|
resolv, err := ioutil.ReadFile("/etc/resolv.conf")
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2015-08-31 22:17:24 +00:00
|
|
|
hash, err := ioutils.HashData(bytes.NewReader(resolv))
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return &File{Content: resolv, Hash: hash}, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetSpecific returns the contents of the user specified resolv.conf file and its hash
|
|
|
|
func GetSpecific(path string) (*File, error) {
|
|
|
|
resolv, err := ioutil.ReadFile(path)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
hash, err := ioutils.HashData(bytes.NewReader(resolv))
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return &File{Content: resolv, Hash: hash}, nil
|
2015-05-06 22:23:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// GetIfChanged retrieves the host /etc/resolv.conf file, checks against the last hash
|
|
|
|
// and, if modified since last check, returns the bytes and new hash.
|
|
|
|
// This feature is used by the resolv.conf updater for containers
|
2015-08-31 22:17:24 +00:00
|
|
|
func GetIfChanged() (*File, error) {
|
2015-05-06 22:23:01 +00:00
|
|
|
lastModified.Lock()
|
|
|
|
defer lastModified.Unlock()
|
|
|
|
|
|
|
|
resolv, err := ioutil.ReadFile("/etc/resolv.conf")
|
|
|
|
if err != nil {
|
2015-08-31 22:17:24 +00:00
|
|
|
return nil, err
|
2015-05-06 22:23:01 +00:00
|
|
|
}
|
|
|
|
newHash, err := ioutils.HashData(bytes.NewReader(resolv))
|
|
|
|
if err != nil {
|
2015-08-31 22:17:24 +00:00
|
|
|
return nil, err
|
2015-05-06 22:23:01 +00:00
|
|
|
}
|
|
|
|
if lastModified.sha256 != newHash {
|
|
|
|
lastModified.sha256 = newHash
|
|
|
|
lastModified.contents = resolv
|
2015-08-31 22:17:24 +00:00
|
|
|
return &File{Content: resolv, Hash: newHash}, nil
|
2015-05-06 22:23:01 +00:00
|
|
|
}
|
|
|
|
// nothing changed, so return no data
|
2015-08-31 22:17:24 +00:00
|
|
|
return nil, nil
|
2015-05-06 22:23:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// GetLastModified retrieves the last used contents and hash of the host resolv.conf.
|
|
|
|
// Used by containers updating on restart
|
2015-08-31 22:17:24 +00:00
|
|
|
func GetLastModified() *File {
|
2015-05-06 22:23:01 +00:00
|
|
|
lastModified.Lock()
|
|
|
|
defer lastModified.Unlock()
|
|
|
|
|
2015-08-31 22:17:24 +00:00
|
|
|
return &File{Content: lastModified.contents, Hash: lastModified.sha256}
|
2015-05-06 22:23:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// FilterResolvDNS cleans up the config in resolvConf. It has two main jobs:
|
|
|
|
// 1. It looks for localhost (127.*|::1) entries in the provided
|
|
|
|
// resolv.conf, removing local nameserver entries, and, if the resulting
|
|
|
|
// cleaned config has no defined nameservers left, adds default DNS entries
|
|
|
|
// 2. Given the caller provides the enable/disable state of IPv6, the filter
|
|
|
|
// code will remove all IPv6 nameservers if it is not enabled for containers
|
|
|
|
//
|
2015-08-31 22:17:24 +00:00
|
|
|
func FilterResolvDNS(resolvConf []byte, ipv6Enabled bool) (*File, error) {
|
2015-05-06 22:23:01 +00:00
|
|
|
cleanedResolvConf := localhostNSRegexp.ReplaceAll(resolvConf, []byte{})
|
|
|
|
// if IPv6 is not enabled, also clean out any IPv6 address nameserver
|
|
|
|
if !ipv6Enabled {
|
|
|
|
cleanedResolvConf = nsIPv6Regexp.ReplaceAll(cleanedResolvConf, []byte{})
|
|
|
|
}
|
|
|
|
// if the resulting resolvConf has no more nameservers defined, add appropriate
|
|
|
|
// default DNS servers for IPv4 and (optionally) IPv6
|
|
|
|
if len(GetNameservers(cleanedResolvConf)) == 0 {
|
|
|
|
logrus.Infof("No non-localhost DNS nameservers are left in resolv.conf. Using default external servers : %v", defaultIPv4Dns)
|
|
|
|
dns := defaultIPv4Dns
|
|
|
|
if ipv6Enabled {
|
|
|
|
logrus.Infof("IPv6 enabled; Adding default IPv6 external servers : %v", defaultIPv6Dns)
|
|
|
|
dns = append(dns, defaultIPv6Dns...)
|
|
|
|
}
|
|
|
|
cleanedResolvConf = append(cleanedResolvConf, []byte("\n"+strings.Join(dns, "\n"))...)
|
|
|
|
}
|
2015-08-31 22:17:24 +00:00
|
|
|
hash, err := ioutils.HashData(bytes.NewReader(cleanedResolvConf))
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
2015-05-06 22:23:01 +00:00
|
|
|
}
|
2015-08-31 22:17:24 +00:00
|
|
|
return &File{Content: cleanedResolvConf, Hash: hash}, nil
|
2015-05-06 22:23:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// getLines parses input into lines and strips away comments.
|
|
|
|
func getLines(input []byte, commentMarker []byte) [][]byte {
|
|
|
|
lines := bytes.Split(input, []byte("\n"))
|
|
|
|
var output [][]byte
|
|
|
|
for _, currentLine := range lines {
|
|
|
|
var commentIndex = bytes.Index(currentLine, commentMarker)
|
|
|
|
if commentIndex == -1 {
|
|
|
|
output = append(output, currentLine)
|
|
|
|
} else {
|
|
|
|
output = append(output, currentLine[:commentIndex])
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return output
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetNameservers returns nameservers (if any) listed in /etc/resolv.conf
|
|
|
|
func GetNameservers(resolvConf []byte) []string {
|
|
|
|
nameservers := []string{}
|
|
|
|
for _, line := range getLines(resolvConf, []byte("#")) {
|
|
|
|
var ns = nsRegexp.FindSubmatch(line)
|
|
|
|
if len(ns) > 0 {
|
|
|
|
nameservers = append(nameservers, string(ns[1]))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nameservers
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetNameserversAsCIDR returns nameservers (if any) listed in
|
|
|
|
// /etc/resolv.conf as CIDR blocks (e.g., "1.2.3.4/32")
|
|
|
|
// This function's output is intended for net.ParseCIDR
|
|
|
|
func GetNameserversAsCIDR(resolvConf []byte) []string {
|
|
|
|
nameservers := []string{}
|
|
|
|
for _, nameserver := range GetNameservers(resolvConf) {
|
|
|
|
nameservers = append(nameservers, nameserver+"/32")
|
|
|
|
}
|
|
|
|
return nameservers
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetSearchDomains returns search domains (if any) listed in /etc/resolv.conf
|
|
|
|
// If more than one search line is encountered, only the contents of the last
|
|
|
|
// one is returned.
|
|
|
|
func GetSearchDomains(resolvConf []byte) []string {
|
|
|
|
domains := []string{}
|
|
|
|
for _, line := range getLines(resolvConf, []byte("#")) {
|
|
|
|
match := searchRegexp.FindSubmatch(line)
|
|
|
|
if match == nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
domains = strings.Fields(string(match[1]))
|
|
|
|
}
|
|
|
|
return domains
|
|
|
|
}
|
|
|
|
|
2015-08-22 00:31:31 +00:00
|
|
|
// GetOptions returns options (if any) listed in /etc/resolv.conf
|
|
|
|
// If more than one options line is encountered, only the contents of the last
|
|
|
|
// one is returned.
|
|
|
|
func GetOptions(resolvConf []byte) []string {
|
|
|
|
options := []string{}
|
|
|
|
for _, line := range getLines(resolvConf, []byte("#")) {
|
|
|
|
match := optionsRegexp.FindSubmatch(line)
|
|
|
|
if match == nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
options = strings.Fields(string(match[1]))
|
|
|
|
}
|
|
|
|
return options
|
|
|
|
}
|
|
|
|
|
2015-05-06 22:23:01 +00:00
|
|
|
// Build writes a configuration file to path containing a "nameserver" entry
|
2015-08-22 00:31:31 +00:00
|
|
|
// for every element in dns, a "search" entry for every element in
|
|
|
|
// dnsSearch, and an "options" entry for every element in dnsOptions.
|
2015-08-31 22:17:24 +00:00
|
|
|
func Build(path string, dns, dnsSearch, dnsOptions []string) (*File, error) {
|
2015-05-06 22:23:01 +00:00
|
|
|
content := bytes.NewBuffer(nil)
|
|
|
|
if len(dnsSearch) > 0 {
|
|
|
|
if searchString := strings.Join(dnsSearch, " "); strings.Trim(searchString, " ") != "." {
|
|
|
|
if _, err := content.WriteString("search " + searchString + "\n"); err != nil {
|
2015-08-31 22:17:24 +00:00
|
|
|
return nil, err
|
2015-05-06 22:23:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-07-02 05:00:48 +00:00
|
|
|
for _, dns := range dns {
|
|
|
|
if _, err := content.WriteString("nameserver " + dns + "\n"); err != nil {
|
2015-08-31 22:17:24 +00:00
|
|
|
return nil, err
|
2015-07-02 05:00:48 +00:00
|
|
|
}
|
|
|
|
}
|
2015-08-22 00:31:31 +00:00
|
|
|
if len(dnsOptions) > 0 {
|
|
|
|
if optsString := strings.Join(dnsOptions, " "); strings.Trim(optsString, " ") != "" {
|
|
|
|
if _, err := content.WriteString("options " + optsString + "\n"); err != nil {
|
2015-08-31 22:17:24 +00:00
|
|
|
return nil, err
|
2015-08-22 00:31:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-07-02 05:00:48 +00:00
|
|
|
|
|
|
|
hash, err := ioutils.HashData(bytes.NewReader(content.Bytes()))
|
|
|
|
if err != nil {
|
2015-08-31 22:17:24 +00:00
|
|
|
return nil, err
|
2015-07-02 05:00:48 +00:00
|
|
|
}
|
2015-05-06 22:23:01 +00:00
|
|
|
|
2015-08-31 22:17:24 +00:00
|
|
|
return &File{Content: content.Bytes(), Hash: hash}, ioutil.WriteFile(path, content.Bytes(), 0644)
|
2015-05-06 22:23:01 +00:00
|
|
|
}
|