From db6ee9954c1f79cc6bac1f876ccef5bcf21e1e44 Mon Sep 17 00:00:00 2001
From: Tom Wilkie <tom@weave.works>
Date: Tue, 28 Jul 2015 09:57:36 +0000
Subject: [PATCH] Allow users to set dns listen address so we can run the weave
 router in the host net namespace.

---
 nameserver/dns.go      | 24 ++++++++++++------------
 nameserver/dns_test.go |  2 +-
 prog/weaver/main.go    |  6 +++---
 3 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/nameserver/dns.go b/nameserver/dns.go
index 118faea4..35e07a23 100644
--- a/nameserver/dns.go
+++ b/nameserver/dns.go
@@ -21,16 +21,16 @@ const (
 	udpBuffSize      = uint16(4096)
 	minUDPSize       = 512
 
-	DefaultPort          = 53
+	DefaultListenAddress = "0.0.0.0:53"
 	DefaultTTL           = 1
 	DefaultClientTimeout = 5 * time.Second
 )
 
 type DNSServer struct {
-	ns     *Nameserver
-	domain string
-	ttl    uint32
-	port   int
+	ns      *Nameserver
+	domain  string
+	ttl     uint32
+	address string
 
 	servers   []*dns.Server
 	upstream  *dns.ClientConfig
@@ -38,14 +38,14 @@ type DNSServer struct {
 	udpClient *dns.Client
 }
 
-func NewDNSServer(ns *Nameserver, domain string, port int, ttl uint32,
+func NewDNSServer(ns *Nameserver, domain string, address string, ttl uint32,
 	clientTimeout time.Duration) (*DNSServer, error) {
 
 	s := &DNSServer{
 		ns:        ns,
 		domain:    dns.Fqdn(domain),
 		ttl:       ttl,
-		port:      port,
+		address:   address,
 		tcpClient: &dns.Client{Net: "tcp", ReadTimeout: clientTimeout},
 		udpClient: &dns.Client{Net: "udp", ReadTimeout: clientTimeout, UDPSize: udpBuffSize},
 	}
@@ -54,26 +54,26 @@ func NewDNSServer(ns *Nameserver, domain string, port int, ttl uint32,
 		return nil, err
 	}
 
-	err = s.listen(port)
+	err = s.listen(address)
 	return s, err
 }
 
 func (d *DNSServer) String() string {
 	var buf bytes.Buffer
 	fmt.Fprintf(&buf, "WeaveDNS (%s)\n", d.ns.ourName)
-	fmt.Fprintf(&buf, "  listening on port %d, for domain %s\n", d.port, d.domain)
+	fmt.Fprintf(&buf, "  listening on %s, for domain %s\n", d.address, d.domain)
 	fmt.Fprintf(&buf, "  response ttl %d\n", d.ttl)
 	return buf.String()
 }
 
-func (d *DNSServer) listen(port int) error {
-	udpListener, err := net.ListenPacket("udp", fmt.Sprintf(":%d", port))
+func (d *DNSServer) listen(address string) error {
+	udpListener, err := net.ListenPacket("udp", address)
 	if err != nil {
 		return err
 	}
 	udpServer := &dns.Server{PacketConn: udpListener, Handler: d.createMux(d.udpClient, minUDPSize)}
 
-	tcpListener, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
+	tcpListener, err := net.Listen("tcp", address)
 	if err != nil {
 		udpServer.Shutdown()
 		return err
diff --git a/nameserver/dns_test.go b/nameserver/dns_test.go
index b44ce94b..6368f4fb 100644
--- a/nameserver/dns_test.go
+++ b/nameserver/dns_test.go
@@ -20,7 +20,7 @@ func TestTruncation(t *testing.T) {
 	peername, err := router.PeerNameFromString("00:00:00:02:00:00")
 	require.Nil(t, err)
 	nameserver := New(peername, nil, nil, "")
-	dnsserver, err := NewDNSServer(nameserver, "weave.local.", 0, 30, 5*time.Second)
+	dnsserver, err := NewDNSServer(nameserver, "weave.local.", "0.0.0.0:0", 30, 5*time.Second)
 	require.Nil(t, err)
 	udpPort := dnsserver.servers[0].PacketConn.LocalAddr().(*net.UDPAddr).Port
 	tcpPort := dnsserver.servers[1].Listener.Addr().(*net.TCPAddr).Port
diff --git a/prog/weaver/main.go b/prog/weaver/main.go
index f61318cb..ebcdba52 100644
--- a/prog/weaver/main.go
+++ b/prog/weaver/main.go
@@ -57,7 +57,7 @@ func main() {
 		peers              []string
 		noDNS              bool
 		dnsDomain          string
-		dnsPort            int
+		dnsListenAddress   string
 		dnsTTL             int
 		dnsClientTimeout   time.Duration
 	)
@@ -83,7 +83,7 @@ func main() {
 	mflag.StringVar(&apiPath, []string{"#api", "-api"}, "unix:///var/run/docker.sock", "Path to Docker API socket")
 	mflag.BoolVar(&noDNS, []string{"-no-dns"}, false, "disable DNS server")
 	mflag.StringVar(&dnsDomain, []string{"-dns-domain"}, nameserver.DefaultDomain, "local domain to server requests for")
-	mflag.IntVar(&dnsPort, []string{"-dns-port"}, nameserver.DefaultPort, "port to listen on for DNS requests")
+	mflag.StringVar(&dnsListenAddress, []string{"-dns-listen-address"}, nameserver.DefaultListenAddress, "address to listen on for DNS requests")
 	mflag.IntVar(&dnsTTL, []string{"-dns-ttl"}, nameserver.DefaultTTL, "TTL for DNS request from our domain")
 	mflag.DurationVar(&dnsClientTimeout, []string{"-dns-fallback-timeout"}, nameserver.DefaultClientTimeout, "timeout for fallback DNS requests")
 
@@ -183,7 +183,7 @@ func main() {
 		}
 		ns.Start()
 		defer ns.Stop()
-		dnsserver, err = nameserver.NewDNSServer(ns, dnsDomain, dnsPort, uint32(dnsTTL), dnsClientTimeout)
+		dnsserver, err = nameserver.NewDNSServer(ns, dnsDomain, dnsListenAddress, uint32(dnsTTL), dnsClientTimeout)
 		if err != nil {
 			Log.Fatal("Unable to start dns server: ", err)
 		}