func main() {
c, err := dns.ClientConfigFromFile("/etc/resolv.conf")
if len(os.Args) != 2 || err != nil {
fmt.Printf("%s DOMAIN\n", os.Args[0])
os.Exit(1)
}
m := new(dns.Msg)
m.MsgHdr.RecursionDesired = true //only set this bit
m.Question = make([]dns.Question, 1)
m.Question[0] = dns.Question{os.Args[1], dns.TypeDNSKEY, dns.ClassINET}
d := new(dns.Conn)
d.RemoteAddr = c.Servers[0]
in, err := dns.SimpleQuery("udp", d, m)
if in != nil {
if in.Rcode != dns.RcodeSuccess {
fmt.Printf(" *** invalid answer name %s after DNSKEY query for %s\n", os.Args[1], os.Args[1])
os.Exit(1)
}
// Stuff must be in the answer section
for _, k := range in.Answer {
// Foreach key would need to provide a DS records, both sha1 and sha256
if key, ok := k.(*dns.RR_DNSKEY); ok {
ds := key.ToDS(dns.HashSHA1)
ds.Hdr.Ttl = 0
fmt.Printf("%v\n", ds)
ds = key.ToDS(dns.HashSHA256)
ds.Hdr.Ttl = 0
fmt.Printf("%v\n", ds)
}
}
} else {
fmt.Printf("*** error: %s\n", err.String())
}
}
func main() {
c, _ := dns.ClientConfigFromFile("/etc/resolv.conf")
if len(os.Args) != 2 {
fmt.Printf("%s DOMAIN\n", os.Args[0])
os.Exit(1)
}
m := new(dns.Msg)
m.Question = make([]dns.Question, 1)
d := new(dns.Conn)
d.RemoteAddr = c.Servers[0]
for _, a := range addresses(d, os.Args[0]) {
d.RemoteAddr = a
if err := d.Dial("udp"); err != nil {
fmt.Printf("%v\n", err)
os.Exit(1)
}
m.Question[0] = dns.Question{"version.bind.", dns.TypeTXT, dns.ClassCHAOS}
in, _ := dns.SimpleQuery("udp", d, m)
if in != nil && in.Answer != nil {
fmt.Printf("%v\n", in.Answer[0])
}
m.Question[0] = dns.Question{"hostname.bind.", dns.TypeTXT, dns.ClassCHAOS}
in, _ = dns.SimpleQuery("udp", d, m)
if in != nil && in.Answer != nil {
fmt.Printf("%v\n", in.Answer[0])
}
}
}
func handle(c *dns.Conn, in *dns.Msg) {
if in.MsgHdr.Response == true {
return // We don't do responses
}
answer := reply(c, in)
c.Write(answer)
}
func newConnMsg(qname, nameserver string, attempts int, qtype, qclass uint16, aa, ad, cd, rd, dnssec, nsid bool) (*dns.Conn, *dns.Msg) {
d := new(dns.Conn)
d.RemoteAddr = nameserver
d.Attempts = attempts
m := new(dns.Msg)
m.MsgHdr.Authoritative = aa
m.MsgHdr.AuthenticatedData = ad
m.MsgHdr.CheckingDisabled = cd
m.MsgHdr.RecursionDesired = rd
m.Question = make([]dns.Question, 1)
if dnssec || nsid {
opt := new(dns.RR_OPT)
opt.SetDo()
opt.SetVersion(0)
opt.SetUDPSize(dns.DefaultMsgSize)
if nsid {
opt.SetNsid("")
}
m.Extra = make([]dns.RR, 1)
m.Extra[0] = opt
}
m.Question[0] = dns.Question{qname, qtype, qclass}
m.Id = dns.Id()
return d, m
}
func reply(c *dns.Conn, i *dns.Msg) {
out, err := doFunkensturm(i)
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s\n", err.String())
return
}
if out != nil {
c.Write(out)
}
}
func handleNotifyOut(addr string) {
if Zone.name == "" || !Zone.correct {
return
}
d := new(dns.Conn)
d.RemoteAddr = addr
m := new(dns.Msg)
m.SetNotify(Zone.name)
fmt.Printf("Sending notifies: zone is ok\n")
dns.QueryRequest <- &dns.Query{Conn: d, Query: m}
}
func handleXfrIn(i *dns.Msg) os.Error {
q := new(dns.Msg)
q.SetAxfr(i.Question[0].Name)
m := make(chan *dns.Xfr)
fmt.Printf("Preparing Xfr for %s\n", i.Question[0].Name)
d := new(dns.Conn)
d.RemoteAddr = "127.0.0.1:53"
err := d.Dial("tcp")
if err != nil {
return err
}
defer d.Close()
fmt.Printf("Calling 127.0.0.1 successful\n")
go d.XfrRead(q, m)
Zone.name = i.Question[0].Name
j := 0
for x := range m {
Zone.rrs[j] = x.RR
j++
}
fmt.Printf("Success retrieved %s\n", Zone.name)
Zone.size = j
return nil
}
func handleNotify(d *dns.Conn, i *dns.Msg) os.Error {
if i.IsNotify() {
fmt.Printf("Incoming notify seen\n")
q := new(dns.Msg)
q.SetReply(i)
err := d.WriteMsg(q)
if err != nil {
return err
}
err = handleXfrIn(i)
if err != nil {
return err
}
}
return nil
}
func main() {
var sserver *string = flag.String("sserver", "127.0.0.1:8053", "Set the listener address")
var rserver *string = flag.String("rserver", "127.0.0.1:53", "Remote server address(es), seperate with commas")
verbose = flag.Bool("verbose", false, "Print packet as it flows through") // verbose needs to be global
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "Usage: %s\n", os.Args[0])
flag.PrintDefaults()
}
flag.Parse()
resolvers := strings.Split(*rserver, ",", -1)
qr = make([]*dns.Resolver, len(resolvers))
for i, ra := range resolvers {
d := new(dns.Conn)
d.RemoteAddr = addr
qr[i] = d
}
f = funkensturm()
ok := f.Setup()
if !ok {
fmt.Fprintf(os.Stderr, "Setup failed")
return
}
err := make(chan os.Error)
go udp(*sserver, err)
go tcp(*sserver, err)
forever:
for {
select {
case e := <-err:
fmt.Printf("Error received, stopping: %s\n", e.String())
break forever
case <-signal.Incoming:
fmt.Printf("Signal received, stopping")
break forever
}
}
close(err)
}
func handleXfrOut(d *dns.Conn, i *dns.Msg) os.Error {
if i.IsAxfr() {
fmt.Printf("Incoming Axfr request seen\n")
if i.Question[0].Name == Zone.name {
fmt.Printf("Matches current zone\n")
if !Zone.correct {
fmt.Printf("Zone was not deemed correct\n")
if err := d.WriteMsg(i); err != nil {
return err
}
return nil
} else {
fmt.Printf("Zone was correct\n")
}
m := make(chan *dns.Xfr)
e := make(chan os.Error)
go d.XfrWrite(i, m, e)
for j := 0; j < Zone.size; j++ {
select {
case m <- &dns.Xfr{Add: true, RR: Zone.rrs[j]}: //
case err := <-e:
return err
}
}
close(m)
} else {
fmt.Printf("No matching zone found\n")
if err := d.WriteMsg(i); err != nil {
return err
}
}
}
return nil
}
func main() {
if len(os.Args) != 2 {
fmt.Printf("%s DOMAIN\n", os.Args[0])
os.Exit(1)
}
d := new(dns.Conn)
c, err := dns.ClientConfigFromFile("/etc/resolv.conf")
// Errorchecking
d.RemoteAddr = c.Servers[0]
m := new(dns.Msg)
m.Id = dns.Id()
m.MsgHdr.RecursionDesired = true
m.Question = make([]dns.Question, 1)
m.Question[0] = dns.Question{os.Args[1], dns.TypeMX, dns.ClassINET}
err = d.Dial("udp")
if err != nil {
fmt.Printf("*** error: %s\n", err.String())
os.Exit(1)
}
in, err := dns.SimpleQuery("udp", d, m)
if in != nil {
if in.Rcode != dns.RcodeSuccess {
fmt.Printf(" *** invalid answer name %s after MX query for %s\n", os.Args[1], os.Args[1])
os.Exit(1)
}
// Stuff must be in the answer section
for _, a := range in.Answer {
fmt.Printf("%v\n", a)
}
} else {
fmt.Printf("*** error: %s\n", err.String())
}
}
// reply checking 'n stuff
func qhandle(d *dns.Conn, i *dns.Msg) {
o, err := d.ExchangeMsg(i, false)
dns.QueryReply <- &dns.Query{Query: i, Reply: o, Conn: d, Err: err}
d.Close()
}