Subversion Repositories openrisc

// Copyright 2009 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

// DNS packet assembly.  See RFC 1035.

//

// This is intended to support name resolution during Dial.

// It doesn't have to be blazing fast.

//

// 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

        dnsTypeAAAA  = 28

        dnsTypeSRV   = 33

        // valid dnsQuestion.qtype only

        dnsTypeAXFR  = 252

        dnsTypeMAILB = 253

        dnsTypeMAILA = 254

        dnsTypeALL   = 255

        // valid dnsQuestion.qclass

        dnsClassINET   = 1

        dnsClassCSNET  = 2

        dnsClassCHAOS  = 3

        dnsClassHESIOD = 4

        dnsClassANY    = 255

        // dnsMsg.rcode

        dnsRcodeSuccess        = 0

        dnsRcodeFormatError    = 1

        dnsRcodeServerFailure  = 2

        dnsRcodeNameError      = 3

        dnsRcodeNotImplemented = 4

        dnsRcodeRefused        = 5

)

// 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 `net:"domain-name"` // `net:"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 `net:"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 `net:"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 `net:"domain-name"`

}

func (rr *dnsRR_MB) Header() *dnsRR_Header {

        return &rr.Hdr

}

type dnsRR_MG struct {

        Hdr dnsRR_Header

        Mg  string `net:"domain-name"`

}

func (rr *dnsRR_MG) Header() *dnsRR_Header {

        return &rr.Hdr

}

type dnsRR_MINFO struct {

        Hdr   dnsRR_Header

        Rmail string `net:"domain-name"`

        Email string `net:"domain-name"`

}

func (rr *dnsRR_MINFO) Header() *dnsRR_Header {

        return &rr.Hdr

}

type dnsRR_MR struct {

        Hdr dnsRR_Header

        Mr  string `net:"domain-name"`

}

func (rr *dnsRR_MR) Header() *dnsRR_Header {

        return &rr.Hdr

}

type dnsRR_MX struct {

        Hdr  dnsRR_Header

        Pref uint16

        Mx   string `net:"domain-name"`

}

func (rr *dnsRR_MX) Header() *dnsRR_Header {

        return &rr.Hdr

}

type dnsRR_NS struct {

        Hdr dnsRR_Header

        Ns  string `net:"domain-name"`

}

func (rr *dnsRR_NS) Header() *dnsRR_Header {

        return &rr.Hdr

}

type dnsRR_PTR struct {

        Hdr dnsRR_Header

        Ptr string `net:"domain-name"`

}

func (rr *dnsRR_PTR) Header() *dnsRR_Header {

        return &rr.Hdr

}

type dnsRR_SOA struct {

        Hdr     dnsRR_Header

        Ns      string `net:"domain-name"`

        Mbox    string `net:"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 `net:"domain-name"`

}

func (rr *dnsRR_SRV) Header() *dnsRR_Header {

        return &rr.Hdr

}

type dnsRR_A struct {

        Hdr dnsRR_Header

        A   uint32 `net:"ipv4"`

}

func (rr *dnsRR_A) Header() *dnsRR_Header {

        return &rr.Hdr

}

type dnsRR_AAAA struct {

        Hdr  dnsRR_Header

        AAAA [16]byte `net:"ipv6"`

}

func (rr *dnsRR_AAAA) 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) },

        dnsTypeAAAA:  func() dnsRR { return new(dnsRR_AAAA) },

}

// Pack a domain name s into msg[off:].

// Domain names are a sequence of counted strings

// split at the dots.  They end with a zero-length string.

func packDomainName(s string, msg []byte, off int) (off1 int, ok bool) {

        // Add trailing dot to canonicalize name.

        if n := len(s); n == 0 || s[n-1] != '.' {

                s += "."

        }

        // 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,

// [n]byte, and other (often anonymous) structs.

func packStructValue(val reflect.Value, msg []byte, off int) (off1 int, ok bool) {

        for i := 0; i < val.NumField(); i++ {

                f := val.Type().Field(i)

                switch fv := val.Field(i); fv.Kind() {

                default:

                        fmt.Fprintf(os.Stderr, "net: dns: unknown packing type %v", f.Type)

                        return len(msg), false

                case reflect.Struct:

                        off, ok = packStructValue(fv, msg, off)

                case reflect.Uint16:

                        if off+2 > len(msg) {

                                return len(msg), false

                        }

                        i := fv.Uint()

                        msg[off] = byte(i >> 8)

                        msg[off+1] = byte(i)

                        off += 2

                case reflect.Uint32:

                        if off+4 > len(msg) {

                                return len(msg), false

                        }

                        i := fv.Uint()

                        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.Array:

                        if fv.Type().Elem().Kind() != reflect.Uint8 {

                                fmt.Fprintf(os.Stderr, "net: dns: unknown packing type %v", f.Type)

                                return len(msg), false

                        }

                        n := fv.Len()

                        if off+n > len(msg) {

                                return len(msg), false

                        }

                        reflect.Copy(reflect.ValueOf(msg[off:off+n]), fv)

                        off += n

                case reflect.String:

                        // There are multiple string encodings.

                        // The tag distinguishes ordinary strings from domain names.

                        s := fv.String()

                        switch f.Tag {

                        default:

                                fmt.Fprintf(os.Stderr, "net: dns: unknown string tag %v", f.Tag)

                                return len(msg), false

                        case `net:"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++

                                off += copy(msg[off:], s)

                        }

                }

        }

        return off, true

}

func structValue(any interface{}) reflect.Value {

        return reflect.ValueOf(any).Elem()

}

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.Value, msg []byte, off int) (off1 int, ok bool) {

        for i := 0; i < val.NumField(); i++ {

                f := val.Type().Field(i)

                switch fv := val.Field(i); fv.Kind() {

                default:

                        fmt.Fprintf(os.Stderr, "net: dns: unknown packing type %v", f.Type)

                        return len(msg), false

                case reflect.Struct:

                        off, ok = unpackStructValue(fv, msg, off)

                case reflect.Uint16:

                        if off+2 > len(msg) {

                                return len(msg), false

                        }

                        i := uint16(msg[off])<<8 | uint16(msg[off+1])

                        fv.SetUint(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.SetUint(uint64(i))

                        off += 4

                case reflect.Array:

                        if fv.Type().Elem().Kind() != reflect.Uint8 {

                                fmt.Fprintf(os.Stderr, "net: dns: unknown packing type %v", f.Type)

                                return len(msg), false

                        }

                        n := fv.Len()

                        if off+n > len(msg) {

                                return len(msg), false

                        }

                        reflect.Copy(fv, reflect.ValueOf(msg[off:off+n]))

                        off += n

                case reflect.String:

                        var s string

                        switch f.Tag {

                        default:

                                fmt.Fprintf(os.Stderr, "net: dns: unknown string tag %v", f.Tag)

                                return len(msg), false

                        case `net:"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.SetString(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 `net:"domain-name"`,

// but does look for an `net:"ipv4"` tag on uint32 variables

// and the `net:"ipv6"` tag on array variables,

// printing them as IP addresses.

func printStructValue(val reflect.Value) string {

        s := "{"

        for i := 0; i < val.NumField(); i++ {

                if i > 0 {

                        s += ", "

                }

                f := val.Type().Field(i)

                if !f.Anonymous {

                        s += f.Name + "="

                }

                fval := val.Field(i)

                if fv := fval; fv.Kind() == reflect.Struct {

                        s += printStructValue(fv)

                } else if fv := fval; (fv.Kind() == reflect.Uint || fv.Kind() == reflect.Uint8 || fv.Kind() == reflect.Uint16 || fv.Kind() == reflect.Uint32 || fv.Kind() == reflect.Uint64 || fv.Kind() == reflect.Uintptr) && f.Tag == `net:"ipv4"` {

                        i := fv.Uint()

                        s += IPv4(byte(i>>24), byte(i>>16), byte(i>>8), byte(i)).String()

                } else if fv := fval; fv.Kind() == reflect.Array && f.Tag == `net:"ipv6"` {

                        i := fv.Interface().([]byte)

                        s += IP(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, 0, dh.Ancount)

        dns.ns = make([]dnsRR, 0, dh.Nscount)

        dns.extra = make([]dnsRR, 0, dh.Arcount)

        var rec dnsRR

        for i := 0; i < len(dns.question); i++ {

                off, ok = unpackStruct(&dns.question[i], msg, off)

        }

        for i := 0; i < int(dh.Ancount); i++ {

                rec, off, ok = unpackRR(msg, off)

                if !ok {

                        return false

                }

                dns.answer = append(dns.answer, rec)

        }

        for i := 0; i < int(dh.Nscount); i++ {

                rec, off, ok = unpackRR(msg, off)

                if !ok {

                        return false

                }

                dns.ns = append(dns.ns, rec)

        }

        for i := 0; i < int(dh.Arcount); i++ {

                rec, off, ok = unpackRR(msg, off)

                if !ok {

                        return false

                }

                dns.extra = append(dns.extra, rec)

        }

        //      if off != len(msg) {

        //              println("extra bytes in dns packet", off, "<", len(msg));

        //      }

        return true

}

func (dns *dnsMsg) String() string {

        s := "DNS: " + printStruct(&dns.dnsMsgHdr) + "\n"

        if len(dns.question) > 0 {

                s += "-- Questions\n"

                for i := 0; i < len(dns.question); i++ {

                        s += printStruct(&dns.question[i]) + "\n"

                }

        }

        if len(dns.answer) > 0 {

                s += "-- Answers\n"

                for i := 0; i < len(dns.answer); i++ {

                        s += printStruct(dns.answer[i]) + "\n"

                }

        }

        if len(dns.ns) > 0 {

                s += "-- Name servers\n"

                for i := 0; i < len(dns.ns); i++ {

                        s += printStruct(dns.ns[i]) + "\n"

                }

        }

        if len(dns.extra) > 0 {

                s += "-- Extra\n"

                for i := 0; i < len(dns.extra); i++ {

                        s += printStruct(dns.extra[i]) + "\n"

                }

        }

        return s

}