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() {
	var serial *int = flag.Int("serial", 0, "Perform an IXFR with the given serial")
	var nameserver *string = flag.String("ns", "127.0.0.1:53", "Query this nameserver")
	//	var secret *string = flag.String("secret", "", "Use this secret for TSIG")
	flag.Parse()
	zone := flag.Arg(flag.NArg() - 1)

	client := dns.NewClient()
	client.Net = "tcp"
	m := new(dns.Msg)
	if *serial > 0 {
		m.SetIxfr(zone, uint32(*serial))
	} else {
		m.SetAxfr(zone)
	}
	if err := client.XfrReceive(m, *nameserver); err == nil {
		for r := range client.ReplyChan {
			if r.Error != nil {
				if r.Error == dns.ErrXfrLast {
					fmt.Printf("%v\n", r.Reply)
				}
				break
			}
			fmt.Printf("%v\n", r.Reply)
		}
	} else {
		fmt.Printf("Error %v\n", err)
	}
}

func main() {
	if len(os.Args) != 2 {
		fmt.Printf("%s DOMAIN\n", os.Args[0])
		os.Exit(1)
	}

	// Error checking
	config, _ := dns.ClientConfigFromFile("/etc/resolv.conf")
	c := dns.NewClient()

	m := new(dns.Msg)
	m.SetQuestion(os.Args[1], dns.TypeMX)
	m.MsgHdr.RecursionDesired = true

	// Simple sync query, nothing fancy
	r := c.Exchange(m, config.Servers[0])

	if r == nil {
		os.Exit(1)
	}

	if r.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 r.Answer {
		fmt.Printf("%v\n", a)
	}
}

func main() {
	if len(os.Args) != 2 {
		fmt.Printf("%s NAMESERVER\n", os.Args[0])
		os.Exit(1)
	}
	conf, _ := dns.ClientConfigFromFile("/etc/resolv.conf")

	m := new(dns.Msg)
	m.Question = make([]dns.Question, 1)
	c := dns.NewClient()

	addr := addresses(conf, c, os.Args[1])
	if len(addr) == 0 {
		fmt.Printf("No address found for %s\n", os.Args[1])
		os.Exit(1)
	}
	for _, a := range addr {
		m.Question[0] = dns.Question{"version.bind.", dns.TypeTXT, dns.ClassCHAOS}
		in := c.Exchange(m, a)
		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 = c.Exchange(m, a)
		if in != nil && in.Answer != nil {
			fmt.Printf("%v\n", in.Answer[0])
		}
	}
}

func main() {
	conf, 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.SetQuestion(dns.Fqdn(os.Args[1]), dns.TypeDNSKEY)
	m.SetEdns0(2048, true)

	c := new(dns.Client)
	r, _ := c.Exchange(m, conf.Servers[0]+":"+conf.Port)
	if r == nil {
		fmt.Printf("*** no answer received for %s\n", os.Args[1])
		os.Exit(1)
	}

	if r.Rcode != dns.RcodeSuccess {
		fmt.Printf(" *** invalid answer name %s after DNSKEY query for %s\n", os.Args[1], os.Args[1])
		os.Exit(1)
	}
	for _, k := range r.Answer {
		if key, ok := k.(*dns.RR_DNSKEY); ok {
			key.Hdr.Ttl = 0
			for _, alg := range []int{dns.SHA1, dns.SHA256, dns.SHA384} {
				ds := key.ToDS(alg)
				fmt.Printf("%v; %d\n", ds, key.Flags)
			}
		}
	}
}

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 addresses(d *dns.Conn, name string) []string {
	m := new(dns.Msg)
	m.MsgHdr.RecursionDesired = true //only set this bit
	m.Question = make([]dns.Question, 1)
	var ips []string

	m.Question[0] = dns.Question{os.Args[1], dns.TypeA, dns.ClassINET}
	in, err := dns.SimpleQuery("udp", d, m)
	if in == nil {
		fmt.Printf("Nothing recevied: %s\n", err.String())
		return nil
	}

	if in.Rcode != dns.RcodeSuccess {
		return nil
	}
	// Stuff must be in the answer section
	for _, a := range in.Answer {
		ips = append(ips, a.(*dns.RR_A).A.String()+":53")
	}
	m.Question[0] = dns.Question{os.Args[1], dns.TypeAAAA, dns.ClassINET}
	in, err = dns.SimpleQuery("udp", d, m)
	if in == nil {
		fmt.Printf("Nothing recevied: %s\n", err.String())
		return ips
	}

	if in.Rcode != dns.RcodeSuccess {
		return ips
	}
	for _, a := range in.Answer {
		ips = append(ips, "["+a.(*dns.RR_AAAA).AAAA.String()+"]:53")
	}
	return ips
}

// Create a dns message from a fingerprint string and
// a DNS question. The order of a string is always the same.
// .,IN,NS,QUERY,NOERROR,qr,aa,tc,RD,ad,ad,z,1,0,0,1,DO,4096,nsid
func (f *fingerprint) msg() *dns.Msg {
	m := new(dns.Msg)
	m.MsgHdr.Id = dns.Id()
	m.Question = make([]dns.Question, 1)
	m.Question[0] = dns.Question{f.Query.Name, f.Query.Qtype, f.Query.Qclass}
	m.MsgHdr.Opcode = f.Opcode
	m.MsgHdr.Rcode = f.Rcode
	m.MsgHdr.Response = f.Response
	m.MsgHdr.Authoritative = f.Authoritative
	m.MsgHdr.Truncated = f.Truncated
	m.MsgHdr.RecursionDesired = f.RecursionDesired
	m.MsgHdr.AuthenticatedData = f.AuthenticatedData
	m.MsgHdr.CheckingDisabled = f.CheckingDisabled
	m.MsgHdr.Zero = f.Zero

	if f.Do {
		// Add an OPT section.
		m.SetEdns0(0, true)
		// We have added an OPT RR, set the size.
		m.Extra[0].(*dns.RR_OPT).SetUDPSize(uint16(f.UDPSize))
		if f.Nsid {
			m.Extra[0].(*dns.RR_OPT).SetNsid("")
		}
	}
	return m
}

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
}

// Check if we have nsec3 records and if so, check them
func nsecCheck(in *dns.Msg) {
	for _, r := range in.Answer {
		if r.Header().Rrtype == dns.TypeNSEC3 {
			goto Check
		}
	}
	for _, r := range in.Ns {
		if r.Header().Rrtype == dns.TypeNSEC3 {
			goto Check
		}
	}
	for _, r := range in.Extra {
		if r.Header().Rrtype == dns.TypeNSEC3 {
			goto Check
		}
	}
	return
Check:
	w, err := in.Nsec3Verify(in.Question[0])
	switch w {
	case dns.NSEC3_NXDOMAIN:
		fmt.Printf(";+ [beta] Correct denial of existence (NSEC3/NXDOMAIN)\n")
	case dns.NSEC3_NODATA:
		fmt.Printf(";+ [beta] Correct denial of existence (NSEC3/NODATA)\n")
	default:
		// w == 0
		if err != nil {
			fmt.Printf(";- [beta] Incorrect denial of existence (NSEC3): %s\n", err.Error())
		}
	}
}

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 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 send(m *dns.Msg) (o []byte) {
	var p *dns.Msg
	for _, c := range qr {
		p, _ = c.Client.Exchange(m, c.Addr)
	}
	o, _ = p.Pack()
	return
}

// For now, we only answer queries for A and NS
func respondWithDotBit(msg *dns.Msg, question dns.Question) {
	// "foo.bar.bit." => ["foo", "bar", "bit"]
	nameParts := strings.Split(question.Name, ".", -1)
	var name []string
	for _, part := range nameParts {
		if part != "" {
			name = append(name, part)
		}
	}

	// edge case, if we get "bit." as question.Name
	// TODO: handle as proper error
	if len(name) <= 1 {
		return
	}
	// ["foo", "bar", "bit"] => ["foo", "bar"]
	name = name[0 : len(name)-1]

	// look up the root "d/bar"
	record, err := nmcLookup(name[len(name)-1])

	if err != nil {
		LOG.Fatalln(err)
	}

	var value NMCValue
	json.Unmarshal([]uint8(record.Value), &value)

	msg.Response = true

	switch question.Qtype {
	case dns.TypeA:
		answerA(msg, question, name, value)
	case dns.TypeAAAA:
		answerAAAA(msg, question, name, value)
		//case dns.TypeNS:    answerNS(msg)
		//case dns.TypeMD:    answerMD(msg)
		//case dns.TypeMF:    answerMF(msg)
		//case dns.TypeCNAME: answerCNAME(msg)
		//case dns.TypeSOA:   answerSOA(msg)
		//case dns.TypeMB:    answerMB(msg)
		//case dns.TypeMG:    answerMG(msg)
		//case dns.TypeMR:    answerMR(msg)
		//case dns.TypeNULL:  answerNULL(msg)
		//case dns.TypeWKS:   answerWKS(msg)
		//case dns.TypePTR:   answerPTR(msg)
		//case dns.TypeHINFO: answerHINFO(msg)
		//case dns.TypeMINFO: answerMINFO(msg)
		//case dns.TypeMX:    answerMX(msg)
		//case dns.TypeTXT:   answerTXT(msg)
		//case dns.TypeSRV:   answerSRV(msg)
	default:
		LOG.Fatalln("Cannot serve name:", name, "qtype:", question.Qtype)
		msg.Rcode = dns.RcodeNotImplemented
	}
}

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}
}

// Add an entry from the cache. The old entry (if any) gets
// overwritten
func (c Cache) add(q *dns.Msg) {
	qname := q.Question[0].Name
	i := intval(q.Question[0].Qclass, q.Question[0].Qtype)
	if c[qname] == nil {
		im := make(map[int][]byte)
		c[qname] = im
	}
	buf, _ := q.Pack()
	im := c[qname]
	im[i] = buf
}

// Add an entry to the cache. The old entry (if any) gets overwritten
func (c Cache) add(q *dns.Msg) {
	c.rw.Lock()
	defer c.rw.Unlock()
	qname := q.Question[0].Name
	i := intval(q.Question[0].Qclass, q.Question[0].Qtype)
	if c.data[qname] == nil {
		im := make(map[int]*item)
		c.data[qname] = im
	}
	buf, _ := q.Pack()
	im := c.data[qname]
	im[i] = &item{time.Seconds(), buf}
}

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 respondTo(conn *net.UDPConn, addr *net.UDPAddr, msg *dns.Msg, raw []uint8) {
	for _, question := range msg.Question {
		if strings.HasSuffix(question.Name, ".bit.") {
			respondWithDotBit(msg, question)
		} else {
			respondWithFallback(raw, msg, question, options.dnsProxy)
		}
	}

	out, ok := msg.Pack()
	if ok == true {
		conn.WriteToUDP(out, addr)
	} else {
		LOG.Fatalln("msg.Pack() failed")
	}
}

func delay(m *dns.Msg) (buf []byte) {
	var (
		ok1 bool
		o   *dns.Msg
	)
	if previous, ok1 = checkDelay(); !ok1 {
		println("Dropping: too often")
		time.Sleep(NSECDELAY)
		return
	}
	println("Ok: let it through")
	for _, c := range qr {
		o, _ = c.Client.Exchange(m, c.Addr)
	}
	buf, _ = o.Pack()
	return
}