Source file src/pkg/net/dnsmsg.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 // DNS packet assembly. See RFC 1035. 6 // 7 // This is intended to support name resolution during Dial. 8 // It doesn't have to be blazing fast. 9 // 10 // Each message structure has a Walk method that is used by 11 // a generic pack/unpack routine. Thus, if in the future we need 12 // to define new message structs, no new pack/unpack/printing code 13 // needs to be written. 14 // 15 // The first half of this file defines the DNS message formats. 16 // The second half implements the conversion to and from wire format. 17 // A few of the structure elements have string tags to aid the 18 // generic pack/unpack routines. 19 // 20 // TODO(rsc): There are enough names defined in this file that they're all 21 // prefixed with dns. Perhaps put this in its own package later. 22 23 package net 24 25 // Packet formats 26 27 // Wire constants. 28 const ( 29 // valid dnsRR_Header.Rrtype and dnsQuestion.qtype 30 dnsTypeA = 1 31 dnsTypeNS = 2 32 dnsTypeMD = 3 33 dnsTypeMF = 4 34 dnsTypeCNAME = 5 35 dnsTypeSOA = 6 36 dnsTypeMB = 7 37 dnsTypeMG = 8 38 dnsTypeMR = 9 39 dnsTypeNULL = 10 40 dnsTypeWKS = 11 41 dnsTypePTR = 12 42 dnsTypeHINFO = 13 43 dnsTypeMINFO = 14 44 dnsTypeMX = 15 45 dnsTypeTXT = 16 46 dnsTypeAAAA = 28 47 dnsTypeSRV = 33 48 49 // valid dnsQuestion.qtype only 50 dnsTypeAXFR = 252 51 dnsTypeMAILB = 253 52 dnsTypeMAILA = 254 53 dnsTypeALL = 255 54 55 // valid dnsQuestion.qclass 56 dnsClassINET = 1 57 dnsClassCSNET = 2 58 dnsClassCHAOS = 3 59 dnsClassHESIOD = 4 60 dnsClassANY = 255 61 62 // dnsMsg.rcode 63 dnsRcodeSuccess = 0 64 dnsRcodeFormatError = 1 65 dnsRcodeServerFailure = 2 66 dnsRcodeNameError = 3 67 dnsRcodeNotImplemented = 4 68 dnsRcodeRefused = 5 69 ) 70 71 // A dnsStruct describes how to iterate over its fields to emulate 72 // reflective marshalling. 73 type dnsStruct interface { 74 // Walk iterates over fields of a structure and calls f 75 // with a reference to that field, the name of the field 76 // and a tag ("", "domain", "ipv4", "ipv6") specifying 77 // particular encodings. Possible concrete types 78 // for v are *uint16, *uint32, *string, or []byte, and 79 // *int, *bool in the case of dnsMsgHdr. 80 // Whenever f returns false, Walk must stop and return 81 // false, and otherwise return true. 82 Walk(f func(v interface{}, name, tag string) (ok bool)) (ok bool) 83 } 84 85 // The wire format for the DNS packet header. 86 type dnsHeader struct { 87 Id uint16 88 Bits uint16 89 Qdcount, Ancount, Nscount, Arcount uint16 90 } 91 92 func (h *dnsHeader) Walk(f func(v interface{}, name, tag string) bool) bool { 93 return f(&h.Id, "Id", "") && 94 f(&h.Bits, "Bits", "") && 95 f(&h.Qdcount, "Qdcount", "") && 96 f(&h.Ancount, "Ancount", "") && 97 f(&h.Nscount, "Nscount", "") && 98 f(&h.Arcount, "Arcount", "") 99 } 100 101 const ( 102 // dnsHeader.Bits 103 _QR = 1 << 15 // query/response (response=1) 104 _AA = 1 << 10 // authoritative 105 _TC = 1 << 9 // truncated 106 _RD = 1 << 8 // recursion desired 107 _RA = 1 << 7 // recursion available 108 ) 109 110 // DNS queries. 111 type dnsQuestion struct { 112 Name string `net:"domain-name"` // `net:"domain-name"` specifies encoding; see packers below 113 Qtype uint16 114 Qclass uint16 115 } 116 117 func (q *dnsQuestion) Walk(f func(v interface{}, name, tag string) bool) bool { 118 return f(&q.Name, "Name", "domain") && 119 f(&q.Qtype, "Qtype", "") && 120 f(&q.Qclass, "Qclass", "") 121 } 122 123 // DNS responses (resource records). 124 // There are many types of messages, 125 // but they all share the same header. 126 type dnsRR_Header struct { 127 Name string `net:"domain-name"` 128 Rrtype uint16 129 Class uint16 130 Ttl uint32 131 Rdlength uint16 // length of data after header 132 } 133 134 func (h *dnsRR_Header) Header() *dnsRR_Header { 135 return h 136 } 137 138 func (h *dnsRR_Header) Walk(f func(v interface{}, name, tag string) bool) bool { 139 return f(&h.Name, "Name", "domain") && 140 f(&h.Rrtype, "Rrtype", "") && 141 f(&h.Class, "Class", "") && 142 f(&h.Ttl, "Ttl", "") && 143 f(&h.Rdlength, "Rdlength", "") 144 } 145 146 type dnsRR interface { 147 dnsStruct 148 Header() *dnsRR_Header 149 } 150 151 // Specific DNS RR formats for each query type. 152 153 type dnsRR_CNAME struct { 154 Hdr dnsRR_Header 155 Cname string `net:"domain-name"` 156 } 157 158 func (rr *dnsRR_CNAME) Header() *dnsRR_Header { 159 return &rr.Hdr 160 } 161 162 func (rr *dnsRR_CNAME) Walk(f func(v interface{}, name, tag string) bool) bool { 163 return rr.Hdr.Walk(f) && f(&rr.Cname, "Cname", "domain") 164 } 165 166 type dnsRR_HINFO struct { 167 Hdr dnsRR_Header 168 Cpu string 169 Os string 170 } 171 172 func (rr *dnsRR_HINFO) Header() *dnsRR_Header { 173 return &rr.Hdr 174 } 175 176 func (rr *dnsRR_HINFO) Walk(f func(v interface{}, name, tag string) bool) bool { 177 return rr.Hdr.Walk(f) && f(&rr.Cpu, "Cpu", "") && f(&rr.Os, "Os", "") 178 } 179 180 type dnsRR_MB struct { 181 Hdr dnsRR_Header 182 Mb string `net:"domain-name"` 183 } 184 185 func (rr *dnsRR_MB) Header() *dnsRR_Header { 186 return &rr.Hdr 187 } 188 189 func (rr *dnsRR_MB) Walk(f func(v interface{}, name, tag string) bool) bool { 190 return rr.Hdr.Walk(f) && f(&rr.Mb, "Mb", "domain") 191 } 192 193 type dnsRR_MG struct { 194 Hdr dnsRR_Header 195 Mg string `net:"domain-name"` 196 } 197 198 func (rr *dnsRR_MG) Header() *dnsRR_Header { 199 return &rr.Hdr 200 } 201 202 func (rr *dnsRR_MG) Walk(f func(v interface{}, name, tag string) bool) bool { 203 return rr.Hdr.Walk(f) && f(&rr.Mg, "Mg", "domain") 204 } 205 206 type dnsRR_MINFO struct { 207 Hdr dnsRR_Header 208 Rmail string `net:"domain-name"` 209 Email string `net:"domain-name"` 210 } 211 212 func (rr *dnsRR_MINFO) Header() *dnsRR_Header { 213 return &rr.Hdr 214 } 215 216 func (rr *dnsRR_MINFO) Walk(f func(v interface{}, name, tag string) bool) bool { 217 return rr.Hdr.Walk(f) && f(&rr.Rmail, "Rmail", "domain") && f(&rr.Email, "Email", "domain") 218 } 219 220 type dnsRR_MR struct { 221 Hdr dnsRR_Header 222 Mr string `net:"domain-name"` 223 } 224 225 func (rr *dnsRR_MR) Header() *dnsRR_Header { 226 return &rr.Hdr 227 } 228 229 func (rr *dnsRR_MR) Walk(f func(v interface{}, name, tag string) bool) bool { 230 return rr.Hdr.Walk(f) && f(&rr.Mr, "Mr", "domain") 231 } 232 233 type dnsRR_MX struct { 234 Hdr dnsRR_Header 235 Pref uint16 236 Mx string `net:"domain-name"` 237 } 238 239 func (rr *dnsRR_MX) Header() *dnsRR_Header { 240 return &rr.Hdr 241 } 242 243 func (rr *dnsRR_MX) Walk(f func(v interface{}, name, tag string) bool) bool { 244 return rr.Hdr.Walk(f) && f(&rr.Pref, "Pref", "") && f(&rr.Mx, "Mx", "domain") 245 } 246 247 type dnsRR_NS struct { 248 Hdr dnsRR_Header 249 Ns string `net:"domain-name"` 250 } 251 252 func (rr *dnsRR_NS) Header() *dnsRR_Header { 253 return &rr.Hdr 254 } 255 256 func (rr *dnsRR_NS) Walk(f func(v interface{}, name, tag string) bool) bool { 257 return rr.Hdr.Walk(f) && f(&rr.Ns, "Ns", "domain") 258 } 259 260 type dnsRR_PTR struct { 261 Hdr dnsRR_Header 262 Ptr string `net:"domain-name"` 263 } 264 265 func (rr *dnsRR_PTR) Header() *dnsRR_Header { 266 return &rr.Hdr 267 } 268 269 func (rr *dnsRR_PTR) Walk(f func(v interface{}, name, tag string) bool) bool { 270 return rr.Hdr.Walk(f) && f(&rr.Ptr, "Ptr", "domain") 271 } 272 273 type dnsRR_SOA struct { 274 Hdr dnsRR_Header 275 Ns string `net:"domain-name"` 276 Mbox string `net:"domain-name"` 277 Serial uint32 278 Refresh uint32 279 Retry uint32 280 Expire uint32 281 Minttl uint32 282 } 283 284 func (rr *dnsRR_SOA) Header() *dnsRR_Header { 285 return &rr.Hdr 286 } 287 288 func (rr *dnsRR_SOA) Walk(f func(v interface{}, name, tag string) bool) bool { 289 return rr.Hdr.Walk(f) && 290 f(&rr.Ns, "Ns", "domain") && 291 f(&rr.Mbox, "Mbox", "domain") && 292 f(&rr.Serial, "Serial", "") && 293 f(&rr.Refresh, "Refresh", "") && 294 f(&rr.Retry, "Retry", "") && 295 f(&rr.Expire, "Expire", "") && 296 f(&rr.Minttl, "Minttl", "") 297 } 298 299 type dnsRR_TXT struct { 300 Hdr dnsRR_Header 301 Txt string // not domain name 302 } 303 304 func (rr *dnsRR_TXT) Header() *dnsRR_Header { 305 return &rr.Hdr 306 } 307 308 func (rr *dnsRR_TXT) Walk(f func(v interface{}, name, tag string) bool) bool { 309 return rr.Hdr.Walk(f) && f(&rr.Txt, "Txt", "") 310 } 311 312 type dnsRR_SRV struct { 313 Hdr dnsRR_Header 314 Priority uint16 315 Weight uint16 316 Port uint16 317 Target string `net:"domain-name"` 318 } 319 320 func (rr *dnsRR_SRV) Header() *dnsRR_Header { 321 return &rr.Hdr 322 } 323 324 func (rr *dnsRR_SRV) Walk(f func(v interface{}, name, tag string) bool) bool { 325 return rr.Hdr.Walk(f) && 326 f(&rr.Priority, "Priority", "") && 327 f(&rr.Weight, "Weight", "") && 328 f(&rr.Port, "Port", "") && 329 f(&rr.Target, "Target", "domain") 330 } 331 332 type dnsRR_A struct { 333 Hdr dnsRR_Header 334 A uint32 `net:"ipv4"` 335 } 336 337 func (rr *dnsRR_A) Header() *dnsRR_Header { 338 return &rr.Hdr 339 } 340 341 func (rr *dnsRR_A) Walk(f func(v interface{}, name, tag string) bool) bool { 342 return rr.Hdr.Walk(f) && f(&rr.A, "A", "ipv4") 343 } 344 345 type dnsRR_AAAA struct { 346 Hdr dnsRR_Header 347 AAAA [16]byte `net:"ipv6"` 348 } 349 350 func (rr *dnsRR_AAAA) Header() *dnsRR_Header { 351 return &rr.Hdr 352 } 353 354 func (rr *dnsRR_AAAA) Walk(f func(v interface{}, name, tag string) bool) bool { 355 return rr.Hdr.Walk(f) && f(rr.AAAA[:], "AAAA", "ipv6") 356 } 357 358 // Packing and unpacking. 359 // 360 // All the packers and unpackers take a (msg []byte, off int) 361 // and return (off1 int, ok bool). If they return ok==false, they 362 // also return off1==len(msg), so that the next unpacker will 363 // also fail. This lets us avoid checks of ok until the end of a 364 // packing sequence. 365 366 // Map of constructors for each RR wire type. 367 var rr_mk = map[int]func() dnsRR{ 368 dnsTypeCNAME: func() dnsRR { return new(dnsRR_CNAME) }, 369 dnsTypeHINFO: func() dnsRR { return new(dnsRR_HINFO) }, 370 dnsTypeMB: func() dnsRR { return new(dnsRR_MB) }, 371 dnsTypeMG: func() dnsRR { return new(dnsRR_MG) }, 372 dnsTypeMINFO: func() dnsRR { return new(dnsRR_MINFO) }, 373 dnsTypeMR: func() dnsRR { return new(dnsRR_MR) }, 374 dnsTypeMX: func() dnsRR { return new(dnsRR_MX) }, 375 dnsTypeNS: func() dnsRR { return new(dnsRR_NS) }, 376 dnsTypePTR: func() dnsRR { return new(dnsRR_PTR) }, 377 dnsTypeSOA: func() dnsRR { return new(dnsRR_SOA) }, 378 dnsTypeTXT: func() dnsRR { return new(dnsRR_TXT) }, 379 dnsTypeSRV: func() dnsRR { return new(dnsRR_SRV) }, 380 dnsTypeA: func() dnsRR { return new(dnsRR_A) }, 381 dnsTypeAAAA: func() dnsRR { return new(dnsRR_AAAA) }, 382 } 383 384 // Pack a domain name s into msg[off:]. 385 // Domain names are a sequence of counted strings 386 // split at the dots. They end with a zero-length string. 387 func packDomainName(s string, msg []byte, off int) (off1 int, ok bool) { 388 // Add trailing dot to canonicalize name. 389 if n := len(s); n == 0 || s[n-1] != '.' { 390 s += "." 391 } 392 393 // Each dot ends a segment of the name. 394 // We trade each dot byte for a length byte. 395 // There is also a trailing zero. 396 // Check that we have all the space we need. 397 tot := len(s) + 1 398 if off+tot > len(msg) { 399 return len(msg), false 400 } 401 402 // Emit sequence of counted strings, chopping at dots. 403 begin := 0 404 for i := 0; i < len(s); i++ { 405 if s[i] == '.' { 406 if i-begin >= 1<<6 { // top two bits of length must be clear 407 return len(msg), false 408 } 409 msg[off] = byte(i - begin) 410 off++ 411 for j := begin; j < i; j++ { 412 msg[off] = s[j] 413 off++ 414 } 415 begin = i + 1 416 } 417 } 418 msg[off] = 0 419 off++ 420 return off, true 421 } 422 423 // Unpack a domain name. 424 // In addition to the simple sequences of counted strings above, 425 // domain names are allowed to refer to strings elsewhere in the 426 // packet, to avoid repeating common suffixes when returning 427 // many entries in a single domain. The pointers are marked 428 // by a length byte with the top two bits set. Ignoring those 429 // two bits, that byte and the next give a 14 bit offset from msg[0] 430 // where we should pick up the trail. 431 // Note that if we jump elsewhere in the packet, 432 // we return off1 == the offset after the first pointer we found, 433 // which is where the next record will start. 434 // In theory, the pointers are only allowed to jump backward. 435 // We let them jump anywhere and stop jumping after a while. 436 func unpackDomainName(msg []byte, off int) (s string, off1 int, ok bool) { 437 s = "" 438 ptr := 0 // number of pointers followed 439 Loop: 440 for { 441 if off >= len(msg) { 442 return "", len(msg), false 443 } 444 c := int(msg[off]) 445 off++ 446 switch c & 0xC0 { 447 case 0x00: 448 if c == 0x00 { 449 // end of name 450 break Loop 451 } 452 // literal string 453 if off+c > len(msg) { 454 return "", len(msg), false 455 } 456 s += string(msg[off:off+c]) + "." 457 off += c 458 case 0xC0: 459 // pointer to somewhere else in msg. 460 // remember location after first ptr, 461 // since that's how many bytes we consumed. 462 // also, don't follow too many pointers -- 463 // maybe there's a loop. 464 if off >= len(msg) { 465 return "", len(msg), false 466 } 467 c1 := msg[off] 468 off++ 469 if ptr == 0 { 470 off1 = off 471 } 472 if ptr++; ptr > 10 { 473 return "", len(msg), false 474 } 475 off = (c^0xC0)<<8 | int(c1) 476 default: 477 // 0x80 and 0x40 are reserved 478 return "", len(msg), false 479 } 480 } 481 if ptr == 0 { 482 off1 = off 483 } 484 return s, off1, true 485 } 486 487 // packStruct packs a structure into msg at specified offset off, and 488 // returns off1 such that msg[off:off1] is the encoded data. 489 func packStruct(any dnsStruct, msg []byte, off int) (off1 int, ok bool) { 490 ok = any.Walk(func(field interface{}, name, tag string) bool { 491 switch fv := field.(type) { 492 default: 493 println("net: dns: unknown packing type") 494 return false 495 case *uint16: 496 i := *fv 497 if off+2 > len(msg) { 498 return false 499 } 500 msg[off] = byte(i >> 8) 501 msg[off+1] = byte(i) 502 off += 2 503 case *uint32: 504 i := *fv 505 msg[off] = byte(i >> 24) 506 msg[off+1] = byte(i >> 16) 507 msg[off+2] = byte(i >> 8) 508 msg[off+3] = byte(i) 509 off += 4 510 case []byte: 511 n := len(fv) 512 if off+n > len(msg) { 513 return false 514 } 515 copy(msg[off:off+n], fv) 516 off += n 517 case *string: 518 s := *fv 519 switch tag { 520 default: 521 println("net: dns: unknown string tag", tag) 522 return false 523 case "domain": 524 off, ok = packDomainName(s, msg, off) 525 if !ok { 526 return false 527 } 528 case "": 529 // Counted string: 1 byte length. 530 if len(s) > 255 || off+1+len(s) > len(msg) { 531 return false 532 } 533 msg[off] = byte(len(s)) 534 off++ 535 off += copy(msg[off:], s) 536 } 537 } 538 return true 539 }) 540 if !ok { 541 return len(msg), false 542 } 543 return off, true 544 } 545 546 // unpackStruct decodes msg[off:] into the given structure, and 547 // returns off1 such that msg[off:off1] is the encoded data. 548 func unpackStruct(any dnsStruct, msg []byte, off int) (off1 int, ok bool) { 549 ok = any.Walk(func(field interface{}, name, tag string) bool { 550 switch fv := field.(type) { 551 default: 552 println("net: dns: unknown packing type") 553 return false 554 case *uint16: 555 if off+2 > len(msg) { 556 return false 557 } 558 *fv = uint16(msg[off])<<8 | uint16(msg[off+1]) 559 off += 2 560 case *uint32: 561 if off+4 > len(msg) { 562 return false 563 } 564 *fv = uint32(msg[off])<<24 | uint32(msg[off+1])<<16 | 565 uint32(msg[off+2])<<8 | uint32(msg[off+3]) 566 off += 4 567 case []byte: 568 n := len(fv) 569 if off+n > len(msg) { 570 return false 571 } 572 copy(fv, msg[off:off+n]) 573 off += n 574 case *string: 575 var s string 576 switch tag { 577 default: 578 println("net: dns: unknown string tag", tag) 579 return false 580 case "domain": 581 s, off, ok = unpackDomainName(msg, off) 582 if !ok { 583 return false 584 } 585 case "": 586 if off >= len(msg) || off+1+int(msg[off]) > len(msg) { 587 return false 588 } 589 n := int(msg[off]) 590 off++ 591 b := make([]byte, n) 592 for i := 0; i < n; i++ { 593 b[i] = msg[off+i] 594 } 595 off += n 596 s = string(b) 597 } 598 *fv = s 599 } 600 return true 601 }) 602 if !ok { 603 return len(msg), false 604 } 605 return off, true 606 } 607 608 // Generic struct printer. Prints fields with tag "ipv4" or "ipv6" 609 // as IP addresses. 610 func printStruct(any dnsStruct) string { 611 s := "{" 612 i := 0 613 any.Walk(func(val interface{}, name, tag string) bool { 614 i++ 615 if i > 1 { 616 s += ", " 617 } 618 s += name + "=" 619 switch tag { 620 case "ipv4": 621 i := val.(uint32) 622 s += IPv4(byte(i>>24), byte(i>>16), byte(i>>8), byte(i)).String() 623 case "ipv6": 624 i := val.([]byte) 625 s += IP(i).String() 626 default: 627 var i int64 628 switch v := val.(type) { 629 default: 630 // can't really happen. 631 s += "<unknown type>" 632 return true 633 case *string: 634 s += *v 635 return true 636 case []byte: 637 s += string(v) 638 return true 639 case *bool: 640 if *v { 641 s += "true" 642 } else { 643 s += "false" 644 } 645 return true 646 case *int: 647 i = int64(*v) 648 case *uint: 649 i = int64(*v) 650 case *uint8: 651 i = int64(*v) 652 case *uint16: 653 i = int64(*v) 654 case *uint32: 655 i = int64(*v) 656 case *uint64: 657 i = int64(*v) 658 case *uintptr: 659 i = int64(*v) 660 } 661 s += itoa(int(i)) 662 } 663 return true 664 }) 665 s += "}" 666 return s 667 } 668 669 // Resource record packer. 670 func packRR(rr dnsRR, msg []byte, off int) (off2 int, ok bool) { 671 var off1 int 672 // pack twice, once to find end of header 673 // and again to find end of packet. 674 // a bit inefficient but this doesn't need to be fast. 675 // off1 is end of header 676 // off2 is end of rr 677 off1, ok = packStruct(rr.Header(), msg, off) 678 off2, ok = packStruct(rr, msg, off) 679 if !ok { 680 return len(msg), false 681 } 682 // pack a third time; redo header with correct data length 683 rr.Header().Rdlength = uint16(off2 - off1) 684 packStruct(rr.Header(), msg, off) 685 return off2, true 686 } 687 688 // Resource record unpacker. 689 func unpackRR(msg []byte, off int) (rr dnsRR, off1 int, ok bool) { 690 // unpack just the header, to find the rr type and length 691 var h dnsRR_Header 692 off0 := off 693 if off, ok = unpackStruct(&h, msg, off); !ok { 694 return nil, len(msg), false 695 } 696 end := off + int(h.Rdlength) 697 698 // make an rr of that type and re-unpack. 699 // again inefficient but doesn't need to be fast. 700 mk, known := rr_mk[int(h.Rrtype)] 701 if !known { 702 return &h, end, true 703 } 704 rr = mk() 705 off, ok = unpackStruct(rr, msg, off0) 706 if off != end { 707 return &h, end, true 708 } 709 return rr, off, ok 710 } 711 712 // Usable representation of a DNS packet. 713 714 // A manually-unpacked version of (id, bits). 715 // This is in its own struct for easy printing. 716 type dnsMsgHdr struct { 717 id uint16 718 response bool 719 opcode int 720 authoritative bool 721 truncated bool 722 recursion_desired bool 723 recursion_available bool 724 rcode int 725 } 726 727 func (h *dnsMsgHdr) Walk(f func(v interface{}, name, tag string) bool) bool { 728 return f(&h.id, "id", "") && 729 f(&h.response, "response", "") && 730 f(&h.opcode, "opcode", "") && 731 f(&h.authoritative, "authoritative", "") && 732 f(&h.truncated, "truncated", "") && 733 f(&h.recursion_desired, "recursion_desired", "") && 734 f(&h.recursion_available, "recursion_available", "") && 735 f(&h.rcode, "rcode", "") 736 } 737 738 type dnsMsg struct { 739 dnsMsgHdr 740 question []dnsQuestion 741 answer []dnsRR 742 ns []dnsRR 743 extra []dnsRR 744 } 745 746 func (dns *dnsMsg) Pack() (msg []byte, ok bool) { 747 var dh dnsHeader 748 749 // Convert convenient dnsMsg into wire-like dnsHeader. 750 dh.Id = dns.id 751 dh.Bits = uint16(dns.opcode)<<11 | uint16(dns.rcode) 752 if dns.recursion_available { 753 dh.Bits |= _RA 754 } 755 if dns.recursion_desired { 756 dh.Bits |= _RD 757 } 758 if dns.truncated { 759 dh.Bits |= _TC 760 } 761 if dns.authoritative { 762 dh.Bits |= _AA 763 } 764 if dns.response { 765 dh.Bits |= _QR 766 } 767 768 // Prepare variable sized arrays. 769 question := dns.question 770 answer := dns.answer 771 ns := dns.ns 772 extra := dns.extra 773 774 dh.Qdcount = uint16(len(question)) 775 dh.Ancount = uint16(len(answer)) 776 dh.Nscount = uint16(len(ns)) 777 dh.Arcount = uint16(len(extra)) 778 779 // Could work harder to calculate message size, 780 // but this is far more than we need and not 781 // big enough to hurt the allocator. 782 msg = make([]byte, 2000) 783 784 // Pack it in: header and then the pieces. 785 off := 0 786 off, ok = packStruct(&dh, msg, off) 787 for i := 0; i < len(question); i++ { 788 off, ok = packStruct(&question[i], msg, off) 789 } 790 for i := 0; i < len(answer); i++ { 791 off, ok = packRR(answer[i], msg, off) 792 } 793 for i := 0; i < len(ns); i++ { 794 off, ok = packRR(ns[i], msg, off) 795 } 796 for i := 0; i < len(extra); i++ { 797 off, ok = packRR(extra[i], msg, off) 798 } 799 if !ok { 800 return nil, false 801 } 802 return msg[0:off], true 803 } 804 805 func (dns *dnsMsg) Unpack(msg []byte) bool { 806 // Header. 807 var dh dnsHeader 808 off := 0 809 var ok bool 810 if off, ok = unpackStruct(&dh, msg, off); !ok { 811 return false 812 } 813 dns.id = dh.Id 814 dns.response = (dh.Bits & _QR) != 0 815 dns.opcode = int(dh.Bits>>11) & 0xF 816 dns.authoritative = (dh.Bits & _AA) != 0 817 dns.truncated = (dh.Bits & _TC) != 0 818 dns.recursion_desired = (dh.Bits & _RD) != 0 819 dns.recursion_available = (dh.Bits & _RA) != 0 820 dns.rcode = int(dh.Bits & 0xF) 821 822 // Arrays. 823 dns.question = make([]dnsQuestion, dh.Qdcount) 824 dns.answer = make([]dnsRR, 0, dh.Ancount) 825 dns.ns = make([]dnsRR, 0, dh.Nscount) 826 dns.extra = make([]dnsRR, 0, dh.Arcount) 827 828 var rec dnsRR 829 830 for i := 0; i < len(dns.question); i++ { 831 off, ok = unpackStruct(&dns.question[i], msg, off) 832 } 833 for i := 0; i < int(dh.Ancount); i++ { 834 rec, off, ok = unpackRR(msg, off) 835 if !ok { 836 return false 837 } 838 dns.answer = append(dns.answer, rec) 839 } 840 for i := 0; i < int(dh.Nscount); i++ { 841 rec, off, ok = unpackRR(msg, off) 842 if !ok { 843 return false 844 } 845 dns.ns = append(dns.ns, rec) 846 } 847 for i := 0; i < int(dh.Arcount); i++ { 848 rec, off, ok = unpackRR(msg, off) 849 if !ok { 850 return false 851 } 852 dns.extra = append(dns.extra, rec) 853 } 854 // if off != len(msg) { 855 // println("extra bytes in dns packet", off, "<", len(msg)); 856 // } 857 return true 858 } 859 860 func (dns *dnsMsg) String() string { 861 s := "DNS: " + printStruct(&dns.dnsMsgHdr) + "\n" 862 if len(dns.question) > 0 { 863 s += "-- Questions\n" 864 for i := 0; i < len(dns.question); i++ { 865 s += printStruct(&dns.question[i]) + "\n" 866 } 867 } 868 if len(dns.answer) > 0 { 869 s += "-- Answers\n" 870 for i := 0; i < len(dns.answer); i++ { 871 s += printStruct(dns.answer[i]) + "\n" 872 } 873 } 874 if len(dns.ns) > 0 { 875 s += "-- Name servers\n" 876 for i := 0; i < len(dns.ns); i++ { 877 s += printStruct(dns.ns[i]) + "\n" 878 } 879 } 880 if len(dns.extra) > 0 { 881 s += "-- Extra\n" 882 for i := 0; i < len(dns.extra); i++ { 883 s += printStruct(dns.extra[i]) + "\n" 884 } 885 } 886 return s 887 }