Source file src/pkg/net/dnsmsg.go

     1	// Copyright 2009 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	// DNS packet assembly.  See RFC 1035.
     6	//
     7	// This is intended to support name resolution during Dial.
     8	// It doesn't have to be blazing fast.
     9	//
    10	// Each message structure has a Walk method that is used by
    11	// a generic pack/unpack routine. Thus, if in the future we need
    12	// to define new message structs, no new pack/unpack/printing code
    13	// needs to be written.
    14	//
    15	// The first half of this file defines the DNS message formats.
    16	// The second half implements the conversion to and from wire format.
    17	// A few of the structure elements have string tags to aid the
    18	// generic pack/unpack routines.
    19	//
    20	// TODO(rsc):  There are enough names defined in this file that they're all
    21	// prefixed with dns.  Perhaps put this in its own package later.
    22	
    23	package net
    24	
    25	// Packet formats
    26	
    27	// Wire constants.
    28	const (
    29		// valid dnsRR_Header.Rrtype and dnsQuestion.qtype
    30		dnsTypeA     = 1
    31		dnsTypeNS    = 2
    32		dnsTypeMD    = 3
    33		dnsTypeMF    = 4
    34		dnsTypeCNAME = 5
    35		dnsTypeSOA   = 6
    36		dnsTypeMB    = 7
    37		dnsTypeMG    = 8
    38		dnsTypeMR    = 9
    39		dnsTypeNULL  = 10
    40		dnsTypeWKS   = 11
    41		dnsTypePTR   = 12
    42		dnsTypeHINFO = 13
    43		dnsTypeMINFO = 14
    44		dnsTypeMX    = 15
    45		dnsTypeTXT   = 16
    46		dnsTypeAAAA  = 28
    47		dnsTypeSRV   = 33
    48	
    49		// valid dnsQuestion.qtype only
    50		dnsTypeAXFR  = 252
    51		dnsTypeMAILB = 253
    52		dnsTypeMAILA = 254
    53		dnsTypeALL   = 255
    54	
    55		// valid dnsQuestion.qclass
    56		dnsClassINET   = 1
    57		dnsClassCSNET  = 2
    58		dnsClassCHAOS  = 3
    59		dnsClassHESIOD = 4
    60		dnsClassANY    = 255
    61	
    62		// dnsMsg.rcode
    63		dnsRcodeSuccess        = 0
    64		dnsRcodeFormatError    = 1
    65		dnsRcodeServerFailure  = 2
    66		dnsRcodeNameError      = 3
    67		dnsRcodeNotImplemented = 4
    68		dnsRcodeRefused        = 5
    69	)
    70	
    71	// A dnsStruct describes how to iterate over its fields to emulate
    72	// reflective marshalling.
    73	type dnsStruct interface {
    74		// Walk iterates over fields of a structure and calls f
    75		// with a reference to that field, the name of the field
    76		// and a tag ("", "domain", "ipv4", "ipv6") specifying
    77		// particular encodings. Possible concrete types
    78		// for v are *uint16, *uint32, *string, or []byte, and
    79		// *int, *bool in the case of dnsMsgHdr.
    80		// Whenever f returns false, Walk must stop and return
    81		// false, and otherwise return true.
    82		Walk(f func(v interface{}, name, tag string) (ok bool)) (ok bool)
    83	}
    84	
    85	// The wire format for the DNS packet header.
    86	type dnsHeader struct {
    87		Id                                 uint16
    88		Bits                               uint16
    89		Qdcount, Ancount, Nscount, Arcount uint16
    90	}
    91	
    92	func (h *dnsHeader) Walk(f func(v interface{}, name, tag string) bool) bool {
    93		return f(&h.Id, "Id", "") &&
    94			f(&h.Bits, "Bits", "") &&
    95			f(&h.Qdcount, "Qdcount", "") &&
    96			f(&h.Ancount, "Ancount", "") &&
    97			f(&h.Nscount, "Nscount", "") &&
    98			f(&h.Arcount, "Arcount", "")
    99	}
   100	
   101	const (
   102		// dnsHeader.Bits
   103		_QR = 1 << 15 // query/response (response=1)
   104		_AA = 1 << 10 // authoritative
   105		_TC = 1 << 9  // truncated
   106		_RD = 1 << 8  // recursion desired
   107		_RA = 1 << 7  // recursion available
   108	)
   109	
   110	// DNS queries.
   111	type dnsQuestion struct {
   112		Name   string `net:"domain-name"` // `net:"domain-name"` specifies encoding; see packers below
   113		Qtype  uint16
   114		Qclass uint16
   115	}
   116	
   117	func (q *dnsQuestion) Walk(f func(v interface{}, name, tag string) bool) bool {
   118		return f(&q.Name, "Name", "domain") &&
   119			f(&q.Qtype, "Qtype", "") &&
   120			f(&q.Qclass, "Qclass", "")
   121	}
   122	
   123	// DNS responses (resource records).
   124	// There are many types of messages,
   125	// but they all share the same header.
   126	type dnsRR_Header struct {
   127		Name     string `net:"domain-name"`
   128		Rrtype   uint16
   129		Class    uint16
   130		Ttl      uint32
   131		Rdlength uint16 // length of data after header
   132	}
   133	
   134	func (h *dnsRR_Header) Header() *dnsRR_Header {
   135		return h
   136	}
   137	
   138	func (h *dnsRR_Header) Walk(f func(v interface{}, name, tag string) bool) bool {
   139		return f(&h.Name, "Name", "domain") &&
   140			f(&h.Rrtype, "Rrtype", "") &&
   141			f(&h.Class, "Class", "") &&
   142			f(&h.Ttl, "Ttl", "") &&
   143			f(&h.Rdlength, "Rdlength", "")
   144	}
   145	
   146	type dnsRR interface {
   147		dnsStruct
   148		Header() *dnsRR_Header
   149	}
   150	
   151	// Specific DNS RR formats for each query type.
   152	
   153	type dnsRR_CNAME struct {
   154		Hdr   dnsRR_Header
   155		Cname string `net:"domain-name"`
   156	}
   157	
   158	func (rr *dnsRR_CNAME) Header() *dnsRR_Header {
   159		return &rr.Hdr
   160	}
   161	
   162	func (rr *dnsRR_CNAME) Walk(f func(v interface{}, name, tag string) bool) bool {
   163		return rr.Hdr.Walk(f) && f(&rr.Cname, "Cname", "domain")
   164	}
   165	
   166	type dnsRR_HINFO struct {
   167		Hdr dnsRR_Header
   168		Cpu string
   169		Os  string
   170	}
   171	
   172	func (rr *dnsRR_HINFO) Header() *dnsRR_Header {
   173		return &rr.Hdr
   174	}
   175	
   176	func (rr *dnsRR_HINFO) Walk(f func(v interface{}, name, tag string) bool) bool {
   177		return rr.Hdr.Walk(f) && f(&rr.Cpu, "Cpu", "") && f(&rr.Os, "Os", "")
   178	}
   179	
   180	type dnsRR_MB struct {
   181		Hdr dnsRR_Header
   182		Mb  string `net:"domain-name"`
   183	}
   184	
   185	func (rr *dnsRR_MB) Header() *dnsRR_Header {
   186		return &rr.Hdr
   187	}
   188	
   189	func (rr *dnsRR_MB) Walk(f func(v interface{}, name, tag string) bool) bool {
   190		return rr.Hdr.Walk(f) && f(&rr.Mb, "Mb", "domain")
   191	}
   192	
   193	type dnsRR_MG struct {
   194		Hdr dnsRR_Header
   195		Mg  string `net:"domain-name"`
   196	}
   197	
   198	func (rr *dnsRR_MG) Header() *dnsRR_Header {
   199		return &rr.Hdr
   200	}
   201	
   202	func (rr *dnsRR_MG) Walk(f func(v interface{}, name, tag string) bool) bool {
   203		return rr.Hdr.Walk(f) && f(&rr.Mg, "Mg", "domain")
   204	}
   205	
   206	type dnsRR_MINFO struct {
   207		Hdr   dnsRR_Header
   208		Rmail string `net:"domain-name"`
   209		Email string `net:"domain-name"`
   210	}
   211	
   212	func (rr *dnsRR_MINFO) Header() *dnsRR_Header {
   213		return &rr.Hdr
   214	}
   215	
   216	func (rr *dnsRR_MINFO) Walk(f func(v interface{}, name, tag string) bool) bool {
   217		return rr.Hdr.Walk(f) && f(&rr.Rmail, "Rmail", "domain") && f(&rr.Email, "Email", "domain")
   218	}
   219	
   220	type dnsRR_MR struct {
   221		Hdr dnsRR_Header
   222		Mr  string `net:"domain-name"`
   223	}
   224	
   225	func (rr *dnsRR_MR) Header() *dnsRR_Header {
   226		return &rr.Hdr
   227	}
   228	
   229	func (rr *dnsRR_MR) Walk(f func(v interface{}, name, tag string) bool) bool {
   230		return rr.Hdr.Walk(f) && f(&rr.Mr, "Mr", "domain")
   231	}
   232	
   233	type dnsRR_MX struct {
   234		Hdr  dnsRR_Header
   235		Pref uint16
   236		Mx   string `net:"domain-name"`
   237	}
   238	
   239	func (rr *dnsRR_MX) Header() *dnsRR_Header {
   240		return &rr.Hdr
   241	}
   242	
   243	func (rr *dnsRR_MX) Walk(f func(v interface{}, name, tag string) bool) bool {
   244		return rr.Hdr.Walk(f) && f(&rr.Pref, "Pref", "") && f(&rr.Mx, "Mx", "domain")
   245	}
   246	
   247	type dnsRR_NS struct {
   248		Hdr dnsRR_Header
   249		Ns  string `net:"domain-name"`
   250	}
   251	
   252	func (rr *dnsRR_NS) Header() *dnsRR_Header {
   253		return &rr.Hdr
   254	}
   255	
   256	func (rr *dnsRR_NS) Walk(f func(v interface{}, name, tag string) bool) bool {
   257		return rr.Hdr.Walk(f) && f(&rr.Ns, "Ns", "domain")
   258	}
   259	
   260	type dnsRR_PTR struct {
   261		Hdr dnsRR_Header
   262		Ptr string `net:"domain-name"`
   263	}
   264	
   265	func (rr *dnsRR_PTR) Header() *dnsRR_Header {
   266		return &rr.Hdr
   267	}
   268	
   269	func (rr *dnsRR_PTR) Walk(f func(v interface{}, name, tag string) bool) bool {
   270		return rr.Hdr.Walk(f) && f(&rr.Ptr, "Ptr", "domain")
   271	}
   272	
   273	type dnsRR_SOA struct {
   274		Hdr     dnsRR_Header
   275		Ns      string `net:"domain-name"`
   276		Mbox    string `net:"domain-name"`
   277		Serial  uint32
   278		Refresh uint32
   279		Retry   uint32
   280		Expire  uint32
   281		Minttl  uint32
   282	}
   283	
   284	func (rr *dnsRR_SOA) Header() *dnsRR_Header {
   285		return &rr.Hdr
   286	}
   287	
   288	func (rr *dnsRR_SOA) Walk(f func(v interface{}, name, tag string) bool) bool {
   289		return rr.Hdr.Walk(f) &&
   290			f(&rr.Ns, "Ns", "domain") &&
   291			f(&rr.Mbox, "Mbox", "domain") &&
   292			f(&rr.Serial, "Serial", "") &&
   293			f(&rr.Refresh, "Refresh", "") &&
   294			f(&rr.Retry, "Retry", "") &&
   295			f(&rr.Expire, "Expire", "") &&
   296			f(&rr.Minttl, "Minttl", "")
   297	}
   298	
   299	type dnsRR_TXT struct {
   300		Hdr dnsRR_Header
   301		Txt string // not domain name
   302	}
   303	
   304	func (rr *dnsRR_TXT) Header() *dnsRR_Header {
   305		return &rr.Hdr
   306	}
   307	
   308	func (rr *dnsRR_TXT) Walk(f func(v interface{}, name, tag string) bool) bool {
   309		return rr.Hdr.Walk(f) && f(&rr.Txt, "Txt", "")
   310	}
   311	
   312	type dnsRR_SRV struct {
   313		Hdr      dnsRR_Header
   314		Priority uint16
   315		Weight   uint16
   316		Port     uint16
   317		Target   string `net:"domain-name"`
   318	}
   319	
   320	func (rr *dnsRR_SRV) Header() *dnsRR_Header {
   321		return &rr.Hdr
   322	}
   323	
   324	func (rr *dnsRR_SRV) Walk(f func(v interface{}, name, tag string) bool) bool {
   325		return rr.Hdr.Walk(f) &&
   326			f(&rr.Priority, "Priority", "") &&
   327			f(&rr.Weight, "Weight", "") &&
   328			f(&rr.Port, "Port", "") &&
   329			f(&rr.Target, "Target", "domain")
   330	}
   331	
   332	type dnsRR_A struct {
   333		Hdr dnsRR_Header
   334		A   uint32 `net:"ipv4"`
   335	}
   336	
   337	func (rr *dnsRR_A) Header() *dnsRR_Header {
   338		return &rr.Hdr
   339	}
   340	
   341	func (rr *dnsRR_A) Walk(f func(v interface{}, name, tag string) bool) bool {
   342		return rr.Hdr.Walk(f) && f(&rr.A, "A", "ipv4")
   343	}
   344	
   345	type dnsRR_AAAA struct {
   346		Hdr  dnsRR_Header
   347		AAAA [16]byte `net:"ipv6"`
   348	}
   349	
   350	func (rr *dnsRR_AAAA) Header() *dnsRR_Header {
   351		return &rr.Hdr
   352	}
   353	
   354	func (rr *dnsRR_AAAA) Walk(f func(v interface{}, name, tag string) bool) bool {
   355		return rr.Hdr.Walk(f) && f(rr.AAAA[:], "AAAA", "ipv6")
   356	}
   357	
   358	// Packing and unpacking.
   359	//
   360	// All the packers and unpackers take a (msg []byte, off int)
   361	// and return (off1 int, ok bool).  If they return ok==false, they
   362	// also return off1==len(msg), so that the next unpacker will
   363	// also fail.  This lets us avoid checks of ok until the end of a
   364	// packing sequence.
   365	
   366	// Map of constructors for each RR wire type.
   367	var rr_mk = map[int]func() dnsRR{
   368		dnsTypeCNAME: func() dnsRR { return new(dnsRR_CNAME) },
   369		dnsTypeHINFO: func() dnsRR { return new(dnsRR_HINFO) },
   370		dnsTypeMB:    func() dnsRR { return new(dnsRR_MB) },
   371		dnsTypeMG:    func() dnsRR { return new(dnsRR_MG) },
   372		dnsTypeMINFO: func() dnsRR { return new(dnsRR_MINFO) },
   373		dnsTypeMR:    func() dnsRR { return new(dnsRR_MR) },
   374		dnsTypeMX:    func() dnsRR { return new(dnsRR_MX) },
   375		dnsTypeNS:    func() dnsRR { return new(dnsRR_NS) },
   376		dnsTypePTR:   func() dnsRR { return new(dnsRR_PTR) },
   377		dnsTypeSOA:   func() dnsRR { return new(dnsRR_SOA) },
   378		dnsTypeTXT:   func() dnsRR { return new(dnsRR_TXT) },
   379		dnsTypeSRV:   func() dnsRR { return new(dnsRR_SRV) },
   380		dnsTypeA:     func() dnsRR { return new(dnsRR_A) },
   381		dnsTypeAAAA:  func() dnsRR { return new(dnsRR_AAAA) },
   382	}
   383	
   384	// Pack a domain name s into msg[off:].
   385	// Domain names are a sequence of counted strings
   386	// split at the dots.  They end with a zero-length string.
   387	func packDomainName(s string, msg []byte, off int) (off1 int, ok bool) {
   388		// Add trailing dot to canonicalize name.
   389		if n := len(s); n == 0 || s[n-1] != '.' {
   390			s += "."
   391		}
   392	
   393		// Each dot ends a segment of the name.
   394		// We trade each dot byte for a length byte.
   395		// There is also a trailing zero.
   396		// Check that we have all the space we need.
   397		tot := len(s) + 1
   398		if off+tot > len(msg) {
   399			return len(msg), false
   400		}
   401	
   402		// Emit sequence of counted strings, chopping at dots.
   403		begin := 0
   404		for i := 0; i < len(s); i++ {
   405			if s[i] == '.' {
   406				if i-begin >= 1<<6 { // top two bits of length must be clear
   407					return len(msg), false
   408				}
   409				msg[off] = byte(i - begin)
   410				off++
   411				for j := begin; j < i; j++ {
   412					msg[off] = s[j]
   413					off++
   414				}
   415				begin = i + 1
   416			}
   417		}
   418		msg[off] = 0
   419		off++
   420		return off, true
   421	}
   422	
   423	// Unpack a domain name.
   424	// In addition to the simple sequences of counted strings above,
   425	// domain names are allowed to refer to strings elsewhere in the
   426	// packet, to avoid repeating common suffixes when returning
   427	// many entries in a single domain.  The pointers are marked
   428	// by a length byte with the top two bits set.  Ignoring those
   429	// two bits, that byte and the next give a 14 bit offset from msg[0]
   430	// where we should pick up the trail.
   431	// Note that if we jump elsewhere in the packet,
   432	// we return off1 == the offset after the first pointer we found,
   433	// which is where the next record will start.
   434	// In theory, the pointers are only allowed to jump backward.
   435	// We let them jump anywhere and stop jumping after a while.
   436	func unpackDomainName(msg []byte, off int) (s string, off1 int, ok bool) {
   437		s = ""
   438		ptr := 0 // number of pointers followed
   439	Loop:
   440		for {
   441			if off >= len(msg) {
   442				return "", len(msg), false
   443			}
   444			c := int(msg[off])
   445			off++
   446			switch c & 0xC0 {
   447			case 0x00:
   448				if c == 0x00 {
   449					// end of name
   450					break Loop
   451				}
   452				// literal string
   453				if off+c > len(msg) {
   454					return "", len(msg), false
   455				}
   456				s += string(msg[off:off+c]) + "."
   457				off += c
   458			case 0xC0:
   459				// pointer to somewhere else in msg.
   460				// remember location after first ptr,
   461				// since that's how many bytes we consumed.
   462				// also, don't follow too many pointers --
   463				// maybe there's a loop.
   464				if off >= len(msg) {
   465					return "", len(msg), false
   466				}
   467				c1 := msg[off]
   468				off++
   469				if ptr == 0 {
   470					off1 = off
   471				}
   472				if ptr++; ptr > 10 {
   473					return "", len(msg), false
   474				}
   475				off = (c^0xC0)<<8 | int(c1)
   476			default:
   477				// 0x80 and 0x40 are reserved
   478				return "", len(msg), false
   479			}
   480		}
   481		if ptr == 0 {
   482			off1 = off
   483		}
   484		return s, off1, true
   485	}
   486	
   487	// packStruct packs a structure into msg at specified offset off, and
   488	// returns off1 such that msg[off:off1] is the encoded data.
   489	func packStruct(any dnsStruct, msg []byte, off int) (off1 int, ok bool) {
   490		ok = any.Walk(func(field interface{}, name, tag string) bool {
   491			switch fv := field.(type) {
   492			default:
   493				println("net: dns: unknown packing type")
   494				return false
   495			case *uint16:
   496				i := *fv
   497				if off+2 > len(msg) {
   498					return false
   499				}
   500				msg[off] = byte(i >> 8)
   501				msg[off+1] = byte(i)
   502				off += 2
   503			case *uint32:
   504				i := *fv
   505				msg[off] = byte(i >> 24)
   506				msg[off+1] = byte(i >> 16)
   507				msg[off+2] = byte(i >> 8)
   508				msg[off+3] = byte(i)
   509				off += 4
   510			case []byte:
   511				n := len(fv)
   512				if off+n > len(msg) {
   513					return false
   514				}
   515				copy(msg[off:off+n], fv)
   516				off += n
   517			case *string:
   518				s := *fv
   519				switch tag {
   520				default:
   521					println("net: dns: unknown string tag", tag)
   522					return false
   523				case "domain":
   524					off, ok = packDomainName(s, msg, off)
   525					if !ok {
   526						return false
   527					}
   528				case "":
   529					// Counted string: 1 byte length.
   530					if len(s) > 255 || off+1+len(s) > len(msg) {
   531						return false
   532					}
   533					msg[off] = byte(len(s))
   534					off++
   535					off += copy(msg[off:], s)
   536				}
   537			}
   538			return true
   539		})
   540		if !ok {
   541			return len(msg), false
   542		}
   543		return off, true
   544	}
   545	
   546	// unpackStruct decodes msg[off:] into the given structure, and
   547	// returns off1 such that msg[off:off1] is the encoded data.
   548	func unpackStruct(any dnsStruct, msg []byte, off int) (off1 int, ok bool) {
   549		ok = any.Walk(func(field interface{}, name, tag string) bool {
   550			switch fv := field.(type) {
   551			default:
   552				println("net: dns: unknown packing type")
   553				return false
   554			case *uint16:
   555				if off+2 > len(msg) {
   556					return false
   557				}
   558				*fv = uint16(msg[off])<<8 | uint16(msg[off+1])
   559				off += 2
   560			case *uint32:
   561				if off+4 > len(msg) {
   562					return false
   563				}
   564				*fv = uint32(msg[off])<<24 | uint32(msg[off+1])<<16 |
   565					uint32(msg[off+2])<<8 | uint32(msg[off+3])
   566				off += 4
   567			case []byte:
   568				n := len(fv)
   569				if off+n > len(msg) {
   570					return false
   571				}
   572				copy(fv, msg[off:off+n])
   573				off += n
   574			case *string:
   575				var s string
   576				switch tag {
   577				default:
   578					println("net: dns: unknown string tag", tag)
   579					return false
   580				case "domain":
   581					s, off, ok = unpackDomainName(msg, off)
   582					if !ok {
   583						return false
   584					}
   585				case "":
   586					if off >= len(msg) || off+1+int(msg[off]) > len(msg) {
   587						return false
   588					}
   589					n := int(msg[off])
   590					off++
   591					b := make([]byte, n)
   592					for i := 0; i < n; i++ {
   593						b[i] = msg[off+i]
   594					}
   595					off += n
   596					s = string(b)
   597				}
   598				*fv = s
   599			}
   600			return true
   601		})
   602		if !ok {
   603			return len(msg), false
   604		}
   605		return off, true
   606	}
   607	
   608	// Generic struct printer. Prints fields with tag "ipv4" or "ipv6"
   609	// as IP addresses.
   610	func printStruct(any dnsStruct) string {
   611		s := "{"
   612		i := 0
   613		any.Walk(func(val interface{}, name, tag string) bool {
   614			i++
   615			if i > 1 {
   616				s += ", "
   617			}
   618			s += name + "="
   619			switch tag {
   620			case "ipv4":
   621				i := val.(uint32)
   622				s += IPv4(byte(i>>24), byte(i>>16), byte(i>>8), byte(i)).String()
   623			case "ipv6":
   624				i := val.([]byte)
   625				s += IP(i).String()
   626			default:
   627				var i int64
   628				switch v := val.(type) {
   629				default:
   630					// can't really happen.
   631					s += "<unknown type>"
   632					return true
   633				case *string:
   634					s += *v
   635					return true
   636				case []byte:
   637					s += string(v)
   638					return true
   639				case *bool:
   640					if *v {
   641						s += "true"
   642					} else {
   643						s += "false"
   644					}
   645					return true
   646				case *int:
   647					i = int64(*v)
   648				case *uint:
   649					i = int64(*v)
   650				case *uint8:
   651					i = int64(*v)
   652				case *uint16:
   653					i = int64(*v)
   654				case *uint32:
   655					i = int64(*v)
   656				case *uint64:
   657					i = int64(*v)
   658				case *uintptr:
   659					i = int64(*v)
   660				}
   661				s += itoa(int(i))
   662			}
   663			return true
   664		})
   665		s += "}"
   666		return s
   667	}
   668	
   669	// Resource record packer.
   670	func packRR(rr dnsRR, msg []byte, off int) (off2 int, ok bool) {
   671		var off1 int
   672		// pack twice, once to find end of header
   673		// and again to find end of packet.
   674		// a bit inefficient but this doesn't need to be fast.
   675		// off1 is end of header
   676		// off2 is end of rr
   677		off1, ok = packStruct(rr.Header(), msg, off)
   678		off2, ok = packStruct(rr, msg, off)
   679		if !ok {
   680			return len(msg), false
   681		}
   682		// pack a third time; redo header with correct data length
   683		rr.Header().Rdlength = uint16(off2 - off1)
   684		packStruct(rr.Header(), msg, off)
   685		return off2, true
   686	}
   687	
   688	// Resource record unpacker.
   689	func unpackRR(msg []byte, off int) (rr dnsRR, off1 int, ok bool) {
   690		// unpack just the header, to find the rr type and length
   691		var h dnsRR_Header
   692		off0 := off
   693		if off, ok = unpackStruct(&h, msg, off); !ok {
   694			return nil, len(msg), false
   695		}
   696		end := off + int(h.Rdlength)
   697	
   698		// make an rr of that type and re-unpack.
   699		// again inefficient but doesn't need to be fast.
   700		mk, known := rr_mk[int(h.Rrtype)]
   701		if !known {
   702			return &h, end, true
   703		}
   704		rr = mk()
   705		off, ok = unpackStruct(rr, msg, off0)
   706		if off != end {
   707			return &h, end, true
   708		}
   709		return rr, off, ok
   710	}
   711	
   712	// Usable representation of a DNS packet.
   713	
   714	// A manually-unpacked version of (id, bits).
   715	// This is in its own struct for easy printing.
   716	type dnsMsgHdr struct {
   717		id                  uint16
   718		response            bool
   719		opcode              int
   720		authoritative       bool
   721		truncated           bool
   722		recursion_desired   bool
   723		recursion_available bool
   724		rcode               int
   725	}
   726	
   727	func (h *dnsMsgHdr) Walk(f func(v interface{}, name, tag string) bool) bool {
   728		return f(&h.id, "id", "") &&
   729			f(&h.response, "response", "") &&
   730			f(&h.opcode, "opcode", "") &&
   731			f(&h.authoritative, "authoritative", "") &&
   732			f(&h.truncated, "truncated", "") &&
   733			f(&h.recursion_desired, "recursion_desired", "") &&
   734			f(&h.recursion_available, "recursion_available", "") &&
   735			f(&h.rcode, "rcode", "")
   736	}
   737	
   738	type dnsMsg struct {
   739		dnsMsgHdr
   740		question []dnsQuestion
   741		answer   []dnsRR
   742		ns       []dnsRR
   743		extra    []dnsRR
   744	}
   745	
   746	func (dns *dnsMsg) Pack() (msg []byte, ok bool) {
   747		var dh dnsHeader
   748	
   749		// Convert convenient dnsMsg into wire-like dnsHeader.
   750		dh.Id = dns.id
   751		dh.Bits = uint16(dns.opcode)<<11 | uint16(dns.rcode)
   752		if dns.recursion_available {
   753			dh.Bits |= _RA
   754		}
   755		if dns.recursion_desired {
   756			dh.Bits |= _RD
   757		}
   758		if dns.truncated {
   759			dh.Bits |= _TC
   760		}
   761		if dns.authoritative {
   762			dh.Bits |= _AA
   763		}
   764		if dns.response {
   765			dh.Bits |= _QR
   766		}
   767	
   768		// Prepare variable sized arrays.
   769		question := dns.question
   770		answer := dns.answer
   771		ns := dns.ns
   772		extra := dns.extra
   773	
   774		dh.Qdcount = uint16(len(question))
   775		dh.Ancount = uint16(len(answer))
   776		dh.Nscount = uint16(len(ns))
   777		dh.Arcount = uint16(len(extra))
   778	
   779		// Could work harder to calculate message size,
   780		// but this is far more than we need and not
   781		// big enough to hurt the allocator.
   782		msg = make([]byte, 2000)
   783	
   784		// Pack it in: header and then the pieces.
   785		off := 0
   786		off, ok = packStruct(&dh, msg, off)
   787		for i := 0; i < len(question); i++ {
   788			off, ok = packStruct(&question[i], msg, off)
   789		}
   790		for i := 0; i < len(answer); i++ {
   791			off, ok = packRR(answer[i], msg, off)
   792		}
   793		for i := 0; i < len(ns); i++ {
   794			off, ok = packRR(ns[i], msg, off)
   795		}
   796		for i := 0; i < len(extra); i++ {
   797			off, ok = packRR(extra[i], msg, off)
   798		}
   799		if !ok {
   800			return nil, false
   801		}
   802		return msg[0:off], true
   803	}
   804	
   805	func (dns *dnsMsg) Unpack(msg []byte) bool {
   806		// Header.
   807		var dh dnsHeader
   808		off := 0
   809		var ok bool
   810		if off, ok = unpackStruct(&dh, msg, off); !ok {
   811			return false
   812		}
   813		dns.id = dh.Id
   814		dns.response = (dh.Bits & _QR) != 0
   815		dns.opcode = int(dh.Bits>>11) & 0xF
   816		dns.authoritative = (dh.Bits & _AA) != 0
   817		dns.truncated = (dh.Bits & _TC) != 0
   818		dns.recursion_desired = (dh.Bits & _RD) != 0
   819		dns.recursion_available = (dh.Bits & _RA) != 0
   820		dns.rcode = int(dh.Bits & 0xF)
   821	
   822		// Arrays.
   823		dns.question = make([]dnsQuestion, dh.Qdcount)
   824		dns.answer = make([]dnsRR, 0, dh.Ancount)
   825		dns.ns = make([]dnsRR, 0, dh.Nscount)
   826		dns.extra = make([]dnsRR, 0, dh.Arcount)
   827	
   828		var rec dnsRR
   829	
   830		for i := 0; i < len(dns.question); i++ {
   831			off, ok = unpackStruct(&dns.question[i], msg, off)
   832		}
   833		for i := 0; i < int(dh.Ancount); i++ {
   834			rec, off, ok = unpackRR(msg, off)
   835			if !ok {
   836				return false
   837			}
   838			dns.answer = append(dns.answer, rec)
   839		}
   840		for i := 0; i < int(dh.Nscount); i++ {
   841			rec, off, ok = unpackRR(msg, off)
   842			if !ok {
   843				return false
   844			}
   845			dns.ns = append(dns.ns, rec)
   846		}
   847		for i := 0; i < int(dh.Arcount); i++ {
   848			rec, off, ok = unpackRR(msg, off)
   849			if !ok {
   850				return false
   851			}
   852			dns.extra = append(dns.extra, rec)
   853		}
   854		//	if off != len(msg) {
   855		//		println("extra bytes in dns packet", off, "<", len(msg));
   856		//	}
   857		return true
   858	}
   859	
   860	func (dns *dnsMsg) String() string {
   861		s := "DNS: " + printStruct(&dns.dnsMsgHdr) + "\n"
   862		if len(dns.question) > 0 {
   863			s += "-- Questions\n"
   864			for i := 0; i < len(dns.question); i++ {
   865				s += printStruct(&dns.question[i]) + "\n"
   866			}
   867		}
   868		if len(dns.answer) > 0 {
   869			s += "-- Answers\n"
   870			for i := 0; i < len(dns.answer); i++ {
   871				s += printStruct(dns.answer[i]) + "\n"
   872			}
   873		}
   874		if len(dns.ns) > 0 {
   875			s += "-- Name servers\n"
   876			for i := 0; i < len(dns.ns); i++ {
   877				s += printStruct(dns.ns[i]) + "\n"
   878			}
   879		}
   880		if len(dns.extra) > 0 {
   881			s += "-- Extra\n"
   882			for i := 0; i < len(dns.extra); i++ {
   883				s += printStruct(dns.extra[i]) + "\n"
   884			}
   885		}
   886		return s
   887	}