community
/
dns
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

New API 

rename resolver.DnsMsg to resolver.Msg. shorter and better
Adapt all files to this change
This commit is contained in:
Miek Gieben 2011-01-13 16:12:02 +01:00
parent c176c33c16
commit fea310bbcf
15 changed files with 57 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
ChangeLog Normal file
View File

@ -0,0 +1,3 @@
* Cherry picked GRONG for server side ideas

8
TODO
View File

@ -2,17 +2,9 @@ Todo:
Short term:
* NSEC3 - need base32 for Nsec3
* Parsing from strings
* Server support
* Signature generation
* Testsuite
* Cleanup the code
* use the responder idea from GRONG
so we then have dns/resolver - asking
and dns/responder - answering
For servers we might need client IP and stuff -- look how
we need to encode this in the DnsMsg (which is the type of
the channel we use to comm. with resolvers)
Issues:
* escaped dots in names \.

2
_examples/axfr/axfr.go
View File

@ -15,7 +15,7 @@ func main() {
m.Question = make([]dns.Question, 1)
m.Question[0] = dns.Question{"atoom.net", dns.TypeAXFR, dns.ClassINET}
ch <- resolver.DnsMsg{m, nil}
ch <- resolver.Msg{m, nil}
for dm := range ch {
fmt.Printf("%v\n",dm.Dns)
}

14
_examples/chaos/chaos.go
View File

@ -17,7 +17,7 @@ func main() {
r.Servers = []string{"127.0.0.1"}
r.Timeout = 2
r.Attempts = 1
var in resolver.DnsMsg
var in resolver.Msg
if len(os.Args) != 2 {
fmt.Printf("%s NAMESERVER\n", os.Args[0])
@ -30,13 +30,13 @@ func main() {
// set the resolver to query the NS directly
r.Servers = []string{a.String()}
m.Question[0] = dns.Question{"version.bind.", dns.TypeTXT, dns.ClassCHAOS}
qr <- resolver.DnsMsg{m, nil}
qr <- resolver.Msg{m, nil}
in = <-qr
if in.Dns != nil && in.Dns.Answer != nil {
fmt.Printf("%v\n", in.Dns.Answer[0])
}
m.Question[0] = dns.Question{"hostname.bind.", dns.TypeTXT, dns.ClassCHAOS}
qr <- resolver.DnsMsg{m, nil}
qr <- resolver.Msg{m, nil}
in = <-qr
if in.Dns != nil && in.Dns.Answer != nil {
fmt.Printf("%v\n", in.Dns.Answer[0])
@ -44,18 +44,18 @@ func main() {
}
// Stop the resolver, send it a null mesg
qr <- resolver.DnsMsg{nil, nil}
qr <- resolver.Msg{nil, nil}
<-qr
}
func addresses(qr chan resolver.DnsMsg, name string) []net.IP {
func addresses(qr chan resolver.Msg, name string) []net.IP {
m := new(dns.Msg)
m.MsgHdr.RecursionDesired = true //only set this bit
m.Question = make([]dns.Question, 1)
var ips []net.IP
m.Question[0] = dns.Question{os.Args[1], dns.TypeA, dns.ClassINET}
qr <- resolver.DnsMsg{m, nil}
qr <- resolver.Msg{m, nil}
in := <-qr
if in.Dns == nil {
@ -71,7 +71,7 @@ func addresses(qr chan resolver.DnsMsg, name string) []net.IP {
ips = append(ips, a.(*dns.RR_A).A)
}
m.Question[0] = dns.Question{os.Args[1], dns.TypeAAAA, dns.ClassINET}
qr <- resolver.DnsMsg{m, nil}
qr <- resolver.Msg{m, nil}
in = <-qr
if in.Dns == nil {

13
_examples/dnssectest/dnssectest.go
View File

@ -2,7 +2,6 @@ package main
import (
"dns"
"dns/dnssec"
"dns/resolver"
"fmt"
)
@ -17,7 +16,7 @@ func main() {
key.Hdr.Ttl = 3600
key.Flags = 257
key.Protocol = 3
key.Algorithm = dnssec.AlgRSASHA1
key.Algorithm = dns.AlgRSASHA1
key.PubKey = "AwEAAaHIwpx3w4VHKi6i1LHnTaWeHCL154Jug0Rtc9ji5qwPXpBo6A5sRv7cSsPQKPIwxLpyCrbJ4mr2L0EPOdvP6z6YfljK2ZmTbogU9aSU2fiq/4wjxbdkLyoDVgtO+JsxNN4bjr4WcWhsmk1Hg93FV9ZpkWb0Tbad8DFq NDzr//kZ"
sig := new(dns.RR_RRSIG)
@ -26,7 +25,7 @@ func main() {
sig.Hdr.Class = dns.ClassINET
sig.Hdr.Ttl = 3600
sig.TypeCovered = dns.TypeDNSKEY
sig.Algorithm = dnssec.AlgRSASHA1
sig.Algorithm = dns.AlgRSASHA1
sig.OrigTtl = 4000
sig.Expiration = 1000
sig.Inception = 800
@ -51,20 +50,20 @@ func main() {
m.Question = make([]dns.Question, 1)
m.Question[0] = dns.Question{"miek.nl", dns.TypeDS, dns.ClassINET}
ch <- resolver.DnsMsg{m, nil}
ch <- resolver.Msg{m, nil}
in := <-ch
fmt.Printf("%v\n", in.Dns)
m.Question[0] = dns.Question{"www.nlnetlabs.nl", dns.TypeRRSIG, dns.ClassINET}
ch <- resolver.DnsMsg{m, nil}
ch <- resolver.Msg{m, nil}
in = <-ch
fmt.Printf("%v\n", in.Dns)
m.Question[0] = dns.Question{"xxxx.nlnetlabs.nl", dns.TypeDNSKEY, dns.ClassINET}
ch <- resolver.DnsMsg{m, nil}
ch <- resolver.Msg{m, nil}
in = <-ch
fmt.Printf("%v\n", in.Dns)
ch <- resolver.DnsMsg{nil, nil}
ch <- resolver.Msg{nil, nil}
<-ch
}

BIN
_examples/mx/_go_.6
View File

Binary file not shown.

4
_examples/mx/mx.go
View File

@ -26,7 +26,7 @@ func main() {
m.Question = make([]dns.Question, 1)
m.Question[0] = dns.Question{os.Args[1], dns.TypeMX, dns.ClassINET}
qr <- resolver.DnsMsg{m, nil}
qr <- resolver.Msg{m, nil}
in := <-qr
if in.Dns != nil {
if in.Dns.Rcode != dns.RcodeSuccess {
@ -42,6 +42,6 @@ func main() {
}
// Stop the resolver, send it a null mesg
qr <- resolver.DnsMsg{nil, nil}
qr <- resolver.Msg{nil, nil}
<-qr
}

6
_examples/notify/notify.go
View File

@ -15,7 +15,7 @@ func main() {
r.Servers = []string{"127.0.0.1"}
r.Timeout = 2
r.Attempts = 1
var in resolver.DnsMsg
var in resolver.Msg
if len(os.Args) != 2 {
fmt.Printf("%s NAMESERVER\n", os.Args[0])
@ -26,7 +26,7 @@ func main() {
m.Question = make([]dns.Question, 1)
m.Question[0] = dns.Question{"miek.nl", dns.TypeSOA, dns.ClassINET}
m.MsgHdr.Opcode = dns.OpcodeNotify
qr <- resolver.DnsMsg{m, nil}
qr <- resolver.Msg{m, nil}
in = <-qr
// if in.Dns != nil && in.Dns.Answer != nil {
if in.Dns != nil {
@ -35,6 +35,6 @@ func main() {
}
// Stop the resolver, send it a null mesg
qr <- resolver.DnsMsg{nil, nil}
qr <- resolver.Msg{nil, nil}
<-qr
}

4
_examples/q/q.go
View File

@ -89,7 +89,7 @@ FLAGS:
for _, v := range qname {
m.Question[0] = dns.Question{v, qtype, qclass}
m.SetId()
qr <- resolver.DnsMsg{m, nil}
qr <- resolver.Msg{m, nil}
in := <-qr
if in.Dns != nil {
if m.Id != in.Dns.Id {
@ -100,6 +100,6 @@ FLAGS:
fmt.Printf("%v\n", in.Error.String())
}
}
qr <- resolver.DnsMsg{nil, nil}
qr <- resolver.Msg{nil, nil}
<-qr
}

2
resolver/axfr_test.go
View File

@ -16,7 +16,7 @@ func TestAXFR(t *testing.T) {
m.Question[0] = dns.Question{"miek.nl", dns.TypeAXFR, dns.ClassINET}
//m.Question[0] = dns.Question{"atoom.net", dns.TypeAXFR, dns.ClassINET}
ch <- DnsMsg{m, nil}
ch <- Msg{m, nil}
for dm := range ch {
var _ = dm
/* fmt.Printf("%v\n",dm.Dns) */

34
resolver/resolver.go
View File

@ -17,7 +17,7 @@
// m.MsgHdr.Recursion_desired = true // header bits
// m.Question = make([]Question, 1) // 1 RR in question sec.
// m.Question[0] = Question{"miek.nl", TypeSOA, ClassINET}
// ch <- DnsMsg{m, nil} // send the query
// ch <- Msg{m, nil} // send the query
// in := <-ch // wait for reply
//
// Note that message id checking is left to the caller
@ -37,7 +37,7 @@ const servErr = "No servers could be reached"
// to send packets to it, for sending Error must be nil.
// A resolver responds with a reply packet and a possible error.
// Sending a nil message instructs to resolver to stop.
type DnsMsg struct {
type Msg struct {
Dns *dns.Msg
Error os.Error
}
@ -61,14 +61,14 @@ type Resolver struct {
// Start a new resolver as a goroutine, return the communication channel.
// Note the a limit amount of sanity checking is done. There is for instance
// no query id matching.
func (res *Resolver) NewQuerier() (ch chan DnsMsg) {
ch = make(chan DnsMsg)
func (res *Resolver) NewQuerier() (ch chan Msg) {
ch = make(chan Msg)
go query(res, ch)
return
}
// The query function.
func query(res *Resolver, msg chan DnsMsg) {
func query(res *Resolver, msg chan Msg) {
// error checking, robustness
var (
c net.Conn
@ -88,7 +88,7 @@ func query(res *Resolver, msg chan DnsMsg) {
case out := <-msg: //msg received
if out.Dns == nil {
// nil message, quit the goroutine
msg <- DnsMsg{nil, nil}
msg <- Msg{nil, nil}
close(msg)
return
}
@ -101,7 +101,7 @@ func query(res *Resolver, msg chan DnsMsg) {
}
sending, ok := out.Dns.Pack()
if !ok {
msg <- DnsMsg{nil, &dns.Error{Error: packErr}}
msg <- Msg{nil, &dns.Error{Error: packErr}}
continue
}
@ -129,9 +129,9 @@ func query(res *Resolver, msg chan DnsMsg) {
}
}
if err != nil {
msg <- DnsMsg{nil, err}
msg <- Msg{nil, err}
} else {
msg <- DnsMsg{in, nil}
msg <- Msg{in, nil}
}
}
}
@ -141,13 +141,13 @@ func query(res *Resolver, msg chan DnsMsg) {
// Start a new xfr as a goroutine, return a channel.
// Channel will be closed when the axfr is finished, until
// that time new messages will appear on the channel
func (res *Resolver) NewXfer() (ch chan DnsMsg) {
ch = make(chan DnsMsg)
func (res *Resolver) NewXfer() (ch chan Msg) {
ch = make(chan Msg)
go axfr(res, ch)
return
}
func axfr(res *Resolver, msg chan DnsMsg) {
func axfr(res *Resolver, msg chan Msg) {
var port string
var err os.Error
var in *dns.Msg
@ -162,7 +162,7 @@ func axfr(res *Resolver, msg chan DnsMsg) {
case out := <-msg: // msg received
if out.Dns == nil {
// stop
msg <- DnsMsg{nil, nil}
msg <- Msg{nil, nil}
close(msg)
return
}
@ -170,7 +170,7 @@ func axfr(res *Resolver, msg chan DnsMsg) {
out.Dns.SetId()
sending, ok := out.Dns.Pack()
if !ok {
msg <- DnsMsg{nil, &dns.Error{Error: packErr}}
msg <- Msg{nil, &dns.Error{Error: packErr}}
}
SERVER:
for i := 0; i < len(res.Servers); i++ {
@ -208,12 +208,12 @@ func axfr(res *Resolver, msg chan DnsMsg) {
if !first {
if !checkSOA(in, false) {
// Soa record not the last one
msg <- DnsMsg{in, nil}
msg <- Msg{in, nil}
continue
// next
} else {
c.Close()
msg <- DnsMsg{in, nil}
msg <- Msg{in, nil}
close(msg)
return
}
@ -222,7 +222,7 @@ func axfr(res *Resolver, msg chan DnsMsg) {
println("Should never be reached")
return
}
msg <- DnsMsg{nil, err}
msg <- Msg{nil, err}
close(msg)
return
}

4
resolver/resolverEdns_test.go
View File

@ -34,7 +34,7 @@ func TestResolverEdns(t *testing.T) {
m.Extra = make([]dns.RR, 1)
m.Extra[0] = edns
ch <- DnsMsg{m, nil}
ch <- Msg{m, nil}
in := <-ch
if in.Dns != nil {
if in.Dns.Rcode != dns.RcodeSuccess {
@ -45,6 +45,6 @@ func TestResolverEdns(t *testing.T) {
} else {
fmt.Printf("Failed to get a good anwer")
}
ch <- DnsMsg{nil, nil}
ch <- Msg{nil, nil}
<-ch // wait for ch to close channel
}

4
resolver/resolverTsig_test.go
View File

@ -33,7 +33,7 @@ func TestResolverTsig(t *testing.T) {
m.Extra[0] = tsig
ch <- DnsMsg{m, nil}
ch <- Msg{m, nil}
in := <-ch
if in.Dns != nil {
if in.Dns.Rcode != dns.RcodeSuccess {
@ -44,6 +44,6 @@ func TestResolverTsig(t *testing.T) {
} else {
fmt.Printf("Failed to get a good anwer")
}
ch <- DnsMsg{nil, nil}
ch <- Msg{nil, nil}
<-ch // wait for ch to close channel
}

6
resolver/resolver_test.go
View File

@ -19,7 +19,7 @@ func TestResolver(t *testing.T) {
// ask something
m.Question[0] = dns.Question{"miek.nl", dns.TypeSOA, dns.ClassINET}
ch <- DnsMsg{m, nil}
ch <- Msg{m, nil}
in := <-ch
if in.Dns != nil && in.Dns.Rcode != dns.RcodeSuccess {
@ -30,7 +30,7 @@ func TestResolver(t *testing.T) {
// ask something
m.Question[0] = dns.Question{"www.nlnetlabs.nl", dns.TypeRRSIG, dns.ClassINET}
ch <- DnsMsg{m, nil}
ch <- Msg{m, nil}
in = <-ch
if in.Dns != nil && in.Dns.Rcode != dns.RcodeSuccess {
@ -41,6 +41,6 @@ func TestResolver(t *testing.T) {
fmt.Printf("%v\n", in.Dns)
}
ch <- DnsMsg{nil, nil}
ch <- Msg{nil, nil}
<-ch
}

16
responder/responder.go
View File

@ -22,14 +22,14 @@ type Server struct {
Mangle func([]byte) []byte // mangle the packet, before sending
}
type serverMsgUDP struct {
type MsgUDP struct {
c *net.UDPConn // connection
addr *net.UDPAddr // remote address
msg []byte // raw dns message
err os.Error // any errors
}
type serverMsgTCP struct {
type MsgTCP struct {
c *net.TCPConn // connection
msg []byte // raw dns message
err os.Error // any errors
@ -60,7 +60,7 @@ func (res *Server) NewResponder(h Responder, ch chan bool) os.Error {
}
switch res.Tcp {
case true:
tch := make(chan serverMsgTCP)
tch := make(chan MsgTCP)
a, _ := net.ResolveTCPAddr(res.Address + ":" + port)
go listenerTCP(a, tch)
foreverTCP:
@ -79,7 +79,7 @@ func (res *Server) NewResponder(h Responder, ch chan bool) os.Error {
}
case false:
uch := make(chan serverMsgUDP)
uch := make(chan MsgUDP)
a, _ := net.ResolveUDPAddr(res.Address + ":" + port)
go listenerUDP(a, uch)
foreverUDP:
@ -99,7 +99,7 @@ func (res *Server) NewResponder(h Responder, ch chan bool) os.Error {
return nil
}
func listenerUDP(a *net.UDPAddr, ch chan serverMsgUDP) {
func listenerUDP(a *net.UDPAddr, ch chan MsgUDP) {
c, _ := net.ListenUDP("udp", a)
// check error TODO(mg)
for {
@ -110,11 +110,11 @@ func listenerUDP(a *net.UDPAddr, ch chan serverMsgUDP) {
}
m = m[:n]
// if closed(ch) c.Close() TODO(mg)
ch <- serverMsgUDP{c, radd, m, nil}
ch <- MsgUDP{c, radd, m, nil}
}
}
func listenerTCP(a *net.TCPAddr, ch chan serverMsgTCP) {
func listenerTCP(a *net.TCPAddr, ch chan MsgTCP) {
t, _ := net.ListenTCP("tcp", a)
for {
l := make([]byte, 2) // receiver length
@ -147,7 +147,7 @@ func listenerTCP(a *net.TCPAddr, ch chan serverMsgTCP) {
}
i += n
}
ch <- serverMsgTCP{c, m, nil}
ch <- MsgTCP{c, m, nil}
}
}