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>main
David Crawshaw
5 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