|
- // Copyright 2009 The Go Authors. All rights reserved.
- // Use of this source code is governed by a BSD-style
- // license that can be found in the LICENSE file.
-
- // Package dnsmessage provides a mostly RFC 1035 compliant implementation of
- // DNS message packing and unpacking.
- //
- // This implementation is designed to minimize heap allocations and avoid
- // unnecessary packing and unpacking as much as possible.
- package dnsmessage
-
- import (
- "errors"
- )
-
- // Packet formats
-
- // A Type is a type of DNS request and response.
- type Type uint16
-
- // A Class is a type of network.
- type Class uint16
-
- // An OpCode is a DNS operation code.
- type OpCode uint16
-
- // An RCode is a DNS response status code.
- type RCode uint16
-
- // Wire constants.
- const (
- // ResourceHeader.Type and Question.Type
- TypeA Type = 1
- TypeNS Type = 2
- TypeCNAME Type = 5
- TypeSOA Type = 6
- TypePTR Type = 12
- TypeMX Type = 15
- TypeTXT Type = 16
- TypeAAAA Type = 28
- TypeSRV Type = 33
-
- // Question.Type
- TypeWKS Type = 11
- TypeHINFO Type = 13
- TypeMINFO Type = 14
- TypeAXFR Type = 252
- TypeALL Type = 255
-
- // ResourceHeader.Class and Question.Class
- ClassINET Class = 1
- ClassCSNET Class = 2
- ClassCHAOS Class = 3
- ClassHESIOD Class = 4
-
- // Question.Class
- ClassANY Class = 255
-
- // Message.Rcode
- RCodeSuccess RCode = 0
- RCodeFormatError RCode = 1
- RCodeServerFailure RCode = 2
- RCodeNameError RCode = 3
- RCodeNotImplemented RCode = 4
- RCodeRefused RCode = 5
- )
-
- var (
- // ErrNotStarted indicates that the prerequisite information isn't
- // available yet because the previous records haven't been appropriately
- // parsed or skipped.
- ErrNotStarted = errors.New("parsing of this type isn't available yet")
-
- // ErrSectionDone indicated that all records in the section have been
- // parsed.
- ErrSectionDone = errors.New("parsing of this section has completed")
-
- errBaseLen = errors.New("insufficient data for base length type")
- errCalcLen = errors.New("insufficient data for calculated length type")
- errReserved = errors.New("segment prefix is reserved")
- errTooManyPtr = errors.New("too many pointers (>10)")
- errInvalidPtr = errors.New("invalid pointer")
- errResourceLen = errors.New("insufficient data for resource body length")
- errSegTooLong = errors.New("segment length too long")
- errZeroSegLen = errors.New("zero length segment")
- errResTooLong = errors.New("resource length too long")
- errTooManyQuestions = errors.New("too many Questions to pack (>65535)")
- errTooManyAnswers = errors.New("too many Answers to pack (>65535)")
- errTooManyAuthorities = errors.New("too many Authorities to pack (>65535)")
- errTooManyAdditionals = errors.New("too many Additionals to pack (>65535)")
- )
-
- type nestedError struct {
- // s is the current level's error message.
- s string
-
- // err is the nested error.
- err error
- }
-
- // nestedError implements error.Error.
- func (e *nestedError) Error() string {
- return e.s + ": " + e.err.Error()
- }
-
- // Header is a representation of a DNS message header.
- type Header struct {
- ID uint16
- Response bool
- OpCode OpCode
- Authoritative bool
- Truncated bool
- RecursionDesired bool
- RecursionAvailable bool
- RCode RCode
- }
-
- func (m *Header) pack() (id uint16, bits uint16) {
- id = m.ID
- bits = uint16(m.OpCode)<<11 | uint16(m.RCode)
- if m.RecursionAvailable {
- bits |= headerBitRA
- }
- if m.RecursionDesired {
- bits |= headerBitRD
- }
- if m.Truncated {
- bits |= headerBitTC
- }
- if m.Authoritative {
- bits |= headerBitAA
- }
- if m.Response {
- bits |= headerBitQR
- }
- return
- }
-
- // Message is a representation of a DNS message.
- type Message struct {
- Header
- Questions []Question
- Answers []Resource
- Authorities []Resource
- Additionals []Resource
- }
-
- type section uint8
-
- const (
- sectionHeader section = iota
- sectionQuestions
- sectionAnswers
- sectionAuthorities
- sectionAdditionals
- sectionDone
-
- headerBitQR = 1 << 15 // query/response (response=1)
- headerBitAA = 1 << 10 // authoritative
- headerBitTC = 1 << 9 // truncated
- headerBitRD = 1 << 8 // recursion desired
- headerBitRA = 1 << 7 // recursion available
- )
-
- var sectionNames = map[section]string{
- sectionHeader: "header",
- sectionQuestions: "Question",
- sectionAnswers: "Answer",
- sectionAuthorities: "Authority",
- sectionAdditionals: "Additional",
- }
-
- // header is the wire format for a DNS message header.
- type header struct {
- id uint16
- bits uint16
- questions uint16
- answers uint16
- authorities uint16
- additionals uint16
- }
-
- func (h *header) count(sec section) uint16 {
- switch sec {
- case sectionQuestions:
- return h.questions
- case sectionAnswers:
- return h.answers
- case sectionAuthorities:
- return h.authorities
- case sectionAdditionals:
- return h.additionals
- }
- return 0
- }
-
- func (h *header) pack(msg []byte) []byte {
- msg = packUint16(msg, h.id)
- msg = packUint16(msg, h.bits)
- msg = packUint16(msg, h.questions)
- msg = packUint16(msg, h.answers)
- msg = packUint16(msg, h.authorities)
- return packUint16(msg, h.additionals)
- }
-
- func (h *header) unpack(msg []byte, off int) (int, error) {
- newOff := off
- var err error
- if h.id, newOff, err = unpackUint16(msg, newOff); err != nil {
- return off, &nestedError{"id", err}
- }
- if h.bits, newOff, err = unpackUint16(msg, newOff); err != nil {
- return off, &nestedError{"bits", err}
- }
- if h.questions, newOff, err = unpackUint16(msg, newOff); err != nil {
- return off, &nestedError{"questions", err}
- }
- if h.answers, newOff, err = unpackUint16(msg, newOff); err != nil {
- return off, &nestedError{"answers", err}
- }
- if h.authorities, newOff, err = unpackUint16(msg, newOff); err != nil {
- return off, &nestedError{"authorities", err}
- }
- if h.additionals, newOff, err = unpackUint16(msg, newOff); err != nil {
- return off, &nestedError{"additionals", err}
- }
- return newOff, nil
- }
-
- func (h *header) header() Header {
- return Header{
- ID: h.id,
- Response: (h.bits & headerBitQR) != 0,
- OpCode: OpCode(h.bits>>11) & 0xF,
- Authoritative: (h.bits & headerBitAA) != 0,
- Truncated: (h.bits & headerBitTC) != 0,
- RecursionDesired: (h.bits & headerBitRD) != 0,
- RecursionAvailable: (h.bits & headerBitRA) != 0,
- RCode: RCode(h.bits & 0xF),
- }
- }
-
- // A Resource is a DNS resource record.
- type Resource interface {
- // Header return's the Resource's ResourceHeader.
- Header() *ResourceHeader
-
- // pack packs a Resource except for its header.
- pack(msg []byte, compression map[string]int) ([]byte, error)
-
- // realType returns the actual type of the Resource. This is used to
- // fill in the header Type field.
- realType() Type
- }
-
- func packResource(msg []byte, resource Resource, compression map[string]int) ([]byte, error) {
- oldMsg := msg
- resource.Header().Type = resource.realType()
- msg, length, err := resource.Header().pack(msg, compression)
- if err != nil {
- return msg, &nestedError{"ResourceHeader", err}
- }
- preLen := len(msg)
- msg, err = resource.pack(msg, compression)
- if err != nil {
- return msg, &nestedError{"content", err}
- }
- conLen := len(msg) - preLen
- if conLen > int(^uint16(0)) {
- return oldMsg, errResTooLong
- }
- // Fill in the length now that we know how long the content is.
- packUint16(length[:0], uint16(conLen))
- resource.Header().Length = uint16(conLen)
- return msg, nil
- }
-
- // A Parser allows incrementally parsing a DNS message.
- //
- // When parsing is started, the Header is parsed. Next, each Question can be
- // either parsed or skipped. Alternatively, all Questions can be skipped at
- // once. When all Questions have been parsed, attempting to parse Questions
- // will return (nil, nil) and attempting to skip Questions will return
- // (true, nil). After all Questions have been either parsed or skipped, all
- // Answers, Authorities and Additionals can be either parsed or skipped in the
- // same way, and each type of Resource must be fully parsed or skipped before
- // proceeding to the next type of Resource.
- //
- // Note that there is no requirement to fully skip or parse the message.
- type Parser struct {
- msg []byte
- header header
-
- section section
- off int
- index int
- resHeaderValid bool
- resHeader ResourceHeader
- }
-
- // Start parses the header and enables the parsing of Questions.
- func (p *Parser) Start(msg []byte) (Header, error) {
- if p.msg != nil {
- *p = Parser{}
- }
- p.msg = msg
- var err error
- if p.off, err = p.header.unpack(msg, 0); err != nil {
- return Header{}, &nestedError{"unpacking header", err}
- }
- p.section = sectionQuestions
- return p.header.header(), nil
- }
-
- func (p *Parser) checkAdvance(sec section) error {
- if p.section < sec {
- return ErrNotStarted
- }
- if p.section > sec {
- return ErrSectionDone
- }
- p.resHeaderValid = false
- if p.index == int(p.header.count(sec)) {
- p.index = 0
- p.section++
- return ErrSectionDone
- }
- return nil
- }
-
- func (p *Parser) resource(sec section) (Resource, error) {
- var r Resource
- hdr, err := p.resourceHeader(sec)
- if err != nil {
- return r, err
- }
- p.resHeaderValid = false
- r, p.off, err = unpackResource(p.msg, p.off, hdr)
- if err != nil {
- return nil, &nestedError{"unpacking " + sectionNames[sec], err}
- }
- p.index++
- return r, nil
- }
-
- func (p *Parser) resourceHeader(sec section) (ResourceHeader, error) {
- if p.resHeaderValid {
- return p.resHeader, nil
- }
- if err := p.checkAdvance(sec); err != nil {
- return ResourceHeader{}, err
- }
- var hdr ResourceHeader
- off, err := hdr.unpack(p.msg, p.off)
- if err != nil {
- return ResourceHeader{}, err
- }
- p.resHeaderValid = true
- p.resHeader = hdr
- p.off = off
- return hdr, nil
- }
-
- func (p *Parser) skipResource(sec section) error {
- if p.resHeaderValid {
- newOff := p.off + int(p.resHeader.Length)
- if newOff > len(p.msg) {
- return errResourceLen
- }
- p.off = newOff
- p.resHeaderValid = false
- p.index++
- return nil
- }
- if err := p.checkAdvance(sec); err != nil {
- return err
- }
- var err error
- p.off, err = skipResource(p.msg, p.off)
- if err != nil {
- return &nestedError{"skipping: " + sectionNames[sec], err}
- }
- p.index++
- return nil
- }
-
- // Question parses a single Question.
- func (p *Parser) Question() (Question, error) {
- if err := p.checkAdvance(sectionQuestions); err != nil {
- return Question{}, err
- }
- name, off, err := unpackName(p.msg, p.off)
- if err != nil {
- return Question{}, &nestedError{"unpacking Question.Name", err}
- }
- typ, off, err := unpackType(p.msg, off)
- if err != nil {
- return Question{}, &nestedError{"unpacking Question.Type", err}
- }
- class, off, err := unpackClass(p.msg, off)
- if err != nil {
- return Question{}, &nestedError{"unpacking Question.Class", err}
- }
- p.off = off
- p.index++
- return Question{name, typ, class}, nil
- }
-
- // AllQuestions parses all Questions.
- func (p *Parser) AllQuestions() ([]Question, error) {
- qs := make([]Question, 0, p.header.questions)
- for {
- q, err := p.Question()
- if err == ErrSectionDone {
- return qs, nil
- }
- if err != nil {
- return nil, err
- }
- qs = append(qs, q)
- }
- }
-
- // SkipQuestion skips a single Question.
- func (p *Parser) SkipQuestion() error {
- if err := p.checkAdvance(sectionQuestions); err != nil {
- return err
- }
- off, err := skipName(p.msg, p.off)
- if err != nil {
- return &nestedError{"skipping Question Name", err}
- }
- if off, err = skipType(p.msg, off); err != nil {
- return &nestedError{"skipping Question Type", err}
- }
- if off, err = skipClass(p.msg, off); err != nil {
- return &nestedError{"skipping Question Class", err}
- }
- p.off = off
- p.index++
- return nil
- }
-
- // SkipAllQuestions skips all Questions.
- func (p *Parser) SkipAllQuestions() error {
- for {
- if err := p.SkipQuestion(); err == ErrSectionDone {
- return nil
- } else if err != nil {
- return err
- }
- }
- }
-
- // AnswerHeader parses a single Answer ResourceHeader.
- func (p *Parser) AnswerHeader() (ResourceHeader, error) {
- return p.resourceHeader(sectionAnswers)
- }
-
- // Answer parses a single Answer Resource.
- func (p *Parser) Answer() (Resource, error) {
- return p.resource(sectionAnswers)
- }
-
- // AllAnswers parses all Answer Resources.
- func (p *Parser) AllAnswers() ([]Resource, error) {
- as := make([]Resource, 0, p.header.answers)
- for {
- a, err := p.Answer()
- if err == ErrSectionDone {
- return as, nil
- }
- if err != nil {
- return nil, err
- }
- as = append(as, a)
- }
- }
-
- // SkipAnswer skips a single Answer Resource.
- func (p *Parser) SkipAnswer() error {
- return p.skipResource(sectionAnswers)
- }
-
- // SkipAllAnswers skips all Answer Resources.
- func (p *Parser) SkipAllAnswers() error {
- for {
- if err := p.SkipAnswer(); err == ErrSectionDone {
- return nil
- } else if err != nil {
- return err
- }
- }
- }
-
- // AuthorityHeader parses a single Authority ResourceHeader.
- func (p *Parser) AuthorityHeader() (ResourceHeader, error) {
- return p.resourceHeader(sectionAuthorities)
- }
-
- // Authority parses a single Authority Resource.
- func (p *Parser) Authority() (Resource, error) {
- return p.resource(sectionAuthorities)
- }
-
- // AllAuthorities parses all Authority Resources.
- func (p *Parser) AllAuthorities() ([]Resource, error) {
- as := make([]Resource, 0, p.header.authorities)
- for {
- a, err := p.Authority()
- if err == ErrSectionDone {
- return as, nil
- }
- if err != nil {
- return nil, err
- }
- as = append(as, a)
- }
- }
-
- // SkipAuthority skips a single Authority Resource.
- func (p *Parser) SkipAuthority() error {
- return p.skipResource(sectionAuthorities)
- }
-
- // SkipAllAuthorities skips all Authority Resources.
- func (p *Parser) SkipAllAuthorities() error {
- for {
- if err := p.SkipAuthority(); err == ErrSectionDone {
- return nil
- } else if err != nil {
- return err
- }
- }
- }
-
- // AdditionalHeader parses a single Additional ResourceHeader.
- func (p *Parser) AdditionalHeader() (ResourceHeader, error) {
- return p.resourceHeader(sectionAdditionals)
- }
-
- // Additional parses a single Additional Resource.
- func (p *Parser) Additional() (Resource, error) {
- return p.resource(sectionAdditionals)
- }
-
- // AllAdditionals parses all Additional Resources.
- func (p *Parser) AllAdditionals() ([]Resource, error) {
- as := make([]Resource, 0, p.header.additionals)
- for {
- a, err := p.Additional()
- if err == ErrSectionDone {
- return as, nil
- }
- if err != nil {
- return nil, err
- }
- as = append(as, a)
- }
- }
-
- // SkipAdditional skips a single Additional Resource.
- func (p *Parser) SkipAdditional() error {
- return p.skipResource(sectionAdditionals)
- }
-
- // SkipAllAdditionals skips all Additional Resources.
- func (p *Parser) SkipAllAdditionals() error {
- for {
- if err := p.SkipAdditional(); err == ErrSectionDone {
- return nil
- } else if err != nil {
- return err
- }
- }
- }
-
- // Unpack parses a full Message.
- func (m *Message) Unpack(msg []byte) error {
- var p Parser
- var err error
- if m.Header, err = p.Start(msg); err != nil {
- return err
- }
- if m.Questions, err = p.AllQuestions(); err != nil {
- return err
- }
- if m.Answers, err = p.AllAnswers(); err != nil {
- return err
- }
- if m.Authorities, err = p.AllAuthorities(); err != nil {
- return err
- }
- if m.Additionals, err = p.AllAdditionals(); err != nil {
- return err
- }
- return nil
- }
-
- // Pack packs a full Message.
- func (m *Message) Pack() ([]byte, error) {
- // Validate the lengths. It is very unlikely that anyone will try to
- // pack more than 65535 of any particular type, but it is possible and
- // we should fail gracefully.
- if len(m.Questions) > int(^uint16(0)) {
- return nil, errTooManyQuestions
- }
- if len(m.Answers) > int(^uint16(0)) {
- return nil, errTooManyAnswers
- }
- if len(m.Authorities) > int(^uint16(0)) {
- return nil, errTooManyAuthorities
- }
- if len(m.Additionals) > int(^uint16(0)) {
- return nil, errTooManyAdditionals
- }
-
- var h header
- h.id, h.bits = m.Header.pack()
-
- h.questions = uint16(len(m.Questions))
- h.answers = uint16(len(m.Answers))
- h.authorities = uint16(len(m.Authorities))
- h.additionals = uint16(len(m.Additionals))
-
- // The starting capacity doesn't matter too much, but most DNS responses
- // Will be <= 512 bytes as it is the limit for DNS over UDP.
- msg := make([]byte, 0, 512)
-
- msg = h.pack(msg)
-
- // RFC 1035 allows (but does not require) compression for packing. RFC
- // 1035 requires unpacking implementations to support compression, so
- // unconditionally enabling it is fine.
- //
- // DNS lookups are typically done over UDP, and RFC 1035 states that UDP
- // DNS packets can be a maximum of 512 bytes long. Without compression,
- // many DNS response packets are over this limit, so enabling
- // compression will help ensure compliance.
- compression := map[string]int{}
-
- for _, q := range m.Questions {
- var err error
- msg, err = q.pack(msg, compression)
- if err != nil {
- return nil, &nestedError{"packing Question", err}
- }
- }
- for _, a := range m.Answers {
- var err error
- msg, err = packResource(msg, a, compression)
- if err != nil {
- return nil, &nestedError{"packing Answer", err}
- }
- }
- for _, a := range m.Authorities {
- var err error
- msg, err = packResource(msg, a, compression)
- if err != nil {
- return nil, &nestedError{"packing Authority", err}
- }
- }
- for _, a := range m.Additionals {
- var err error
- msg, err = packResource(msg, a, compression)
- if err != nil {
- return nil, &nestedError{"packing Additional", err}
- }
- }
-
- return msg, nil
- }
-
- // An ResourceHeader is the header of a DNS resource record. There are
- // many types of DNS resource records, but they all share the same header.
- type ResourceHeader struct {
- // Name is the domain name for which this resource record pertains.
- Name string
-
- // Type is the type of DNS resource record.
- //
- // This field will be set automatically during packing.
- Type Type
-
- // Class is the class of network to which this DNS resource record
- // pertains.
- Class Class
-
- // TTL is the length of time (measured in seconds) which this resource
- // record is valid for (time to live). All Resources in a set should
- // have the same TTL (RFC 2181 Section 5.2).
- TTL uint32
-
- // Length is the length of data in the resource record after the header.
- //
- // This field will be set automatically during packing.
- Length uint16
- }
-
- // Header implements Resource.Header.
- func (h *ResourceHeader) Header() *ResourceHeader {
- return h
- }
-
- // pack packs all of the fields in a ResourceHeader except for the length. The
- // length bytes are returned as a slice so they can be filled in after the rest
- // of the Resource has been packed.
- func (h *ResourceHeader) pack(oldMsg []byte, compression map[string]int) (msg []byte, length []byte, err error) {
- msg = oldMsg
- if msg, err = packName(msg, h.Name, compression); err != nil {
- return oldMsg, nil, &nestedError{"Name", err}
- }
- msg = packType(msg, h.Type)
- msg = packClass(msg, h.Class)
- msg = packUint32(msg, h.TTL)
- lenBegin := len(msg)
- msg = packUint16(msg, h.Length)
- return msg, msg[lenBegin:], nil
- }
-
- func (h *ResourceHeader) unpack(msg []byte, off int) (int, error) {
- newOff := off
- var err error
- if h.Name, newOff, err = unpackName(msg, newOff); err != nil {
- return off, &nestedError{"Name", err}
- }
- if h.Type, newOff, err = unpackType(msg, newOff); err != nil {
- return off, &nestedError{"Type", err}
- }
- if h.Class, newOff, err = unpackClass(msg, newOff); err != nil {
- return off, &nestedError{"Class", err}
- }
- if h.TTL, newOff, err = unpackUint32(msg, newOff); err != nil {
- return off, &nestedError{"TTL", err}
- }
- if h.Length, newOff, err = unpackUint16(msg, newOff); err != nil {
- return off, &nestedError{"Length", err}
- }
- return newOff, nil
- }
-
- func skipResource(msg []byte, off int) (int, error) {
- newOff, err := skipName(msg, off)
- if err != nil {
- return off, &nestedError{"Name", err}
- }
- if newOff, err = skipType(msg, newOff); err != nil {
- return off, &nestedError{"Type", err}
- }
- if newOff, err = skipClass(msg, newOff); err != nil {
- return off, &nestedError{"Class", err}
- }
- if newOff, err = skipUint32(msg, newOff); err != nil {
- return off, &nestedError{"TTL", err}
- }
- length, newOff, err := unpackUint16(msg, newOff)
- if err != nil {
- return off, &nestedError{"Length", err}
- }
- if newOff += int(length); newOff > len(msg) {
- return off, errResourceLen
- }
- return newOff, nil
- }
-
- func packUint16(msg []byte, field uint16) []byte {
- return append(msg, byte(field>>8), byte(field))
- }
-
- func unpackUint16(msg []byte, off int) (uint16, int, error) {
- if off+2 > len(msg) {
- return 0, off, errBaseLen
- }
- return uint16(msg[off])<<8 | uint16(msg[off+1]), off + 2, nil
- }
-
- func skipUint16(msg []byte, off int) (int, error) {
- if off+2 > len(msg) {
- return off, errBaseLen
- }
- return off + 2, nil
- }
-
- func packType(msg []byte, field Type) []byte {
- return packUint16(msg, uint16(field))
- }
-
- func unpackType(msg []byte, off int) (Type, int, error) {
- t, o, err := unpackUint16(msg, off)
- return Type(t), o, err
- }
-
- func skipType(msg []byte, off int) (int, error) {
- return skipUint16(msg, off)
- }
-
- func packClass(msg []byte, field Class) []byte {
- return packUint16(msg, uint16(field))
- }
-
- func unpackClass(msg []byte, off int) (Class, int, error) {
- c, o, err := unpackUint16(msg, off)
- return Class(c), o, err
- }
-
- func skipClass(msg []byte, off int) (int, error) {
- return skipUint16(msg, off)
- }
-
- func packUint32(msg []byte, field uint32) []byte {
- return append(
- msg,
- byte(field>>24),
- byte(field>>16),
- byte(field>>8),
- byte(field),
- )
- }
-
- func unpackUint32(msg []byte, off int) (uint32, int, error) {
- if off+4 > len(msg) {
- return 0, off, errBaseLen
- }
- v := uint32(msg[off])<<24 | uint32(msg[off+1])<<16 | uint32(msg[off+2])<<8 | uint32(msg[off+3])
- return v, off + 4, nil
- }
-
- func skipUint32(msg []byte, off int) (int, error) {
- if off+4 > len(msg) {
- return off, errBaseLen
- }
- return off + 4, nil
- }
-
- func packText(msg []byte, field string) []byte {
- for len(field) > 0 {
- l := len(field)
- if l > 255 {
- l = 255
- }
- msg = append(msg, byte(l))
- msg = append(msg, field[:l]...)
- field = field[l:]
- }
- return msg
- }
-
- func unpackText(msg []byte, off int) (string, int, error) {
- if off >= len(msg) {
- return "", off, errBaseLen
- }
- beginOff := off + 1
- endOff := beginOff + int(msg[off])
- if endOff > len(msg) {
- return "", off, errCalcLen
- }
- return string(msg[beginOff:endOff]), endOff, nil
- }
-
- func skipText(msg []byte, off int) (int, error) {
- if off >= len(msg) {
- return off, errBaseLen
- }
- endOff := off + 1 + int(msg[off])
- if endOff > len(msg) {
- return off, errCalcLen
- }
- return endOff, nil
- }
-
- func packBytes(msg []byte, field []byte) []byte {
- return append(msg, field...)
- }
-
- func unpackBytes(msg []byte, off int, field []byte) (int, error) {
- newOff := off + len(field)
- if newOff > len(msg) {
- return off, errBaseLen
- }
- copy(field, msg[off:newOff])
- return newOff, nil
- }
-
- func skipBytes(msg []byte, off int, field []byte) (int, error) {
- newOff := off + len(field)
- if newOff > len(msg) {
- return off, errBaseLen
- }
- return newOff, nil
- }
-
- // packName packs a domain name.
- //
- // Domain names are a sequence of counted strings split at the dots. They end
- // with a zero-length string. Compression can be used to reuse domain suffixes.
- //
- // The compression map will be updated with new domain suffixes. If compression
- // is nil, compression will not be used.
- func packName(msg []byte, name string, compression map[string]int) ([]byte, error) {
- oldMsg := msg
-
- // Add a trailing dot to canonicalize name.
- if n := len(name); n == 0 || name[n-1] != '.' {
- name += "."
- }
-
- // Allow root domain.
- if name == "." {
- return append(msg, 0), nil
- }
-
- // Emit sequence of counted strings, chopping at dots.
- for i, begin := 0, 0; i < len(name); i++ {
- // Check for the end of the segment.
- if name[i] == '.' {
- // The two most significant bits have special meaning.
- // It isn't allowed for segments to be long enough to
- // need them.
- if i-begin >= 1<<6 {
- return oldMsg, errSegTooLong
- }
-
- // Segments must have a non-zero length.
- if i-begin == 0 {
- return oldMsg, errZeroSegLen
- }
-
- msg = append(msg, byte(i-begin))
-
- for j := begin; j < i; j++ {
- msg = append(msg, name[j])
- }
-
- begin = i + 1
- continue
- }
-
- // We can only compress domain suffixes starting with a new
- // segment. A pointer is two bytes with the two most significant
- // bits set to 1 to indicate that it is a pointer.
- if (i == 0 || name[i-1] == '.') && compression != nil {
- if ptr, ok := compression[name[i:]]; ok {
- // Hit. Emit a pointer instead of the rest of
- // the domain.
- return append(msg, byte(ptr>>8|0xC0), byte(ptr)), nil
- }
-
- // Miss. Add the suffix to the compression table if the
- // offset can be stored in the available 14 bytes.
- if len(msg) <= int(^uint16(0)>>2) {
- compression[name[i:]] = len(msg)
- }
- }
- }
- return append(msg, 0), nil
- }
-
- // unpackName unpacks a domain name.
- func unpackName(msg []byte, off int) (string, int, error) {
- // currOff is the current working offset.
- currOff := off
-
- // newOff is the offset where the next record will start. Pointers lead
- // to data that belongs to other names and thus doesn't count towards to
- // the usage of this name.
- newOff := off
-
- // name is the domain name being unpacked.
- name := make([]byte, 0, 255)
-
- // ptr is the number of pointers followed.
- var ptr int
- Loop:
- for {
- if currOff >= len(msg) {
- return "", off, errBaseLen
- }
- c := int(msg[currOff])
- currOff++
- switch c & 0xC0 {
- case 0x00: // String segment
- if c == 0x00 {
- // A zero length signals the end of the name.
- break Loop
- }
- endOff := currOff + c
- if endOff > len(msg) {
- return "", off, errCalcLen
- }
- name = append(name, msg[currOff:endOff]...)
- name = append(name, '.')
- currOff = endOff
- case 0xC0: // Pointer
- if currOff >= len(msg) {
- return "", off, errInvalidPtr
- }
- c1 := msg[currOff]
- currOff++
- if ptr == 0 {
- newOff = currOff
- }
- // Don't follow too many pointers, maybe there's a loop.
- if ptr++; ptr > 10 {
- return "", off, errTooManyPtr
- }
- currOff = (c^0xC0)<<8 | int(c1)
- default:
- // Prefixes 0x80 and 0x40 are reserved.
- return "", off, errReserved
- }
- }
- if len(name) == 0 {
- name = append(name, '.')
- }
- if ptr == 0 {
- newOff = currOff
- }
- return string(name), newOff, nil
- }
-
- func skipName(msg []byte, off int) (int, error) {
- // newOff is the offset where the next record will start. Pointers lead
- // to data that belongs to other names and thus doesn't count towards to
- // the usage of this name.
- newOff := off
-
- Loop:
- for {
- if newOff >= len(msg) {
- return off, errBaseLen
- }
- c := int(msg[newOff])
- newOff++
- switch c & 0xC0 {
- case 0x00:
- if c == 0x00 {
- // A zero length signals the end of the name.
- break Loop
- }
- // literal string
- newOff += c
- if newOff > len(msg) {
- return off, errCalcLen
- }
- case 0xC0:
- // Pointer to somewhere else in msg.
-
- // Pointers are two bytes.
- newOff++
-
- // Don't follow the pointer as the data here has ended.
- break Loop
- default:
- // Prefixes 0x80 and 0x40 are reserved.
- return off, errReserved
- }
- }
-
- return newOff, nil
- }
-
- // A Question is a DNS query.
- type Question struct {
- Name string
- Type Type
- Class Class
- }
-
- func (q *Question) pack(msg []byte, compression map[string]int) ([]byte, error) {
- msg, err := packName(msg, q.Name, compression)
- if err != nil {
- return msg, &nestedError{"Name", err}
- }
- msg = packType(msg, q.Type)
- return packClass(msg, q.Class), nil
- }
-
- func unpackResource(msg []byte, off int, hdr ResourceHeader) (Resource, int, error) {
- var (
- r Resource
- err error
- name string
- )
- switch hdr.Type {
- case TypeA:
- r, err = unpackAResource(hdr, msg, off)
- name = "A"
- case TypeNS:
- r, err = unpackNSResource(hdr, msg, off)
- name = "NS"
- case TypeCNAME:
- r, err = unpackCNAMEResource(hdr, msg, off)
- name = "CNAME"
- case TypeSOA:
- r, err = unpackSOAResource(hdr, msg, off)
- name = "SOA"
- case TypePTR:
- r, err = unpackPTRResource(hdr, msg, off)
- name = "PTR"
- case TypeMX:
- r, err = unpackMXResource(hdr, msg, off)
- name = "MX"
- case TypeTXT:
- r, err = unpackTXTResource(hdr, msg, off)
- name = "TXT"
- case TypeAAAA:
- r, err = unpackAAAAResource(hdr, msg, off)
- name = "AAAA"
- case TypeSRV:
- r, err = unpackSRVResource(hdr, msg, off)
- name = "SRV"
- }
- if err != nil {
- return nil, off, &nestedError{name + " record", err}
- }
- if r != nil {
- return r, off + int(hdr.Length), nil
- }
- return nil, off, errors.New("invalid resource type: " + string(hdr.Type+'0'))
- }
-
- // A CNAMEResource is a CNAME Resource record.
- type CNAMEResource struct {
- ResourceHeader
-
- CNAME string
- }
-
- func (r *CNAMEResource) realType() Type {
- return TypeCNAME
- }
-
- func (r *CNAMEResource) pack(msg []byte, compression map[string]int) ([]byte, error) {
- return packName(msg, r.CNAME, compression)
- }
-
- func unpackCNAMEResource(hdr ResourceHeader, msg []byte, off int) (*CNAMEResource, error) {
- cname, _, err := unpackName(msg, off)
- if err != nil {
- return nil, err
- }
- return &CNAMEResource{hdr, cname}, nil
- }
-
- // An MXResource is an MX Resource record.
- type MXResource struct {
- ResourceHeader
-
- Pref uint16
- MX string
- }
-
- func (r *MXResource) realType() Type {
- return TypeMX
- }
-
- func (r *MXResource) pack(msg []byte, compression map[string]int) ([]byte, error) {
- oldMsg := msg
- msg = packUint16(msg, r.Pref)
- msg, err := packName(msg, r.MX, compression)
- if err != nil {
- return oldMsg, &nestedError{"MXResource.MX", err}
- }
- return msg, nil
- }
-
- func unpackMXResource(hdr ResourceHeader, msg []byte, off int) (*MXResource, error) {
- pref, off, err := unpackUint16(msg, off)
- if err != nil {
- return nil, &nestedError{"Pref", err}
- }
- mx, _, err := unpackName(msg, off)
- if err != nil {
- return nil, &nestedError{"MX", err}
- }
- return &MXResource{hdr, pref, mx}, nil
- }
-
- // An NSResource is an NS Resource record.
- type NSResource struct {
- ResourceHeader
-
- NS string
- }
-
- func (r *NSResource) realType() Type {
- return TypeNS
- }
-
- func (r *NSResource) pack(msg []byte, compression map[string]int) ([]byte, error) {
- return packName(msg, r.NS, compression)
- }
-
- func unpackNSResource(hdr ResourceHeader, msg []byte, off int) (*NSResource, error) {
- ns, _, err := unpackName(msg, off)
- if err != nil {
- return nil, err
- }
- return &NSResource{hdr, ns}, nil
- }
-
- // A PTRResource is a PTR Resource record.
- type PTRResource struct {
- ResourceHeader
-
- PTR string
- }
-
- func (r *PTRResource) realType() Type {
- return TypePTR
- }
-
- func (r *PTRResource) pack(msg []byte, compression map[string]int) ([]byte, error) {
- return packName(msg, r.PTR, compression)
- }
-
- func unpackPTRResource(hdr ResourceHeader, msg []byte, off int) (*PTRResource, error) {
- ptr, _, err := unpackName(msg, off)
- if err != nil {
- return nil, err
- }
- return &PTRResource{hdr, ptr}, nil
- }
-
- // An SOAResource is an SOA Resource record.
- type SOAResource struct {
- ResourceHeader
-
- NS string
- MBox string
- Serial uint32
- Refresh uint32
- Retry uint32
- Expire uint32
-
- // MinTTL the is the default TTL of Resources records which did not
- // contain a TTL value and the TTL of negative responses. (RFC 2308
- // Section 4)
- MinTTL uint32
- }
-
- func (r *SOAResource) realType() Type {
- return TypeSOA
- }
-
- func (r *SOAResource) pack(msg []byte, compression map[string]int) ([]byte, error) {
- oldMsg := msg
- msg, err := packName(msg, r.NS, compression)
- if err != nil {
- return oldMsg, &nestedError{"SOAResource.NS", err}
- }
- msg, err = packName(msg, r.MBox, compression)
- if err != nil {
- return oldMsg, &nestedError{"SOAResource.MBox", err}
- }
- msg = packUint32(msg, r.Serial)
- msg = packUint32(msg, r.Refresh)
- msg = packUint32(msg, r.Retry)
- msg = packUint32(msg, r.Expire)
- return packUint32(msg, r.MinTTL), nil
- }
-
- func unpackSOAResource(hdr ResourceHeader, msg []byte, off int) (*SOAResource, error) {
- ns, off, err := unpackName(msg, off)
- if err != nil {
- return nil, &nestedError{"NS", err}
- }
- mbox, off, err := unpackName(msg, off)
- if err != nil {
- return nil, &nestedError{"MBox", err}
- }
- serial, off, err := unpackUint32(msg, off)
- if err != nil {
- return nil, &nestedError{"Serial", err}
- }
- refresh, off, err := unpackUint32(msg, off)
- if err != nil {
- return nil, &nestedError{"Refresh", err}
- }
- retry, off, err := unpackUint32(msg, off)
- if err != nil {
- return nil, &nestedError{"Retry", err}
- }
- expire, off, err := unpackUint32(msg, off)
- if err != nil {
- return nil, &nestedError{"Expire", err}
- }
- minTTL, _, err := unpackUint32(msg, off)
- if err != nil {
- return nil, &nestedError{"MinTTL", err}
- }
- return &SOAResource{hdr, ns, mbox, serial, refresh, retry, expire, minTTL}, nil
- }
-
- // A TXTResource is a TXT Resource record.
- type TXTResource struct {
- ResourceHeader
-
- Txt string // Not a domain name.
- }
-
- func (r *TXTResource) realType() Type {
- return TypeTXT
- }
-
- func (r *TXTResource) pack(msg []byte, compression map[string]int) ([]byte, error) {
- return packText(msg, r.Txt), nil
- }
-
- func unpackTXTResource(hdr ResourceHeader, msg []byte, off int) (*TXTResource, error) {
- var txt string
- for n := uint16(0); n < hdr.Length; {
- var t string
- var err error
- if t, off, err = unpackText(msg, off); err != nil {
- return nil, &nestedError{"text", err}
- }
- // Check if we got too many bytes.
- if hdr.Length-n < uint16(len(t))+1 {
- return nil, errCalcLen
- }
- n += uint16(len(t)) + 1
- txt += t
- }
- return &TXTResource{hdr, txt}, nil
- }
-
- // An SRVResource is an SRV Resource record.
- type SRVResource struct {
- ResourceHeader
-
- Priority uint16
- Weight uint16
- Port uint16
- Target string // Not compressed as per RFC 2782.
- }
-
- func (r *SRVResource) realType() Type {
- return TypeSRV
- }
-
- func (r *SRVResource) pack(msg []byte, compression map[string]int) ([]byte, error) {
- oldMsg := msg
- msg = packUint16(msg, r.Priority)
- msg = packUint16(msg, r.Weight)
- msg = packUint16(msg, r.Port)
- msg, err := packName(msg, r.Target, nil)
- if err != nil {
- return oldMsg, &nestedError{"SRVResource.Target", err}
- }
- return msg, nil
- }
-
- func unpackSRVResource(hdr ResourceHeader, msg []byte, off int) (*SRVResource, error) {
- priority, off, err := unpackUint16(msg, off)
- if err != nil {
- return nil, &nestedError{"Priority", err}
- }
- weight, off, err := unpackUint16(msg, off)
- if err != nil {
- return nil, &nestedError{"Weight", err}
- }
- port, off, err := unpackUint16(msg, off)
- if err != nil {
- return nil, &nestedError{"Port", err}
- }
- target, _, err := unpackName(msg, off)
- if err != nil {
- return nil, &nestedError{"Target", err}
- }
- return &SRVResource{hdr, priority, weight, port, target}, nil
- }
-
- // An AResource is an A Resource record.
- type AResource struct {
- ResourceHeader
-
- A [4]byte
- }
-
- func (r *AResource) realType() Type {
- return TypeA
- }
-
- func (r *AResource) pack(msg []byte, compression map[string]int) ([]byte, error) {
- return packBytes(msg, r.A[:]), nil
- }
-
- func unpackAResource(hdr ResourceHeader, msg []byte, off int) (*AResource, error) {
- var a [4]byte
- if _, err := unpackBytes(msg, off, a[:]); err != nil {
- return nil, err
- }
- return &AResource{hdr, a}, nil
- }
-
- // An AAAAResource is an AAAA Resource record.
- type AAAAResource struct {
- ResourceHeader
-
- AAAA [16]byte
- }
-
- func (r *AAAAResource) realType() Type {
- return TypeAAAA
- }
-
- func (r *AAAAResource) pack(msg []byte, compression map[string]int) ([]byte, error) {
- return packBytes(msg, r.AAAA[:]), nil
- }
-
- func unpackAAAAResource(hdr ResourceHeader, msg []byte, off int) (*AAAAResource, error) {
- var aaaa [16]byte
- if _, err := unpackBytes(msg, off, aaaa[:]); err != nil {
- return nil, err
- }
- return &AAAAResource{hdr, aaaa}, nil
- }
|