dns.go

Documentation: github.com/miekg/dns

     1  package dns
     2  
     3  import (
     4  	"encoding/hex"
     5  	"strconv"
     6  )
     7  
     8  const (
     9  	year68     = 1 << 31 // For RFC1982 (Serial Arithmetic) calculations in 32 bits.
    10  	defaultTtl = 3600    // Default internal TTL.
    11  
    12  	// DefaultMsgSize is the standard default for messages larger than 512 bytes.
    13  	DefaultMsgSize = 4096
    14  	// MinMsgSize is the minimal size of a DNS packet.
    15  	MinMsgSize = 512
    16  	// MaxMsgSize is the largest possible DNS packet.
    17  	MaxMsgSize = 65535
    18  )
    19  
    20  // Error represents a DNS error.
    21  type Error struct{ err string }
    22  
    23  func (e *Error) Error() string {
    24  	if e == nil {
    25  		return "dns: <nil>"
    26  	}
    27  	return "dns: " + e.err
    28  }
    29  
    30  // An RR represents a resource record.
    31  type RR interface {
    32  	// Header returns the header of an resource record. The header contains
    33  	// everything up to the rdata.
    34  	Header() *RR_Header
    35  	// String returns the text representation of the resource record.
    36  	String() string
    37  
    38  	// copy returns a copy of the RR
    39  	copy() RR
    40  
    41  	// len returns the length (in octets) of the compressed or uncompressed RR in wire format.
    42  	//
    43  	// If compression is nil, the uncompressed size will be returned, otherwise the compressed
    44  	// size will be returned and domain names will be added to the map for future compression.
    45  	len(off int, compression map[string]struct{}) int
    46  
    47  	// pack packs the records RDATA into wire format. The header will
    48  	// already have been packed into msg.
    49  	pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error)
    50  
    51  	// unpack unpacks an RR from wire format.
    52  	//
    53  	// This will only be called on a new and empty RR type with only the header populated. It
    54  	// will only be called if the record's RDATA is non-empty.
    55  	unpack(msg []byte, off int) (off1 int, err error)
    56  
    57  	// parse parses an RR from zone file format.
    58  	//
    59  	// This will only be called on a new and empty RR type with only the header populated.
    60  	parse(c *zlexer, origin string) *ParseError
    61  
    62  	// isDuplicate returns whether the two RRs are duplicates.
    63  	isDuplicate(r2 RR) bool
    64  }
    65  
    66  // RR_Header is the header all DNS resource records share.
    67  type RR_Header struct {
    68  	Name     string `dns:"cdomain-name"`
    69  	Rrtype   uint16
    70  	Class    uint16
    71  	Ttl      uint32
    72  	Rdlength uint16 // Length of data after header.
    73  }
    74  
    75  // Header returns itself. This is here to make RR_Header implements the RR interface.
    76  func (h *RR_Header) Header() *RR_Header { return h }
    77  
    78  // Just to implement the RR interface.
    79  func (h *RR_Header) copy() RR { return nil }
    80  
    81  func (h *RR_Header) String() string {
    82  	var s string
    83  
    84  	if h.Rrtype == TypeOPT {
    85  		s = ";"
    86  		// and maybe other things
    87  	}
    88  
    89  	s += sprintName(h.Name) + "\t"
    90  	s += strconv.FormatInt(int64(h.Ttl), 10) + "\t"
    91  	s += Class(h.Class).String() + "\t"
    92  	s += Type(h.Rrtype).String() + "\t"
    93  	return s
    94  }
    95  
    96  func (h *RR_Header) len(off int, compression map[string]struct{}) int {
    97  	l := domainNameLen(h.Name, off, compression, true)
    98  	l += 10 // rrtype(2) + class(2) + ttl(4) + rdlength(2)
    99  	return l
   100  }
   101  
   102  func (h *RR_Header) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
   103  	// RR_Header has no RDATA to pack.
   104  	return off, nil
   105  }
   106  
   107  func (h *RR_Header) unpack(msg []byte, off int) (int, error) {
   108  	panic("dns: internal error: unpack should never be called on RR_Header")
   109  }
   110  
   111  func (h *RR_Header) parse(c *zlexer, origin string) *ParseError {
   112  	panic("dns: internal error: parse should never be called on RR_Header")
   113  }
   114  
   115  // ToRFC3597 converts a known RR to the unknown RR representation from RFC 3597.
   116  func (rr *RFC3597) ToRFC3597(r RR) error {
   117  	buf := make([]byte, Len(r))
   118  	headerEnd, off, err := packRR(r, buf, 0, compressionMap{}, false)
   119  	if err != nil {
   120  		return err
   121  	}
   122  	buf = buf[:off]
   123  
   124  	*rr = RFC3597{Hdr: *r.Header()}
   125  	rr.Hdr.Rdlength = uint16(off - headerEnd)
   126  
   127  	if noRdata(rr.Hdr) {
   128  		return nil
   129  	}
   130  
   131  	_, err = rr.unpack(buf, headerEnd)
   132  	return err
   133  }
   134  
   135  // fromRFC3597 converts an unknown RR representation from RFC 3597 to the known RR type.
   136  func (rr *RFC3597) fromRFC3597(r RR) error {
   137  	hdr := r.Header()
   138  	*hdr = rr.Hdr
   139  
   140  	// Can't overflow uint16 as the length of Rdata is validated in (*RFC3597).parse.
   141  	// We can only get here when rr was constructed with that method.
   142  	hdr.Rdlength = uint16(hex.DecodedLen(len(rr.Rdata)))
   143  
   144  	if noRdata(*hdr) {
   145  		// Dynamic update.
   146  		return nil
   147  	}
   148  
   149  	// rr.pack requires an extra allocation and a copy so we just decode Rdata
   150  	// manually, it's simpler anyway.
   151  	msg, err := hex.DecodeString(rr.Rdata)
   152  	if err != nil {
   153  		return err
   154  	}
   155  
   156  	_, err = r.unpack(msg, 0)
   157  	return err
   158  }
   159
View as plain text