mirror of https://github.com/tailscale/tailscale/
net/dns: set WSL /etc/resolv.conf
We also have to make a one-off change to /etc/wsl.conf to stop every invocation of wsl.exe clobbering the /etc/resolv.conf. This appears to be a safe change to make permanently, as even though the resolv.conf is constantly clobbered, it is always the same stable internal IP that is set as a nameserver. (I believe the resolv.conf clobbering predates the MS stub resolver.) Tested on WSL2, should work for WSL1 too. Fixes #775 Signed-off-by: David Crawshaw <crawshaw@tailscale.com>pull/2276/head
David Crawshaw
3 years ago
committed by
David Crawshaw
parent
9b063b86c3
commit
1147c7fd4f
@ -0,0 +1,29 @@
|
||||
// Copyright (c) 2021 Tailscale Inc & AUTHORS All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package dns
|
||||
|
||||
import (
|
||||
"regexp"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// parseIni parses a basic .ini file, used for wsl.conf.
|
||||
func parseIni(data string) map[string]map[string]string {
|
||||
sectionRE := regexp.MustCompile(`^\[([^]]+)\]`)
|
||||
kvRE := regexp.MustCompile(`^\s*(\w+)\s*=\s*([^#]*)`)
|
||||
|
||||
ini := map[string]map[string]string{}
|
||||
var section string
|
||||
for _, line := range strings.Split(data, "\n") {
|
||||
if res := sectionRE.FindStringSubmatch(line); len(res) > 1 {
|
||||
section = res[1]
|
||||
ini[section] = map[string]string{}
|
||||
} else if res := kvRE.FindStringSubmatch(line); len(res) > 2 {
|
||||
k, v := strings.TrimSpace(res[1]), strings.TrimSpace(res[2])
|
||||
ini[section][k] = v
|
||||
}
|
||||
}
|
||||
return ini
|
||||
}
|
||||
@ -0,0 +1,37 @@
|
||||
// Copyright (c) 2021 Tailscale Inc & AUTHORS All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package dns
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestParseIni(t *testing.T) {
|
||||
var tests = []struct {
|
||||
src string
|
||||
want map[string]map[string]string
|
||||
}{
|
||||
{
|
||||
src: `# appended wsl.conf file
|
||||
[automount]
|
||||
enabled = true
|
||||
root=/mnt/
|
||||
# added by tailscale
|
||||
[network] # trailing comment
|
||||
generateResolvConf = false # trailing comment`,
|
||||
want: map[string]map[string]string{
|
||||
"automount": map[string]string{"enabled": "true", "root": "/mnt/"},
|
||||
"network": map[string]string{"generateResolvConf": "false"},
|
||||
},
|
||||
},
|
||||
}
|
||||
for _, test := range tests {
|
||||
got := parseIni(test.src)
|
||||
if !reflect.DeepEqual(got, test.want) {
|
||||
t.Errorf("for:\n%s\ngot: %v\nwant: %v", test.src, got, test.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,217 @@
|
||||
// Copyright (c) 2021 Tailscale Inc & AUTHORS All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package dns
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"os"
|
||||
"os/exec"
|
||||
"strings"
|
||||
"syscall"
|
||||
"unicode/utf16"
|
||||
|
||||
"tailscale.com/types/logger"
|
||||
)
|
||||
|
||||
// wslDistros reports the names of the installed WSL2 linux distributions.
|
||||
func wslDistros(logf logger.Logf) []string {
|
||||
cmd := exec.Command("wsl.exe", "-l")
|
||||
cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}
|
||||
b, err := cmd.CombinedOutput()
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
// The first line of output is a WSL header. E.g.
|
||||
//
|
||||
// C:\tsdev>wsl.exe -l
|
||||
// Windows Subsystem for Linux Distributions:
|
||||
// Ubuntu-20.04 (Default)
|
||||
//
|
||||
// We can skip it by passing '-q', but here we put it to work.
|
||||
// It turns out wsl.exe -l is broken, and outputs UTF-16 names
|
||||
// that nothing can read. (Try `wsl.exe -l | more`.)
|
||||
// So we look at the header to see if it's UTF-16.
|
||||
// If so, we run the rest through a UTF-16 parser.
|
||||
//
|
||||
// https://github.com/microsoft/WSL/issues/4607
|
||||
var output string
|
||||
if bytes.HasPrefix(b, []byte("W\x00i\x00n\x00d\x00o\x00w\x00s\x00")) {
|
||||
output, err = decodeUTF16(b)
|
||||
if err != nil {
|
||||
logf("failed to decode wsl.exe -l output %q: %v", b, err)
|
||||
return nil
|
||||
}
|
||||
} else {
|
||||
output = string(b)
|
||||
}
|
||||
fmt.Printf("wslDistros: %q\n", output)
|
||||
lines := strings.Split(output, "\n")
|
||||
if len(lines) < 1 {
|
||||
return nil
|
||||
}
|
||||
lines = lines[1:] // drop "Windows Subsystem For Linux" header
|
||||
|
||||
var distros []string
|
||||
for _, name := range lines {
|
||||
name = strings.TrimSpace(name)
|
||||
name = strings.TrimSuffix(name, " (Default)")
|
||||
if name == "" {
|
||||
continue
|
||||
}
|
||||
fmt.Printf("wslDistros: name=%q\n", name)
|
||||
distros = append(distros, name)
|
||||
}
|
||||
return distros
|
||||
}
|
||||
|
||||
func decodeUTF16(b []byte) (string, error) {
|
||||
if len(b) == 0 {
|
||||
return "", nil
|
||||
} else if len(b)%2 != 0 {
|
||||
return "", fmt.Errorf("decodeUTF16: invalid length %d", len(b))
|
||||
}
|
||||
var u16 []uint16
|
||||
for i := 0; i < len(b); i += 2 {
|
||||
u16 = append(u16, uint16(b[i])+(uint16(b[i+1])<<8))
|
||||
}
|
||||
return string(utf16.Decode(u16)), nil
|
||||
}
|
||||
|
||||
// wslManager is a DNS manager for WSL2 linux distributions.
|
||||
// It configures /etc/wsl.conf and /etc/resolv.conf.
|
||||
type wslManager struct {
|
||||
logf logger.Logf
|
||||
managers map[string]directManager // distro name -> manager
|
||||
}
|
||||
|
||||
func newWSLManager(logf logger.Logf, distros []string) *wslManager {
|
||||
m := &wslManager{
|
||||
logf: logf,
|
||||
managers: make(map[string]directManager),
|
||||
}
|
||||
for _, distro := range distros {
|
||||
m.managers[distro] = newDirectManagerOnFS(wslFS{
|
||||
user: "root",
|
||||
distro: distro,
|
||||
})
|
||||
}
|
||||
return m
|
||||
}
|
||||
|
||||
func (wm *wslManager) SetDNS(cfg OSConfig) error {
|
||||
if !cfg.IsZero() {
|
||||
if wm.setWSLConf() {
|
||||
// What's this? So glad you asked.
|
||||
//
|
||||
// WSL2 writes the /etc/resolv.conf.
|
||||
// It is aggressive about it. Every time you execute wsl.exe,
|
||||
// it writes it. (Opening a terminal is done by running wsl.exe.)
|
||||
// You can turn this off using /etc/wsl.conf! But: this wsl.conf
|
||||
// file is only parsed when the VM boots up. To do that, we
|
||||
// have to shut down WSL2.
|
||||
//
|
||||
// So we do it here, before we call wsl.exe to write resolv.conf.
|
||||
if b, err := wslCommand("--shutdown").CombinedOutput(); err != nil {
|
||||
wm.logf("WSL SetDNS shutdown: %v: %s", err, b)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for distro, m := range wm.managers {
|
||||
if err := m.SetDNS(cfg); err != nil {
|
||||
wm.logf("WSL(%q) SetDNS: %v", distro, err)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
const wslConf = "/etc/wsl.conf"
|
||||
const wslConfSection = `# added by tailscale
|
||||
[network]
|
||||
generateResolvConf = false
|
||||
`
|
||||
|
||||
// setWSLConf attempts to disable generateResolvConf in each WSL2 linux.
|
||||
// If any are changed, it reports true.
|
||||
func (wm *wslManager) setWSLConf() (changed bool) {
|
||||
for distro, m := range wm.managers {
|
||||
b, err := m.fs.ReadFile(wslConf)
|
||||
if err != nil && !os.IsNotExist(err) {
|
||||
wm.logf("WSL(%q) wsl.conf: read: %v", distro, err)
|
||||
continue
|
||||
}
|
||||
ini := parseIni(string(b))
|
||||
if v := ini["network"]["generateResolvConf"]; v == "" {
|
||||
b = append(b, wslConfSection...)
|
||||
if err := m.fs.WriteFile(wslConf, b, 0644); err != nil {
|
||||
wm.logf("WSL(%q) wsl.conf: write: %v", distro, err)
|
||||
continue
|
||||
}
|
||||
changed = true
|
||||
}
|
||||
}
|
||||
return changed
|
||||
}
|
||||
|
||||
func (m *wslManager) SupportsSplitDNS() bool { return false }
|
||||
func (m *wslManager) Close() error { return m.SetDNS(OSConfig{}) }
|
||||
|
||||
// wslFS is a pinholeFS implemented on top of wsl.exe.
|
||||
//
|
||||
// We access WSL2 file systems via wsl.exe instead of \\wsl$\ because
|
||||
// the netpath appears to operate as the standard user, not root.
|
||||
type wslFS struct {
|
||||
user string
|
||||
distro string
|
||||
}
|
||||
|
||||
func (fs wslFS) Stat(name string) (isRegular bool, err error) {
|
||||
err = fs.cmd("test", "-f", name).Run()
|
||||
if ee, _ := err.(*exec.ExitError); ee != nil {
|
||||
if ee.ExitCode() == 1 {
|
||||
return false, os.ErrNotExist
|
||||
}
|
||||
return false, err
|
||||
}
|
||||
return true, nil
|
||||
}
|
||||
|
||||
func (fs wslFS) Rename(oldName, newName string) error {
|
||||
return fs.cmd("mv", "--", oldName, newName).Run()
|
||||
}
|
||||
func (fs wslFS) Remove(name string) error { return fs.cmd("rm", "--", name).Run() }
|
||||
|
||||
func (fs wslFS) ReadFile(name string) ([]byte, error) {
|
||||
b, err := fs.cmd("cat", "--", name).CombinedOutput()
|
||||
if ee, _ := err.(*exec.ExitError); ee != nil && ee.ExitCode() == 1 {
|
||||
return nil, os.ErrNotExist
|
||||
}
|
||||
return b, err
|
||||
}
|
||||
|
||||
func (fs wslFS) WriteFile(name string, contents []byte, perm os.FileMode) error {
|
||||
cmd := fs.cmd("tee", "--", name)
|
||||
cmd.Stdin = bytes.NewReader(contents)
|
||||
cmd.Stdout = nil
|
||||
if err := cmd.Run(); err != nil {
|
||||
return err
|
||||
}
|
||||
return fs.cmd("chmod", "--", fmt.Sprintf("%04o", perm), name).Run()
|
||||
}
|
||||
|
||||
func (fs wslFS) cmd(args ...string) *exec.Cmd {
|
||||
cmd := wslCommand("-u", fs.user, "-d", fs.distro, "-e")
|
||||
cmd.Args = append(cmd.Args, args...)
|
||||
fmt.Printf("wslFS.cmd: %v\n", cmd.Args)
|
||||
return cmd
|
||||
}
|
||||
|
||||
func wslCommand(args ...string) *exec.Cmd {
|
||||
cmd := exec.Command("wsl.exe", args...)
|
||||
cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}
|
||||
return cmd
|
||||
}
|
||||
Loading…
Reference in New Issue