Source file src/pkg/vendor/golang.org/x/net/dns/dnsmessage/message.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	// Package dnsmessage provides a mostly RFC 1035 compliant implementation of
     6	// DNS message packing and unpacking.
     7	//
     8	// The package also supports messages with Extension Mechanisms for DNS
     9	// (EDNS(0)) as defined in RFC 6891.
    10	//
    11	// This implementation is designed to minimize heap allocations and avoid
    12	// unnecessary packing and unpacking as much as possible.
    13	package dnsmessage
    14	
    15	import (
    16		"errors"
    17	)
    18	
    19	// Message formats
    20	
    21	// A Type is a type of DNS request and response.
    22	type Type uint16
    23	
    24	const (
    25		// ResourceHeader.Type and Question.Type
    26		TypeA     Type = 1
    27		TypeNS    Type = 2
    28		TypeCNAME Type = 5
    29		TypeSOA   Type = 6
    30		TypePTR   Type = 12
    31		TypeMX    Type = 15
    32		TypeTXT   Type = 16
    33		TypeAAAA  Type = 28
    34		TypeSRV   Type = 33
    35		TypeOPT   Type = 41
    36	
    37		// Question.Type
    38		TypeWKS   Type = 11
    39		TypeHINFO Type = 13
    40		TypeMINFO Type = 14
    41		TypeAXFR  Type = 252
    42		TypeALL   Type = 255
    43	)
    44	
    45	var typeNames = map[Type]string{
    46		TypeA:     "TypeA",
    47		TypeNS:    "TypeNS",
    48		TypeCNAME: "TypeCNAME",
    49		TypeSOA:   "TypeSOA",
    50		TypePTR:   "TypePTR",
    51		TypeMX:    "TypeMX",
    52		TypeTXT:   "TypeTXT",
    53		TypeAAAA:  "TypeAAAA",
    54		TypeSRV:   "TypeSRV",
    55		TypeOPT:   "TypeOPT",
    56		TypeWKS:   "TypeWKS",
    57		TypeHINFO: "TypeHINFO",
    58		TypeMINFO: "TypeMINFO",
    59		TypeAXFR:  "TypeAXFR",
    60		TypeALL:   "TypeALL",
    61	}
    62	
    63	// String implements fmt.Stringer.String.
    64	func (t Type) String() string {
    65		if n, ok := typeNames[t]; ok {
    66			return n
    67		}
    68		return printUint16(uint16(t))
    69	}
    70	
    71	// GoString implements fmt.GoStringer.GoString.
    72	func (t Type) GoString() string {
    73		if n, ok := typeNames[t]; ok {
    74			return "dnsmessage." + n
    75		}
    76		return printUint16(uint16(t))
    77	}
    78	
    79	// A Class is a type of network.
    80	type Class uint16
    81	
    82	const (
    83		// ResourceHeader.Class and Question.Class
    84		ClassINET   Class = 1
    85		ClassCSNET  Class = 2
    86		ClassCHAOS  Class = 3
    87		ClassHESIOD Class = 4
    88	
    89		// Question.Class
    90		ClassANY Class = 255
    91	)
    92	
    93	var classNames = map[Class]string{
    94		ClassINET:   "ClassINET",
    95		ClassCSNET:  "ClassCSNET",
    96		ClassCHAOS:  "ClassCHAOS",
    97		ClassHESIOD: "ClassHESIOD",
    98		ClassANY:    "ClassANY",
    99	}
   100	
   101	// String implements fmt.Stringer.String.
   102	func (c Class) String() string {
   103		if n, ok := classNames[c]; ok {
   104			return n
   105		}
   106		return printUint16(uint16(c))
   107	}
   108	
   109	// GoString implements fmt.GoStringer.GoString.
   110	func (c Class) GoString() string {
   111		if n, ok := classNames[c]; ok {
   112			return "dnsmessage." + n
   113		}
   114		return printUint16(uint16(c))
   115	}
   116	
   117	// An OpCode is a DNS operation code.
   118	type OpCode uint16
   119	
   120	// GoString implements fmt.GoStringer.GoString.
   121	func (o OpCode) GoString() string {
   122		return printUint16(uint16(o))
   123	}
   124	
   125	// An RCode is a DNS response status code.
   126	type RCode uint16
   127	
   128	const (
   129		// Message.Rcode
   130		RCodeSuccess        RCode = 0
   131		RCodeFormatError    RCode = 1
   132		RCodeServerFailure  RCode = 2
   133		RCodeNameError      RCode = 3
   134		RCodeNotImplemented RCode = 4
   135		RCodeRefused        RCode = 5
   136	)
   137	
   138	var rCodeNames = map[RCode]string{
   139		RCodeSuccess:        "RCodeSuccess",
   140		RCodeFormatError:    "RCodeFormatError",
   141		RCodeServerFailure:  "RCodeServerFailure",
   142		RCodeNameError:      "RCodeNameError",
   143		RCodeNotImplemented: "RCodeNotImplemented",
   144		RCodeRefused:        "RCodeRefused",
   145	}
   146	
   147	// String implements fmt.Stringer.String.
   148	func (r RCode) String() string {
   149		if n, ok := rCodeNames[r]; ok {
   150			return n
   151		}
   152		return printUint16(uint16(r))
   153	}
   154	
   155	// GoString implements fmt.GoStringer.GoString.
   156	func (r RCode) GoString() string {
   157		if n, ok := rCodeNames[r]; ok {
   158			return "dnsmessage." + n
   159		}
   160		return printUint16(uint16(r))
   161	}
   162	
   163	func printPaddedUint8(i uint8) string {
   164		b := byte(i)
   165		return string([]byte{
   166			b/100 + '0',
   167			b/10%10 + '0',
   168			b%10 + '0',
   169		})
   170	}
   171	
   172	func printUint8Bytes(buf []byte, i uint8) []byte {
   173		b := byte(i)
   174		if i >= 100 {
   175			buf = append(buf, b/100+'0')
   176		}
   177		if i >= 10 {
   178			buf = append(buf, b/10%10+'0')
   179		}
   180		return append(buf, b%10+'0')
   181	}
   182	
   183	func printByteSlice(b []byte) string {
   184		if len(b) == 0 {
   185			return ""
   186		}
   187		buf := make([]byte, 0, 5*len(b))
   188		buf = printUint8Bytes(buf, uint8(b[0]))
   189		for _, n := range b[1:] {
   190			buf = append(buf, ',', ' ')
   191			buf = printUint8Bytes(buf, uint8(n))
   192		}
   193		return string(buf)
   194	}
   195	
   196	const hexDigits = "0123456789abcdef"
   197	
   198	func printString(str []byte) string {
   199		buf := make([]byte, 0, len(str))
   200		for i := 0; i < len(str); i++ {
   201			c := str[i]
   202			if c == '.' || c == '-' || c == ' ' ||
   203				'A' <= c && c <= 'Z' ||
   204				'a' <= c && c <= 'z' ||
   205				'0' <= c && c <= '9' {
   206				buf = append(buf, c)
   207				continue
   208			}
   209	
   210			upper := c >> 4
   211			lower := (c << 4) >> 4
   212			buf = append(
   213				buf,
   214				'\\',
   215				'x',
   216				hexDigits[upper],
   217				hexDigits[lower],
   218			)
   219		}
   220		return string(buf)
   221	}
   222	
   223	func printUint16(i uint16) string {
   224		return printUint32(uint32(i))
   225	}
   226	
   227	func printUint32(i uint32) string {
   228		// Max value is 4294967295.
   229		buf := make([]byte, 10)
   230		for b, d := buf, uint32(1000000000); d > 0; d /= 10 {
   231			b[0] = byte(i/d%10 + '0')
   232			if b[0] == '0' && len(b) == len(buf) && len(buf) > 1 {
   233				buf = buf[1:]
   234			}
   235			b = b[1:]
   236			i %= d
   237		}
   238		return string(buf)
   239	}
   240	
   241	func printBool(b bool) string {
   242		if b {
   243			return "true"
   244		}
   245		return "false"
   246	}
   247	
   248	var (
   249		// ErrNotStarted indicates that the prerequisite information isn't
   250		// available yet because the previous records haven't been appropriately
   251		// parsed, skipped or finished.
   252		ErrNotStarted = errors.New("parsing/packing of this type isn't available yet")
   253	
   254		// ErrSectionDone indicated that all records in the section have been
   255		// parsed or finished.
   256		ErrSectionDone = errors.New("parsing/packing of this section has completed")
   257	
   258		errBaseLen            = errors.New("insufficient data for base length type")
   259		errCalcLen            = errors.New("insufficient data for calculated length type")
   260		errReserved           = errors.New("segment prefix is reserved")
   261		errTooManyPtr         = errors.New("too many pointers (>10)")
   262		errInvalidPtr         = errors.New("invalid pointer")
   263		errNilResouceBody     = errors.New("nil resource body")
   264		errResourceLen        = errors.New("insufficient data for resource body length")
   265		errSegTooLong         = errors.New("segment length too long")
   266		errZeroSegLen         = errors.New("zero length segment")
   267		errResTooLong         = errors.New("resource length too long")
   268		errTooManyQuestions   = errors.New("too many Questions to pack (>65535)")
   269		errTooManyAnswers     = errors.New("too many Answers to pack (>65535)")
   270		errTooManyAuthorities = errors.New("too many Authorities to pack (>65535)")
   271		errTooManyAdditionals = errors.New("too many Additionals to pack (>65535)")
   272		errNonCanonicalName   = errors.New("name is not in canonical format (it must end with a .)")
   273		errStringTooLong      = errors.New("character string exceeds maximum length (255)")
   274		errCompressedSRV      = errors.New("compressed name in SRV resource data")
   275	)
   276	
   277	// Internal constants.
   278	const (
   279		// packStartingCap is the default initial buffer size allocated during
   280		// packing.
   281		//
   282		// The starting capacity doesn't matter too much, but most DNS responses
   283		// Will be <= 512 bytes as it is the limit for DNS over UDP.
   284		packStartingCap = 512
   285	
   286		// uint16Len is the length (in bytes) of a uint16.
   287		uint16Len = 2
   288	
   289		// uint32Len is the length (in bytes) of a uint32.
   290		uint32Len = 4
   291	
   292		// headerLen is the length (in bytes) of a DNS header.
   293		//
   294		// A header is comprised of 6 uint16s and no padding.
   295		headerLen = 6 * uint16Len
   296	)
   297	
   298	type nestedError struct {
   299		// s is the current level's error message.
   300		s string
   301	
   302		// err is the nested error.
   303		err error
   304	}
   305	
   306	// nestedError implements error.Error.
   307	func (e *nestedError) Error() string {
   308		return e.s + ": " + e.err.Error()
   309	}
   310	
   311	// Header is a representation of a DNS message header.
   312	type Header struct {
   313		ID                 uint16
   314		Response           bool
   315		OpCode             OpCode
   316		Authoritative      bool
   317		Truncated          bool
   318		RecursionDesired   bool
   319		RecursionAvailable bool
   320		RCode              RCode
   321	}
   322	
   323	func (m *Header) pack() (id uint16, bits uint16) {
   324		id = m.ID
   325		bits = uint16(m.OpCode)<<11 | uint16(m.RCode)
   326		if m.RecursionAvailable {
   327			bits |= headerBitRA
   328		}
   329		if m.RecursionDesired {
   330			bits |= headerBitRD
   331		}
   332		if m.Truncated {
   333			bits |= headerBitTC
   334		}
   335		if m.Authoritative {
   336			bits |= headerBitAA
   337		}
   338		if m.Response {
   339			bits |= headerBitQR
   340		}
   341		return
   342	}
   343	
   344	// GoString implements fmt.GoStringer.GoString.
   345	func (m *Header) GoString() string {
   346		return "dnsmessage.Header{" +
   347			"ID: " + printUint16(m.ID) + ", " +
   348			"Response: " + printBool(m.Response) + ", " +
   349			"OpCode: " + m.OpCode.GoString() + ", " +
   350			"Authoritative: " + printBool(m.Authoritative) + ", " +
   351			"Truncated: " + printBool(m.Truncated) + ", " +
   352			"RecursionDesired: " + printBool(m.RecursionDesired) + ", " +
   353			"RecursionAvailable: " + printBool(m.RecursionAvailable) + ", " +
   354			"RCode: " + m.RCode.GoString() + "}"
   355	}
   356	
   357	// Message is a representation of a DNS message.
   358	type Message struct {
   359		Header
   360		Questions   []Question
   361		Answers     []Resource
   362		Authorities []Resource
   363		Additionals []Resource
   364	}
   365	
   366	type section uint8
   367	
   368	const (
   369		sectionNotStarted section = iota
   370		sectionHeader
   371		sectionQuestions
   372		sectionAnswers
   373		sectionAuthorities
   374		sectionAdditionals
   375		sectionDone
   376	
   377		headerBitQR = 1 << 15 // query/response (response=1)
   378		headerBitAA = 1 << 10 // authoritative
   379		headerBitTC = 1 << 9  // truncated
   380		headerBitRD = 1 << 8  // recursion desired
   381		headerBitRA = 1 << 7  // recursion available
   382	)
   383	
   384	var sectionNames = map[section]string{
   385		sectionHeader:      "header",
   386		sectionQuestions:   "Question",
   387		sectionAnswers:     "Answer",
   388		sectionAuthorities: "Authority",
   389		sectionAdditionals: "Additional",
   390	}
   391	
   392	// header is the wire format for a DNS message header.
   393	type header struct {
   394		id          uint16
   395		bits        uint16
   396		questions   uint16
   397		answers     uint16
   398		authorities uint16
   399		additionals uint16
   400	}
   401	
   402	func (h *header) count(sec section) uint16 {
   403		switch sec {
   404		case sectionQuestions:
   405			return h.questions
   406		case sectionAnswers:
   407			return h.answers
   408		case sectionAuthorities:
   409			return h.authorities
   410		case sectionAdditionals:
   411			return h.additionals
   412		}
   413		return 0
   414	}
   415	
   416	// pack appends the wire format of the header to msg.
   417	func (h *header) pack(msg []byte) []byte {
   418		msg = packUint16(msg, h.id)
   419		msg = packUint16(msg, h.bits)
   420		msg = packUint16(msg, h.questions)
   421		msg = packUint16(msg, h.answers)
   422		msg = packUint16(msg, h.authorities)
   423		return packUint16(msg, h.additionals)
   424	}
   425	
   426	func (h *header) unpack(msg []byte, off int) (int, error) {
   427		newOff := off
   428		var err error
   429		if h.id, newOff, err = unpackUint16(msg, newOff); err != nil {
   430			return off, &nestedError{"id", err}
   431		}
   432		if h.bits, newOff, err = unpackUint16(msg, newOff); err != nil {
   433			return off, &nestedError{"bits", err}
   434		}
   435		if h.questions, newOff, err = unpackUint16(msg, newOff); err != nil {
   436			return off, &nestedError{"questions", err}
   437		}
   438		if h.answers, newOff, err = unpackUint16(msg, newOff); err != nil {
   439			return off, &nestedError{"answers", err}
   440		}
   441		if h.authorities, newOff, err = unpackUint16(msg, newOff); err != nil {
   442			return off, &nestedError{"authorities", err}
   443		}
   444		if h.additionals, newOff, err = unpackUint16(msg, newOff); err != nil {
   445			return off, &nestedError{"additionals", err}
   446		}
   447		return newOff, nil
   448	}
   449	
   450	func (h *header) header() Header {
   451		return Header{
   452			ID:                 h.id,
   453			Response:           (h.bits & headerBitQR) != 0,
   454			OpCode:             OpCode(h.bits>>11) & 0xF,
   455			Authoritative:      (h.bits & headerBitAA) != 0,
   456			Truncated:          (h.bits & headerBitTC) != 0,
   457			RecursionDesired:   (h.bits & headerBitRD) != 0,
   458			RecursionAvailable: (h.bits & headerBitRA) != 0,
   459			RCode:              RCode(h.bits & 0xF),
   460		}
   461	}
   462	
   463	// A Resource is a DNS resource record.
   464	type Resource struct {
   465		Header ResourceHeader
   466		Body   ResourceBody
   467	}
   468	
   469	func (r *Resource) GoString() string {
   470		return "dnsmessage.Resource{" +
   471			"Header: " + r.Header.GoString() +
   472			", Body: &" + r.Body.GoString() +
   473			"}"
   474	}
   475	
   476	// A ResourceBody is a DNS resource record minus the header.
   477	type ResourceBody interface {
   478		// pack packs a Resource except for its header.
   479		pack(msg []byte, compression map[string]int, compressionOff int) ([]byte, error)
   480	
   481		// realType returns the actual type of the Resource. This is used to
   482		// fill in the header Type field.
   483		realType() Type
   484	
   485		// GoString implements fmt.GoStringer.GoString.
   486		GoString() string
   487	}
   488	
   489	// pack appends the wire format of the Resource to msg.
   490	func (r *Resource) pack(msg []byte, compression map[string]int, compressionOff int) ([]byte, error) {
   491		if r.Body == nil {
   492			return msg, errNilResouceBody
   493		}
   494		oldMsg := msg
   495		r.Header.Type = r.Body.realType()
   496		msg, lenOff, err := r.Header.pack(msg, compression, compressionOff)
   497		if err != nil {
   498			return msg, &nestedError{"ResourceHeader", err}
   499		}
   500		preLen := len(msg)
   501		msg, err = r.Body.pack(msg, compression, compressionOff)
   502		if err != nil {
   503			return msg, &nestedError{"content", err}
   504		}
   505		if err := r.Header.fixLen(msg, lenOff, preLen); err != nil {
   506			return oldMsg, err
   507		}
   508		return msg, nil
   509	}
   510	
   511	// A Parser allows incrementally parsing a DNS message.
   512	//
   513	// When parsing is started, the Header is parsed. Next, each Question can be
   514	// either parsed or skipped. Alternatively, all Questions can be skipped at
   515	// once. When all Questions have been parsed, attempting to parse Questions
   516	// will return (nil, nil) and attempting to skip Questions will return
   517	// (true, nil). After all Questions have been either parsed or skipped, all
   518	// Answers, Authorities and Additionals can be either parsed or skipped in the
   519	// same way, and each type of Resource must be fully parsed or skipped before
   520	// proceeding to the next type of Resource.
   521	//
   522	// Note that there is no requirement to fully skip or parse the message.
   523	type Parser struct {
   524		msg    []byte
   525		header header
   526	
   527		section        section
   528		off            int
   529		index          int
   530		resHeaderValid bool
   531		resHeader      ResourceHeader
   532	}
   533	
   534	// Start parses the header and enables the parsing of Questions.
   535	func (p *Parser) Start(msg []byte) (Header, error) {
   536		if p.msg != nil {
   537			*p = Parser{}
   538		}
   539		p.msg = msg
   540		var err error
   541		if p.off, err = p.header.unpack(msg, 0); err != nil {
   542			return Header{}, &nestedError{"unpacking header", err}
   543		}
   544		p.section = sectionQuestions
   545		return p.header.header(), nil
   546	}
   547	
   548	func (p *Parser) checkAdvance(sec section) error {
   549		if p.section < sec {
   550			return ErrNotStarted
   551		}
   552		if p.section > sec {
   553			return ErrSectionDone
   554		}
   555		p.resHeaderValid = false
   556		if p.index == int(p.header.count(sec)) {
   557			p.index = 0
   558			p.section++
   559			return ErrSectionDone
   560		}
   561		return nil
   562	}
   563	
   564	func (p *Parser) resource(sec section) (Resource, error) {
   565		var r Resource
   566		var err error
   567		r.Header, err = p.resourceHeader(sec)
   568		if err != nil {
   569			return r, err
   570		}
   571		p.resHeaderValid = false
   572		r.Body, p.off, err = unpackResourceBody(p.msg, p.off, r.Header)
   573		if err != nil {
   574			return Resource{}, &nestedError{"unpacking " + sectionNames[sec], err}
   575		}
   576		p.index++
   577		return r, nil
   578	}
   579	
   580	func (p *Parser) resourceHeader(sec section) (ResourceHeader, error) {
   581		if p.resHeaderValid {
   582			return p.resHeader, nil
   583		}
   584		if err := p.checkAdvance(sec); err != nil {
   585			return ResourceHeader{}, err
   586		}
   587		var hdr ResourceHeader
   588		off, err := hdr.unpack(p.msg, p.off)
   589		if err != nil {
   590			return ResourceHeader{}, err
   591		}
   592		p.resHeaderValid = true
   593		p.resHeader = hdr
   594		p.off = off
   595		return hdr, nil
   596	}
   597	
   598	func (p *Parser) skipResource(sec section) error {
   599		if p.resHeaderValid {
   600			newOff := p.off + int(p.resHeader.Length)
   601			if newOff > len(p.msg) {
   602				return errResourceLen
   603			}
   604			p.off = newOff
   605			p.resHeaderValid = false
   606			p.index++
   607			return nil
   608		}
   609		if err := p.checkAdvance(sec); err != nil {
   610			return err
   611		}
   612		var err error
   613		p.off, err = skipResource(p.msg, p.off)
   614		if err != nil {
   615			return &nestedError{"skipping: " + sectionNames[sec], err}
   616		}
   617		p.index++
   618		return nil
   619	}
   620	
   621	// Question parses a single Question.
   622	func (p *Parser) Question() (Question, error) {
   623		if err := p.checkAdvance(sectionQuestions); err != nil {
   624			return Question{}, err
   625		}
   626		var name Name
   627		off, err := name.unpack(p.msg, p.off)
   628		if err != nil {
   629			return Question{}, &nestedError{"unpacking Question.Name", err}
   630		}
   631		typ, off, err := unpackType(p.msg, off)
   632		if err != nil {
   633			return Question{}, &nestedError{"unpacking Question.Type", err}
   634		}
   635		class, off, err := unpackClass(p.msg, off)
   636		if err != nil {
   637			return Question{}, &nestedError{"unpacking Question.Class", err}
   638		}
   639		p.off = off
   640		p.index++
   641		return Question{name, typ, class}, nil
   642	}
   643	
   644	// AllQuestions parses all Questions.
   645	func (p *Parser) AllQuestions() ([]Question, error) {
   646		// Multiple questions are valid according to the spec,
   647		// but servers don't actually support them. There will
   648		// be at most one question here.
   649		//
   650		// Do not pre-allocate based on info in p.header, since
   651		// the data is untrusted.
   652		qs := []Question{}
   653		for {
   654			q, err := p.Question()
   655			if err == ErrSectionDone {
   656				return qs, nil
   657			}
   658			if err != nil {
   659				return nil, err
   660			}
   661			qs = append(qs, q)
   662		}
   663	}
   664	
   665	// SkipQuestion skips a single Question.
   666	func (p *Parser) SkipQuestion() error {
   667		if err := p.checkAdvance(sectionQuestions); err != nil {
   668			return err
   669		}
   670		off, err := skipName(p.msg, p.off)
   671		if err != nil {
   672			return &nestedError{"skipping Question Name", err}
   673		}
   674		if off, err = skipType(p.msg, off); err != nil {
   675			return &nestedError{"skipping Question Type", err}
   676		}
   677		if off, err = skipClass(p.msg, off); err != nil {
   678			return &nestedError{"skipping Question Class", err}
   679		}
   680		p.off = off
   681		p.index++
   682		return nil
   683	}
   684	
   685	// SkipAllQuestions skips all Questions.
   686	func (p *Parser) SkipAllQuestions() error {
   687		for {
   688			if err := p.SkipQuestion(); err == ErrSectionDone {
   689				return nil
   690			} else if err != nil {
   691				return err
   692			}
   693		}
   694	}
   695	
   696	// AnswerHeader parses a single Answer ResourceHeader.
   697	func (p *Parser) AnswerHeader() (ResourceHeader, error) {
   698		return p.resourceHeader(sectionAnswers)
   699	}
   700	
   701	// Answer parses a single Answer Resource.
   702	func (p *Parser) Answer() (Resource, error) {
   703		return p.resource(sectionAnswers)
   704	}
   705	
   706	// AllAnswers parses all Answer Resources.
   707	func (p *Parser) AllAnswers() ([]Resource, error) {
   708		// The most common query is for A/AAAA, which usually returns
   709		// a handful of IPs.
   710		//
   711		// Pre-allocate up to a certain limit, since p.header is
   712		// untrusted data.
   713		n := int(p.header.answers)
   714		if n > 20 {
   715			n = 20
   716		}
   717		as := make([]Resource, 0, n)
   718		for {
   719			a, err := p.Answer()
   720			if err == ErrSectionDone {
   721				return as, nil
   722			}
   723			if err != nil {
   724				return nil, err
   725			}
   726			as = append(as, a)
   727		}
   728	}
   729	
   730	// SkipAnswer skips a single Answer Resource.
   731	func (p *Parser) SkipAnswer() error {
   732		return p.skipResource(sectionAnswers)
   733	}
   734	
   735	// SkipAllAnswers skips all Answer Resources.
   736	func (p *Parser) SkipAllAnswers() error {
   737		for {
   738			if err := p.SkipAnswer(); err == ErrSectionDone {
   739				return nil
   740			} else if err != nil {
   741				return err
   742			}
   743		}
   744	}
   745	
   746	// AuthorityHeader parses a single Authority ResourceHeader.
   747	func (p *Parser) AuthorityHeader() (ResourceHeader, error) {
   748		return p.resourceHeader(sectionAuthorities)
   749	}
   750	
   751	// Authority parses a single Authority Resource.
   752	func (p *Parser) Authority() (Resource, error) {
   753		return p.resource(sectionAuthorities)
   754	}
   755	
   756	// AllAuthorities parses all Authority Resources.
   757	func (p *Parser) AllAuthorities() ([]Resource, error) {
   758		// Authorities contains SOA in case of NXDOMAIN and friends,
   759		// otherwise it is empty.
   760		//
   761		// Pre-allocate up to a certain limit, since p.header is
   762		// untrusted data.
   763		n := int(p.header.authorities)
   764		if n > 10 {
   765			n = 10
   766		}
   767		as := make([]Resource, 0, n)
   768		for {
   769			a, err := p.Authority()
   770			if err == ErrSectionDone {
   771				return as, nil
   772			}
   773			if err != nil {
   774				return nil, err
   775			}
   776			as = append(as, a)
   777		}
   778	}
   779	
   780	// SkipAuthority skips a single Authority Resource.
   781	func (p *Parser) SkipAuthority() error {
   782		return p.skipResource(sectionAuthorities)
   783	}
   784	
   785	// SkipAllAuthorities skips all Authority Resources.
   786	func (p *Parser) SkipAllAuthorities() error {
   787		for {
   788			if err := p.SkipAuthority(); err == ErrSectionDone {
   789				return nil
   790			} else if err != nil {
   791				return err
   792			}
   793		}
   794	}
   795	
   796	// AdditionalHeader parses a single Additional ResourceHeader.
   797	func (p *Parser) AdditionalHeader() (ResourceHeader, error) {
   798		return p.resourceHeader(sectionAdditionals)
   799	}
   800	
   801	// Additional parses a single Additional Resource.
   802	func (p *Parser) Additional() (Resource, error) {
   803		return p.resource(sectionAdditionals)
   804	}
   805	
   806	// AllAdditionals parses all Additional Resources.
   807	func (p *Parser) AllAdditionals() ([]Resource, error) {
   808		// Additionals usually contain OPT, and sometimes A/AAAA
   809		// glue records.
   810		//
   811		// Pre-allocate up to a certain limit, since p.header is
   812		// untrusted data.
   813		n := int(p.header.additionals)
   814		if n > 10 {
   815			n = 10
   816		}
   817		as := make([]Resource, 0, n)
   818		for {
   819			a, err := p.Additional()
   820			if err == ErrSectionDone {
   821				return as, nil
   822			}
   823			if err != nil {
   824				return nil, err
   825			}
   826			as = append(as, a)
   827		}
   828	}
   829	
   830	// SkipAdditional skips a single Additional Resource.
   831	func (p *Parser) SkipAdditional() error {
   832		return p.skipResource(sectionAdditionals)
   833	}
   834	
   835	// SkipAllAdditionals skips all Additional Resources.
   836	func (p *Parser) SkipAllAdditionals() error {
   837		for {
   838			if err := p.SkipAdditional(); err == ErrSectionDone {
   839				return nil
   840			} else if err != nil {
   841				return err
   842			}
   843		}
   844	}
   845	
   846	// CNAMEResource parses a single CNAMEResource.
   847	//
   848	// One of the XXXHeader methods must have been called before calling this
   849	// method.
   850	func (p *Parser) CNAMEResource() (CNAMEResource, error) {
   851		if !p.resHeaderValid || p.resHeader.Type != TypeCNAME {
   852			return CNAMEResource{}, ErrNotStarted
   853		}
   854		r, err := unpackCNAMEResource(p.msg, p.off)
   855		if err != nil {
   856			return CNAMEResource{}, err
   857		}
   858		p.off += int(p.resHeader.Length)
   859		p.resHeaderValid = false
   860		p.index++
   861		return r, nil
   862	}
   863	
   864	// MXResource parses a single MXResource.
   865	//
   866	// One of the XXXHeader methods must have been called before calling this
   867	// method.
   868	func (p *Parser) MXResource() (MXResource, error) {
   869		if !p.resHeaderValid || p.resHeader.Type != TypeMX {
   870			return MXResource{}, ErrNotStarted
   871		}
   872		r, err := unpackMXResource(p.msg, p.off)
   873		if err != nil {
   874			return MXResource{}, err
   875		}
   876		p.off += int(p.resHeader.Length)
   877		p.resHeaderValid = false
   878		p.index++
   879		return r, nil
   880	}
   881	
   882	// NSResource parses a single NSResource.
   883	//
   884	// One of the XXXHeader methods must have been called before calling this
   885	// method.
   886	func (p *Parser) NSResource() (NSResource, error) {
   887		if !p.resHeaderValid || p.resHeader.Type != TypeNS {
   888			return NSResource{}, ErrNotStarted
   889		}
   890		r, err := unpackNSResource(p.msg, p.off)
   891		if err != nil {
   892			return NSResource{}, err
   893		}
   894		p.off += int(p.resHeader.Length)
   895		p.resHeaderValid = false
   896		p.index++
   897		return r, nil
   898	}
   899	
   900	// PTRResource parses a single PTRResource.
   901	//
   902	// One of the XXXHeader methods must have been called before calling this
   903	// method.
   904	func (p *Parser) PTRResource() (PTRResource, error) {
   905		if !p.resHeaderValid || p.resHeader.Type != TypePTR {
   906			return PTRResource{}, ErrNotStarted
   907		}
   908		r, err := unpackPTRResource(p.msg, p.off)
   909		if err != nil {
   910			return PTRResource{}, err
   911		}
   912		p.off += int(p.resHeader.Length)
   913		p.resHeaderValid = false
   914		p.index++
   915		return r, nil
   916	}
   917	
   918	// SOAResource parses a single SOAResource.
   919	//
   920	// One of the XXXHeader methods must have been called before calling this
   921	// method.
   922	func (p *Parser) SOAResource() (SOAResource, error) {
   923		if !p.resHeaderValid || p.resHeader.Type != TypeSOA {
   924			return SOAResource{}, ErrNotStarted
   925		}
   926		r, err := unpackSOAResource(p.msg, p.off)
   927		if err != nil {
   928			return SOAResource{}, err
   929		}
   930		p.off += int(p.resHeader.Length)
   931		p.resHeaderValid = false
   932		p.index++
   933		return r, nil
   934	}
   935	
   936	// TXTResource parses a single TXTResource.
   937	//
   938	// One of the XXXHeader methods must have been called before calling this
   939	// method.
   940	func (p *Parser) TXTResource() (TXTResource, error) {
   941		if !p.resHeaderValid || p.resHeader.Type != TypeTXT {
   942			return TXTResource{}, ErrNotStarted
   943		}
   944		r, err := unpackTXTResource(p.msg, p.off, p.resHeader.Length)
   945		if err != nil {
   946			return TXTResource{}, err
   947		}
   948		p.off += int(p.resHeader.Length)
   949		p.resHeaderValid = false
   950		p.index++
   951		return r, nil
   952	}
   953	
   954	// SRVResource parses a single SRVResource.
   955	//
   956	// One of the XXXHeader methods must have been called before calling this
   957	// method.
   958	func (p *Parser) SRVResource() (SRVResource, error) {
   959		if !p.resHeaderValid || p.resHeader.Type != TypeSRV {
   960			return SRVResource{}, ErrNotStarted
   961		}
   962		r, err := unpackSRVResource(p.msg, p.off)
   963		if err != nil {
   964			return SRVResource{}, err
   965		}
   966		p.off += int(p.resHeader.Length)
   967		p.resHeaderValid = false
   968		p.index++
   969		return r, nil
   970	}
   971	
   972	// AResource parses a single AResource.
   973	//
   974	// One of the XXXHeader methods must have been called before calling this
   975	// method.
   976	func (p *Parser) AResource() (AResource, error) {
   977		if !p.resHeaderValid || p.resHeader.Type != TypeA {
   978			return AResource{}, ErrNotStarted
   979		}
   980		r, err := unpackAResource(p.msg, p.off)
   981		if err != nil {
   982			return AResource{}, err
   983		}
   984		p.off += int(p.resHeader.Length)
   985		p.resHeaderValid = false
   986		p.index++
   987		return r, nil
   988	}
   989	
   990	// AAAAResource parses a single AAAAResource.
   991	//
   992	// One of the XXXHeader methods must have been called before calling this
   993	// method.
   994	func (p *Parser) AAAAResource() (AAAAResource, error) {
   995		if !p.resHeaderValid || p.resHeader.Type != TypeAAAA {
   996			return AAAAResource{}, ErrNotStarted
   997		}
   998		r, err := unpackAAAAResource(p.msg, p.off)
   999		if err != nil {
  1000			return AAAAResource{}, err
  1001		}
  1002		p.off += int(p.resHeader.Length)
  1003		p.resHeaderValid = false
  1004		p.index++
  1005		return r, nil
  1006	}
  1007	
  1008	// OPTResource parses a single OPTResource.
  1009	//
  1010	// One of the XXXHeader methods must have been called before calling this
  1011	// method.
  1012	func (p *Parser) OPTResource() (OPTResource, error) {
  1013		if !p.resHeaderValid || p.resHeader.Type != TypeOPT {
  1014			return OPTResource{}, ErrNotStarted
  1015		}
  1016		r, err := unpackOPTResource(p.msg, p.off, p.resHeader.Length)
  1017		if err != nil {
  1018			return OPTResource{}, err
  1019		}
  1020		p.off += int(p.resHeader.Length)
  1021		p.resHeaderValid = false
  1022		p.index++
  1023		return r, nil
  1024	}
  1025	
  1026	// Unpack parses a full Message.
  1027	func (m *Message) Unpack(msg []byte) error {
  1028		var p Parser
  1029		var err error
  1030		if m.Header, err = p.Start(msg); err != nil {
  1031			return err
  1032		}
  1033		if m.Questions, err = p.AllQuestions(); err != nil {
  1034			return err
  1035		}
  1036		if m.Answers, err = p.AllAnswers(); err != nil {
  1037			return err
  1038		}
  1039		if m.Authorities, err = p.AllAuthorities(); err != nil {
  1040			return err
  1041		}
  1042		if m.Additionals, err = p.AllAdditionals(); err != nil {
  1043			return err
  1044		}
  1045		return nil
  1046	}
  1047	
  1048	// Pack packs a full Message.
  1049	func (m *Message) Pack() ([]byte, error) {
  1050		return m.AppendPack(make([]byte, 0, packStartingCap))
  1051	}
  1052	
  1053	// AppendPack is like Pack but appends the full Message to b and returns the
  1054	// extended buffer.
  1055	func (m *Message) AppendPack(b []byte) ([]byte, error) {
  1056		// Validate the lengths. It is very unlikely that anyone will try to
  1057		// pack more than 65535 of any particular type, but it is possible and
  1058		// we should fail gracefully.
  1059		if len(m.Questions) > int(^uint16(0)) {
  1060			return nil, errTooManyQuestions
  1061		}
  1062		if len(m.Answers) > int(^uint16(0)) {
  1063			return nil, errTooManyAnswers
  1064		}
  1065		if len(m.Authorities) > int(^uint16(0)) {
  1066			return nil, errTooManyAuthorities
  1067		}
  1068		if len(m.Additionals) > int(^uint16(0)) {
  1069			return nil, errTooManyAdditionals
  1070		}
  1071	
  1072		var h header
  1073		h.id, h.bits = m.Header.pack()
  1074	
  1075		h.questions = uint16(len(m.Questions))
  1076		h.answers = uint16(len(m.Answers))
  1077		h.authorities = uint16(len(m.Authorities))
  1078		h.additionals = uint16(len(m.Additionals))
  1079	
  1080		compressionOff := len(b)
  1081		msg := h.pack(b)
  1082	
  1083		// RFC 1035 allows (but does not require) compression for packing. RFC
  1084		// 1035 requires unpacking implementations to support compression, so
  1085		// unconditionally enabling it is fine.
  1086		//
  1087		// DNS lookups are typically done over UDP, and RFC 1035 states that UDP
  1088		// DNS messages can be a maximum of 512 bytes long. Without compression,
  1089		// many DNS response messages are over this limit, so enabling
  1090		// compression will help ensure compliance.
  1091		compression := map[string]int{}
  1092	
  1093		for i := range m.Questions {
  1094			var err error
  1095			if msg, err = m.Questions[i].pack(msg, compression, compressionOff); err != nil {
  1096				return nil, &nestedError{"packing Question", err}
  1097			}
  1098		}
  1099		for i := range m.Answers {
  1100			var err error
  1101			if msg, err = m.Answers[i].pack(msg, compression, compressionOff); err != nil {
  1102				return nil, &nestedError{"packing Answer", err}
  1103			}
  1104		}
  1105		for i := range m.Authorities {
  1106			var err error
  1107			if msg, err = m.Authorities[i].pack(msg, compression, compressionOff); err != nil {
  1108				return nil, &nestedError{"packing Authority", err}
  1109			}
  1110		}
  1111		for i := range m.Additionals {
  1112			var err error
  1113			if msg, err = m.Additionals[i].pack(msg, compression, compressionOff); err != nil {
  1114				return nil, &nestedError{"packing Additional", err}
  1115			}
  1116		}
  1117	
  1118		return msg, nil
  1119	}
  1120	
  1121	// GoString implements fmt.GoStringer.GoString.
  1122	func (m *Message) GoString() string {
  1123		s := "dnsmessage.Message{Header: " + m.Header.GoString() + ", " +
  1124			"Questions: []dnsmessage.Question{"
  1125		if len(m.Questions) > 0 {
  1126			s += m.Questions[0].GoString()
  1127			for _, q := range m.Questions[1:] {
  1128				s += ", " + q.GoString()
  1129			}
  1130		}
  1131		s += "}, Answers: []dnsmessage.Resource{"
  1132		if len(m.Answers) > 0 {
  1133			s += m.Answers[0].GoString()
  1134			for _, a := range m.Answers[1:] {
  1135				s += ", " + a.GoString()
  1136			}
  1137		}
  1138		s += "}, Authorities: []dnsmessage.Resource{"
  1139		if len(m.Authorities) > 0 {
  1140			s += m.Authorities[0].GoString()
  1141			for _, a := range m.Authorities[1:] {
  1142				s += ", " + a.GoString()
  1143			}
  1144		}
  1145		s += "}, Additionals: []dnsmessage.Resource{"
  1146		if len(m.Additionals) > 0 {
  1147			s += m.Additionals[0].GoString()
  1148			for _, a := range m.Additionals[1:] {
  1149				s += ", " + a.GoString()
  1150			}
  1151		}
  1152		return s + "}}"
  1153	}
  1154	
  1155	// A Builder allows incrementally packing a DNS message.
  1156	//
  1157	// Example usage:
  1158	//	buf := make([]byte, 2, 514)
  1159	//	b := NewBuilder(buf, Header{...})
  1160	//	b.EnableCompression()
  1161	//	// Optionally start a section and add things to that section.
  1162	//	// Repeat adding sections as necessary.
  1163	//	buf, err := b.Finish()
  1164	//	// If err is nil, buf[2:] will contain the built bytes.
  1165	type Builder struct {
  1166		// msg is the storage for the message being built.
  1167		msg []byte
  1168	
  1169		// section keeps track of the current section being built.
  1170		section section
  1171	
  1172		// header keeps track of what should go in the header when Finish is
  1173		// called.
  1174		header header
  1175	
  1176		// start is the starting index of the bytes allocated in msg for header.
  1177		start int
  1178	
  1179		// compression is a mapping from name suffixes to their starting index
  1180		// in msg.
  1181		compression map[string]int
  1182	}
  1183	
  1184	// NewBuilder creates a new builder with compression disabled.
  1185	//
  1186	// Note: Most users will want to immediately enable compression with the
  1187	// EnableCompression method. See that method's comment for why you may or may
  1188	// not want to enable compression.
  1189	//
  1190	// The DNS message is appended to the provided initial buffer buf (which may be
  1191	// nil) as it is built. The final message is returned by the (*Builder).Finish
  1192	// method, which may return the same underlying array if there was sufficient
  1193	// capacity in the slice.
  1194	func NewBuilder(buf []byte, h Header) Builder {
  1195		if buf == nil {
  1196			buf = make([]byte, 0, packStartingCap)
  1197		}
  1198		b := Builder{msg: buf, start: len(buf)}
  1199		b.header.id, b.header.bits = h.pack()
  1200		var hb [headerLen]byte
  1201		b.msg = append(b.msg, hb[:]...)
  1202		b.section = sectionHeader
  1203		return b
  1204	}
  1205	
  1206	// EnableCompression enables compression in the Builder.
  1207	//
  1208	// Leaving compression disabled avoids compression related allocations, but can
  1209	// result in larger message sizes. Be careful with this mode as it can cause
  1210	// messages to exceed the UDP size limit.
  1211	//
  1212	// According to RFC 1035, section 4.1.4, the use of compression is optional, but
  1213	// all implementations must accept both compressed and uncompressed DNS
  1214	// messages.
  1215	//
  1216	// Compression should be enabled before any sections are added for best results.
  1217	func (b *Builder) EnableCompression() {
  1218		b.compression = map[string]int{}
  1219	}
  1220	
  1221	func (b *Builder) startCheck(s section) error {
  1222		if b.section <= sectionNotStarted {
  1223			return ErrNotStarted
  1224		}
  1225		if b.section > s {
  1226			return ErrSectionDone
  1227		}
  1228		return nil
  1229	}
  1230	
  1231	// StartQuestions prepares the builder for packing Questions.
  1232	func (b *Builder) StartQuestions() error {
  1233		if err := b.startCheck(sectionQuestions); err != nil {
  1234			return err
  1235		}
  1236		b.section = sectionQuestions
  1237		return nil
  1238	}
  1239	
  1240	// StartAnswers prepares the builder for packing Answers.
  1241	func (b *Builder) StartAnswers() error {
  1242		if err := b.startCheck(sectionAnswers); err != nil {
  1243			return err
  1244		}
  1245		b.section = sectionAnswers
  1246		return nil
  1247	}
  1248	
  1249	// StartAuthorities prepares the builder for packing Authorities.
  1250	func (b *Builder) StartAuthorities() error {
  1251		if err := b.startCheck(sectionAuthorities); err != nil {
  1252			return err
  1253		}
  1254		b.section = sectionAuthorities
  1255		return nil
  1256	}
  1257	
  1258	// StartAdditionals prepares the builder for packing Additionals.
  1259	func (b *Builder) StartAdditionals() error {
  1260		if err := b.startCheck(sectionAdditionals); err != nil {
  1261			return err
  1262		}
  1263		b.section = sectionAdditionals
  1264		return nil
  1265	}
  1266	
  1267	func (b *Builder) incrementSectionCount() error {
  1268		var count *uint16
  1269		var err error
  1270		switch b.section {
  1271		case sectionQuestions:
  1272			count = &b.header.questions
  1273			err = errTooManyQuestions
  1274		case sectionAnswers:
  1275			count = &b.header.answers
  1276			err = errTooManyAnswers
  1277		case sectionAuthorities:
  1278			count = &b.header.authorities
  1279			err = errTooManyAuthorities
  1280		case sectionAdditionals:
  1281			count = &b.header.additionals
  1282			err = errTooManyAdditionals
  1283		}
  1284		if *count == ^uint16(0) {
  1285			return err
  1286		}
  1287		*count++
  1288		return nil
  1289	}
  1290	
  1291	// Question adds a single Question.
  1292	func (b *Builder) Question(q Question) error {
  1293		if b.section < sectionQuestions {
  1294			return ErrNotStarted
  1295		}
  1296		if b.section > sectionQuestions {
  1297			return ErrSectionDone
  1298		}
  1299		msg, err := q.pack(b.msg, b.compression, b.start)
  1300		if err != nil {
  1301			return err
  1302		}
  1303		if err := b.incrementSectionCount(); err != nil {
  1304			return err
  1305		}
  1306		b.msg = msg
  1307		return nil
  1308	}
  1309	
  1310	func (b *Builder) checkResourceSection() error {
  1311		if b.section < sectionAnswers {
  1312			return ErrNotStarted
  1313		}
  1314		if b.section > sectionAdditionals {
  1315			return ErrSectionDone
  1316		}
  1317		return nil
  1318	}
  1319	
  1320	// CNAMEResource adds a single CNAMEResource.
  1321	func (b *Builder) CNAMEResource(h ResourceHeader, r CNAMEResource) error {
  1322		if err := b.checkResourceSection(); err != nil {
  1323			return err
  1324		}
  1325		h.Type = r.realType()
  1326		msg, lenOff, err := h.pack(b.msg, b.compression, b.start)
  1327		if err != nil {
  1328			return &nestedError{"ResourceHeader", err}
  1329		}
  1330		preLen := len(msg)
  1331		if msg, err = r.pack(msg, b.compression, b.start); err != nil {
  1332			return &nestedError{"CNAMEResource body", err}
  1333		}
  1334		if err := h.fixLen(msg, lenOff, preLen); err != nil {
  1335			return err
  1336		}
  1337		if err := b.incrementSectionCount(); err != nil {
  1338			return err
  1339		}
  1340		b.msg = msg
  1341		return nil
  1342	}
  1343	
  1344	// MXResource adds a single MXResource.
  1345	func (b *Builder) MXResource(h ResourceHeader, r MXResource) error {
  1346		if err := b.checkResourceSection(); err != nil {
  1347			return err
  1348		}
  1349		h.Type = r.realType()
  1350		msg, lenOff, err := h.pack(b.msg, b.compression, b.start)
  1351		if err != nil {
  1352			return &nestedError{"ResourceHeader", err}
  1353		}
  1354		preLen := len(msg)
  1355		if msg, err = r.pack(msg, b.compression, b.start); err != nil {
  1356			return &nestedError{"MXResource body", err}
  1357		}
  1358		if err := h.fixLen(msg, lenOff, preLen); err != nil {
  1359			return err
  1360		}
  1361		if err := b.incrementSectionCount(); err != nil {
  1362			return err
  1363		}
  1364		b.msg = msg
  1365		return nil
  1366	}
  1367	
  1368	// NSResource adds a single NSResource.
  1369	func (b *Builder) NSResource(h ResourceHeader, r NSResource) error {
  1370		if err := b.checkResourceSection(); err != nil {
  1371			return err
  1372		}
  1373		h.Type = r.realType()
  1374		msg, lenOff, err := h.pack(b.msg, b.compression, b.start)
  1375		if err != nil {
  1376			return &nestedError{"ResourceHeader", err}
  1377		}
  1378		preLen := len(msg)
  1379		if msg, err = r.pack(msg, b.compression, b.start); err != nil {
  1380			return &nestedError{"NSResource body", err}
  1381		}
  1382		if err := h.fixLen(msg, lenOff, preLen); err != nil {
  1383			return err
  1384		}
  1385		if err := b.incrementSectionCount(); err != nil {
  1386			return err
  1387		}
  1388		b.msg = msg
  1389		return nil
  1390	}
  1391	
  1392	// PTRResource adds a single PTRResource.
  1393	func (b *Builder) PTRResource(h ResourceHeader, r PTRResource) error {
  1394		if err := b.checkResourceSection(); err != nil {
  1395			return err
  1396		}
  1397		h.Type = r.realType()
  1398		msg, lenOff, err := h.pack(b.msg, b.compression, b.start)
  1399		if err != nil {
  1400			return &nestedError{"ResourceHeader", err}
  1401		}
  1402		preLen := len(msg)
  1403		if msg, err = r.pack(msg, b.compression, b.start); err != nil {
  1404			return &nestedError{"PTRResource body", err}
  1405		}
  1406		if err := h.fixLen(msg, lenOff, preLen); err != nil {
  1407			return err
  1408		}
  1409		if err := b.incrementSectionCount(); err != nil {
  1410			return err
  1411		}
  1412		b.msg = msg
  1413		return nil
  1414	}
  1415	
  1416	// SOAResource adds a single SOAResource.
  1417	func (b *Builder) SOAResource(h ResourceHeader, r SOAResource) error {
  1418		if err := b.checkResourceSection(); err != nil {
  1419			return err
  1420		}
  1421		h.Type = r.realType()
  1422		msg, lenOff, err := h.pack(b.msg, b.compression, b.start)
  1423		if err != nil {
  1424			return &nestedError{"ResourceHeader", err}
  1425		}
  1426		preLen := len(msg)
  1427		if msg, err = r.pack(msg, b.compression, b.start); err != nil {
  1428			return &nestedError{"SOAResource body", err}
  1429		}
  1430		if err := h.fixLen(msg, lenOff, preLen); err != nil {
  1431			return err
  1432		}
  1433		if err := b.incrementSectionCount(); err != nil {
  1434			return err
  1435		}
  1436		b.msg = msg
  1437		return nil
  1438	}
  1439	
  1440	// TXTResource adds a single TXTResource.
  1441	func (b *Builder) TXTResource(h ResourceHeader, r TXTResource) error {
  1442		if err := b.checkResourceSection(); err != nil {
  1443			return err
  1444		}
  1445		h.Type = r.realType()
  1446		msg, lenOff, err := h.pack(b.msg, b.compression, b.start)
  1447		if err != nil {
  1448			return &nestedError{"ResourceHeader", err}
  1449		}
  1450		preLen := len(msg)
  1451		if msg, err = r.pack(msg, b.compression, b.start); err != nil {
  1452			return &nestedError{"TXTResource body", err}
  1453		}
  1454		if err := h.fixLen(msg, lenOff, preLen); err != nil {
  1455			return err
  1456		}
  1457		if err := b.incrementSectionCount(); err != nil {
  1458			return err
  1459		}
  1460		b.msg = msg
  1461		return nil
  1462	}
  1463	
  1464	// SRVResource adds a single SRVResource.
  1465	func (b *Builder) SRVResource(h ResourceHeader, r SRVResource) error {
  1466		if err := b.checkResourceSection(); err != nil {
  1467			return err
  1468		}
  1469		h.Type = r.realType()
  1470		msg, lenOff, err := h.pack(b.msg, b.compression, b.start)
  1471		if err != nil {
  1472			return &nestedError{"ResourceHeader", err}
  1473		}
  1474		preLen := len(msg)
  1475		if msg, err = r.pack(msg, b.compression, b.start); err != nil {
  1476			return &nestedError{"SRVResource body", err}
  1477		}
  1478		if err := h.fixLen(msg, lenOff, preLen); err != nil {
  1479			return err
  1480		}
  1481		if err := b.incrementSectionCount(); err != nil {
  1482			return err
  1483		}
  1484		b.msg = msg
  1485		return nil
  1486	}
  1487	
  1488	// AResource adds a single AResource.
  1489	func (b *Builder) AResource(h ResourceHeader, r AResource) error {
  1490		if err := b.checkResourceSection(); err != nil {
  1491			return err
  1492		}
  1493		h.Type = r.realType()
  1494		msg, lenOff, err := h.pack(b.msg, b.compression, b.start)
  1495		if err != nil {
  1496			return &nestedError{"ResourceHeader", err}
  1497		}
  1498		preLen := len(msg)
  1499		if msg, err = r.pack(msg, b.compression, b.start); err != nil {
  1500			return &nestedError{"AResource body", err}
  1501		}
  1502		if err := h.fixLen(msg, lenOff, preLen); err != nil {
  1503			return err
  1504		}
  1505		if err := b.incrementSectionCount(); err != nil {
  1506			return err
  1507		}
  1508		b.msg = msg
  1509		return nil
  1510	}
  1511	
  1512	// AAAAResource adds a single AAAAResource.
  1513	func (b *Builder) AAAAResource(h ResourceHeader, r AAAAResource) error {
  1514		if err := b.checkResourceSection(); err != nil {
  1515			return err
  1516		}
  1517		h.Type = r.realType()
  1518		msg, lenOff, err := h.pack(b.msg, b.compression, b.start)
  1519		if err != nil {
  1520			return &nestedError{"ResourceHeader", err}
  1521		}
  1522		preLen := len(msg)
  1523		if msg, err = r.pack(msg, b.compression, b.start); err != nil {
  1524			return &nestedError{"AAAAResource body", err}
  1525		}
  1526		if err := h.fixLen(msg, lenOff, preLen); err != nil {
  1527			return err
  1528		}
  1529		if err := b.incrementSectionCount(); err != nil {
  1530			return err
  1531		}
  1532		b.msg = msg
  1533		return nil
  1534	}
  1535	
  1536	// OPTResource adds a single OPTResource.
  1537	func (b *Builder) OPTResource(h ResourceHeader, r OPTResource) error {
  1538		if err := b.checkResourceSection(); err != nil {
  1539			return err
  1540		}
  1541		h.Type = r.realType()
  1542		msg, lenOff, err := h.pack(b.msg, b.compression, b.start)
  1543		if err != nil {
  1544			return &nestedError{"ResourceHeader", err}
  1545		}
  1546		preLen := len(msg)
  1547		if msg, err = r.pack(msg, b.compression, b.start); err != nil {
  1548			return &nestedError{"OPTResource body", err}
  1549		}
  1550		if err := h.fixLen(msg, lenOff, preLen); err != nil {
  1551			return err
  1552		}
  1553		if err := b.incrementSectionCount(); err != nil {
  1554			return err
  1555		}
  1556		b.msg = msg
  1557		return nil
  1558	}
  1559	
  1560	// Finish ends message building and generates a binary message.
  1561	func (b *Builder) Finish() ([]byte, error) {
  1562		if b.section < sectionHeader {
  1563			return nil, ErrNotStarted
  1564		}
  1565		b.section = sectionDone
  1566		// Space for the header was allocated in NewBuilder.
  1567		b.header.pack(b.msg[b.start:b.start])
  1568		return b.msg, nil
  1569	}
  1570	
  1571	// A ResourceHeader is the header of a DNS resource record. There are
  1572	// many types of DNS resource records, but they all share the same header.
  1573	type ResourceHeader struct {
  1574		// Name is the domain name for which this resource record pertains.
  1575		Name Name
  1576	
  1577		// Type is the type of DNS resource record.
  1578		//
  1579		// This field will be set automatically during packing.
  1580		Type Type
  1581	
  1582		// Class is the class of network to which this DNS resource record
  1583		// pertains.
  1584		Class Class
  1585	
  1586		// TTL is the length of time (measured in seconds) which this resource
  1587		// record is valid for (time to live). All Resources in a set should
  1588		// have the same TTL (RFC 2181 Section 5.2).
  1589		TTL uint32
  1590	
  1591		// Length is the length of data in the resource record after the header.
  1592		//
  1593		// This field will be set automatically during packing.
  1594		Length uint16
  1595	}
  1596	
  1597	// GoString implements fmt.GoStringer.GoString.
  1598	func (h *ResourceHeader) GoString() string {
  1599		return "dnsmessage.ResourceHeader{" +
  1600			"Name: " + h.Name.GoString() + ", " +
  1601			"Type: " + h.Type.GoString() + ", " +
  1602			"Class: " + h.Class.GoString() + ", " +
  1603			"TTL: " + printUint32(h.TTL) + ", " +
  1604			"Length: " + printUint16(h.Length) + "}"
  1605	}
  1606	
  1607	// pack appends the wire format of the ResourceHeader to oldMsg.
  1608	//
  1609	// lenOff is the offset in msg where the Length field was packed.
  1610	func (h *ResourceHeader) pack(oldMsg []byte, compression map[string]int, compressionOff int) (msg []byte, lenOff int, err error) {
  1611		msg = oldMsg
  1612		if msg, err = h.Name.pack(msg, compression, compressionOff); err != nil {
  1613			return oldMsg, 0, &nestedError{"Name", err}
  1614		}
  1615		msg = packType(msg, h.Type)
  1616		msg = packClass(msg, h.Class)
  1617		msg = packUint32(msg, h.TTL)
  1618		lenOff = len(msg)
  1619		msg = packUint16(msg, h.Length)
  1620		return msg, lenOff, nil
  1621	}
  1622	
  1623	func (h *ResourceHeader) unpack(msg []byte, off int) (int, error) {
  1624		newOff := off
  1625		var err error
  1626		if newOff, err = h.Name.unpack(msg, newOff); err != nil {
  1627			return off, &nestedError{"Name", err}
  1628		}
  1629		if h.Type, newOff, err = unpackType(msg, newOff); err != nil {
  1630			return off, &nestedError{"Type", err}
  1631		}
  1632		if h.Class, newOff, err = unpackClass(msg, newOff); err != nil {
  1633			return off, &nestedError{"Class", err}
  1634		}
  1635		if h.TTL, newOff, err = unpackUint32(msg, newOff); err != nil {
  1636			return off, &nestedError{"TTL", err}
  1637		}
  1638		if h.Length, newOff, err = unpackUint16(msg, newOff); err != nil {
  1639			return off, &nestedError{"Length", err}
  1640		}
  1641		return newOff, nil
  1642	}
  1643	
  1644	// fixLen updates a packed ResourceHeader to include the length of the
  1645	// ResourceBody.
  1646	//
  1647	// lenOff is the offset of the ResourceHeader.Length field in msg.
  1648	//
  1649	// preLen is the length that msg was before the ResourceBody was packed.
  1650	func (h *ResourceHeader) fixLen(msg []byte, lenOff int, preLen int) error {
  1651		conLen := len(msg) - preLen
  1652		if conLen > int(^uint16(0)) {
  1653			return errResTooLong
  1654		}
  1655	
  1656		// Fill in the length now that we know how long the content is.
  1657		packUint16(msg[lenOff:lenOff], uint16(conLen))
  1658		h.Length = uint16(conLen)
  1659	
  1660		return nil
  1661	}
  1662	
  1663	// EDNS(0) wire costants.
  1664	const (
  1665		edns0Version = 0
  1666	
  1667		edns0DNSSECOK     = 0x00008000
  1668		ednsVersionMask   = 0x00ff0000
  1669		edns0DNSSECOKMask = 0x00ff8000
  1670	)
  1671	
  1672	// SetEDNS0 configures h for EDNS(0).
  1673	//
  1674	// The provided extRCode must be an extedned RCode.
  1675	func (h *ResourceHeader) SetEDNS0(udpPayloadLen int, extRCode RCode, dnssecOK bool) error {
  1676		h.Name = Name{Data: [nameLen]byte{'.'}, Length: 1} // RFC 6891 section 6.1.2
  1677		h.Type = TypeOPT
  1678		h.Class = Class(udpPayloadLen)
  1679		h.TTL = uint32(extRCode) >> 4 << 24
  1680		if dnssecOK {
  1681			h.TTL |= edns0DNSSECOK
  1682		}
  1683		return nil
  1684	}
  1685	
  1686	// DNSSECAllowed reports whether the DNSSEC OK bit is set.
  1687	func (h *ResourceHeader) DNSSECAllowed() bool {
  1688		return h.TTL&edns0DNSSECOKMask == edns0DNSSECOK // RFC 6891 section 6.1.3
  1689	}
  1690	
  1691	// ExtendedRCode returns an extended RCode.
  1692	//
  1693	// The provided rcode must be the RCode in DNS message header.
  1694	func (h *ResourceHeader) ExtendedRCode(rcode RCode) RCode {
  1695		if h.TTL&ednsVersionMask == edns0Version { // RFC 6891 section 6.1.3
  1696			return RCode(h.TTL>>24<<4) | rcode
  1697		}
  1698		return rcode
  1699	}
  1700	
  1701	func skipResource(msg []byte, off int) (int, error) {
  1702		newOff, err := skipName(msg, off)
  1703		if err != nil {
  1704			return off, &nestedError{"Name", err}
  1705		}
  1706		if newOff, err = skipType(msg, newOff); err != nil {
  1707			return off, &nestedError{"Type", err}
  1708		}
  1709		if newOff, err = skipClass(msg, newOff); err != nil {
  1710			return off, &nestedError{"Class", err}
  1711		}
  1712		if newOff, err = skipUint32(msg, newOff); err != nil {
  1713			return off, &nestedError{"TTL", err}
  1714		}
  1715		length, newOff, err := unpackUint16(msg, newOff)
  1716		if err != nil {
  1717			return off, &nestedError{"Length", err}
  1718		}
  1719		if newOff += int(length); newOff > len(msg) {
  1720			return off, errResourceLen
  1721		}
  1722		return newOff, nil
  1723	}
  1724	
  1725	// packUint16 appends the wire format of field to msg.
  1726	func packUint16(msg []byte, field uint16) []byte {
  1727		return append(msg, byte(field>>8), byte(field))
  1728	}
  1729	
  1730	func unpackUint16(msg []byte, off int) (uint16, int, error) {
  1731		if off+uint16Len > len(msg) {
  1732			return 0, off, errBaseLen
  1733		}
  1734		return uint16(msg[off])<<8 | uint16(msg[off+1]), off + uint16Len, nil
  1735	}
  1736	
  1737	func skipUint16(msg []byte, off int) (int, error) {
  1738		if off+uint16Len > len(msg) {
  1739			return off, errBaseLen
  1740		}
  1741		return off + uint16Len, nil
  1742	}
  1743	
  1744	// packType appends the wire format of field to msg.
  1745	func packType(msg []byte, field Type) []byte {
  1746		return packUint16(msg, uint16(field))
  1747	}
  1748	
  1749	func unpackType(msg []byte, off int) (Type, int, error) {
  1750		t, o, err := unpackUint16(msg, off)
  1751		return Type(t), o, err
  1752	}
  1753	
  1754	func skipType(msg []byte, off int) (int, error) {
  1755		return skipUint16(msg, off)
  1756	}
  1757	
  1758	// packClass appends the wire format of field to msg.
  1759	func packClass(msg []byte, field Class) []byte {
  1760		return packUint16(msg, uint16(field))
  1761	}
  1762	
  1763	func unpackClass(msg []byte, off int) (Class, int, error) {
  1764		c, o, err := unpackUint16(msg, off)
  1765		return Class(c), o, err
  1766	}
  1767	
  1768	func skipClass(msg []byte, off int) (int, error) {
  1769		return skipUint16(msg, off)
  1770	}
  1771	
  1772	// packUint32 appends the wire format of field to msg.
  1773	func packUint32(msg []byte, field uint32) []byte {
  1774		return append(
  1775			msg,
  1776			byte(field>>24),
  1777			byte(field>>16),
  1778			byte(field>>8),
  1779			byte(field),
  1780		)
  1781	}
  1782	
  1783	func unpackUint32(msg []byte, off int) (uint32, int, error) {
  1784		if off+uint32Len > len(msg) {
  1785			return 0, off, errBaseLen
  1786		}
  1787		v := uint32(msg[off])<<24 | uint32(msg[off+1])<<16 | uint32(msg[off+2])<<8 | uint32(msg[off+3])
  1788		return v, off + uint32Len, nil
  1789	}
  1790	
  1791	func skipUint32(msg []byte, off int) (int, error) {
  1792		if off+uint32Len > len(msg) {
  1793			return off, errBaseLen
  1794		}
  1795		return off + uint32Len, nil
  1796	}
  1797	
  1798	// packText appends the wire format of field to msg.
  1799	func packText(msg []byte, field string) ([]byte, error) {
  1800		l := len(field)
  1801		if l > 255 {
  1802			return nil, errStringTooLong
  1803		}
  1804		msg = append(msg, byte(l))
  1805		msg = append(msg, field...)
  1806	
  1807		return msg, nil
  1808	}
  1809	
  1810	func unpackText(msg []byte, off int) (string, int, error) {
  1811		if off >= len(msg) {
  1812			return "", off, errBaseLen
  1813		}
  1814		beginOff := off + 1
  1815		endOff := beginOff + int(msg[off])
  1816		if endOff > len(msg) {
  1817			return "", off, errCalcLen
  1818		}
  1819		return string(msg[beginOff:endOff]), endOff, nil
  1820	}
  1821	
  1822	func skipText(msg []byte, off int) (int, error) {
  1823		if off >= len(msg) {
  1824			return off, errBaseLen
  1825		}
  1826		endOff := off + 1 + int(msg[off])
  1827		if endOff > len(msg) {
  1828			return off, errCalcLen
  1829		}
  1830		return endOff, nil
  1831	}
  1832	
  1833	// packBytes appends the wire format of field to msg.
  1834	func packBytes(msg []byte, field []byte) []byte {
  1835		return append(msg, field...)
  1836	}
  1837	
  1838	func unpackBytes(msg []byte, off int, field []byte) (int, error) {
  1839		newOff := off + len(field)
  1840		if newOff > len(msg) {
  1841			return off, errBaseLen
  1842		}
  1843		copy(field, msg[off:newOff])
  1844		return newOff, nil
  1845	}
  1846	
  1847	func skipBytes(msg []byte, off int, field []byte) (int, error) {
  1848		newOff := off + len(field)
  1849		if newOff > len(msg) {
  1850			return off, errBaseLen
  1851		}
  1852		return newOff, nil
  1853	}
  1854	
  1855	const nameLen = 255
  1856	
  1857	// A Name is a non-encoded domain name. It is used instead of strings to avoid
  1858	// allocations.
  1859	type Name struct {
  1860		Data   [nameLen]byte
  1861		Length uint8
  1862	}
  1863	
  1864	// NewName creates a new Name from a string.
  1865	func NewName(name string) (Name, error) {
  1866		if len([]byte(name)) > nameLen {
  1867			return Name{}, errCalcLen
  1868		}
  1869		n := Name{Length: uint8(len(name))}
  1870		copy(n.Data[:], []byte(name))
  1871		return n, nil
  1872	}
  1873	
  1874	// MustNewName creates a new Name from a string and panics on error.
  1875	func MustNewName(name string) Name {
  1876		n, err := NewName(name)
  1877		if err != nil {
  1878			panic("creating name: " + err.Error())
  1879		}
  1880		return n
  1881	}
  1882	
  1883	// String implements fmt.Stringer.String.
  1884	func (n Name) String() string {
  1885		return string(n.Data[:n.Length])
  1886	}
  1887	
  1888	// GoString implements fmt.GoStringer.GoString.
  1889	func (n *Name) GoString() string {
  1890		return `dnsmessage.MustNewName("` + printString(n.Data[:n.Length]) + `")`
  1891	}
  1892	
  1893	// pack appends the wire format of the Name to msg.
  1894	//
  1895	// Domain names are a sequence of counted strings split at the dots. They end
  1896	// with a zero-length string. Compression can be used to reuse domain suffixes.
  1897	//
  1898	// The compression map will be updated with new domain suffixes. If compression
  1899	// is nil, compression will not be used.
  1900	func (n *Name) pack(msg []byte, compression map[string]int, compressionOff int) ([]byte, error) {
  1901		oldMsg := msg
  1902	
  1903		// Add a trailing dot to canonicalize name.
  1904		if n.Length == 0 || n.Data[n.Length-1] != '.' {
  1905			return oldMsg, errNonCanonicalName
  1906		}
  1907	
  1908		// Allow root domain.
  1909		if n.Data[0] == '.' && n.Length == 1 {
  1910			return append(msg, 0), nil
  1911		}
  1912	
  1913		// Emit sequence of counted strings, chopping at dots.
  1914		for i, begin := 0, 0; i < int(n.Length); i++ {
  1915			// Check for the end of the segment.
  1916			if n.Data[i] == '.' {
  1917				// The two most significant bits have special meaning.
  1918				// It isn't allowed for segments to be long enough to
  1919				// need them.
  1920				if i-begin >= 1<<6 {
  1921					return oldMsg, errSegTooLong
  1922				}
  1923	
  1924				// Segments must have a non-zero length.
  1925				if i-begin == 0 {
  1926					return oldMsg, errZeroSegLen
  1927				}
  1928	
  1929				msg = append(msg, byte(i-begin))
  1930	
  1931				for j := begin; j < i; j++ {
  1932					msg = append(msg, n.Data[j])
  1933				}
  1934	
  1935				begin = i + 1
  1936				continue
  1937			}
  1938	
  1939			// We can only compress domain suffixes starting with a new
  1940			// segment. A pointer is two bytes with the two most significant
  1941			// bits set to 1 to indicate that it is a pointer.
  1942			if (i == 0 || n.Data[i-1] == '.') && compression != nil {
  1943				if ptr, ok := compression[string(n.Data[i:])]; ok {
  1944					// Hit. Emit a pointer instead of the rest of
  1945					// the domain.
  1946					return append(msg, byte(ptr>>8|0xC0), byte(ptr)), nil
  1947				}
  1948	
  1949				// Miss. Add the suffix to the compression table if the
  1950				// offset can be stored in the available 14 bytes.
  1951				if len(msg) <= int(^uint16(0)>>2) {
  1952					compression[string(n.Data[i:])] = len(msg) - compressionOff
  1953				}
  1954			}
  1955		}
  1956		return append(msg, 0), nil
  1957	}
  1958	
  1959	// unpack unpacks a domain name.
  1960	func (n *Name) unpack(msg []byte, off int) (int, error) {
  1961		return n.unpackCompressed(msg, off, true /* allowCompression */)
  1962	}
  1963	
  1964	func (n *Name) unpackCompressed(msg []byte, off int, allowCompression bool) (int, error) {
  1965		// currOff is the current working offset.
  1966		currOff := off
  1967	
  1968		// newOff is the offset where the next record will start. Pointers lead
  1969		// to data that belongs to other names and thus doesn't count towards to
  1970		// the usage of this name.
  1971		newOff := off
  1972	
  1973		// ptr is the number of pointers followed.
  1974		var ptr int
  1975	
  1976		// Name is a slice representation of the name data.
  1977		name := n.Data[:0]
  1978	
  1979	Loop:
  1980		for {
  1981			if currOff >= len(msg) {
  1982				return off, errBaseLen
  1983			}
  1984			c := int(msg[currOff])
  1985			currOff++
  1986			switch c & 0xC0 {
  1987			case 0x00: // String segment
  1988				if c == 0x00 {
  1989					// A zero length signals the end of the name.
  1990					break Loop
  1991				}
  1992				endOff := currOff + c
  1993				if endOff > len(msg) {
  1994					return off, errCalcLen
  1995				}
  1996				name = append(name, msg[currOff:endOff]...)
  1997				name = append(name, '.')
  1998				currOff = endOff
  1999			case 0xC0: // Pointer
  2000				if !allowCompression {
  2001					return off, errCompressedSRV
  2002				}
  2003				if currOff >= len(msg) {
  2004					return off, errInvalidPtr
  2005				}
  2006				c1 := msg[currOff]
  2007				currOff++
  2008				if ptr == 0 {
  2009					newOff = currOff
  2010				}
  2011				// Don't follow too many pointers, maybe there's a loop.
  2012				if ptr++; ptr > 10 {
  2013					return off, errTooManyPtr
  2014				}
  2015				currOff = (c^0xC0)<<8 | int(c1)
  2016			default:
  2017				// Prefixes 0x80 and 0x40 are reserved.
  2018				return off, errReserved
  2019			}
  2020		}
  2021		if len(name) == 0 {
  2022			name = append(name, '.')
  2023		}
  2024		if len(name) > len(n.Data) {
  2025			return off, errCalcLen
  2026		}
  2027		n.Length = uint8(len(name))
  2028		if ptr == 0 {
  2029			newOff = currOff
  2030		}
  2031		return newOff, nil
  2032	}
  2033	
  2034	func skipName(msg []byte, off int) (int, error) {
  2035		// newOff is the offset where the next record will start. Pointers lead
  2036		// to data that belongs to other names and thus doesn't count towards to
  2037		// the usage of this name.
  2038		newOff := off
  2039	
  2040	Loop:
  2041		for {
  2042			if newOff >= len(msg) {
  2043				return off, errBaseLen
  2044			}
  2045			c := int(msg[newOff])
  2046			newOff++
  2047			switch c & 0xC0 {
  2048			case 0x00:
  2049				if c == 0x00 {
  2050					// A zero length signals the end of the name.
  2051					break Loop
  2052				}
  2053				// literal string
  2054				newOff += c
  2055				if newOff > len(msg) {
  2056					return off, errCalcLen
  2057				}
  2058			case 0xC0:
  2059				// Pointer to somewhere else in msg.
  2060	
  2061				// Pointers are two bytes.
  2062				newOff++
  2063	
  2064				// Don't follow the pointer as the data here has ended.
  2065				break Loop
  2066			default:
  2067				// Prefixes 0x80 and 0x40 are reserved.
  2068				return off, errReserved
  2069			}
  2070		}
  2071	
  2072		return newOff, nil
  2073	}
  2074	
  2075	// A Question is a DNS query.
  2076	type Question struct {
  2077		Name  Name
  2078		Type  Type
  2079		Class Class
  2080	}
  2081	
  2082	// pack appends the wire format of the Question to msg.
  2083	func (q *Question) pack(msg []byte, compression map[string]int, compressionOff int) ([]byte, error) {
  2084		msg, err := q.Name.pack(msg, compression, compressionOff)
  2085		if err != nil {
  2086			return msg, &nestedError{"Name", err}
  2087		}
  2088		msg = packType(msg, q.Type)
  2089		return packClass(msg, q.Class), nil
  2090	}
  2091	
  2092	// GoString implements fmt.GoStringer.GoString.
  2093	func (q *Question) GoString() string {
  2094		return "dnsmessage.Question{" +
  2095			"Name: " + q.Name.GoString() + ", " +
  2096			"Type: " + q.Type.GoString() + ", " +
  2097			"Class: " + q.Class.GoString() + "}"
  2098	}
  2099	
  2100	func unpackResourceBody(msg []byte, off int, hdr ResourceHeader) (ResourceBody, int, error) {
  2101		var (
  2102			r    ResourceBody
  2103			err  error
  2104			name string
  2105		)
  2106		switch hdr.Type {
  2107		case TypeA:
  2108			var rb AResource
  2109			rb, err = unpackAResource(msg, off)
  2110			r = &rb
  2111			name = "A"
  2112		case TypeNS:
  2113			var rb NSResource
  2114			rb, err = unpackNSResource(msg, off)
  2115			r = &rb
  2116			name = "NS"
  2117		case TypeCNAME:
  2118			var rb CNAMEResource
  2119			rb, err = unpackCNAMEResource(msg, off)
  2120			r = &rb
  2121			name = "CNAME"
  2122		case TypeSOA:
  2123			var rb SOAResource
  2124			rb, err = unpackSOAResource(msg, off)
  2125			r = &rb
  2126			name = "SOA"
  2127		case TypePTR:
  2128			var rb PTRResource
  2129			rb, err = unpackPTRResource(msg, off)
  2130			r = &rb
  2131			name = "PTR"
  2132		case TypeMX:
  2133			var rb MXResource
  2134			rb, err = unpackMXResource(msg, off)
  2135			r = &rb
  2136			name = "MX"
  2137		case TypeTXT:
  2138			var rb TXTResource
  2139			rb, err = unpackTXTResource(msg, off, hdr.Length)
  2140			r = &rb
  2141			name = "TXT"
  2142		case TypeAAAA:
  2143			var rb AAAAResource
  2144			rb, err = unpackAAAAResource(msg, off)
  2145			r = &rb
  2146			name = "AAAA"
  2147		case TypeSRV:
  2148			var rb SRVResource
  2149			rb, err = unpackSRVResource(msg, off)
  2150			r = &rb
  2151			name = "SRV"
  2152		case TypeOPT:
  2153			var rb OPTResource
  2154			rb, err = unpackOPTResource(msg, off, hdr.Length)
  2155			r = &rb
  2156			name = "OPT"
  2157		}
  2158		if err != nil {
  2159			return nil, off, &nestedError{name + " record", err}
  2160		}
  2161		if r == nil {
  2162			return nil, off, errors.New("invalid resource type: " + string(hdr.Type+'0'))
  2163		}
  2164		return r, off + int(hdr.Length), nil
  2165	}
  2166	
  2167	// A CNAMEResource is a CNAME Resource record.
  2168	type CNAMEResource struct {
  2169		CNAME Name
  2170	}
  2171	
  2172	func (r *CNAMEResource) realType() Type {
  2173		return TypeCNAME
  2174	}
  2175	
  2176	// pack appends the wire format of the CNAMEResource to msg.
  2177	func (r *CNAMEResource) pack(msg []byte, compression map[string]int, compressionOff int) ([]byte, error) {
  2178		return r.CNAME.pack(msg, compression, compressionOff)
  2179	}
  2180	
  2181	// GoString implements fmt.GoStringer.GoString.
  2182	func (r *CNAMEResource) GoString() string {
  2183		return "dnsmessage.CNAMEResource{CNAME: " + r.CNAME.GoString() + "}"
  2184	}
  2185	
  2186	func unpackCNAMEResource(msg []byte, off int) (CNAMEResource, error) {
  2187		var cname Name
  2188		if _, err := cname.unpack(msg, off); err != nil {
  2189			return CNAMEResource{}, err
  2190		}
  2191		return CNAMEResource{cname}, nil
  2192	}
  2193	
  2194	// An MXResource is an MX Resource record.
  2195	type MXResource struct {
  2196		Pref uint16
  2197		MX   Name
  2198	}
  2199	
  2200	func (r *MXResource) realType() Type {
  2201		return TypeMX
  2202	}
  2203	
  2204	// pack appends the wire format of the MXResource to msg.
  2205	func (r *MXResource) pack(msg []byte, compression map[string]int, compressionOff int) ([]byte, error) {
  2206		oldMsg := msg
  2207		msg = packUint16(msg, r.Pref)
  2208		msg, err := r.MX.pack(msg, compression, compressionOff)
  2209		if err != nil {
  2210			return oldMsg, &nestedError{"MXResource.MX", err}
  2211		}
  2212		return msg, nil
  2213	}
  2214	
  2215	// GoString implements fmt.GoStringer.GoString.
  2216	func (r *MXResource) GoString() string {
  2217		return "dnsmessage.MXResource{" +
  2218			"Pref: " + printUint16(r.Pref) + ", " +
  2219			"MX: " + r.MX.GoString() + "}"
  2220	}
  2221	
  2222	func unpackMXResource(msg []byte, off int) (MXResource, error) {
  2223		pref, off, err := unpackUint16(msg, off)
  2224		if err != nil {
  2225			return MXResource{}, &nestedError{"Pref", err}
  2226		}
  2227		var mx Name
  2228		if _, err := mx.unpack(msg, off); err != nil {
  2229			return MXResource{}, &nestedError{"MX", err}
  2230		}
  2231		return MXResource{pref, mx}, nil
  2232	}
  2233	
  2234	// An NSResource is an NS Resource record.
  2235	type NSResource struct {
  2236		NS Name
  2237	}
  2238	
  2239	func (r *NSResource) realType() Type {
  2240		return TypeNS
  2241	}
  2242	
  2243	// pack appends the wire format of the NSResource to msg.
  2244	func (r *NSResource) pack(msg []byte, compression map[string]int, compressionOff int) ([]byte, error) {
  2245		return r.NS.pack(msg, compression, compressionOff)
  2246	}
  2247	
  2248	// GoString implements fmt.GoStringer.GoString.
  2249	func (r *NSResource) GoString() string {
  2250		return "dnsmessage.NSResource{NS: " + r.NS.GoString() + "}"
  2251	}
  2252	
  2253	func unpackNSResource(msg []byte, off int) (NSResource, error) {
  2254		var ns Name
  2255		if _, err := ns.unpack(msg, off); err != nil {
  2256			return NSResource{}, err
  2257		}
  2258		return NSResource{ns}, nil
  2259	}
  2260	
  2261	// A PTRResource is a PTR Resource record.
  2262	type PTRResource struct {
  2263		PTR Name
  2264	}
  2265	
  2266	func (r *PTRResource) realType() Type {
  2267		return TypePTR
  2268	}
  2269	
  2270	// pack appends the wire format of the PTRResource to msg.
  2271	func (r *PTRResource) pack(msg []byte, compression map[string]int, compressionOff int) ([]byte, error) {
  2272		return r.PTR.pack(msg, compression, compressionOff)
  2273	}
  2274	
  2275	// GoString implements fmt.GoStringer.GoString.
  2276	func (r *PTRResource) GoString() string {
  2277		return "dnsmessage.PTRResource{PTR: " + r.PTR.GoString() + "}"
  2278	}
  2279	
  2280	func unpackPTRResource(msg []byte, off int) (PTRResource, error) {
  2281		var ptr Name
  2282		if _, err := ptr.unpack(msg, off); err != nil {
  2283			return PTRResource{}, err
  2284		}
  2285		return PTRResource{ptr}, nil
  2286	}
  2287	
  2288	// An SOAResource is an SOA Resource record.
  2289	type SOAResource struct {
  2290		NS      Name
  2291		MBox    Name
  2292		Serial  uint32
  2293		Refresh uint32
  2294		Retry   uint32
  2295		Expire  uint32
  2296	
  2297		// MinTTL the is the default TTL of Resources records which did not
  2298		// contain a TTL value and the TTL of negative responses. (RFC 2308
  2299		// Section 4)
  2300		MinTTL uint32
  2301	}
  2302	
  2303	func (r *SOAResource) realType() Type {
  2304		return TypeSOA
  2305	}
  2306	
  2307	// pack appends the wire format of the SOAResource to msg.
  2308	func (r *SOAResource) pack(msg []byte, compression map[string]int, compressionOff int) ([]byte, error) {
  2309		oldMsg := msg
  2310		msg, err := r.NS.pack(msg, compression, compressionOff)
  2311		if err != nil {
  2312			return oldMsg, &nestedError{"SOAResource.NS", err}
  2313		}
  2314		msg, err = r.MBox.pack(msg, compression, compressionOff)
  2315		if err != nil {
  2316			return oldMsg, &nestedError{"SOAResource.MBox", err}
  2317		}
  2318		msg = packUint32(msg, r.Serial)
  2319		msg = packUint32(msg, r.Refresh)
  2320		msg = packUint32(msg, r.Retry)
  2321		msg = packUint32(msg, r.Expire)
  2322		return packUint32(msg, r.MinTTL), nil
  2323	}
  2324	
  2325	// GoString implements fmt.GoStringer.GoString.
  2326	func (r *SOAResource) GoString() string {
  2327		return "dnsmessage.SOAResource{" +
  2328			"NS: " + r.NS.GoString() + ", " +
  2329			"MBox: " + r.MBox.GoString() + ", " +
  2330			"Serial: " + printUint32(r.Serial) + ", " +
  2331			"Refresh: " + printUint32(r.Refresh) + ", " +
  2332			"Retry: " + printUint32(r.Retry) + ", " +
  2333			"Expire: " + printUint32(r.Expire) + ", " +
  2334			"MinTTL: " + printUint32(r.MinTTL) + "}"
  2335	}
  2336	
  2337	func unpackSOAResource(msg []byte, off int) (SOAResource, error) {
  2338		var ns Name
  2339		off, err := ns.unpack(msg, off)
  2340		if err != nil {
  2341			return SOAResource{}, &nestedError{"NS", err}
  2342		}
  2343		var mbox Name
  2344		if off, err = mbox.unpack(msg, off); err != nil {
  2345			return SOAResource{}, &nestedError{"MBox", err}
  2346		}
  2347		serial, off, err := unpackUint32(msg, off)
  2348		if err != nil {
  2349			return SOAResource{}, &nestedError{"Serial", err}
  2350		}
  2351		refresh, off, err := unpackUint32(msg, off)
  2352		if err != nil {
  2353			return SOAResource{}, &nestedError{"Refresh", err}
  2354		}
  2355		retry, off, err := unpackUint32(msg, off)
  2356		if err != nil {
  2357			return SOAResource{}, &nestedError{"Retry", err}
  2358		}
  2359		expire, off, err := unpackUint32(msg, off)
  2360		if err != nil {
  2361			return SOAResource{}, &nestedError{"Expire", err}
  2362		}
  2363		minTTL, _, err := unpackUint32(msg, off)
  2364		if err != nil {
  2365			return SOAResource{}, &nestedError{"MinTTL", err}
  2366		}
  2367		return SOAResource{ns, mbox, serial, refresh, retry, expire, minTTL}, nil
  2368	}
  2369	
  2370	// A TXTResource is a TXT Resource record.
  2371	type TXTResource struct {
  2372		TXT []string
  2373	}
  2374	
  2375	func (r *TXTResource) realType() Type {
  2376		return TypeTXT
  2377	}
  2378	
  2379	// pack appends the wire format of the TXTResource to msg.
  2380	func (r *TXTResource) pack(msg []byte, compression map[string]int, compressionOff int) ([]byte, error) {
  2381		oldMsg := msg
  2382		for _, s := range r.TXT {
  2383			var err error
  2384			msg, err = packText(msg, s)
  2385			if err != nil {
  2386				return oldMsg, err
  2387			}
  2388		}
  2389		return msg, nil
  2390	}
  2391	
  2392	// GoString implements fmt.GoStringer.GoString.
  2393	func (r *TXTResource) GoString() string {
  2394		s := "dnsmessage.TXTResource{TXT: []string{"
  2395		if len(r.TXT) == 0 {
  2396			return s + "}}"
  2397		}
  2398		s += `"` + printString([]byte(r.TXT[0]))
  2399		for _, t := range r.TXT[1:] {
  2400			s += `", "` + printString([]byte(t))
  2401		}
  2402		return s + `"}}`
  2403	}
  2404	
  2405	func unpackTXTResource(msg []byte, off int, length uint16) (TXTResource, error) {
  2406		txts := make([]string, 0, 1)
  2407		for n := uint16(0); n < length; {
  2408			var t string
  2409			var err error
  2410			if t, off, err = unpackText(msg, off); err != nil {
  2411				return TXTResource{}, &nestedError{"text", err}
  2412			}
  2413			// Check if we got too many bytes.
  2414			if length-n < uint16(len(t))+1 {
  2415				return TXTResource{}, errCalcLen
  2416			}
  2417			n += uint16(len(t)) + 1
  2418			txts = append(txts, t)
  2419		}
  2420		return TXTResource{txts}, nil
  2421	}
  2422	
  2423	// An SRVResource is an SRV Resource record.
  2424	type SRVResource struct {
  2425		Priority uint16
  2426		Weight   uint16
  2427		Port     uint16
  2428		Target   Name // Not compressed as per RFC 2782.
  2429	}
  2430	
  2431	func (r *SRVResource) realType() Type {
  2432		return TypeSRV
  2433	}
  2434	
  2435	// pack appends the wire format of the SRVResource to msg.
  2436	func (r *SRVResource) pack(msg []byte, compression map[string]int, compressionOff int) ([]byte, error) {
  2437		oldMsg := msg
  2438		msg = packUint16(msg, r.Priority)
  2439		msg = packUint16(msg, r.Weight)
  2440		msg = packUint16(msg, r.Port)
  2441		msg, err := r.Target.pack(msg, nil, compressionOff)
  2442		if err != nil {
  2443			return oldMsg, &nestedError{"SRVResource.Target", err}
  2444		}
  2445		return msg, nil
  2446	}
  2447	
  2448	// GoString implements fmt.GoStringer.GoString.
  2449	func (r *SRVResource) GoString() string {
  2450		return "dnsmessage.SRVResource{" +
  2451			"Priority: " + printUint16(r.Priority) + ", " +
  2452			"Weight: " + printUint16(r.Weight) + ", " +
  2453			"Port: " + printUint16(r.Port) + ", " +
  2454			"Target: " + r.Target.GoString() + "}"
  2455	}
  2456	
  2457	func unpackSRVResource(msg []byte, off int) (SRVResource, error) {
  2458		priority, off, err := unpackUint16(msg, off)
  2459		if err != nil {
  2460			return SRVResource{}, &nestedError{"Priority", err}
  2461		}
  2462		weight, off, err := unpackUint16(msg, off)
  2463		if err != nil {
  2464			return SRVResource{}, &nestedError{"Weight", err}
  2465		}
  2466		port, off, err := unpackUint16(msg, off)
  2467		if err != nil {
  2468			return SRVResource{}, &nestedError{"Port", err}
  2469		}
  2470		var target Name
  2471		if _, err := target.unpackCompressed(msg, off, false /* allowCompression */); err != nil {
  2472			return SRVResource{}, &nestedError{"Target", err}
  2473		}
  2474		return SRVResource{priority, weight, port, target}, nil
  2475	}
  2476	
  2477	// An AResource is an A Resource record.
  2478	type AResource struct {
  2479		A [4]byte
  2480	}
  2481	
  2482	func (r *AResource) realType() Type {
  2483		return TypeA
  2484	}
  2485	
  2486	// pack appends the wire format of the AResource to msg.
  2487	func (r *AResource) pack(msg []byte, compression map[string]int, compressionOff int) ([]byte, error) {
  2488		return packBytes(msg, r.A[:]), nil
  2489	}
  2490	
  2491	// GoString implements fmt.GoStringer.GoString.
  2492	func (r *AResource) GoString() string {
  2493		return "dnsmessage.AResource{" +
  2494			"A: [4]byte{" + printByteSlice(r.A[:]) + "}}"
  2495	}
  2496	
  2497	func unpackAResource(msg []byte, off int) (AResource, error) {
  2498		var a [4]byte
  2499		if _, err := unpackBytes(msg, off, a[:]); err != nil {
  2500			return AResource{}, err
  2501		}
  2502		return AResource{a}, nil
  2503	}
  2504	
  2505	// An AAAAResource is an AAAA Resource record.
  2506	type AAAAResource struct {
  2507		AAAA [16]byte
  2508	}
  2509	
  2510	func (r *AAAAResource) realType() Type {
  2511		return TypeAAAA
  2512	}
  2513	
  2514	// GoString implements fmt.GoStringer.GoString.
  2515	func (r *AAAAResource) GoString() string {
  2516		return "dnsmessage.AAAAResource{" +
  2517			"AAAA: [16]byte{" + printByteSlice(r.AAAA[:]) + "}}"
  2518	}
  2519	
  2520	// pack appends the wire format of the AAAAResource to msg.
  2521	func (r *AAAAResource) pack(msg []byte, compression map[string]int, compressionOff int) ([]byte, error) {
  2522		return packBytes(msg, r.AAAA[:]), nil
  2523	}
  2524	
  2525	func unpackAAAAResource(msg []byte, off int) (AAAAResource, error) {
  2526		var aaaa [16]byte
  2527		if _, err := unpackBytes(msg, off, aaaa[:]); err != nil {
  2528			return AAAAResource{}, err
  2529		}
  2530		return AAAAResource{aaaa}, nil
  2531	}
  2532	
  2533	// An OPTResource is an OPT pseudo Resource record.
  2534	//
  2535	// The pseudo resource record is part of the extension mechanisms for DNS
  2536	// as defined in RFC 6891.
  2537	type OPTResource struct {
  2538		Options []Option
  2539	}
  2540	
  2541	// An Option represents a DNS message option within OPTResource.
  2542	//
  2543	// The message option is part of the extension mechanisms for DNS as
  2544	// defined in RFC 6891.
  2545	type Option struct {
  2546		Code uint16 // option code
  2547		Data []byte
  2548	}
  2549	
  2550	// GoString implements fmt.GoStringer.GoString.
  2551	func (o *Option) GoString() string {
  2552		return "dnsmessage.Option{" +
  2553			"Code: " + printUint16(o.Code) + ", " +
  2554			"Data: []byte{" + printByteSlice(o.Data) + "}}"
  2555	}
  2556	
  2557	func (r *OPTResource) realType() Type {
  2558		return TypeOPT
  2559	}
  2560	
  2561	func (r *OPTResource) pack(msg []byte, compression map[string]int, compressionOff int) ([]byte, error) {
  2562		for _, opt := range r.Options {
  2563			msg = packUint16(msg, opt.Code)
  2564			l := uint16(len(opt.Data))
  2565			msg = packUint16(msg, l)
  2566			msg = packBytes(msg, opt.Data)
  2567		}
  2568		return msg, nil
  2569	}
  2570	
  2571	// GoString implements fmt.GoStringer.GoString.
  2572	func (r *OPTResource) GoString() string {
  2573		s := "dnsmessage.OPTResource{Options: []dnsmessage.Option{"
  2574		if len(r.Options) == 0 {
  2575			return s + "}}"
  2576		}
  2577		s += r.Options[0].GoString()
  2578		for _, o := range r.Options[1:] {
  2579			s += ", " + o.GoString()
  2580		}
  2581		return s + "}}"
  2582	}
  2583	
  2584	func unpackOPTResource(msg []byte, off int, length uint16) (OPTResource, error) {
  2585		var opts []Option
  2586		for oldOff := off; off < oldOff+int(length); {
  2587			var err error
  2588			var o Option
  2589			o.Code, off, err = unpackUint16(msg, off)
  2590			if err != nil {
  2591				return OPTResource{}, &nestedError{"Code", err}
  2592			}
  2593			var l uint16
  2594			l, off, err = unpackUint16(msg, off)
  2595			if err != nil {
  2596				return OPTResource{}, &nestedError{"Data", err}
  2597			}
  2598			o.Data = make([]byte, l)
  2599			if copy(o.Data, msg[off:]) != int(l) {
  2600				return OPTResource{}, &nestedError{"Data", errCalcLen}
  2601			}
  2602			off += int(l)
  2603			opts = append(opts, o)
  2604		}
  2605		return OPTResource{opts}, nil
  2606	}
  2607	

View as plain text