The Go Programming Language

• Home
•  
• Installing Go
• Go Resources
•  
• Selected Documents
• Tutorial
• Effective Go
• FAQ
• Language Design FAQ
• Programming FAQ
•  
• References
• Language Specification
• Package documentation
• Command documentation
• Source files
•  
• Help & Community
• Go Blog
• Go Nuts mailing list
• #go-nuts on irc.freenode.net
• @go_nuts on Twitter
• gocoding YouTube Channel
• Issue tracker
• Go Wiki
•  
• Go Dashboard
• Build Status
• External Packages
• Benchmarks
•  
•  
• Go code search
•  
• Last update
• Fri Sep 10 01:40:37 PDT 2010
• release.2010-09-06

Source file src/pkg/net/dnsmsg.go

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

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

package net

import (
    "fmt"
    "os"
    "reflect"
)

// Packet formats

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

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

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

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

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

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

// DNS queries.
type dnsQuestion struct {
    Name   string "domain-name" // "domain-name" specifies encoding; see packers below
    Qtype  uint16
    Qclass uint16
}

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

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

type dnsRR interface {
    Header() *dnsRR_Header
}


// Specific DNS RR formats for each query type.

type dnsRR_CNAME struct {
    Hdr   dnsRR_Header
    Cname string "domain-name"
}

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

type dnsRR_HINFO struct {
    Hdr dnsRR_Header
    Cpu string
    Os  string
}

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

type dnsRR_MB struct {
    Hdr dnsRR_Header
    Mb  string "domain-name"
}

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

type dnsRR_MG struct {
    Hdr dnsRR_Header
    Mg  string "domain-name"
}

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

type dnsRR_MINFO struct {
    Hdr   dnsRR_Header
    Rmail string "domain-name"
    Email string "domain-name"
}

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

type dnsRR_MR struct {
    Hdr dnsRR_Header
    Mr  string "domain-name"
}

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

type dnsRR_MX struct {
    Hdr  dnsRR_Header
    Pref uint16
    Mx   string "domain-name"
}

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

type dnsRR_NS struct {
    Hdr dnsRR_Header
    Ns  string "domain-name"
}

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

type dnsRR_PTR struct {
    Hdr dnsRR_Header
    Ptr string "domain-name"
}

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

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

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

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

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

type dnsRR_SRV struct {
    Hdr      dnsRR_Header
    Priority uint16
    Weight   uint16
    Port     uint16
    Target   string "domain-name"
}

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

type dnsRR_A struct {
    Hdr dnsRR_Header
    A   uint32 "ipv4"
}

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


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

// Map of constructors for each RR wire type.
var rr_mk = map[int]func() dnsRR{
    dnsTypeCNAME: func() dnsRR { return new(dnsRR_CNAME) },
    dnsTypeHINFO: func() dnsRR { return new(dnsRR_HINFO) },
    dnsTypeMB:    func() dnsRR { return new(dnsRR_MB) },
    dnsTypeMG:    func() dnsRR { return new(dnsRR_MG) },
    dnsTypeMINFO: func() dnsRR { return new(dnsRR_MINFO) },
    dnsTypeMR:    func() dnsRR { return new(dnsRR_MR) },
    dnsTypeMX:    func() dnsRR { return new(dnsRR_MX) },
    dnsTypeNS:    func() dnsRR { return new(dnsRR_NS) },
    dnsTypePTR:   func() dnsRR { return new(dnsRR_PTR) },
    dnsTypeSOA:   func() dnsRR { return new(dnsRR_SOA) },
    dnsTypeTXT:   func() dnsRR { return new(dnsRR_TXT) },
    dnsTypeSRV:   func() dnsRR { return new(dnsRR_SRV) },
    dnsTypeA:     func() dnsRR { return new(dnsRR_A) },
}

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

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

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

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

// TODO(rsc): Move into generic library?
// Pack a reflect.StructValue into msg.  Struct members can only be uint16, uint32, string,
// and other (often anonymous) structs.
func packStructValue(val *reflect.StructValue, msg []byte, off int) (off1 int, ok bool) {
    for i := 0; i < val.NumField(); i++ {
        f := val.Type().(*reflect.StructType).Field(i)
        switch fv := val.Field(i).(type) {
        default:
        BadType:
            fmt.Fprintf(os.Stderr, "net: dns: unknown packing type %v", f.Type)
            return len(msg), false
        case *reflect.StructValue:
            off, ok = packStructValue(fv, msg, off)
        case *reflect.UintValue:
            i := fv.Get()
            switch fv.Type().Kind() {
            default:
                goto BadType
            case reflect.Uint16:
                if off+2 > len(msg) {
                    return len(msg), false
                }
                msg[off] = byte(i >> 8)
                msg[off+1] = byte(i)
                off += 2
            case reflect.Uint32:
                if off+4 > len(msg) {
                    return len(msg), false
                }
                msg[off] = byte(i >> 24)
                msg[off+1] = byte(i >> 16)
                msg[off+2] = byte(i >> 8)
                msg[off+3] = byte(i)
                off += 4
            }
        case *reflect.StringValue:
            // There are multiple string encodings.
            // The tag distinguishes ordinary strings from domain names.
            s := fv.Get()
            switch f.Tag {
            default:
                fmt.Fprintf(os.Stderr, "net: dns: unknown string tag %v", f.Tag)
                return len(msg), false
            case "domain-name":
                off, ok = packDomainName(s, msg, off)
                if !ok {
                    return len(msg), false
                }
            case "":
                // Counted string: 1 byte length.
                if len(s) > 255 || off+1+len(s) > len(msg) {
                    return len(msg), false
                }
                msg[off] = byte(len(s))
                off++
                for i := 0; i < len(s); i++ {
                    msg[off+i] = s[i]
                }
                off += len(s)
            }
        }
    }
    return off, true
}

func structValue(any interface{}) *reflect.StructValue {
    return reflect.NewValue(any).(*reflect.PtrValue).Elem().(*reflect.StructValue)
}

func packStruct(any interface{}, msg []byte, off int) (off1 int, ok bool) {
    off, ok = packStructValue(structValue(any), msg, off)
    return off, ok
}

// TODO(rsc): Move into generic library?
// Unpack a reflect.StructValue from msg.
// Same restrictions as packStructValue.
func unpackStructValue(val *reflect.StructValue, msg []byte, off int) (off1 int, ok bool) {
    for i := 0; i < val.NumField(); i++ {
        f := val.Type().(*reflect.StructType).Field(i)
        switch fv := val.Field(i).(type) {
        default:
        BadType:
            fmt.Fprintf(os.Stderr, "net: dns: unknown packing type %v", f.Type)
            return len(msg), false
        case *reflect.StructValue:
            off, ok = unpackStructValue(fv, msg, off)
        case *reflect.UintValue:
            switch fv.Type().Kind() {
            default:
                goto BadType
            case reflect.Uint16:
                if off+2 > len(msg) {
                    return len(msg), false
                }
                i := uint16(msg[off])<<8 | uint16(msg[off+1])
                fv.Set(uint64(i))
                off += 2
            case reflect.Uint32:
                if off+4 > len(msg) {
                    return len(msg), false
                }
                i := uint32(msg[off])<<24 | uint32(msg[off+1])<<16 | uint32(msg[off+2])<<8 | uint32(msg[off+3])
                fv.Set(uint64(i))
                off += 4
            }
        case *reflect.StringValue:
            var s string
            switch f.Tag {
            default:
                fmt.Fprintf(os.Stderr, "net: dns: unknown string tag %v", f.Tag)
                return len(msg), false
            case "domain-name":
                s, off, ok = unpackDomainName(msg, off)
                if !ok {
                    return len(msg), false
                }
            case "":
                if off >= len(msg) || off+1+int(msg[off]) > len(msg) {
                    return len(msg), false
                }
                n := int(msg[off])
                off++
                b := make([]byte, n)
                for i := 0; i < n; i++ {
                    b[i] = msg[off+i]
                }
                off += n
                s = string(b)
            }
            fv.Set(s)
        }
    }
    return off, true
}

func unpackStruct(any interface{}, msg []byte, off int) (off1 int, ok bool) {
    off, ok = unpackStructValue(structValue(any), msg, off)
    return off, ok
}

// Generic struct printer.
// Doesn't care about the string tag "domain-name",
// but does look for an "ipv4" tag on uint32 variables,
// printing them as IP addresses.
func printStructValue(val *reflect.StructValue) string {
    s := "{"
    for i := 0; i < val.NumField(); i++ {
        if i > 0 {
            s += ", "
        }
        f := val.Type().(*reflect.StructType).Field(i)
        if !f.Anonymous {
            s += f.Name + "="
        }
        fval := val.Field(i)
        if fv, ok := fval.(*reflect.StructValue); ok {
            s += printStructValue(fv)
        } else if fv, ok := fval.(*reflect.UintValue); ok && f.Tag == "ipv4" {
            i := fv.Get()
            s += IPv4(byte(i>>24), byte(i>>16), byte(i>>8), byte(i)).String()
        } else {
            s += fmt.Sprint(fval.Interface())
        }
    }
    s += "}"
    return s
}

func printStruct(any interface{}) string { return printStructValue(structValue(any)) }

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

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

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

// Usable representation of a DNS packet.

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

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


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

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

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

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

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

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

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

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

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

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

Except as noted, this content is licensed under Creative Commons Attribution 3.0.