Golang Msg.Answer方法代碼示例

func handleQueryCHAOS(w dns.ResponseWriter, req *dns.Msg) {
	m := new(dns.Msg)
	qname := strings.ToLower(req.Question[0].Name)
	qtype := req.Question[0].Qtype
	qclass := req.Question[0].Qclass

	m.Extra = make([]dns.RR, 1)
	m.Extra[0] = spamCH

	if qclass != dns.ClassCHAOS {
		m.SetRcode(req, dns.RcodeServerFailure)
		send(w, m)
		return
	}

	if (qname == "version.bind." || qname == "id.server.") && qtype == dns.TypeTXT {
		m.SetReply(req)
		m.Answer = make([]dns.RR, 1)
		m.Answer[0] = &dns.RR_TXT{Hdr: dns.RR_Header{Name: qname,
			Rrtype: qtype, Class: qclass}, Txt: "NS 0.0.1"}
		send(w, m)
		return
	}
	if (qname == "authors.bind." || qname == "authors.server.") && qtype == dns.TypeTXT {
		m.SetReply(req)
		m.Answer = make([]dns.RR, 1)
		m.Answer[0] = &dns.RR_TXT{Hdr: dns.RR_Header{Name: qname,
			Rrtype: qtype, Class: qclass}, Txt: "Miek Gieben"}
		send(w, m)
		return
	}
	m.SetRcode(req, dns.RcodeServerFailure)
	send(w, m)
	return
}

func handleReflect(w dns.ResponseWriter, r *dns.Msg) {
	var (
		v4  bool
		rr  dns.RR
		str string
		a   net.IP
	)
	// TC must be done here
	m := new(dns.Msg)
	m.SetReply(r)
	m.Compress = *compress
	if ip, ok := w.RemoteAddr().(*net.UDPAddr); ok {
		str = "Port: " + strconv.Itoa(ip.Port) + " (udp)"
		a = ip.IP
		v4 = a.To4() != nil
	}
	if ip, ok := w.RemoteAddr().(*net.TCPAddr); ok {
		str = "Port: " + strconv.Itoa(ip.Port) + " (tcp)"
		a = ip.IP
		v4 = a.To4() != nil
	}

	if v4 {
		rr = new(dns.RR_A)
		rr.(*dns.RR_A).Hdr = dns.RR_Header{Name: dom, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 0}
		rr.(*dns.RR_A).A = a.To4()
	} else {
		rr = new(dns.RR_AAAA)
		rr.(*dns.RR_AAAA).Hdr = dns.RR_Header{Name: dom, Rrtype: dns.TypeAAAA, Class: dns.ClassINET, Ttl: 0}
		rr.(*dns.RR_AAAA).AAAA = a
	}

	t := new(dns.RR_TXT)
	t.Hdr = dns.RR_Header{Name: dom, Rrtype: dns.TypeTXT, Class: dns.ClassINET, Ttl: 0}
	t.Txt = []string{str}

	switch r.Question[0].Qtype {
	case dns.TypeTXT:
		m.Answer = append(m.Answer, t)
		m.Extra = append(m.Extra, rr)
	default:
		fallthrough
	case dns.TypeAAAA, dns.TypeA:
		m.Answer = append(m.Answer, rr)
		m.Extra = append(m.Extra, t)
	}

	if r.IsTsig() {
		if w.TsigStatus() == nil {
			m.SetTsig(r.Extra[len(r.Extra)-1].(*dns.RR_TSIG).Hdr.Name, dns.HmacMD5, 300, r.MsgHdr.Id, time.Now().Unix())
		} else {
			println("Status", w.TsigStatus().Error())
		}
	}
	if *printf {
		fmt.Printf("%v\n", m.String())
	}
	w.Write(m)
}

func handleQuery(w dns.ResponseWriter, req *dns.Msg) {
	var dnssec bool
	m := new(dns.Msg)
	if req.Question[0].Qclass != dns.ClassINET {
		m.SetRcode(req, dns.RcodeServerFailure)
		send(w, m)
		return
	}
	m.SetReply(req)
	m.Ns = ns
	m.Extra = make([]dns.RR, 1)
	m.Extra[0] = spamIN

	// Check DNSSEC OK
	for _, v := range req.Extra {
		if o, ok := v.(*dns.RR_OPT); ok {
			if dnssec = o.Do(); dnssec {
				m.Extra = append(m.Extra, o)
				m.Ns = nsDNSSEC
				break
			}
		}
	}

	//m.Answer = make([]dns.RR, 0)
	s, _ := zone.LookupQuestion(req.Question[0])
	if s == nil {
		// Authority section should only contain the SOA record for NXDOMAIN
		m.Ns = m.Ns[:1]
		m.Ns[0] = soa
		m.MsgHdr.Rcode = dns.RcodeNameError
		send(w, m)
		// Lookup the previous name in the Nxt list for this zone
		// and insert the nsec/nsec3 from that. Also give the nsec
		// that proofs there is no wildcard
		return
	}

	// TODO CNAME
	//cname:
	switch req.Question[0].Qtype {
	case dns.TypeRRSIG:
		m.Answer = s.RRsigs
	case dns.TypeNSEC, dns.TypeNSEC3:
		m.Answer = []dns.RR{s.Nxt}
	default:
		m.Answer = s.RRs
	}
	if dnssec && req.Question[0].Qtype != dns.TypeRRSIG && len(s.RRsigs) > 0 {
		for _, r := range s.RRsigs {
			m.Answer = append(m.Answer, r)
		}
	}
	if *debug {
		println(m.Question[0].String())
	}
	send(w, m)
}

func respondWithFallback(raw []uint8, clientMsg *dns.Msg, clientQuestion dns.Question, proxy *net.UDPAddr) {
	LOG.Println("fallback:", clientQuestion, proxy)
	conn, err := net.Dial("udp", proxy.String())
	if err != nil {
		LOG.Fatalln(err)
	}

	conn.Write(raw)

	buffer := make([]byte, 1<<15)
	size, err := conn.Read(buffer)
	if err != nil {
		LOG.Fatalln(err, proxy)
	}

	msg := &dns.Msg{}
	msg.Unpack(buffer[0:size])

	LOG.Println(msg)

	for _, answer := range msg.Answer {
		clientMsg.Answer = append(clientMsg.Answer, answer)
	}

	clientMsg.Rcode = msg.Rcode
	clientMsg.Response = msg.Response
	clientMsg.Authoritative = msg.Authoritative
	clientMsg.Recursion_desired = msg.Recursion_desired
	clientMsg.Recursion_available = msg.Recursion_available
}

func handleReflect(w dns.ResponseWriter, r *dns.Msg) {
	m := new(dns.Msg)
	m.SetReply(r)
	m.Extra = make([]dns.RR, 1)
	m.Answer = make([]dns.RR, 1)
	var (
		v4  bool
		rr  dns.RR
		str string
		a   net.IP
	)

	if ip, ok := w.RemoteAddr().(*net.UDPAddr); ok {
		str = "Port: " + strconv.Itoa(ip.Port) + " (udp)"
		a = ip.IP
		v4 = a.To4() != nil
	}
	if ip, ok := w.RemoteAddr().(*net.TCPAddr); ok {
		str = "Port: " + strconv.Itoa(ip.Port) + " (tcp)"
		a = ip.IP
		v4 = a.To4() != nil
	}

	if v4 {
		rr = new(dns.RR_A)
		rr.(*dns.RR_A).Hdr = dns.RR_Header{Name: dom, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 0}
		rr.(*dns.RR_A).A = a
	} else {
		rr = new(dns.RR_AAAA)
		rr.(*dns.RR_AAAA).Hdr = dns.RR_Header{Name: dom, Rrtype: dns.TypeAAAA, Class: dns.ClassINET, Ttl: 0}
		rr.(*dns.RR_AAAA).AAAA = a
	}

	t := new(dns.RR_TXT)
	t.Hdr = dns.RR_Header{Name: dom, Rrtype: dns.TypeTXT, Class: dns.ClassINET, Ttl: 0}
	t.Txt = str
	m.Extra[0] = t
	m.Answer[0] = rr

	b, ok := m.Pack()
	if !ok {
		return
	}
	w.Write(b)
}

func reply(c *dns.Conn, in *dns.Msg) []byte {
	m := new(dns.Msg)
	m.SetReply(in)

	m.Question = make([]dns.Question, 1)
	m.Answer = make([]dns.RR, 1)
	m.Extra = make([]dns.RR, 1)

	// Copy the question.
	m.Question[0] = in.Question[0]

	// Some foo to check if we are called through ip6 or ip4.
	// We add the correct reply RR.
	var ad net.IP
	if c.UDP != nil {
		ad = c.Addr.(*net.UDPAddr).IP
	} else {
		ad = c.Addr.(*net.TCPAddr).IP
	}

	if ad.To4() != nil {
		r := new(dns.RR_A)
		r.Hdr = dns.RR_Header{Name: "whoami.miek.nl.", Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 0}
		r.A = ad
		m.Answer[0] = r
	} else {
		r := new(dns.RR_AAAA)
		r.Hdr = dns.RR_Header{Name: "whoami.miek.nl.", Rrtype: dns.TypeAAAA, Class: dns.ClassINET, Ttl: 0}
		r.AAAA = ad
		m.Answer[0] = r
	}

	t := new(dns.RR_TXT)
	t.Hdr = dns.RR_Header{Name: "whoami.miek.nl.", Rrtype: dns.TypeTXT, Class: dns.ClassINET, Ttl: 0}
	if c.TCP != nil {
		t.Txt = "Port: " + strconv.Itoa(c.Port) + " (tcp)"
	} else {
		t.Txt = "Port: " + strconv.Itoa(c.Port) + " (udp)"
	}
	m.Extra[0] = t

	b, _ := m.Pack()
	return b
}

func answerAAAA(msg *dns.Msg, question dns.Question, name []string, value NMCValue) {
	var parsedIp net.IP
	// len == 1 means root domain: check "ip" and "map".""
	if len(name) == 1 {
		vips := value.Ip6

		if len(vips) == 0 {
			// can't answer, make an error here.
			return
		} else {
			parsedIp = net.ParseIP(vips[0])
		}
	}

	ip := parsedIp.To16()
	if ip == nil {
		return
	}

	LOG.Println("AAAA", name, "=>", ip)

	rraaaa := &dns.RR_AAAA{}
	copy(ip, rraaaa.AAAA[:])

	rrh := &dns.RR_Header{
		Name:     question.Name,
		Rrtype:   dns.TypeAAAA,
		Class:    dns.ClassINET,
		Ttl:      60,
		Rdlength: 100,
	}
	rraaaa.Hdr = *rrh

	msg.Rcode = dns.RcodeSuccess
	msg.Answer = append(msg.Answer, rraaaa)
	msg.Response = true
	msg.Authoritative = true
	msg.Recursion_desired = true
	msg.Recursion_available = true
}

func sign(m *dns.Msg) *dns.Msg {
	sg := new(dns.RR_RRSIG)
	sg.Hdr = dns.RR_Header{"www.example.org.", dns.TypeRRSIG, dns.ClassINET, 14400, 0}
	sg.Expiration = 1296534305  // date -u '+%s' -d"2011-02-01 04:25:05"
	sg.Inception = 1293942305   // date -u '+%s' -d"2011-01-02 04:25:05"
	sg.KeyTag = pubkey.KeyTag() // Get the keyfrom the Key
	sg.SignerName = pubkey.Hdr.Name
	sg.Algorithm = dns.AlgRSASHA256

	if len(m.Answer) > 0 {
		// sign the first record
		an := m.Answer[0]
		sg.TypeCovered = an.Header().Rrtype
		sg.Labels = dns.LabelCount(an.Header().Name)
		sg.OrigTtl = an.Header().Ttl
		switch p := privkey.(type) {
		case *rsa.PrivateKey:
			sg.Sign(p, []dns.RR{an})
		}
	}
	m.Answer = append(m.Answer, sg)
	return m
}

func handleReflect(w dns.ResponseWriter, r *dns.Msg) {
	var (
		v4  bool
		rr  dns.RR
		str string
		a   net.IP
	)
	m := new(dns.Msg)
	m.SetReply(r)
	if ip, ok := w.RemoteAddr().(*net.UDPAddr); ok {
		str = "Port: " + strconv.Itoa(ip.Port) + " (udp)"
		a = ip.IP
		v4 = a.To4() != nil
	}
	if ip, ok := w.RemoteAddr().(*net.TCPAddr); ok {
		str = "Port: " + strconv.Itoa(ip.Port) + " (tcp)"
		a = ip.IP
		v4 = a.To4() != nil
	}

	if v4 {
		rr = new(dns.RR_A)
		rr.(*dns.RR_A).Hdr = dns.RR_Header{Name: dom, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 0}
		rr.(*dns.RR_A).A = a.To4()
	} else {
		rr = new(dns.RR_AAAA)
		rr.(*dns.RR_AAAA).Hdr = dns.RR_Header{Name: dom, Rrtype: dns.TypeAAAA, Class: dns.ClassINET, Ttl: 0}
		rr.(*dns.RR_AAAA).AAAA = a
	}

	t := new(dns.RR_TXT)
	t.Hdr = dns.RR_Header{Name: dom, Rrtype: dns.TypeTXT, Class: dns.ClassINET, Ttl: 0}
	t.Txt = str

	switch r.Question[0].Qtype {
	case dns.TypeTXT:
		m.Answer = append(m.Answer, t)
		m.Extra = append(m.Extra, rr)
	default:
		fallthrough
	case dns.TypeAAAA, dns.TypeA:
		m.Answer = append(m.Answer, rr)
		m.Extra = append(m.Extra, t)

	}
	/*
	   nsec3 := new(dns.RR_NSEC3)
	   nsec3.Hdr = dns.RR_Header{Name: dom, Rrtype: dns.TypeNSEC3, Class: dns.ClassINET, Ttl: 0}
	   nsec3.Hash = dns.SHA1
	   nsec3.Flags = 0
	   nsec3.Iterations = 1
	   nsec3.Salt = "AABB"
	   nsec3.SaltLength = uint8(len(nsec3.Salt)/2)
	   nsec3.NextDomain = "miek.nl."
	   nsec3.TypeBitMap = []uint16{dns.TypeA, dns.TypeNS, dns.TypeSOA, dns.TypeTXT, dns.TypeRRSIG, 4000, 4001, 5949}
	   nsec3.HashNames("miek.nl.")
	   m.Extra = append(m.Extra, nsec3)
	*/

	b, ok := m.Pack()
	if *printf {
		fmt.Printf("%v\n", m.String())
	}
	if !ok {
		log.Print("Packing failed")
		m.SetRcode(r, dns.RcodeServerFailure)
		m.Extra = nil
		m.Answer = nil
		b, _ = m.Pack()
	}
	w.Write(b)
}

func answerA(msg *dns.Msg, question dns.Question, name []string, value NMCValue) {
	var parsedIp net.IP
	// len == 1 means root domain: check "ip" and "map".""
	if len(name) == 1 {
		vips := value.Ip

		// this is legacy support
		if len(vips) == 0 {
			vmap := value.Map
			if vmap == nil {
				return
			}

			vmip, ok := value.Map[""]
			if !ok && vmip == "" {
				// can't answer, make an error here.
				return
			}

			switch vmip.(type) {
			case nil:
				return
			case map[string]interface{}:
				nsAvailable := vmip.(map[string]interface{})["ns"]

				switch nsAvailable.(type) {
				case []interface{}:
					ns := nsAvailable.([]interface{})[0]

					switch ns.(type) {
					case string:
						h := dns.MsgHdr{
							Id:                uint16(rand.Int()) ^ uint16(time.Nanoseconds()),
							Recursion_desired: true,
						}

						q := &dns.Question{
							Name:   question.Name,
							Qtype:  dns.TypeA,
							Qclass: dns.ClassINET,
						}

						m := &dns.Msg{}
						m.MsgHdr = h
						m.Question = append(m.Question, *q)

						LOG.Println(m)

						out, ok := m.Pack()
						if !ok {
							LOG.Fatalln("Failed to Pack:", msg)
						}

						nsaddr := ns.(string) + ":53"
						conn, err := net.Dial("udp", nsaddr)
						if err != nil {
							LOG.Fatalf("net.DialUDP(\"udp\", nil, %v) => %v", nsaddr, err)
						}
						LOG.Println("out:", out)

						n, err := conn.Write(out)
						if err != nil {
							LOG.Fatalln(err)
						}
						LOG.Println("wrote:", n)

						conn.SetReadTimeout(10e9)
						defer conn.Close()

						b := make([]byte, 1<<15)
						s, err := conn.Read(b)
						if err != nil {
							LOG.Fatalln(err, nsaddr)
						}

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

						a := &dns.Msg{}
						a.Unpack(b[0:s])

						LOG.Println("a:", a)

						msg.Answer = append(msg.Answer, a.Answer[0])
						return
					default:
						LOG.Printf("can't find the type of: %#v", ns)
					}
				default:
					LOG.Printf("can't find the type of: %#v", nsAvailable)
				}
			case string:
				parsedIp = net.ParseIP(vmip.(string))
			default:
				LOG.Printf("can't find the type of: %#v", vmip)
			}

		} else {
//.........這裏部分代碼省略.........