src/net/dnsmsg.go - go - Git at Google

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 // DNS packet assembly. See RFC 1035.
 //
 // This is intended to support name resolution during Dial.
 // It doesn't have to be blazing fast.
 //
 // Each message structure has a Walk method that is used by
 // a generic pack/unpack routine. Thus, if in the future we need
 // to define new message structs, no new pack/unpack/printing code
 // needs to be written.
 //
 // The first half of this file defines the DNS message formats.
 // The second half implements the conversion to and from wire format.
 // A few of the structure elements have string tags to aid the
 // generic pack/unpack routines.
 //
 // TODO(rsc):  There are enough names defined in this file that they're all
 // prefixed with dns. Perhaps put this in its own package later.

 package net

 // Packet formats

 // Wire constants.
 const (
 	// valid dnsRR_Header.Rrtype and dnsQuestion.qtype
 	dnsTypeA     = 1
 	dnsTypeNS    = 2
 	dnsTypeMD    = 3
 	dnsTypeMF    = 4
 	dnsTypeCNAME = 5
 	dnsTypeSOA   = 6
 	dnsTypeMB    = 7
 	dnsTypeMG    = 8
 	dnsTypeMR    = 9
 	dnsTypeNULL  = 10
 	dnsTypeWKS   = 11
 	dnsTypePTR   = 12
 	dnsTypeHINFO = 13
 	dnsTypeMINFO = 14
 	dnsTypeMX    = 15
 	dnsTypeTXT   = 16
 	dnsTypeAAAA  = 28
 	dnsTypeSRV   = 33

 	// valid dnsQuestion.qtype only
 	dnsTypeAXFR  = 252
 	dnsTypeMAILB = 253
 	dnsTypeMAILA = 254
 	dnsTypeALL   = 255

 	// valid dnsQuestion.qclass
 	dnsClassINET   = 1
 	dnsClassCSNET  = 2
 	dnsClassCHAOS  = 3
 	dnsClassHESIOD = 4
 	dnsClassANY    = 255

 	// dnsMsg.rcode
 	dnsRcodeSuccess        = 0
 	dnsRcodeFormatError    = 1
 	dnsRcodeServerFailure  = 2
 	dnsRcodeNameError      = 3
 	dnsRcodeNotImplemented = 4
 	dnsRcodeRefused        = 5
 )

 // A dnsStruct describes how to iterate over its fields to emulate
 // reflective marshalling.
 type dnsStruct interface {
 	// Walk iterates over fields of a structure and calls f
 	// with a reference to that field, the name of the field
 	// and a tag ("", "domain", "ipv4", "ipv6") specifying
 	// particular encodings. Possible concrete types
 	// for v are *uint16, *uint32, *string, or []byte, and
 	// *int, *bool in the case of dnsMsgHdr.
 	// Whenever f returns false, Walk must stop and return
 	// false, and otherwise return true.
 	Walk(f func(v interface{}, name, tag string) (ok bool)) (ok bool)
 }

 // The wire format for the DNS packet header.
 type dnsHeader struct {
 	Id                                 uint16
 	Bits                               uint16
 	Qdcount, Ancount, Nscount, Arcount uint16
 }

 func (h *dnsHeader) Walk(f func(v interface{}, name, tag string) bool) bool {
 	return f(&h.Id, "Id", "") &&
 		f(&h.Bits, "Bits", "") &&
 		f(&h.Qdcount, "Qdcount", "") &&
 		f(&h.Ancount, "Ancount", "") &&
 		f(&h.Nscount, "Nscount", "") &&
 		f(&h.Arcount, "Arcount", "")
 }

 const (
 	// dnsHeader.Bits
 	_QR = 1 << 15 // query/response (response=1)
 	_AA = 1 << 10 // authoritative
 	_TC = 1 << 9  // truncated
 	_RD = 1 << 8  // recursion desired
 	_RA = 1 << 7  // recursion available
 )

 // DNS queries.
 type dnsQuestion struct {
 	Name   string
 	Qtype  uint16
 	Qclass uint16
 }

 func (q *dnsQuestion) Walk(f func(v interface{}, name, tag string) bool) bool {
 	return f(&q.Name, "Name", "domain") &&
 		f(&q.Qtype, "Qtype", "") &&
 		f(&q.Qclass, "Qclass", "")
 }

 // DNS responses (resource records).
 // There are many types of messages,
 // but they all share the same header.
 type dnsRR_Header struct {
 	Name     string
 	Rrtype   uint16
 	Class    uint16
 	Ttl      uint32
 	Rdlength uint16 // length of data after header
 }

 func (h *dnsRR_Header) Header() *dnsRR_Header {
 	return h
 }

 func (h *dnsRR_Header) Walk(f func(v interface{}, name, tag string) bool) bool {
 	return f(&h.Name, "Name", "domain") &&
 		f(&h.Rrtype, "Rrtype", "") &&
 		f(&h.Class, "Class", "") &&
 		f(&h.Ttl, "Ttl", "") &&
 		f(&h.Rdlength, "Rdlength", "")
 }

 type dnsRR interface {
 	dnsStruct
 	Header() *dnsRR_Header
 }

 // Specific DNS RR formats for each query type.

 type dnsRR_CNAME struct {
 	Hdr   dnsRR_Header
 	Cname string
 }

 func (rr *dnsRR_CNAME) Header() *dnsRR_Header {
 	return &rr.Hdr
 }

 func (rr *dnsRR_CNAME) Walk(f func(v interface{}, name, tag string) bool) bool {
 	return rr.Hdr.Walk(f) && f(&rr.Cname, "Cname", "domain")
 }

 type dnsRR_MX struct {
 	Hdr  dnsRR_Header
 	Pref uint16
 	Mx   string
 }

 func (rr *dnsRR_MX) Header() *dnsRR_Header {
 	return &rr.Hdr
 }

 func (rr *dnsRR_MX) Walk(f func(v interface{}, name, tag string) bool) bool {
 	return rr.Hdr.Walk(f) && f(&rr.Pref, "Pref", "") && f(&rr.Mx, "Mx", "domain")
 }

 type dnsRR_NS struct {
 	Hdr dnsRR_Header
 	Ns  string
 }

 func (rr *dnsRR_NS) Header() *dnsRR_Header {
 	return &rr.Hdr
 }

 func (rr *dnsRR_NS) Walk(f func(v interface{}, name, tag string) bool) bool {
 	return rr.Hdr.Walk(f) && f(&rr.Ns, "Ns", "domain")
 }

 type dnsRR_PTR struct {
 	Hdr dnsRR_Header
 	Ptr string
 }

 func (rr *dnsRR_PTR) Header() *dnsRR_Header {
 	return &rr.Hdr
 }

 func (rr *dnsRR_PTR) Walk(f func(v interface{}, name, tag string) bool) bool {
 	return rr.Hdr.Walk(f) && f(&rr.Ptr, "Ptr", "domain")
 }

 type dnsRR_SOA struct {
 	Hdr     dnsRR_Header
 	Ns      string
 	Mbox    string
 	Serial  uint32
 	Refresh uint32
 	Retry   uint32
 	Expire  uint32
 	Minttl  uint32
 }

 func (rr *dnsRR_SOA) Header() *dnsRR_Header {
 	return &rr.Hdr
 }

 func (rr *dnsRR_SOA) Walk(f func(v interface{}, name, tag string) bool) bool {
 	return rr.Hdr.Walk(f) &&
 		f(&rr.Ns, "Ns", "domain") &&
 		f(&rr.Mbox, "Mbox", "domain") &&
 		f(&rr.Serial, "Serial", "") &&
 		f(&rr.Refresh, "Refresh", "") &&
 		f(&rr.Retry, "Retry", "") &&
 		f(&rr.Expire, "Expire", "") &&
 		f(&rr.Minttl, "Minttl", "")
 }

 type dnsRR_TXT struct {
 	Hdr dnsRR_Header
 	Txt string // not domain name
 }

 func (rr *dnsRR_TXT) Header() *dnsRR_Header {
 	return &rr.Hdr
 }

 func (rr *dnsRR_TXT) Walk(f func(v interface{}, name, tag string) bool) bool {
 	if !rr.Hdr.Walk(f) {
 		return false
 	}
 	var n uint16 = 0
 	for n < rr.Hdr.Rdlength {
 		var txt string
 		if !f(&txt, "Txt", "") {
 			return false
 		}
 		// more bytes than rr.Hdr.Rdlength said there would be
 		if rr.Hdr.Rdlength-n < uint16(len(txt))+1 {
 			return false
 		}
 		n += uint16(len(txt)) + 1
 		rr.Txt += txt
 	}
 	return true
 }

 type dnsRR_SRV struct {
 	Hdr      dnsRR_Header
 	Priority uint16
 	Weight   uint16
 	Port     uint16
 	Target   string
 }

 func (rr *dnsRR_SRV) Header() *dnsRR_Header {
 	return &rr.Hdr
 }

 func (rr *dnsRR_SRV) Walk(f func(v interface{}, name, tag string) bool) bool {
 	return rr.Hdr.Walk(f) &&
 		f(&rr.Priority, "Priority", "") &&
 		f(&rr.Weight, "Weight", "") &&
 		f(&rr.Port, "Port", "") &&
 		f(&rr.Target, "Target", "domain")
 }

 type dnsRR_A struct {
 	Hdr dnsRR_Header
 	A   uint32
 }

 func (rr *dnsRR_A) Header() *dnsRR_Header {
 	return &rr.Hdr
 }

 func (rr *dnsRR_A) Walk(f func(v interface{}, name, tag string) bool) bool {
 	return rr.Hdr.Walk(f) && f(&rr.A, "A", "ipv4")
 }

 type dnsRR_AAAA struct {
 	Hdr  dnsRR_Header
 	AAAA [16]byte
 }

 func (rr *dnsRR_AAAA) Header() *dnsRR_Header {
 	return &rr.Hdr
 }

 func (rr *dnsRR_AAAA) Walk(f func(v interface{}, name, tag string) bool) bool {
 	return rr.Hdr.Walk(f) && f(rr.AAAA[:], "AAAA", "ipv6")
 }

 // Packing and unpacking.
 //
 // All the packers and unpackers take a (msg []byte, off int)
 // and return (off1 int, ok bool).  If they return ok==false, they
 // also return off1==len(msg), so that the next unpacker will
 // also fail. This lets us avoid checks of ok until the end of a
 // packing sequence.

 // Map of constructors for each RR wire type.
 var rr_mk = map[int]func() dnsRR{
 	dnsTypeCNAME: func() dnsRR { return new(dnsRR_CNAME) },
 	dnsTypeMX:    func() dnsRR { return new(dnsRR_MX) },
 	dnsTypeNS:    func() dnsRR { return new(dnsRR_NS) },
 	dnsTypePTR:   func() dnsRR { return new(dnsRR_PTR) },
 	dnsTypeSOA:   func() dnsRR { return new(dnsRR_SOA) },
 	dnsTypeTXT:   func() dnsRR { return new(dnsRR_TXT) },
 	dnsTypeSRV:   func() dnsRR { return new(dnsRR_SRV) },
 	dnsTypeA:     func() dnsRR { return new(dnsRR_A) },
 	dnsTypeAAAA:  func() dnsRR { return new(dnsRR_AAAA) },
 }

 // Pack a domain name s into msg[off:].
 // Domain names are a sequence of counted strings
 // split at the dots. They end with a zero-length string.
 func packDomainName(s string, msg []byte, off int) (off1 int, ok bool) {
 	// Add trailing dot to canonicalize name.
 	if n := len(s); n == 0 || s[n-1] != '.' {
 		s += "."
 	}

 	// Allow root domain.
 	if s == "." {
 		msg[off] = 0
 		off++
 		return off, true
 	}

 	// Each dot ends a segment of the name.
 	// We trade each dot byte for a length byte.
 	// There is also a trailing zero.
 	// Check that we have all the space we need.
 	tot := len(s) + 1
 	if off+tot > len(msg) {
 		return len(msg), false
 	}

 	// Emit sequence of counted strings, chopping at dots.
 	begin := 0
 	for i := 0; i < len(s); i++ {
 		if s[i] == '.' {
 			if i-begin >= 1<<6 { // top two bits of length must be clear
 				return len(msg), false
 			}
 			if i-begin == 0 {
 				return len(msg), false
 			}

 			msg[off] = byte(i - begin)
 			off++

 			for j := begin; j < i; j++ {
 				msg[off] = s[j]
 				off++
 			}
 			begin = i + 1
 		}
 	}
 	msg[off] = 0
 	off++
 	return off, true
 }

 // Unpack a domain name.
 // In addition to the simple sequences of counted strings above,
 // domain names are allowed to refer to strings elsewhere in the
 // packet, to avoid repeating common suffixes when returning
 // many entries in a single domain. The pointers are marked
 // by a length byte with the top two bits set. Ignoring those
 // two bits, that byte and the next give a 14 bit offset from msg[0]
 // where we should pick up the trail.
 // Note that if we jump elsewhere in the packet,
 // we return off1 == the offset after the first pointer we found,
 // which is where the next record will start.
 // In theory, the pointers are only allowed to jump backward.
 // We let them jump anywhere and stop jumping after a while.
 func unpackDomainName(msg []byte, off int) (s string, off1 int, ok bool) {
 	s = ""
 	ptr := 0 // number of pointers followed
 Loop:
 	for {
 		if off >= len(msg) {
 			return "", len(msg), false
 		}
 		c := int(msg[off])
 		off++
 		switch c & 0xC0 {
 		case 0x00:
 			if c == 0x00 {
 				// end of name
 				break Loop
 			}
 			// literal string
 			if off+c > len(msg) {
 				return "", len(msg), false
 			}
 			s += string(msg[off:off+c]) + "."
 			off += c
 		case 0xC0:
 			// pointer to somewhere else in msg.
 			// remember location after first ptr,
 			// since that's how many bytes we consumed.
 			// also, don't follow too many pointers --
 			// maybe there's a loop.
 			if off >= len(msg) {
 				return "", len(msg), false
 			}
 			c1 := msg[off]
 			off++
 			if ptr == 0 {
 				off1 = off
 			}
 			if ptr++; ptr > 10 {
 				return "", len(msg), false
 			}
 			off = (c^0xC0)<<8 | int(c1)
 		default:
 			// 0x80 and 0x40 are reserved
 			return "", len(msg), false
 		}
 	}
 	if len(s) == 0 {
 		s = "."
 	}
 	if ptr == 0 {
 		off1 = off
 	}
 	return s, off1, true
 }

 // packStruct packs a structure into msg at specified offset off, and
 // returns off1 such that msg[off:off1] is the encoded data.
 func packStruct(any dnsStruct, msg []byte, off int) (off1 int, ok bool) {
 	ok = any.Walk(func(field interface{}, name, tag string) bool {
 		switch fv := field.(type) {
 		default:
 			println("net: dns: unknown packing type")
 			return false
 		case *uint16:
 			i := *fv
 			if off+2 > len(msg) {
 				return false
 			}
 			msg[off] = byte(i >> 8)
 			msg[off+1] = byte(i)
 			off += 2
 		case *uint32:
 			i := *fv
 			msg[off] = byte(i >> 24)
 			msg[off+1] = byte(i >> 16)
 			msg[off+2] = byte(i >> 8)
 			msg[off+3] = byte(i)
 			off += 4
 		case []byte:
 			n := len(fv)
 			if off+n > len(msg) {
 				return false
 			}
 			copy(msg[off:off+n], fv)
 			off += n
 		case *string:
 			s := *fv
 			switch tag {
 			default:
 				println("net: dns: unknown string tag", tag)
 				return false
 			case "domain":
 				off, ok = packDomainName(s, msg, off)
 				if !ok {
 					return false
 				}
 			case "":
 				// Counted string: 1 byte length.
 				if len(s) > 255 || off+1+len(s) > len(msg) {
 					return false
 				}
 				msg[off] = byte(len(s))
 				off++
 				off += copy(msg[off:], s)
 			}
 		}
 		return true
 	})
 	if !ok {
 		return len(msg), false
 	}
 	return off, true
 }

 // unpackStruct decodes msg[off:] into the given structure, and
 // returns off1 such that msg[off:off1] is the encoded data.
 func unpackStruct(any dnsStruct, msg []byte, off int) (off1 int, ok bool) {
 	ok = any.Walk(func(field interface{}, name, tag string) bool {
 		switch fv := field.(type) {
 		default:
 			println("net: dns: unknown packing type")
 			return false
 		case *uint16:
 			if off+2 > len(msg) {
 				return false
 			}
 			*fv = uint16(msg[off])<<8 | uint16(msg[off+1])
 			off += 2
 		case *uint32:
 			if off+4 > len(msg) {
 				return false
 			}
 			*fv = uint32(msg[off])<<24 | uint32(msg[off+1])<<16 |
 				uint32(msg[off+2])<<8 | uint32(msg[off+3])
 			off += 4
 		case []byte:
 			n := len(fv)
 			if off+n > len(msg) {
 				return false
 			}
 			copy(fv, msg[off:off+n])
 			off += n
 		case *string:
 			var s string
 			switch tag {
 			default:
 				println("net: dns: unknown string tag", tag)
 				return false
 			case "domain":
 				s, off, ok = unpackDomainName(msg, off)
 				if !ok {
 					return false
 				}
 			case "":
 				if off >= len(msg) || off+1+int(msg[off]) > len(msg) {
 					return false
 				}
 				n := int(msg[off])
 				off++
 				b := make([]byte, n)
 				for i := 0; i < n; i++ {
 					b[i] = msg[off+i]
 				}
 				off += n
 				s = string(b)
 			}
 			*fv = s
 		}
 		return true
 	})
 	if !ok {
 		return len(msg), false
 	}
 	return off, true
 }

 // Generic struct printer. Prints fields with tag "ipv4" or "ipv6"
 // as IP addresses.
 func printStruct(any dnsStruct) string {
 	s := "{"
 	i := 0
 	any.Walk(func(val interface{}, name, tag string) bool {
 		i++
 		if i > 1 {
 			s += ", "
 		}
 		s += name + "="
 		switch tag {
 		case "ipv4":
 			i := *val.(*uint32)
 			s += IPv4(byte(i>>24), byte(i>>16), byte(i>>8), byte(i)).String()
 		case "ipv6":
 			i := val.([]byte)
 			s += IP(i).String()
 		default:
 			var i int64
 			switch v := val.(type) {
 			default:
 				// can't really happen.
 				s += "<unknown type>"
 				return true
 			case *string:
 				s += *v
 				return true
 			case []byte:
 				s += string(v)
 				return true
 			case *bool:
 				if *v {
 					s += "true"
 				} else {
 					s += "false"
 				}
 				return true
 			case *int:
 				i = int64(*v)
 			case *uint:
 				i = int64(*v)
 			case *uint8:
 				i = int64(*v)
 			case *uint16:
 				i = int64(*v)
 			case *uint32:
 				i = int64(*v)
 			case *uint64:
 				i = int64(*v)
 			case *uintptr:
 				i = int64(*v)
 			}
 			s += itoa(int(i))
 		}
 		return true
 	})
 	s += "}"
 	return s
 }

 // Resource record packer.
 func packRR(rr dnsRR, msg []byte, off int) (off2 int, ok bool) {
 	var off1 int
 	// pack twice, once to find end of header
 	// and again to find end of packet.
 	// a bit inefficient but this doesn't need to be fast.
 	// off1 is end of header
 	// off2 is end of rr
 	off1, ok = packStruct(rr.Header(), msg, off)
 	if !ok {
 		return len(msg), false
 	}
 	off2, ok = packStruct(rr, msg, off)
 	if !ok {
 		return len(msg), false
 	}
 	// pack a third time; redo header with correct data length
 	rr.Header().Rdlength = uint16(off2 - off1)
 	packStruct(rr.Header(), msg, off)
 	return off2, true
 }

 // Resource record unpacker.
 func unpackRR(msg []byte, off int) (rr dnsRR, off1 int, ok bool) {
 	// unpack just the header, to find the rr type and length
 	var h dnsRR_Header
 	off0 := off
 	if off, ok = unpackStruct(&h, msg, off); !ok {
 		return nil, len(msg), false
 	}
 	end := off + int(h.Rdlength)

 	// make an rr of that type and re-unpack.
 	// again inefficient but doesn't need to be fast.
 	mk, known := rr_mk[int(h.Rrtype)]
 	if !known {
 		return &h, end, true
 	}
 	rr = mk()
 	off, ok = unpackStruct(rr, msg, off0)
 	if off != end {
 		return &h, end, true
 	}
 	return rr, off, ok
 }

 // Usable representation of a DNS packet.

 // A manually-unpacked version of (id, bits).
 // This is in its own struct for easy printing.
 type dnsMsgHdr struct {
 	id                  uint16
 	response            bool
 	opcode              int
 	authoritative       bool
 	truncated           bool
 	recursion_desired   bool
 	recursion_available bool
 	rcode               int
 }

 func (h *dnsMsgHdr) Walk(f func(v interface{}, name, tag string) bool) bool {
 	return f(&h.id, "id", "") &&
 		f(&h.response, "response", "") &&
 		f(&h.opcode, "opcode", "") &&
 		f(&h.authoritative, "authoritative", "") &&
 		f(&h.truncated, "truncated", "") &&
 		f(&h.recursion_desired, "recursion_desired", "") &&
 		f(&h.recursion_available, "recursion_available", "") &&
 		f(&h.rcode, "rcode", "")
 }

 type dnsMsg struct {
 	dnsMsgHdr
 	question []dnsQuestion
 	answer   []dnsRR
 	ns       []dnsRR
 	extra    []dnsRR
 }

 func (dns *dnsMsg) Pack() (msg []byte, ok bool) {
 	var dh dnsHeader

 	// Convert convenient dnsMsg into wire-like dnsHeader.
 	dh.Id = dns.id
 	dh.Bits = uint16(dns.opcode)<<11 | uint16(dns.rcode)
 	if dns.recursion_available {
 		dh.Bits |= _RA
 	}
 	if dns.recursion_desired {
 		dh.Bits |= _RD
 	}
 	if dns.truncated {
 		dh.Bits |= _TC
 	}
 	if dns.authoritative {
 		dh.Bits |= _AA
 	}
 	if dns.response {
 		dh.Bits |= _QR
 	}

 	// Prepare variable sized arrays.
 	question := dns.question
 	answer := dns.answer
 	ns := dns.ns
 	extra := dns.extra

 	dh.Qdcount = uint16(len(question))
 	dh.Ancount = uint16(len(answer))
 	dh.Nscount = uint16(len(ns))
 	dh.Arcount = uint16(len(extra))

 	// Could work harder to calculate message size,
 	// but this is far more than we need and not
 	// big enough to hurt the allocator.
 	msg = make([]byte, 2000)

 	// Pack it in: header and then the pieces.
 	off := 0
 	off, ok = packStruct(&dh, msg, off)
 	if !ok {
 		return nil, false
 	}
 	for i := 0; i < len(question); i++ {
 		off, ok = packStruct(&question[i], msg, off)
 		if !ok {
 			return nil, false
 		}
 	}
 	for i := 0; i < len(answer); i++ {
 		off, ok = packRR(answer[i], msg, off)
 		if !ok {
 			return nil, false
 		}
 	}
 	for i := 0; i < len(ns); i++ {
 		off, ok = packRR(ns[i], msg, off)
 		if !ok {
 			return nil, false
 		}
 	}
 	for i := 0; i < len(extra); i++ {
 		off, ok = packRR(extra[i], msg, off)
 		if !ok {
 			return nil, false
 		}
 	}
 	return msg[0:off], true
 }

 func (dns *dnsMsg) Unpack(msg []byte) bool {
 	// Header.
 	var dh dnsHeader
 	off := 0
 	var ok bool
 	if off, ok = unpackStruct(&dh, msg, off); !ok {
 		return false
 	}
 	dns.id = dh.Id
 	dns.response = (dh.Bits & _QR) != 0
 	dns.opcode = int(dh.Bits>>11) & 0xF
 	dns.authoritative = (dh.Bits & _AA) != 0
 	dns.truncated = (dh.Bits & _TC) != 0
 	dns.recursion_desired = (dh.Bits & _RD) != 0
 	dns.recursion_available = (dh.Bits & _RA) != 0
 	dns.rcode = int(dh.Bits & 0xF)

 	// Arrays.
 	dns.question = make([]dnsQuestion, dh.Qdcount)
 	dns.answer = make([]dnsRR, 0, dh.Ancount)
 	dns.ns = make([]dnsRR, 0, dh.Nscount)
 	dns.extra = make([]dnsRR, 0, dh.Arcount)

 	var rec dnsRR

 	for i := 0; i < len(dns.question); i++ {
 		off, ok = unpackStruct(&dns.question[i], msg, off)
 		if !ok {
 			return false
 		}
 	}
 	for i := 0; i < int(dh.Ancount); i++ {
 		rec, off, ok = unpackRR(msg, off)
 		if !ok {
 			return false
 		}
 		dns.answer = append(dns.answer, rec)
 	}
 	for i := 0; i < int(dh.Nscount); i++ {
 		rec, off, ok = unpackRR(msg, off)
 		if !ok {
 			return false
 		}
 		dns.ns = append(dns.ns, rec)
 	}
 	for i := 0; i < int(dh.Arcount); i++ {
 		rec, off, ok = unpackRR(msg, off)
 		if !ok {
 			return false
 		}
 		dns.extra = append(dns.extra, rec)
 	}
 	//	if off != len(msg) {
 	//		println("extra bytes in dns packet", off, "<", len(msg));
 	//	}
 	return true
 }

 func (dns *dnsMsg) String() string {
 	s := "DNS: " + printStruct(&dns.dnsMsgHdr) + "\n"
 	if len(dns.question) > 0 {
 		s += "-- Questions\n"
 		for i := 0; i < len(dns.question); i++ {
 			s += printStruct(&dns.question[i]) + "\n"
 		}
 	}
 	if len(dns.answer) > 0 {
 		s += "-- Answers\n"
 		for i := 0; i < len(dns.answer); i++ {
 			s += printStruct(dns.answer[i]) + "\n"
 		}
 	}
 	if len(dns.ns) > 0 {
 		s += "-- Name servers\n"
 		for i := 0; i < len(dns.ns); i++ {
 			s += printStruct(dns.ns[i]) + "\n"
 		}
 	}
 	if len(dns.extra) > 0 {
 		s += "-- Extra\n"
 		for i := 0; i < len(dns.extra); i++ {
 			s += printStruct(dns.extra[i]) + "\n"
 		}
 	}
 	return s
 }

 // IsResponseTo reports whether m is an acceptable response to query.
 func (m *dnsMsg) IsResponseTo(query *dnsMsg) bool {
 	if !m.response {
 		return false
 	}
 	if m.id != query.id {
 		return false
 	}
 	if len(m.question) != len(query.question) {
 		return false
 	}
 	for i, q := range m.question {
 		q2 := query.question[i]
 		if !equalASCIILabel(q.Name, q2.Name) || q.Qtype != q2.Qtype || q.Qclass != q2.Qclass {
 			return false
 		}
 	}
 	return true
 }
	// Copyright 2009 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	// DNS packet assembly. See RFC 1035.
	//
	// This is intended to support name resolution during Dial.
	// It doesn't have to be blazing fast.
	//
	// Each message structure has a Walk method that is used by
	// a generic pack/unpack routine. Thus, if in the future we need
	// to define new message structs, no new pack/unpack/printing code
	// needs to be written.
	//
	// The first half of this file defines the DNS message formats.
	// The second half implements the conversion to and from wire format.
	// A few of the structure elements have string tags to aid the
	// generic pack/unpack routines.
	//
	// TODO(rsc): There are enough names defined in this file that they're all
	// prefixed with dns. Perhaps put this in its own package later.

	package net

	// Packet formats

	// Wire constants.
	const (
	// valid dnsRR_Header.Rrtype and dnsQuestion.qtype
	dnsTypeA = 1
	dnsTypeNS = 2
	dnsTypeMD = 3
	dnsTypeMF = 4
	dnsTypeCNAME = 5
	dnsTypeSOA = 6
	dnsTypeMB = 7
	dnsTypeMG = 8
	dnsTypeMR = 9
	dnsTypeNULL = 10
	dnsTypeWKS = 11
	dnsTypePTR = 12
	dnsTypeHINFO = 13
	dnsTypeMINFO = 14
	dnsTypeMX = 15
	dnsTypeTXT = 16
	dnsTypeAAAA = 28
	dnsTypeSRV = 33

	// valid dnsQuestion.qtype only
	dnsTypeAXFR = 252
	dnsTypeMAILB = 253
	dnsTypeMAILA = 254
	dnsTypeALL = 255

	// valid dnsQuestion.qclass
	dnsClassINET = 1
	dnsClassCSNET = 2
	dnsClassCHAOS = 3
	dnsClassHESIOD = 4
	dnsClassANY = 255

	// dnsMsg.rcode
	dnsRcodeSuccess = 0
	dnsRcodeFormatError = 1
	dnsRcodeServerFailure = 2
	dnsRcodeNameError = 3
	dnsRcodeNotImplemented = 4
	dnsRcodeRefused = 5
	)

	// A dnsStruct describes how to iterate over its fields to emulate
	// reflective marshalling.
	type dnsStruct interface {
	// Walk iterates over fields of a structure and calls f
	// with a reference to that field, the name of the field
	// and a tag ("", "domain", "ipv4", "ipv6") specifying
	// particular encodings. Possible concrete types
	// for v are uint16, uint32, *string, or []byte, and
	// int, bool in the case of dnsMsgHdr.
	// Whenever f returns false, Walk must stop and return
	// false, and otherwise return true.
	Walk(f func(v interface{}, name, tag string) (ok bool)) (ok bool)
	}

	// The wire format for the DNS packet header.
	type dnsHeader struct {
	Id uint16
	Bits uint16
	Qdcount, Ancount, Nscount, Arcount uint16
	}

	func (h *dnsHeader) Walk(f func(v interface{}, name, tag string) bool) bool {
	return f(&h.Id, "Id", "") &&
	f(&h.Bits, "Bits", "") &&
	f(&h.Qdcount, "Qdcount", "") &&
	f(&h.Ancount, "Ancount", "") &&
	f(&h.Nscount, "Nscount", "") &&
	f(&h.Arcount, "Arcount", "")
	}

	const (
	// dnsHeader.Bits
	_QR = 1 << 15 // query/response (response=1)
	_AA = 1 << 10 // authoritative
	_TC = 1 << 9 // truncated
	_RD = 1 << 8 // recursion desired
	_RA = 1 << 7 // recursion available
	)

	// DNS queries.
	type dnsQuestion struct {
	Name string
	Qtype uint16
	Qclass uint16
	}

	func (q *dnsQuestion) Walk(f func(v interface{}, name, tag string) bool) bool {
	return f(&q.Name, "Name", "domain") &&
	f(&q.Qtype, "Qtype", "") &&
	f(&q.Qclass, "Qclass", "")
	}

	// DNS responses (resource records).
	// There are many types of messages,
	// but they all share the same header.
	type dnsRR_Header struct {
	Name string
	Rrtype uint16
	Class uint16
	Ttl uint32
	Rdlength uint16 // length of data after header
	}

	func (h dnsRR_Header) Header() dnsRR_Header {
	return h
	}

	func (h *dnsRR_Header) Walk(f func(v interface{}, name, tag string) bool) bool {
	return f(&h.Name, "Name", "domain") &&
	f(&h.Rrtype, "Rrtype", "") &&
	f(&h.Class, "Class", "") &&
	f(&h.Ttl, "Ttl", "") &&
	f(&h.Rdlength, "Rdlength", "")
	}

	type dnsRR interface {
	dnsStruct
	Header() *dnsRR_Header
	}

	// Specific DNS RR formats for each query type.

	type dnsRR_CNAME struct {
	Hdr dnsRR_Header
	Cname string
	}

	func (rr dnsRR_CNAME) Header() dnsRR_Header {
	return &rr.Hdr
	}

	func (rr *dnsRR_CNAME) Walk(f func(v interface{}, name, tag string) bool) bool {
	return rr.Hdr.Walk(f) && f(&rr.Cname, "Cname", "domain")
	}

	type dnsRR_MX struct {
	Hdr dnsRR_Header
	Pref uint16
	Mx string
	}

	func (rr dnsRR_MX) Header() dnsRR_Header {
	return &rr.Hdr
	}

	func (rr *dnsRR_MX) Walk(f func(v interface{}, name, tag string) bool) bool {
	return rr.Hdr.Walk(f) && f(&rr.Pref, "Pref", "") && f(&rr.Mx, "Mx", "domain")
	}

	type dnsRR_NS struct {
	Hdr dnsRR_Header
	Ns string
	}

	func (rr dnsRR_NS) Header() dnsRR_Header {
	return &rr.Hdr
	}

	func (rr *dnsRR_NS) Walk(f func(v interface{}, name, tag string) bool) bool {
	return rr.Hdr.Walk(f) && f(&rr.Ns, "Ns", "domain")
	}

	type dnsRR_PTR struct {
	Hdr dnsRR_Header
	Ptr string
	}

	func (rr dnsRR_PTR) Header() dnsRR_Header {
	return &rr.Hdr
	}

	func (rr *dnsRR_PTR) Walk(f func(v interface{}, name, tag string) bool) bool {
	return rr.Hdr.Walk(f) && f(&rr.Ptr, "Ptr", "domain")
	}

	type dnsRR_SOA struct {
	Hdr dnsRR_Header
	Ns string
	Mbox string
	Serial uint32
	Refresh uint32
	Retry uint32
	Expire uint32
	Minttl uint32
	}

	func (rr dnsRR_SOA) Header() dnsRR_Header {
	return &rr.Hdr
	}

	func (rr *dnsRR_SOA) Walk(f func(v interface{}, name, tag string) bool) bool {
	return rr.Hdr.Walk(f) &&
	f(&rr.Ns, "Ns", "domain") &&
	f(&rr.Mbox, "Mbox", "domain") &&
	f(&rr.Serial, "Serial", "") &&
	f(&rr.Refresh, "Refresh", "") &&
	f(&rr.Retry, "Retry", "") &&
	f(&rr.Expire, "Expire", "") &&
	f(&rr.Minttl, "Minttl", "")
	}

	type dnsRR_TXT struct {
	Hdr dnsRR_Header
	Txt string // not domain name
	}

	func (rr dnsRR_TXT) Header() dnsRR_Header {
	return &rr.Hdr
	}

	func (rr *dnsRR_TXT) Walk(f func(v interface{}, name, tag string) bool) bool {
	if !rr.Hdr.Walk(f) {
	return false
	}
	var n uint16 = 0
	for n < rr.Hdr.Rdlength {
	var txt string
	if !f(&txt, "Txt", "") {
	return false
	}
	// more bytes than rr.Hdr.Rdlength said there would be
	if rr.Hdr.Rdlength-n < uint16(len(txt))+1 {
	return false
	}
	n += uint16(len(txt)) + 1
	rr.Txt += txt
	}
	return true
	}

	type dnsRR_SRV struct {
	Hdr dnsRR_Header
	Priority uint16
	Weight uint16
	Port uint16
	Target string
	}

	func (rr dnsRR_SRV) Header() dnsRR_Header {
	return &rr.Hdr
	}

	func (rr *dnsRR_SRV) Walk(f func(v interface{}, name, tag string) bool) bool {
	return rr.Hdr.Walk(f) &&
	f(&rr.Priority, "Priority", "") &&
	f(&rr.Weight, "Weight", "") &&
	f(&rr.Port, "Port", "") &&
	f(&rr.Target, "Target", "domain")
	}

	type dnsRR_A struct {
	Hdr dnsRR_Header
	A uint32
	}

	func (rr dnsRR_A) Header() dnsRR_Header {
	return &rr.Hdr
	}

	func (rr *dnsRR_A) Walk(f func(v interface{}, name, tag string) bool) bool {
	return rr.Hdr.Walk(f) && f(&rr.A, "A", "ipv4")
	}

	type dnsRR_AAAA struct {
	Hdr dnsRR_Header
	AAAA [16]byte
	}

	func (rr dnsRR_AAAA) Header() dnsRR_Header {
	return &rr.Hdr
	}

	func (rr *dnsRR_AAAA) Walk(f func(v interface{}, name, tag string) bool) bool {
	return rr.Hdr.Walk(f) && f(rr.AAAA[:], "AAAA", "ipv6")
	}

	// Packing and unpacking.
	//
	// All the packers and unpackers take a (msg []byte, off int)
	// and return (off1 int, ok bool). If they return ok==false, they
	// also return off1==len(msg), so that the next unpacker will
	// also fail. This lets us avoid checks of ok until the end of a
	// packing sequence.

	// Map of constructors for each RR wire type.
	var rr_mk = map[int]func() dnsRR{
	dnsTypeCNAME: func() dnsRR { return new(dnsRR_CNAME) },
	dnsTypeMX: func() dnsRR { return new(dnsRR_MX) },
	dnsTypeNS: func() dnsRR { return new(dnsRR_NS) },
	dnsTypePTR: func() dnsRR { return new(dnsRR_PTR) },
	dnsTypeSOA: func() dnsRR { return new(dnsRR_SOA) },
	dnsTypeTXT: func() dnsRR { return new(dnsRR_TXT) },
	dnsTypeSRV: func() dnsRR { return new(dnsRR_SRV) },
	dnsTypeA: func() dnsRR { return new(dnsRR_A) },
	dnsTypeAAAA: func() dnsRR { return new(dnsRR_AAAA) },
	}

	// Pack a domain name s into msg[off:].
	// Domain names are a sequence of counted strings
	// split at the dots. They end with a zero-length string.
	func packDomainName(s string, msg []byte, off int) (off1 int, ok bool) {
	// Add trailing dot to canonicalize name.
	if n := len(s); n == 0 \|\| s[n-1] != '.' {
	s += "."
	}

	// Allow root domain.
	if s == "." {
	msg[off] = 0
	off++
	return off, true
	}

	// Each dot ends a segment of the name.
	// We trade each dot byte for a length byte.
	// There is also a trailing zero.
	// Check that we have all the space we need.
	tot := len(s) + 1
	if off+tot > len(msg) {
	return len(msg), false
	}

	// Emit sequence of counted strings, chopping at dots.
	begin := 0
	for i := 0; i < len(s); i++ {
	if s[i] == '.' {
	if i-begin >= 1<<6 { // top two bits of length must be clear
	return len(msg), false
	}
	if i-begin == 0 {
	return len(msg), false
	}

	msg[off] = byte(i - begin)
	off++

	for j := begin; j < i; j++ {
	msg[off] = s[j]
	off++
	}
	begin = i + 1
	}
	}
	msg[off] = 0
	off++
	return off, true
	}

	// Unpack a domain name.
	// In addition to the simple sequences of counted strings above,
	// domain names are allowed to refer to strings elsewhere in the
	// packet, to avoid repeating common suffixes when returning
	// many entries in a single domain. The pointers are marked
	// by a length byte with the top two bits set. Ignoring those
	// two bits, that byte and the next give a 14 bit offset from msg[0]
	// where we should pick up the trail.
	// Note that if we jump elsewhere in the packet,
	// we return off1 == the offset after the first pointer we found,
	// which is where the next record will start.
	// In theory, the pointers are only allowed to jump backward.
	// We let them jump anywhere and stop jumping after a while.
	func unpackDomainName(msg []byte, off int) (s string, off1 int, ok bool) {
	s = ""
	ptr := 0 // number of pointers followed
	Loop:
	for {
	if off >= len(msg) {
	return "", len(msg), false
	}
	c := int(msg[off])
	off++
	switch c & 0xC0 {
	case 0x00:
	if c == 0x00 {
	// end of name
	break Loop
	}
	// literal string
	if off+c > len(msg) {
	return "", len(msg), false
	}
	s += string(msg[off:off+c]) + "."
	off += c
	case 0xC0:
	// pointer to somewhere else in msg.
	// remember location after first ptr,
	// since that's how many bytes we consumed.
	// also, don't follow too many pointers --
	// maybe there's a loop.
	if off >= len(msg) {
	return "", len(msg), false
	}
	c1 := msg[off]
	off++
	if ptr == 0 {
	off1 = off
	}
	if ptr++; ptr > 10 {
	return "", len(msg), false
	}
	off = (c^0xC0)<<8 \| int(c1)
	default:
	// 0x80 and 0x40 are reserved
	return "", len(msg), false
	}
	}
	if len(s) == 0 {
	s = "."
	}
	if ptr == 0 {
	off1 = off
	}
	return s, off1, true
	}

	// packStruct packs a structure into msg at specified offset off, and
	// returns off1 such that msg[off:off1] is the encoded data.
	func packStruct(any dnsStruct, msg []byte, off int) (off1 int, ok bool) {
	ok = any.Walk(func(field interface{}, name, tag string) bool {
	switch fv := field.(type) {
	default:
	println("net: dns: unknown packing type")
	return false
	case *uint16:
	i := *fv
	if off+2 > len(msg) {
	return false
	}
	msg[off] = byte(i >> 8)
	msg[off+1] = byte(i)
	off += 2
	case *uint32:
	i := *fv
	msg[off] = byte(i >> 24)
	msg[off+1] = byte(i >> 16)
	msg[off+2] = byte(i >> 8)
	msg[off+3] = byte(i)
	off += 4
	case []byte:
	n := len(fv)
	if off+n > len(msg) {
	return false
	}
	copy(msg[off:off+n], fv)
	off += n
	case *string:
	s := *fv
	switch tag {
	default:
	println("net: dns: unknown string tag", tag)
	return false
	case "domain":
	off, ok = packDomainName(s, msg, off)
	if !ok {
	return false
	}
	case "":
	// Counted string: 1 byte length.
	if len(s) > 255 \|\| off+1+len(s) > len(msg) {
	return false
	}
	msg[off] = byte(len(s))
	off++
	off += copy(msg[off:], s)
	}
	}
	return true
	})
	if !ok {
	return len(msg), false
	}
	return off, true
	}

	// unpackStruct decodes msg[off:] into the given structure, and
	// returns off1 such that msg[off:off1] is the encoded data.
	func unpackStruct(any dnsStruct, msg []byte, off int) (off1 int, ok bool) {
	ok = any.Walk(func(field interface{}, name, tag string) bool {
	switch fv := field.(type) {
	default:
	println("net: dns: unknown packing type")
	return false
	case *uint16:
	if off+2 > len(msg) {
	return false
	}
	*fv = uint16(msg[off])<<8 \| uint16(msg[off+1])
	off += 2
	case *uint32:
	if off+4 > len(msg) {
	return false
	}
	*fv = uint32(msg[off])<<24 \| uint32(msg[off+1])<<16 \|
	uint32(msg[off+2])<<8 \| uint32(msg[off+3])
	off += 4
	case []byte:
	n := len(fv)
	if off+n > len(msg) {
	return false
	}
	copy(fv, msg[off:off+n])
	off += n
	case *string:
	var s string
	switch tag {
	default:
	println("net: dns: unknown string tag", tag)
	return false
	case "domain":
	s, off, ok = unpackDomainName(msg, off)
	if !ok {
	return false
	}
	case "":
	if off >= len(msg) \|\| off+1+int(msg[off]) > len(msg) {
	return false
	}
	n := int(msg[off])
	off++
	b := make([]byte, n)
	for i := 0; i < n; i++ {
	b[i] = msg[off+i]
	}
	off += n
	s = string(b)
	}
	*fv = s
	}
	return true
	})
	if !ok {
	return len(msg), false
	}
	return off, true
	}

	// Generic struct printer. Prints fields with tag "ipv4" or "ipv6"
	// as IP addresses.
	func printStruct(any dnsStruct) string {
	s := "{"
	i := 0
	any.Walk(func(val interface{}, name, tag string) bool {
	i++
	if i > 1 {
	s += ", "
	}
	s += name + "="
	switch tag {
	case "ipv4":
	i := val.(uint32)
	s += IPv4(byte(i>>24), byte(i>>16), byte(i>>8), byte(i)).String()
	case "ipv6":
	i := val.([]byte)
	s += IP(i).String()
	default:
	var i int64
	switch v := val.(type) {
	default:
	// can't really happen.
	s += "<unknown type>"
	return true
	case *string:
	s += *v
	return true
	case []byte:
	s += string(v)
	return true
	case *bool:
	if *v {
	s += "true"
	} else {
	s += "false"
	}
	return true
	case *int:
	i = int64(*v)
	case *uint:
	i = int64(*v)
	case *uint8:
	i = int64(*v)
	case *uint16:
	i = int64(*v)
	case *uint32:
	i = int64(*v)
	case *uint64:
	i = int64(*v)
	case *uintptr:
	i = int64(*v)
	}
	s += itoa(int(i))
	}
	return true
	})
	s += "}"
	return s
	}

	// Resource record packer.
	func packRR(rr dnsRR, msg []byte, off int) (off2 int, ok bool) {
	var off1 int
	// pack twice, once to find end of header
	// and again to find end of packet.
	// a bit inefficient but this doesn't need to be fast.
	// off1 is end of header
	// off2 is end of rr
	off1, ok = packStruct(rr.Header(), msg, off)
	if !ok {
	return len(msg), false
	}
	off2, ok = packStruct(rr, msg, off)
	if !ok {
	return len(msg), false
	}
	// pack a third time; redo header with correct data length
	rr.Header().Rdlength = uint16(off2 - off1)
	packStruct(rr.Header(), msg, off)
	return off2, true
	}

	// Resource record unpacker.
	func unpackRR(msg []byte, off int) (rr dnsRR, off1 int, ok bool) {
	// unpack just the header, to find the rr type and length
	var h dnsRR_Header
	off0 := off
	if off, ok = unpackStruct(&h, msg, off); !ok {
	return nil, len(msg), false
	}
	end := off + int(h.Rdlength)

	// make an rr of that type and re-unpack.
	// again inefficient but doesn't need to be fast.
	mk, known := rr_mk[int(h.Rrtype)]
	if !known {
	return &h, end, true
	}
	rr = mk()
	off, ok = unpackStruct(rr, msg, off0)
	if off != end {
	return &h, end, true
	}
	return rr, off, ok
	}

	// Usable representation of a DNS packet.

	// A manually-unpacked version of (id, bits).
	// This is in its own struct for easy printing.
	type dnsMsgHdr struct {
	id uint16
	response bool
	opcode int
	authoritative bool
	truncated bool
	recursion_desired bool
	recursion_available bool
	rcode int
	}

	func (h *dnsMsgHdr) Walk(f func(v interface{}, name, tag string) bool) bool {
	return f(&h.id, "id", "") &&
	f(&h.response, "response", "") &&
	f(&h.opcode, "opcode", "") &&
	f(&h.authoritative, "authoritative", "") &&
	f(&h.truncated, "truncated", "") &&
	f(&h.recursion_desired, "recursion_desired", "") &&
	f(&h.recursion_available, "recursion_available", "") &&
	f(&h.rcode, "rcode", "")
	}

	type dnsMsg struct {
	dnsMsgHdr
	question []dnsQuestion
	answer []dnsRR
	ns []dnsRR
	extra []dnsRR
	}

	func (dns *dnsMsg) Pack() (msg []byte, ok bool) {
	var dh dnsHeader

	// Convert convenient dnsMsg into wire-like dnsHeader.
	dh.Id = dns.id
	dh.Bits = uint16(dns.opcode)<<11 \| uint16(dns.rcode)
	if dns.recursion_available {
	dh.Bits \|= _RA
	}
	if dns.recursion_desired {
	dh.Bits \|= _RD
	}
	if dns.truncated {
	dh.Bits \|= _TC
	}
	if dns.authoritative {
	dh.Bits \|= _AA
	}
	if dns.response {
	dh.Bits \|= _QR
	}

	// Prepare variable sized arrays.
	question := dns.question
	answer := dns.answer
	ns := dns.ns
	extra := dns.extra

	dh.Qdcount = uint16(len(question))
	dh.Ancount = uint16(len(answer))
	dh.Nscount = uint16(len(ns))
	dh.Arcount = uint16(len(extra))

	// Could work harder to calculate message size,
	// but this is far more than we need and not
	// big enough to hurt the allocator.
	msg = make([]byte, 2000)

	// Pack it in: header and then the pieces.
	off := 0
	off, ok = packStruct(&dh, msg, off)
	if !ok {
	return nil, false
	}
	for i := 0; i < len(question); i++ {
	off, ok = packStruct(&question[i], msg, off)
	if !ok {
	return nil, false
	}
	}
	for i := 0; i < len(answer); i++ {
	off, ok = packRR(answer[i], msg, off)
	if !ok {
	return nil, false
	}
	}
	for i := 0; i < len(ns); i++ {
	off, ok = packRR(ns[i], msg, off)
	if !ok {
	return nil, false
	}
	}
	for i := 0; i < len(extra); i++ {
	off, ok = packRR(extra[i], msg, off)
	if !ok {
	return nil, false
	}
	}
	return msg[0:off], true
	}

	func (dns *dnsMsg) Unpack(msg []byte) bool {
	// Header.
	var dh dnsHeader
	off := 0
	var ok bool
	if off, ok = unpackStruct(&dh, msg, off); !ok {
	return false
	}
	dns.id = dh.Id
	dns.response = (dh.Bits & _QR) != 0
	dns.opcode = int(dh.Bits>>11) & 0xF
	dns.authoritative = (dh.Bits & _AA) != 0
	dns.truncated = (dh.Bits & _TC) != 0
	dns.recursion_desired = (dh.Bits & _RD) != 0
	dns.recursion_available = (dh.Bits & _RA) != 0
	dns.rcode = int(dh.Bits & 0xF)

	// Arrays.
	dns.question = make([]dnsQuestion, dh.Qdcount)
	dns.answer = make([]dnsRR, 0, dh.Ancount)
	dns.ns = make([]dnsRR, 0, dh.Nscount)
	dns.extra = make([]dnsRR, 0, dh.Arcount)

	var rec dnsRR

	for i := 0; i < len(dns.question); i++ {
	off, ok = unpackStruct(&dns.question[i], msg, off)
	if !ok {
	return false
	}
	}
	for i := 0; i < int(dh.Ancount); i++ {
	rec, off, ok = unpackRR(msg, off)
	if !ok {
	return false
	}
	dns.answer = append(dns.answer, rec)
	}
	for i := 0; i < int(dh.Nscount); i++ {
	rec, off, ok = unpackRR(msg, off)
	if !ok {
	return false
	}
	dns.ns = append(dns.ns, rec)
	}
	for i := 0; i < int(dh.Arcount); i++ {
	rec, off, ok = unpackRR(msg, off)
	if !ok {
	return false
	}
	dns.extra = append(dns.extra, rec)
	}
	// if off != len(msg) {
	// println("extra bytes in dns packet", off, "<", len(msg));
	// }
	return true
	}

	func (dns *dnsMsg) String() string {
	s := "DNS: " + printStruct(&dns.dnsMsgHdr) + "\n"
	if len(dns.question) > 0 {
	s += "-- Questions\n"
	for i := 0; i < len(dns.question); i++ {
	s += printStruct(&dns.question[i]) + "\n"
	}
	}
	if len(dns.answer) > 0 {
	s += "-- Answers\n"
	for i := 0; i < len(dns.answer); i++ {
	s += printStruct(dns.answer[i]) + "\n"
	}
	}
	if len(dns.ns) > 0 {
	s += "-- Name servers\n"
	for i := 0; i < len(dns.ns); i++ {
	s += printStruct(dns.ns[i]) + "\n"
	}
	}
	if len(dns.extra) > 0 {
	s += "-- Extra\n"
	for i := 0; i < len(dns.extra); i++ {
	s += printStruct(dns.extra[i]) + "\n"
	}
	}
	return s
	}

	// IsResponseTo reports whether m is an acceptable response to query.
	func (m dnsMsg) IsResponseTo(query dnsMsg) bool {
	if !m.response {
	return false
	}
	if m.id != query.id {
	return false
	}
	if len(m.question) != len(query.question) {
	return false
	}
	for i, q := range m.question {
	q2 := query.question[i]
	if !equalASCIILabel(q.Name, q2.Name) \|\| q.Qtype != q2.Qtype \|\| q.Qclass != q2.Qclass {
	return false
	}
	}
	return true
	}