Responder channel is now os.Error

to make it possible to send errors back

_examples/funkensturm/funkensturm.go

@@ -223,7 +223,7 @@ func main() {
 	s.Address = addr
 	s.Port = port
 	var srv *server
-	rs := make(chan bool)
+	rs := make(chan os.Error)
 	go s.NewResponder(srv, rs)
 
 forever:
@@ -236,7 +236,7 @@ forever:
 			break forever
 		}
 	}
-	rs <- true // shutdown responder
+	rs <- nil // shutdown responder
 	<-rs // wait for confirmation
         // And the resolvers
         for _, q := range qr {

_examples/reflect/reflect.go

@@ -17,9 +17,10 @@
 package main
 
 import (
+	"os"
 	"net"
-        "strconv"
 	"dns"
+	"strconv"
 	"dns/responder"
 	"runtime"
 	"os/signal"
@@ -100,7 +101,7 @@ func main() {
 	s.Address = "127.0.0.1"
 	s.Port = "8053"
 	var srv *server
-        ch := make(chan bool)
+	ch := make(chan os.Error)
 	go s.NewResponder(srv, ch)
 
 	t := new(responder.Server)
@@ -108,7 +109,7 @@ func main() {
 	t.Port = "8053"
 	t.Tcp = true
 	var srvt *server
-        cht := make(chan bool)
+	cht := make(chan os.Error)
 	go t.NewResponder(srvt, cht)
 
 forever:
@@ -117,13 +118,15 @@ forever:
 		select {
 		case <-signal.Incoming:
 			println("Signal received, stopping")
-                        ch <- true
-                        cht <- true
+			ch <- nil
+			cht <- nil
 			break forever
-                case <-cht:
+		case e := <-cht:
 			// last message from tcp channel
-                case <-ch:
+			println(e.String())
+		case e := <-ch:
 			// last message from udp channel
+			println(e.String())
 		}
 	}
 	close(cht)

_examples/rude/rude.go

@@ -10,6 +10,7 @@
 package main
 
 import (
+	"os"
 	"net"
 	"dns"
 	"dns/responder"
@@ -52,7 +53,7 @@ func main() {
 	s.Address = "127.0.0.1"
 	s.Port = "8053"
 	var srv *server
-	ch := make(chan bool)
+	ch := make(chan os.Error)
 	go s.NewResponder(srv, ch)
 
 forever:
@@ -61,9 +62,13 @@ forever:
 		select {
 		case <-signal.Incoming:
 			println("Signal received, stopping")
-			ch <- true
+			ch <- nil
 			<-ch
 			break forever
+		case e := <-cht:
+			println(e.String())
+		case e := <-ch:
+			println(e.String())
 		}
 	}
 }

responder/responder.go

@@ -59,12 +59,12 @@ type Responder interface {
 	ResponderTCP(c *net.TCPConn, in []byte)
 }
 
-// Start a new responder. The returned channel is only used to stop the responder.
-// Send 'true' to make it stop
-func (res *Server) NewResponder(h Responder, stop chan bool) {
+// Start a new responder. The returned channel is used to stop the responder.
+// Send 'nil' to make it stop. It can also return error via the channel.
+func (res *Server) NewResponder(h Responder, stop chan os.Error) {
 	var port string
 	if len(res.Address) == 0 {
-		// We cannot start responding without an addresss
+                stop <- &dns.Error{Error: "No addresses"}
 		return
 	}
 	if res.Port == "" {
@@ -83,14 +83,12 @@ func (res *Server) NewResponder(h Responder, stop chan bool) {
 		for {
 			select {
 			case <-stop:
-				stop <- true
+				stop <- nil
 				listener.Close()
 				break foreverTCP
 			case s := <-tch:
 				if s.err != nil {
-					// always fatal??
-                                        stop <- false
-					println(s.err.String())
+                                        stop <- s.err
 				} else {
 					go h.ResponderTCP(s.tcp, s.msg)
 				}
@@ -105,13 +103,11 @@ func (res *Server) NewResponder(h Responder, stop chan bool) {
 		for {
 			select {
 			case <-stop:
-				stop <- true
+				stop <- nil
 				break foreverUDP
 			case s := <-uch:
 				if s.err != nil {
-					//continue
-                                        stop <- false
-					println(s.err.String())
+                                        stop <- s.err
 				} else {
 					go h.ResponderUDP(s.udp, s.addr, s.msg)
 				}

responder/responder_test.go

@@ -1,6 +1,7 @@
 package responder
 
 import (
+        "os"
 	"testing"
         "fmt"
 	"dns"
@@ -66,7 +67,7 @@ func TestResponder(t *testing.T) {
 	su.Address = "127.0.0.1"
 	su.Port = "8053"
 	var us *myserv
-	uch := make(chan bool)
+	uch := make(chan os.Error)
 	go su.NewResponder(us, uch)
 
 	/* tcp servertje */
@@ -75,23 +76,23 @@ func TestResponder(t *testing.T) {
 	st.Port = "8053"
 	st.Tcp = true
 	var ts *myserv
-	tch := make(chan bool)
+	tch := make(chan os.Error)
 	go st.NewResponder(ts, tch)
 	time.Sleep(1 * 1e9)
-	uch <- true
-	tch <- true
+	uch <- nil
+	tch <- nil
 	<-uch
 	<-tch
 }
 
 /*
 func TestReflectorResponder(t *testing.T) {
-	stop := make(chan bool)
+	stop := make(chan os.Error)
 	s := new(Server)
 	s.Port = "8053"
 	s.Address = "127.0.0.1"
 
-	stoptcp := make(chan bool)
+	stoptcp := make(chan os.Error)
 	stcp := new(Server)
 	stcp.Port = "8053"
 	stcp.Address = "127.0.0.1"
@@ -101,8 +102,8 @@ func TestReflectorResponder(t *testing.T) {
 	go s.NewResponder(Reflector, stop)
 
 	time.Sleep(1 * 1e9)
-	stop <- true
-	stoptcp <- true
+	stop <- nil
+	stoptcp <- nil
 	<-stop
 	<-stoptcp
 }
@@ -175,7 +176,7 @@ func TestResponderTsig(t *testing.T) {
 	su.Address = "127.0.0.1"
 	su.Port = "8053"
 	var us *servtsig
-	uch := make(chan bool)
+	uch := make(chan os.Error)
 	go su.NewResponder(us, uch)
 
 	/* tcp servertje */
@@ -184,11 +185,11 @@ func TestResponderTsig(t *testing.T) {
 	st.Port = "8053"
 	st.Tcp = true
 	var ts *servtsig
-	tch := make(chan bool)
+	tch := make(chan os.Error)
 	go st.NewResponder(ts, tch)
 	time.Sleep(1 * 1e9)
-	uch <- true
-	tch <- true
+	uch <- nil
+	tch <- nil
 	<-uch
 	<-tch
 }