vendor/github.com/miekg/dns/zmsg.go

   1 // Code generated by "go run msg_generate.go"; DO NOT EDIT.
   2
   3 package dns
   4
   5 // pack*() functions
   6
   7 func (rr *A) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
   8         off, err = packDataA(rr.A, msg, off)
   9         if err != nil {
  10                 return off, err
  11         }
  12         return off, nil
  13 }
  14
  15 func (rr *AAAA) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
  16         off, err = packDataAAAA(rr.AAAA, msg, off)
  17         if err != nil {
  18                 return off, err
  19         }
  20         return off, nil
  21 }
  22
  23 func (rr *AFSDB) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
  24         off, err = packUint16(rr.Subtype, msg, off)
  25         if err != nil {
  26                 return off, err
  27         }
  28         off, err = packDomainName(rr.Hostname, msg, off, compression, false)
  29         if err != nil {
  30                 return off, err
  31         }
  32         return off, nil
  33 }
  34
  35 func (rr *ANY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
  36         return off, nil
  37 }
  38
  39 func (rr *AVC) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
  40         off, err = packStringTxt(rr.Txt, msg, off)
  41         if err != nil {
  42                 return off, err
  43         }
  44         return off, nil
  45 }
  46
  47 func (rr *CAA) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
  48         off, err = packUint8(rr.Flag, msg, off)
  49         if err != nil {
  50                 return off, err
  51         }
  52         off, err = packString(rr.Tag, msg, off)
  53         if err != nil {
  54                 return off, err
  55         }
  56         off, err = packStringOctet(rr.Value, msg, off)
  57         if err != nil {
  58                 return off, err
  59         }
  60         return off, nil
  61 }
  62
  63 func (rr *CDNSKEY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
  64         off, err = packUint16(rr.Flags, msg, off)
  65         if err != nil {
  66                 return off, err
  67         }
  68         off, err = packUint8(rr.Protocol, msg, off)
  69         if err != nil {
  70                 return off, err
  71         }
  72         off, err = packUint8(rr.Algorithm, msg, off)
  73         if err != nil {
  74                 return off, err
  75         }
  76         off, err = packStringBase64(rr.PublicKey, msg, off)
  77         if err != nil {
  78                 return off, err
  79         }
  80         return off, nil
  81 }
  82
  83 func (rr *CDS) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
  84         off, err = packUint16(rr.KeyTag, msg, off)
  85         if err != nil {
  86                 return off, err
  87         }
  88         off, err = packUint8(rr.Algorithm, msg, off)
  89         if err != nil {
  90                 return off, err
  91         }
  92         off, err = packUint8(rr.DigestType, msg, off)
  93         if err != nil {
  94                 return off, err
  95         }
  96         off, err = packStringHex(rr.Digest, msg, off)
  97         if err != nil {
  98                 return off, err
  99         }
 100         return off, nil
 101 }
 102
 103 func (rr *CERT) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 104         off, err = packUint16(rr.Type, msg, off)
 105         if err != nil {
 106                 return off, err
 107         }
 108         off, err = packUint16(rr.KeyTag, msg, off)
 109         if err != nil {
 110                 return off, err
 111         }
 112         off, err = packUint8(rr.Algorithm, msg, off)
 113         if err != nil {
 114                 return off, err
 115         }
 116         off, err = packStringBase64(rr.Certificate, msg, off)
 117         if err != nil {
 118                 return off, err
 119         }
 120         return off, nil
 121 }
 122
 123 func (rr *CNAME) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 124         off, err = packDomainName(rr.Target, msg, off, compression, compress)
 125         if err != nil {
 126                 return off, err
 127         }
 128         return off, nil
 129 }
 130
 131 func (rr *CSYNC) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 132         off, err = packUint32(rr.Serial, msg, off)
 133         if err != nil {
 134                 return off, err
 135         }
 136         off, err = packUint16(rr.Flags, msg, off)
 137         if err != nil {
 138                 return off, err
 139         }
 140         off, err = packDataNsec(rr.TypeBitMap, msg, off)
 141         if err != nil {
 142                 return off, err
 143         }
 144         return off, nil
 145 }
 146
 147 func (rr *DHCID) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 148         off, err = packStringBase64(rr.Digest, msg, off)
 149         if err != nil {
 150                 return off, err
 151         }
 152         return off, nil
 153 }
 154
 155 func (rr *DLV) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 156         off, err = packUint16(rr.KeyTag, msg, off)
 157         if err != nil {
 158                 return off, err
 159         }
 160         off, err = packUint8(rr.Algorithm, msg, off)
 161         if err != nil {
 162                 return off, err
 163         }
 164         off, err = packUint8(rr.DigestType, msg, off)
 165         if err != nil {
 166                 return off, err
 167         }
 168         off, err = packStringHex(rr.Digest, msg, off)
 169         if err != nil {
 170                 return off, err
 171         }
 172         return off, nil
 173 }
 174
 175 func (rr *DNAME) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 176         off, err = packDomainName(rr.Target, msg, off, compression, false)
 177         if err != nil {
 178                 return off, err
 179         }
 180         return off, nil
 181 }
 182
 183 func (rr *DNSKEY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 184         off, err = packUint16(rr.Flags, msg, off)
 185         if err != nil {
 186                 return off, err
 187         }
 188         off, err = packUint8(rr.Protocol, msg, off)
 189         if err != nil {
 190                 return off, err
 191         }
 192         off, err = packUint8(rr.Algorithm, msg, off)
 193         if err != nil {
 194                 return off, err
 195         }
 196         off, err = packStringBase64(rr.PublicKey, msg, off)
 197         if err != nil {
 198                 return off, err
 199         }
 200         return off, nil
 201 }
 202
 203 func (rr *DS) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 204         off, err = packUint16(rr.KeyTag, msg, off)
 205         if err != nil {
 206                 return off, err
 207         }
 208         off, err = packUint8(rr.Algorithm, msg, off)
 209         if err != nil {
 210                 return off, err
 211         }
 212         off, err = packUint8(rr.DigestType, msg, off)
 213         if err != nil {
 214                 return off, err
 215         }
 216         off, err = packStringHex(rr.Digest, msg, off)
 217         if err != nil {
 218                 return off, err
 219         }
 220         return off, nil
 221 }
 222
 223 func (rr *EID) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 224         off, err = packStringHex(rr.Endpoint, msg, off)
 225         if err != nil {
 226                 return off, err
 227         }
 228         return off, nil
 229 }
 230
 231 func (rr *EUI48) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 232         off, err = packUint48(rr.Address, msg, off)
 233         if err != nil {
 234                 return off, err
 235         }
 236         return off, nil
 237 }
 238
 239 func (rr *EUI64) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 240         off, err = packUint64(rr.Address, msg, off)
 241         if err != nil {
 242                 return off, err
 243         }
 244         return off, nil
 245 }
 246
 247 func (rr *GID) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 248         off, err = packUint32(rr.Gid, msg, off)
 249         if err != nil {
 250                 return off, err
 251         }
 252         return off, nil
 253 }
 254
 255 func (rr *GPOS) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 256         off, err = packString(rr.Longitude, msg, off)
 257         if err != nil {
 258                 return off, err
 259         }
 260         off, err = packString(rr.Latitude, msg, off)
 261         if err != nil {
 262                 return off, err
 263         }
 264         off, err = packString(rr.Altitude, msg, off)
 265         if err != nil {
 266                 return off, err
 267         }
 268         return off, nil
 269 }
 270
 271 func (rr *HINFO) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 272         off, err = packString(rr.Cpu, msg, off)
 273         if err != nil {
 274                 return off, err
 275         }
 276         off, err = packString(rr.Os, msg, off)
 277         if err != nil {
 278                 return off, err
 279         }
 280         return off, nil
 281 }
 282
 283 func (rr *HIP) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 284         off, err = packUint8(rr.HitLength, msg, off)
 285         if err != nil {
 286                 return off, err
 287         }
 288         off, err = packUint8(rr.PublicKeyAlgorithm, msg, off)
 289         if err != nil {
 290                 return off, err
 291         }
 292         off, err = packUint16(rr.PublicKeyLength, msg, off)
 293         if err != nil {
 294                 return off, err
 295         }
 296         off, err = packStringHex(rr.Hit, msg, off)
 297         if err != nil {
 298                 return off, err
 299         }
 300         off, err = packStringBase64(rr.PublicKey, msg, off)
 301         if err != nil {
 302                 return off, err
 303         }
 304         off, err = packDataDomainNames(rr.RendezvousServers, msg, off, compression, false)
 305         if err != nil {
 306                 return off, err
 307         }
 308         return off, nil
 309 }
 310
 311 func (rr *KEY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 312         off, err = packUint16(rr.Flags, msg, off)
 313         if err != nil {
 314                 return off, err
 315         }
 316         off, err = packUint8(rr.Protocol, msg, off)
 317         if err != nil {
 318                 return off, err
 319         }
 320         off, err = packUint8(rr.Algorithm, msg, off)
 321         if err != nil {
 322                 return off, err
 323         }
 324         off, err = packStringBase64(rr.PublicKey, msg, off)
 325         if err != nil {
 326                 return off, err
 327         }
 328         return off, nil
 329 }
 330
 331 func (rr *KX) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 332         off, err = packUint16(rr.Preference, msg, off)
 333         if err != nil {
 334                 return off, err
 335         }
 336         off, err = packDomainName(rr.Exchanger, msg, off, compression, false)
 337         if err != nil {
 338                 return off, err
 339         }
 340         return off, nil
 341 }
 342
 343 func (rr *L32) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 344         off, err = packUint16(rr.Preference, msg, off)
 345         if err != nil {
 346                 return off, err
 347         }
 348         off, err = packDataA(rr.Locator32, msg, off)
 349         if err != nil {
 350                 return off, err
 351         }
 352         return off, nil
 353 }
 354
 355 func (rr *L64) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 356         off, err = packUint16(rr.Preference, msg, off)
 357         if err != nil {
 358                 return off, err
 359         }
 360         off, err = packUint64(rr.Locator64, msg, off)
 361         if err != nil {
 362                 return off, err
 363         }
 364         return off, nil
 365 }
 366
 367 func (rr *LOC) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 368         off, err = packUint8(rr.Version, msg, off)
 369         if err != nil {
 370                 return off, err
 371         }
 372         off, err = packUint8(rr.Size, msg, off)
 373         if err != nil {
 374                 return off, err
 375         }
 376         off, err = packUint8(rr.HorizPre, msg, off)
 377         if err != nil {
 378                 return off, err
 379         }
 380         off, err = packUint8(rr.VertPre, msg, off)
 381         if err != nil {
 382                 return off, err
 383         }
 384         off, err = packUint32(rr.Latitude, msg, off)
 385         if err != nil {
 386                 return off, err
 387         }
 388         off, err = packUint32(rr.Longitude, msg, off)
 389         if err != nil {
 390                 return off, err
 391         }
 392         off, err = packUint32(rr.Altitude, msg, off)
 393         if err != nil {
 394                 return off, err
 395         }
 396         return off, nil
 397 }
 398
 399 func (rr *LP) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 400         off, err = packUint16(rr.Preference, msg, off)
 401         if err != nil {
 402                 return off, err
 403         }
 404         off, err = packDomainName(rr.Fqdn, msg, off, compression, false)
 405         if err != nil {
 406                 return off, err
 407         }
 408         return off, nil
 409 }
 410
 411 func (rr *MB) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 412         off, err = packDomainName(rr.Mb, msg, off, compression, compress)
 413         if err != nil {
 414                 return off, err
 415         }
 416         return off, nil
 417 }
 418
 419 func (rr *MD) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 420         off, err = packDomainName(rr.Md, msg, off, compression, compress)
 421         if err != nil {
 422                 return off, err
 423         }
 424         return off, nil
 425 }
 426
 427 func (rr *MF) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 428         off, err = packDomainName(rr.Mf, msg, off, compression, compress)
 429         if err != nil {
 430                 return off, err
 431         }
 432         return off, nil
 433 }
 434
 435 func (rr *MG) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 436         off, err = packDomainName(rr.Mg, msg, off, compression, compress)
 437         if err != nil {
 438                 return off, err
 439         }
 440         return off, nil
 441 }
 442
 443 func (rr *MINFO) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 444         off, err = packDomainName(rr.Rmail, msg, off, compression, compress)
 445         if err != nil {
 446                 return off, err
 447         }
 448         off, err = packDomainName(rr.Email, msg, off, compression, compress)
 449         if err != nil {
 450                 return off, err
 451         }
 452         return off, nil
 453 }
 454
 455 func (rr *MR) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 456         off, err = packDomainName(rr.Mr, msg, off, compression, compress)
 457         if err != nil {
 458                 return off, err
 459         }
 460         return off, nil
 461 }
 462
 463 func (rr *MX) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 464         off, err = packUint16(rr.Preference, msg, off)
 465         if err != nil {
 466                 return off, err
 467         }
 468         off, err = packDomainName(rr.Mx, msg, off, compression, compress)
 469         if err != nil {
 470                 return off, err
 471         }
 472         return off, nil
 473 }
 474
 475 func (rr *NAPTR) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 476         off, err = packUint16(rr.Order, msg, off)
 477         if err != nil {
 478                 return off, err
 479         }
 480         off, err = packUint16(rr.Preference, msg, off)
 481         if err != nil {
 482                 return off, err
 483         }
 484         off, err = packString(rr.Flags, msg, off)
 485         if err != nil {
 486                 return off, err
 487         }
 488         off, err = packString(rr.Service, msg, off)
 489         if err != nil {
 490                 return off, err
 491         }
 492         off, err = packString(rr.Regexp, msg, off)
 493         if err != nil {
 494                 return off, err
 495         }
 496         off, err = packDomainName(rr.Replacement, msg, off, compression, false)
 497         if err != nil {
 498                 return off, err
 499         }
 500         return off, nil
 501 }
 502
 503 func (rr *NID) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 504         off, err = packUint16(rr.Preference, msg, off)
 505         if err != nil {
 506                 return off, err
 507         }
 508         off, err = packUint64(rr.NodeID, msg, off)
 509         if err != nil {
 510                 return off, err
 511         }
 512         return off, nil
 513 }
 514
 515 func (rr *NIMLOC) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 516         off, err = packStringHex(rr.Locator, msg, off)
 517         if err != nil {
 518                 return off, err
 519         }
 520         return off, nil
 521 }
 522
 523 func (rr *NINFO) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 524         off, err = packStringTxt(rr.ZSData, msg, off)
 525         if err != nil {
 526                 return off, err
 527         }
 528         return off, nil
 529 }
 530
 531 func (rr *NS) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 532         off, err = packDomainName(rr.Ns, msg, off, compression, compress)
 533         if err != nil {
 534                 return off, err
 535         }
 536         return off, nil
 537 }
 538
 539 func (rr *NSAPPTR) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 540         off, err = packDomainName(rr.Ptr, msg, off, compression, false)
 541         if err != nil {
 542                 return off, err
 543         }
 544         return off, nil
 545 }
 546
 547 func (rr *NSEC) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 548         off, err = packDomainName(rr.NextDomain, msg, off, compression, false)
 549         if err != nil {
 550                 return off, err
 551         }
 552         off, err = packDataNsec(rr.TypeBitMap, msg, off)
 553         if err != nil {
 554                 return off, err
 555         }
 556         return off, nil
 557 }
 558
 559 func (rr *NSEC3) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 560         off, err = packUint8(rr.Hash, msg, off)
 561         if err != nil {
 562                 return off, err
 563         }
 564         off, err = packUint8(rr.Flags, msg, off)
 565         if err != nil {
 566                 return off, err
 567         }
 568         off, err = packUint16(rr.Iterations, msg, off)
 569         if err != nil {
 570                 return off, err
 571         }
 572         off, err = packUint8(rr.SaltLength, msg, off)
 573         if err != nil {
 574                 return off, err
 575         }
 576         // Only pack salt if value is not "-", i.e. empty
 577         if rr.Salt != "-" {
 578                 off, err = packStringHex(rr.Salt, msg, off)
 579                 if err != nil {
 580                         return off, err
 581                 }
 582         }
 583         off, err = packUint8(rr.HashLength, msg, off)
 584         if err != nil {
 585                 return off, err
 586         }
 587         off, err = packStringBase32(rr.NextDomain, msg, off)
 588         if err != nil {
 589                 return off, err
 590         }
 591         off, err = packDataNsec(rr.TypeBitMap, msg, off)
 592         if err != nil {
 593                 return off, err
 594         }
 595         return off, nil
 596 }
 597
 598 func (rr *NSEC3PARAM) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 599         off, err = packUint8(rr.Hash, msg, off)
 600         if err != nil {
 601                 return off, err
 602         }
 603         off, err = packUint8(rr.Flags, msg, off)
 604         if err != nil {
 605                 return off, err
 606         }
 607         off, err = packUint16(rr.Iterations, msg, off)
 608         if err != nil {
 609                 return off, err
 610         }
 611         off, err = packUint8(rr.SaltLength, msg, off)
 612         if err != nil {
 613                 return off, err
 614         }
 615         // Only pack salt if value is not "-", i.e. empty
 616         if rr.Salt != "-" {
 617                 off, err = packStringHex(rr.Salt, msg, off)
 618                 if err != nil {
 619                         return off, err
 620                 }
 621         }
 622         return off, nil
 623 }
 624
 625 func (rr *NULL) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 626         off, err = packStringAny(rr.Data, msg, off)
 627         if err != nil {
 628                 return off, err
 629         }
 630         return off, nil
 631 }
 632
 633 func (rr *OPENPGPKEY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 634         off, err = packStringBase64(rr.PublicKey, msg, off)
 635         if err != nil {
 636                 return off, err
 637         }
 638         return off, nil
 639 }
 640
 641 func (rr *OPT) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 642         off, err = packDataOpt(rr.Option, msg, off)
 643         if err != nil {
 644                 return off, err
 645         }
 646         return off, nil
 647 }
 648
 649 func (rr *PTR) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 650         off, err = packDomainName(rr.Ptr, msg, off, compression, compress)
 651         if err != nil {
 652                 return off, err
 653         }
 654         return off, nil
 655 }
 656
 657 func (rr *PX) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 658         off, err = packUint16(rr.Preference, msg, off)
 659         if err != nil {
 660                 return off, err
 661         }
 662         off, err = packDomainName(rr.Map822, msg, off, compression, false)
 663         if err != nil {
 664                 return off, err
 665         }
 666         off, err = packDomainName(rr.Mapx400, msg, off, compression, false)
 667         if err != nil {
 668                 return off, err
 669         }
 670         return off, nil
 671 }
 672
 673 func (rr *RFC3597) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 674         off, err = packStringHex(rr.Rdata, msg, off)
 675         if err != nil {
 676                 return off, err
 677         }
 678         return off, nil
 679 }
 680
 681 func (rr *RKEY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 682         off, err = packUint16(rr.Flags, msg, off)
 683         if err != nil {
 684                 return off, err
 685         }
 686         off, err = packUint8(rr.Protocol, msg, off)
 687         if err != nil {
 688                 return off, err
 689         }
 690         off, err = packUint8(rr.Algorithm, msg, off)
 691         if err != nil {
 692                 return off, err
 693         }
 694         off, err = packStringBase64(rr.PublicKey, msg, off)
 695         if err != nil {
 696                 return off, err
 697         }
 698         return off, nil
 699 }
 700
 701 func (rr *RP) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 702         off, err = packDomainName(rr.Mbox, msg, off, compression, false)
 703         if err != nil {
 704                 return off, err
 705         }
 706         off, err = packDomainName(rr.Txt, msg, off, compression, false)
 707         if err != nil {
 708                 return off, err
 709         }
 710         return off, nil
 711 }
 712
 713 func (rr *RRSIG) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 714         off, err = packUint16(rr.TypeCovered, msg, off)
 715         if err != nil {
 716                 return off, err
 717         }
 718         off, err = packUint8(rr.Algorithm, msg, off)
 719         if err != nil {
 720                 return off, err
 721         }
 722         off, err = packUint8(rr.Labels, msg, off)
 723         if err != nil {
 724                 return off, err
 725         }
 726         off, err = packUint32(rr.OrigTtl, msg, off)
 727         if err != nil {
 728                 return off, err
 729         }
 730         off, err = packUint32(rr.Expiration, msg, off)
 731         if err != nil {
 732                 return off, err
 733         }
 734         off, err = packUint32(rr.Inception, msg, off)
 735         if err != nil {
 736                 return off, err
 737         }
 738         off, err = packUint16(rr.KeyTag, msg, off)
 739         if err != nil {
 740                 return off, err
 741         }
 742         off, err = packDomainName(rr.SignerName, msg, off, compression, false)
 743         if err != nil {
 744                 return off, err
 745         }
 746         off, err = packStringBase64(rr.Signature, msg, off)
 747         if err != nil {
 748                 return off, err
 749         }
 750         return off, nil
 751 }
 752
 753 func (rr *RT) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 754         off, err = packUint16(rr.Preference, msg, off)
 755         if err != nil {
 756                 return off, err
 757         }
 758         off, err = packDomainName(rr.Host, msg, off, compression, false)
 759         if err != nil {
 760                 return off, err
 761         }
 762         return off, nil
 763 }
 764
 765 func (rr *SIG) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 766         off, err = packUint16(rr.TypeCovered, msg, off)
 767         if err != nil {
 768                 return off, err
 769         }
 770         off, err = packUint8(rr.Algorithm, msg, off)
 771         if err != nil {
 772                 return off, err
 773         }
 774         off, err = packUint8(rr.Labels, msg, off)
 775         if err != nil {
 776                 return off, err
 777         }
 778         off, err = packUint32(rr.OrigTtl, msg, off)
 779         if err != nil {
 780                 return off, err
 781         }
 782         off, err = packUint32(rr.Expiration, msg, off)
 783         if err != nil {
 784                 return off, err
 785         }
 786         off, err = packUint32(rr.Inception, msg, off)
 787         if err != nil {
 788                 return off, err
 789         }
 790         off, err = packUint16(rr.KeyTag, msg, off)
 791         if err != nil {
 792                 return off, err
 793         }
 794         off, err = packDomainName(rr.SignerName, msg, off, compression, false)
 795         if err != nil {
 796                 return off, err
 797         }
 798         off, err = packStringBase64(rr.Signature, msg, off)
 799         if err != nil {
 800                 return off, err
 801         }
 802         return off, nil
 803 }
 804
 805 func (rr *SMIMEA) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 806         off, err = packUint8(rr.Usage, msg, off)
 807         if err != nil {
 808                 return off, err
 809         }
 810         off, err = packUint8(rr.Selector, msg, off)
 811         if err != nil {
 812                 return off, err
 813         }
 814         off, err = packUint8(rr.MatchingType, msg, off)
 815         if err != nil {
 816                 return off, err
 817         }
 818         off, err = packStringHex(rr.Certificate, msg, off)
 819         if err != nil {
 820                 return off, err
 821         }
 822         return off, nil
 823 }
 824
 825 func (rr *SOA) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 826         off, err = packDomainName(rr.Ns, msg, off, compression, compress)
 827         if err != nil {
 828                 return off, err
 829         }
 830         off, err = packDomainName(rr.Mbox, msg, off, compression, compress)
 831         if err != nil {
 832                 return off, err
 833         }
 834         off, err = packUint32(rr.Serial, msg, off)
 835         if err != nil {
 836                 return off, err
 837         }
 838         off, err = packUint32(rr.Refresh, msg, off)
 839         if err != nil {
 840                 return off, err
 841         }
 842         off, err = packUint32(rr.Retry, msg, off)
 843         if err != nil {
 844                 return off, err
 845         }
 846         off, err = packUint32(rr.Expire, msg, off)
 847         if err != nil {
 848                 return off, err
 849         }
 850         off, err = packUint32(rr.Minttl, msg, off)
 851         if err != nil {
 852                 return off, err
 853         }
 854         return off, nil
 855 }
 856
 857 func (rr *SPF) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 858         off, err = packStringTxt(rr.Txt, msg, off)
 859         if err != nil {
 860                 return off, err
 861         }
 862         return off, nil
 863 }
 864
 865 func (rr *SRV) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 866         off, err = packUint16(rr.Priority, msg, off)
 867         if err != nil {
 868                 return off, err
 869         }
 870         off, err = packUint16(rr.Weight, msg, off)
 871         if err != nil {
 872                 return off, err
 873         }
 874         off, err = packUint16(rr.Port, msg, off)
 875         if err != nil {
 876                 return off, err
 877         }
 878         off, err = packDomainName(rr.Target, msg, off, compression, false)
 879         if err != nil {
 880                 return off, err
 881         }
 882         return off, nil
 883 }
 884
 885 func (rr *SSHFP) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 886         off, err = packUint8(rr.Algorithm, msg, off)
 887         if err != nil {
 888                 return off, err
 889         }
 890         off, err = packUint8(rr.Type, msg, off)
 891         if err != nil {
 892                 return off, err
 893         }
 894         off, err = packStringHex(rr.FingerPrint, msg, off)
 895         if err != nil {
 896                 return off, err
 897         }
 898         return off, nil
 899 }
 900
 901 func (rr *TA) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 902         off, err = packUint16(rr.KeyTag, msg, off)
 903         if err != nil {
 904                 return off, err
 905         }
 906         off, err = packUint8(rr.Algorithm, msg, off)
 907         if err != nil {
 908                 return off, err
 909         }
 910         off, err = packUint8(rr.DigestType, msg, off)
 911         if err != nil {
 912                 return off, err
 913         }
 914         off, err = packStringHex(rr.Digest, msg, off)
 915         if err != nil {
 916                 return off, err
 917         }
 918         return off, nil
 919 }
 920
 921 func (rr *TALINK) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 922         off, err = packDomainName(rr.PreviousName, msg, off, compression, false)
 923         if err != nil {
 924                 return off, err
 925         }
 926         off, err = packDomainName(rr.NextName, msg, off, compression, false)
 927         if err != nil {
 928                 return off, err
 929         }
 930         return off, nil
 931 }
 932
 933 func (rr *TKEY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 934         off, err = packDomainName(rr.Algorithm, msg, off, compression, false)
 935         if err != nil {
 936                 return off, err
 937         }
 938         off, err = packUint32(rr.Inception, msg, off)
 939         if err != nil {
 940                 return off, err
 941         }
 942         off, err = packUint32(rr.Expiration, msg, off)
 943         if err != nil {
 944                 return off, err
 945         }
 946         off, err = packUint16(rr.Mode, msg, off)
 947         if err != nil {
 948                 return off, err
 949         }
 950         off, err = packUint16(rr.Error, msg, off)
 951         if err != nil {
 952                 return off, err
 953         }
 954         off, err = packUint16(rr.KeySize, msg, off)
 955         if err != nil {
 956                 return off, err
 957         }
 958         off, err = packStringHex(rr.Key, msg, off)
 959         if err != nil {
 960                 return off, err
 961         }
 962         off, err = packUint16(rr.OtherLen, msg, off)
 963         if err != nil {
 964                 return off, err
 965         }
 966         off, err = packStringHex(rr.OtherData, msg, off)
 967         if err != nil {
 968                 return off, err
 969         }
 970         return off, nil
 971 }
 972
 973 func (rr *TLSA) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 974         off, err = packUint8(rr.Usage, msg, off)
 975         if err != nil {
 976                 return off, err
 977         }
 978         off, err = packUint8(rr.Selector, msg, off)
 979         if err != nil {
 980                 return off, err
 981         }
 982         off, err = packUint8(rr.MatchingType, msg, off)
 983         if err != nil {
 984                 return off, err
 985         }
 986         off, err = packStringHex(rr.Certificate, msg, off)
 987         if err != nil {
 988                 return off, err
 989         }
 990         return off, nil
 991 }
 992
 993 func (rr *TSIG) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
 994         off, err = packDomainName(rr.Algorithm, msg, off, compression, false)
 995         if err != nil {
 996                 return off, err
 997         }
 998         off, err = packUint48(rr.TimeSigned, msg, off)
 999         if err != nil {
1000                 return off, err
1001         }
1002         off, err = packUint16(rr.Fudge, msg, off)
1003         if err != nil {
1004                 return off, err
1005         }
1006         off, err = packUint16(rr.MACSize, msg, off)
1007         if err != nil {
1008                 return off, err
1009         }
1010         off, err = packStringHex(rr.MAC, msg, off)
1011         if err != nil {
1012                 return off, err
1013         }
1014         off, err = packUint16(rr.OrigId, msg, off)
1015         if err != nil {
1016                 return off, err
1017         }
1018         off, err = packUint16(rr.Error, msg, off)
1019         if err != nil {
1020                 return off, err
1021         }
1022         off, err = packUint16(rr.OtherLen, msg, off)
1023         if err != nil {
1024                 return off, err
1025         }
1026         off, err = packStringHex(rr.OtherData, msg, off)
1027         if err != nil {
1028                 return off, err
1029         }
1030         return off, nil
1031 }
1032
1033 func (rr *TXT) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
1034         off, err = packStringTxt(rr.Txt, msg, off)
1035         if err != nil {
1036                 return off, err
1037         }
1038         return off, nil
1039 }
1040
1041 func (rr *UID) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
1042         off, err = packUint32(rr.Uid, msg, off)
1043         if err != nil {
1044                 return off, err
1045         }
1046         return off, nil
1047 }
1048
1049 func (rr *UINFO) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
1050         off, err = packString(rr.Uinfo, msg, off)
1051         if err != nil {
1052                 return off, err
1053         }
1054         return off, nil
1055 }
1056
1057 func (rr *URI) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
1058         off, err = packUint16(rr.Priority, msg, off)
1059         if err != nil {
1060                 return off, err
1061         }
1062         off, err = packUint16(rr.Weight, msg, off)
1063         if err != nil {
1064                 return off, err
1065         }
1066         off, err = packStringOctet(rr.Target, msg, off)
1067         if err != nil {
1068                 return off, err
1069         }
1070         return off, nil
1071 }
1072
1073 func (rr *X25) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
1074         off, err = packString(rr.PSDNAddress, msg, off)
1075         if err != nil {
1076                 return off, err
1077         }
1078         return off, nil
1079 }
1080
1081 // unpack*() functions
1082
1083 func (rr *A) unpack(msg []byte, off int) (off1 int, err error) {
1084         rdStart := off
1085         _ = rdStart
1086
1087         rr.A, off, err = unpackDataA(msg, off)
1088         if err != nil {
1089                 return off, err
1090         }
1091         return off, nil
1092 }
1093
1094 func (rr *AAAA) unpack(msg []byte, off int) (off1 int, err error) {
1095         rdStart := off
1096         _ = rdStart
1097
1098         rr.AAAA, off, err = unpackDataAAAA(msg, off)
1099         if err != nil {
1100                 return off, err
1101         }
1102         return off, nil
1103 }
1104
1105 func (rr *AFSDB) unpack(msg []byte, off int) (off1 int, err error) {
1106         rdStart := off
1107         _ = rdStart
1108
1109         rr.Subtype, off, err = unpackUint16(msg, off)
1110         if err != nil {
1111                 return off, err
1112         }
1113         if off == len(msg) {
1114                 return off, nil
1115         }
1116         rr.Hostname, off, err = UnpackDomainName(msg, off)
1117         if err != nil {
1118                 return off, err
1119         }
1120         return off, nil
1121 }
1122
1123 func (rr *ANY) unpack(msg []byte, off int) (off1 int, err error) {
1124         rdStart := off
1125         _ = rdStart
1126
1127         return off, nil
1128 }
1129
1130 func (rr *AVC) unpack(msg []byte, off int) (off1 int, err error) {
1131         rdStart := off
1132         _ = rdStart
1133
1134         rr.Txt, off, err = unpackStringTxt(msg, off)
1135         if err != nil {
1136                 return off, err
1137         }
1138         return off, nil
1139 }
1140
1141 func (rr *CAA) unpack(msg []byte, off int) (off1 int, err error) {
1142         rdStart := off
1143         _ = rdStart
1144
1145         rr.Flag, off, err = unpackUint8(msg, off)
1146         if err != nil {
1147                 return off, err
1148         }
1149         if off == len(msg) {
1150                 return off, nil
1151         }
1152         rr.Tag, off, err = unpackString(msg, off)
1153         if err != nil {
1154                 return off, err
1155         }
1156         if off == len(msg) {
1157                 return off, nil
1158         }
1159         rr.Value, off, err = unpackStringOctet(msg, off)
1160         if err != nil {
1161                 return off, err
1162         }
1163         return off, nil
1164 }
1165
1166 func (rr *CDNSKEY) unpack(msg []byte, off int) (off1 int, err error) {
1167         rdStart := off
1168         _ = rdStart
1169
1170         rr.Flags, off, err = unpackUint16(msg, off)
1171         if err != nil {
1172                 return off, err
1173         }
1174         if off == len(msg) {
1175                 return off, nil
1176         }
1177         rr.Protocol, off, err = unpackUint8(msg, off)
1178         if err != nil {
1179                 return off, err
1180         }
1181         if off == len(msg) {
1182                 return off, nil
1183         }
1184         rr.Algorithm, off, err = unpackUint8(msg, off)
1185         if err != nil {
1186                 return off, err
1187         }
1188         if off == len(msg) {
1189                 return off, nil
1190         }
1191         rr.PublicKey, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
1192         if err != nil {
1193                 return off, err
1194         }
1195         return off, nil
1196 }
1197
1198 func (rr *CDS) unpack(msg []byte, off int) (off1 int, err error) {
1199         rdStart := off
1200         _ = rdStart
1201
1202         rr.KeyTag, off, err = unpackUint16(msg, off)
1203         if err != nil {
1204                 return off, err
1205         }
1206         if off == len(msg) {
1207                 return off, nil
1208         }
1209         rr.Algorithm, off, err = unpackUint8(msg, off)
1210         if err != nil {
1211                 return off, err
1212         }
1213         if off == len(msg) {
1214                 return off, nil
1215         }
1216         rr.DigestType, off, err = unpackUint8(msg, off)
1217         if err != nil {
1218                 return off, err
1219         }
1220         if off == len(msg) {
1221                 return off, nil
1222         }
1223         rr.Digest, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
1224         if err != nil {
1225                 return off, err
1226         }
1227         return off, nil
1228 }
1229
1230 func (rr *CERT) unpack(msg []byte, off int) (off1 int, err error) {
1231         rdStart := off
1232         _ = rdStart
1233
1234         rr.Type, off, err = unpackUint16(msg, off)
1235         if err != nil {
1236                 return off, err
1237         }
1238         if off == len(msg) {
1239                 return off, nil
1240         }
1241         rr.KeyTag, off, err = unpackUint16(msg, off)
1242         if err != nil {
1243                 return off, err
1244         }
1245         if off == len(msg) {
1246                 return off, nil
1247         }
1248         rr.Algorithm, off, err = unpackUint8(msg, off)
1249         if err != nil {
1250                 return off, err
1251         }
1252         if off == len(msg) {
1253                 return off, nil
1254         }
1255         rr.Certificate, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
1256         if err != nil {
1257                 return off, err
1258         }
1259         return off, nil
1260 }
1261
1262 func (rr *CNAME) unpack(msg []byte, off int) (off1 int, err error) {
1263         rdStart := off
1264         _ = rdStart
1265
1266         rr.Target, off, err = UnpackDomainName(msg, off)
1267         if err != nil {
1268                 return off, err
1269         }
1270         return off, nil
1271 }
1272
1273 func (rr *CSYNC) unpack(msg []byte, off int) (off1 int, err error) {
1274         rdStart := off
1275         _ = rdStart
1276
1277         rr.Serial, off, err = unpackUint32(msg, off)
1278         if err != nil {
1279                 return off, err
1280         }
1281         if off == len(msg) {
1282                 return off, nil
1283         }
1284         rr.Flags, off, err = unpackUint16(msg, off)
1285         if err != nil {
1286                 return off, err
1287         }
1288         if off == len(msg) {
1289                 return off, nil
1290         }
1291         rr.TypeBitMap, off, err = unpackDataNsec(msg, off)
1292         if err != nil {
1293                 return off, err
1294         }
1295         return off, nil
1296 }
1297
1298 func (rr *DHCID) unpack(msg []byte, off int) (off1 int, err error) {
1299         rdStart := off
1300         _ = rdStart
1301
1302         rr.Digest, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
1303         if err != nil {
1304                 return off, err
1305         }
1306         return off, nil
1307 }
1308
1309 func (rr *DLV) unpack(msg []byte, off int) (off1 int, err error) {
1310         rdStart := off
1311         _ = rdStart
1312
1313         rr.KeyTag, off, err = unpackUint16(msg, off)
1314         if err != nil {
1315                 return off, err
1316         }
1317         if off == len(msg) {
1318                 return off, nil
1319         }
1320         rr.Algorithm, off, err = unpackUint8(msg, off)
1321         if err != nil {
1322                 return off, err
1323         }
1324         if off == len(msg) {
1325                 return off, nil
1326         }
1327         rr.DigestType, off, err = unpackUint8(msg, off)
1328         if err != nil {
1329                 return off, err
1330         }
1331         if off == len(msg) {
1332                 return off, nil
1333         }
1334         rr.Digest, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
1335         if err != nil {
1336                 return off, err
1337         }
1338         return off, nil
1339 }
1340
1341 func (rr *DNAME) unpack(msg []byte, off int) (off1 int, err error) {
1342         rdStart := off
1343         _ = rdStart
1344
1345         rr.Target, off, err = UnpackDomainName(msg, off)
1346         if err != nil {
1347                 return off, err
1348         }
1349         return off, nil
1350 }
1351
1352 func (rr *DNSKEY) unpack(msg []byte, off int) (off1 int, err error) {
1353         rdStart := off
1354         _ = rdStart
1355
1356         rr.Flags, off, err = unpackUint16(msg, off)
1357         if err != nil {
1358                 return off, err
1359         }
1360         if off == len(msg) {
1361                 return off, nil
1362         }
1363         rr.Protocol, off, err = unpackUint8(msg, off)
1364         if err != nil {
1365                 return off, err
1366         }
1367         if off == len(msg) {
1368                 return off, nil
1369         }
1370         rr.Algorithm, off, err = unpackUint8(msg, off)
1371         if err != nil {
1372                 return off, err
1373         }
1374         if off == len(msg) {
1375                 return off, nil
1376         }
1377         rr.PublicKey, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
1378         if err != nil {
1379                 return off, err
1380         }
1381         return off, nil
1382 }
1383
1384 func (rr *DS) unpack(msg []byte, off int) (off1 int, err error) {
1385         rdStart := off
1386         _ = rdStart
1387
1388         rr.KeyTag, off, err = unpackUint16(msg, off)
1389         if err != nil {
1390                 return off, err
1391         }
1392         if off == len(msg) {
1393                 return off, nil
1394         }
1395         rr.Algorithm, off, err = unpackUint8(msg, off)
1396         if err != nil {
1397                 return off, err
1398         }
1399         if off == len(msg) {
1400                 return off, nil
1401         }
1402         rr.DigestType, off, err = unpackUint8(msg, off)
1403         if err != nil {
1404                 return off, err
1405         }
1406         if off == len(msg) {
1407                 return off, nil
1408         }
1409         rr.Digest, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
1410         if err != nil {
1411                 return off, err
1412         }
1413         return off, nil
1414 }
1415
1416 func (rr *EID) unpack(msg []byte, off int) (off1 int, err error) {
1417         rdStart := off
1418         _ = rdStart
1419
1420         rr.Endpoint, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
1421         if err != nil {
1422                 return off, err
1423         }
1424         return off, nil
1425 }
1426
1427 func (rr *EUI48) unpack(msg []byte, off int) (off1 int, err error) {
1428         rdStart := off
1429         _ = rdStart
1430
1431         rr.Address, off, err = unpackUint48(msg, off)
1432         if err != nil {
1433                 return off, err
1434         }
1435         return off, nil
1436 }
1437
1438 func (rr *EUI64) unpack(msg []byte, off int) (off1 int, err error) {
1439         rdStart := off
1440         _ = rdStart
1441
1442         rr.Address, off, err = unpackUint64(msg, off)
1443         if err != nil {
1444                 return off, err
1445         }
1446         return off, nil
1447 }
1448
1449 func (rr *GID) unpack(msg []byte, off int) (off1 int, err error) {
1450         rdStart := off
1451         _ = rdStart
1452
1453         rr.Gid, off, err = unpackUint32(msg, off)
1454         if err != nil {
1455                 return off, err
1456         }
1457         return off, nil
1458 }
1459
1460 func (rr *GPOS) unpack(msg []byte, off int) (off1 int, err error) {
1461         rdStart := off
1462         _ = rdStart
1463
1464         rr.Longitude, off, err = unpackString(msg, off)
1465         if err != nil {
1466                 return off, err
1467         }
1468         if off == len(msg) {
1469                 return off, nil
1470         }
1471         rr.Latitude, off, err = unpackString(msg, off)
1472         if err != nil {
1473                 return off, err
1474         }
1475         if off == len(msg) {
1476                 return off, nil
1477         }
1478         rr.Altitude, off, err = unpackString(msg, off)
1479         if err != nil {
1480                 return off, err
1481         }
1482         return off, nil
1483 }
1484
1485 func (rr *HINFO) unpack(msg []byte, off int) (off1 int, err error) {
1486         rdStart := off
1487         _ = rdStart
1488
1489         rr.Cpu, off, err = unpackString(msg, off)
1490         if err != nil {
1491                 return off, err
1492         }
1493         if off == len(msg) {
1494                 return off, nil
1495         }
1496         rr.Os, off, err = unpackString(msg, off)
1497         if err != nil {
1498                 return off, err
1499         }
1500         return off, nil
1501 }
1502
1503 func (rr *HIP) unpack(msg []byte, off int) (off1 int, err error) {
1504         rdStart := off
1505         _ = rdStart
1506
1507         rr.HitLength, off, err = unpackUint8(msg, off)
1508         if err != nil {
1509                 return off, err
1510         }
1511         if off == len(msg) {
1512                 return off, nil
1513         }
1514         rr.PublicKeyAlgorithm, off, err = unpackUint8(msg, off)
1515         if err != nil {
1516                 return off, err
1517         }
1518         if off == len(msg) {
1519                 return off, nil
1520         }
1521         rr.PublicKeyLength, off, err = unpackUint16(msg, off)
1522         if err != nil {
1523                 return off, err
1524         }
1525         if off == len(msg) {
1526                 return off, nil
1527         }
1528         rr.Hit, off, err = unpackStringHex(msg, off, off+int(rr.HitLength))
1529         if err != nil {
1530                 return off, err
1531         }
1532         rr.PublicKey, off, err = unpackStringBase64(msg, off, off+int(rr.PublicKeyLength))
1533         if err != nil {
1534                 return off, err
1535         }
1536         rr.RendezvousServers, off, err = unpackDataDomainNames(msg, off, rdStart+int(rr.Hdr.Rdlength))
1537         if err != nil {
1538                 return off, err
1539         }
1540         return off, nil
1541 }
1542
1543 func (rr *KEY) unpack(msg []byte, off int) (off1 int, err error) {
1544         rdStart := off
1545         _ = rdStart
1546
1547         rr.Flags, off, err = unpackUint16(msg, off)
1548         if err != nil {
1549                 return off, err
1550         }
1551         if off == len(msg) {
1552                 return off, nil
1553         }
1554         rr.Protocol, off, err = unpackUint8(msg, off)
1555         if err != nil {
1556                 return off, err
1557         }
1558         if off == len(msg) {
1559                 return off, nil
1560         }
1561         rr.Algorithm, off, err = unpackUint8(msg, off)
1562         if err != nil {
1563                 return off, err
1564         }
1565         if off == len(msg) {
1566                 return off, nil
1567         }
1568         rr.PublicKey, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
1569         if err != nil {
1570                 return off, err
1571         }
1572         return off, nil
1573 }
1574
1575 func (rr *KX) unpack(msg []byte, off int) (off1 int, err error) {
1576         rdStart := off
1577         _ = rdStart
1578
1579         rr.Preference, off, err = unpackUint16(msg, off)
1580         if err != nil {
1581                 return off, err
1582         }
1583         if off == len(msg) {
1584                 return off, nil
1585         }
1586         rr.Exchanger, off, err = UnpackDomainName(msg, off)
1587         if err != nil {
1588                 return off, err
1589         }
1590         return off, nil
1591 }
1592
1593 func (rr *L32) unpack(msg []byte, off int) (off1 int, err error) {
1594         rdStart := off
1595         _ = rdStart
1596
1597         rr.Preference, off, err = unpackUint16(msg, off)
1598         if err != nil {
1599                 return off, err
1600         }
1601         if off == len(msg) {
1602                 return off, nil
1603         }
1604         rr.Locator32, off, err = unpackDataA(msg, off)
1605         if err != nil {
1606                 return off, err
1607         }
1608         return off, nil
1609 }
1610
1611 func (rr *L64) unpack(msg []byte, off int) (off1 int, err error) {
1612         rdStart := off
1613         _ = rdStart
1614
1615         rr.Preference, off, err = unpackUint16(msg, off)
1616         if err != nil {
1617                 return off, err
1618         }
1619         if off == len(msg) {
1620                 return off, nil
1621         }
1622         rr.Locator64, off, err = unpackUint64(msg, off)
1623         if err != nil {
1624                 return off, err
1625         }
1626         return off, nil
1627 }
1628
1629 func (rr *LOC) unpack(msg []byte, off int) (off1 int, err error) {
1630         rdStart := off
1631         _ = rdStart
1632
1633         rr.Version, off, err = unpackUint8(msg, off)
1634         if err != nil {
1635                 return off, err
1636         }
1637         if off == len(msg) {
1638                 return off, nil
1639         }
1640         rr.Size, off, err = unpackUint8(msg, off)
1641         if err != nil {
1642                 return off, err
1643         }
1644         if off == len(msg) {
1645                 return off, nil
1646         }
1647         rr.HorizPre, off, err = unpackUint8(msg, off)
1648         if err != nil {
1649                 return off, err
1650         }
1651         if off == len(msg) {
1652                 return off, nil
1653         }
1654         rr.VertPre, off, err = unpackUint8(msg, off)
1655         if err != nil {
1656                 return off, err
1657         }
1658         if off == len(msg) {
1659                 return off, nil
1660         }
1661         rr.Latitude, off, err = unpackUint32(msg, off)
1662         if err != nil {
1663                 return off, err
1664         }
1665         if off == len(msg) {
1666                 return off, nil
1667         }
1668         rr.Longitude, off, err = unpackUint32(msg, off)
1669         if err != nil {
1670                 return off, err
1671         }
1672         if off == len(msg) {
1673                 return off, nil
1674         }
1675         rr.Altitude, off, err = unpackUint32(msg, off)
1676         if err != nil {
1677                 return off, err
1678         }
1679         return off, nil
1680 }
1681
1682 func (rr *LP) unpack(msg []byte, off int) (off1 int, err error) {
1683         rdStart := off
1684         _ = rdStart
1685
1686         rr.Preference, off, err = unpackUint16(msg, off)
1687         if err != nil {
1688                 return off, err
1689         }
1690         if off == len(msg) {
1691                 return off, nil
1692         }
1693         rr.Fqdn, off, err = UnpackDomainName(msg, off)
1694         if err != nil {
1695                 return off, err
1696         }
1697         return off, nil
1698 }
1699
1700 func (rr *MB) unpack(msg []byte, off int) (off1 int, err error) {
1701         rdStart := off
1702         _ = rdStart
1703
1704         rr.Mb, off, err = UnpackDomainName(msg, off)
1705         if err != nil {
1706                 return off, err
1707         }
1708         return off, nil
1709 }
1710
1711 func (rr *MD) unpack(msg []byte, off int) (off1 int, err error) {
1712         rdStart := off
1713         _ = rdStart
1714
1715         rr.Md, off, err = UnpackDomainName(msg, off)
1716         if err != nil {
1717                 return off, err
1718         }
1719         return off, nil
1720 }
1721
1722 func (rr *MF) unpack(msg []byte, off int) (off1 int, err error) {
1723         rdStart := off
1724         _ = rdStart
1725
1726         rr.Mf, off, err = UnpackDomainName(msg, off)
1727         if err != nil {
1728                 return off, err
1729         }
1730         return off, nil
1731 }
1732
1733 func (rr *MG) unpack(msg []byte, off int) (off1 int, err error) {
1734         rdStart := off
1735         _ = rdStart
1736
1737         rr.Mg, off, err = UnpackDomainName(msg, off)
1738         if err != nil {
1739                 return off, err
1740         }
1741         return off, nil
1742 }
1743
1744 func (rr *MINFO) unpack(msg []byte, off int) (off1 int, err error) {
1745         rdStart := off
1746         _ = rdStart
1747
1748         rr.Rmail, off, err = UnpackDomainName(msg, off)
1749         if err != nil {
1750                 return off, err
1751         }
1752         if off == len(msg) {
1753                 return off, nil
1754         }
1755         rr.Email, off, err = UnpackDomainName(msg, off)
1756         if err != nil {
1757                 return off, err
1758         }
1759         return off, nil
1760 }
1761
1762 func (rr *MR) unpack(msg []byte, off int) (off1 int, err error) {
1763         rdStart := off
1764         _ = rdStart
1765
1766         rr.Mr, off, err = UnpackDomainName(msg, off)
1767         if err != nil {
1768                 return off, err
1769         }
1770         return off, nil
1771 }
1772
1773 func (rr *MX) unpack(msg []byte, off int) (off1 int, err error) {
1774         rdStart := off
1775         _ = rdStart
1776
1777         rr.Preference, off, err = unpackUint16(msg, off)
1778         if err != nil {
1779                 return off, err
1780         }
1781         if off == len(msg) {
1782                 return off, nil
1783         }
1784         rr.Mx, off, err = UnpackDomainName(msg, off)
1785         if err != nil {
1786                 return off, err
1787         }
1788         return off, nil
1789 }
1790
1791 func (rr *NAPTR) unpack(msg []byte, off int) (off1 int, err error) {
1792         rdStart := off
1793         _ = rdStart
1794
1795         rr.Order, off, err = unpackUint16(msg, off)
1796         if err != nil {
1797                 return off, err
1798         }
1799         if off == len(msg) {
1800                 return off, nil
1801         }
1802         rr.Preference, off, err = unpackUint16(msg, off)
1803         if err != nil {
1804                 return off, err
1805         }
1806         if off == len(msg) {
1807                 return off, nil
1808         }
1809         rr.Flags, off, err = unpackString(msg, off)
1810         if err != nil {
1811                 return off, err
1812         }
1813         if off == len(msg) {
1814                 return off, nil
1815         }
1816         rr.Service, off, err = unpackString(msg, off)
1817         if err != nil {
1818                 return off, err
1819         }
1820         if off == len(msg) {
1821                 return off, nil
1822         }
1823         rr.Regexp, off, err = unpackString(msg, off)
1824         if err != nil {
1825                 return off, err
1826         }
1827         if off == len(msg) {
1828                 return off, nil
1829         }
1830         rr.Replacement, off, err = UnpackDomainName(msg, off)
1831         if err != nil {
1832                 return off, err
1833         }
1834         return off, nil
1835 }
1836
1837 func (rr *NID) unpack(msg []byte, off int) (off1 int, err error) {
1838         rdStart := off
1839         _ = rdStart
1840
1841         rr.Preference, off, err = unpackUint16(msg, off)
1842         if err != nil {
1843                 return off, err
1844         }
1845         if off == len(msg) {
1846                 return off, nil
1847         }
1848         rr.NodeID, off, err = unpackUint64(msg, off)
1849         if err != nil {
1850                 return off, err
1851         }
1852         return off, nil
1853 }
1854
1855 func (rr *NIMLOC) unpack(msg []byte, off int) (off1 int, err error) {
1856         rdStart := off
1857         _ = rdStart
1858
1859         rr.Locator, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
1860         if err != nil {
1861                 return off, err
1862         }
1863         return off, nil
1864 }
1865
1866 func (rr *NINFO) unpack(msg []byte, off int) (off1 int, err error) {
1867         rdStart := off
1868         _ = rdStart
1869
1870         rr.ZSData, off, err = unpackStringTxt(msg, off)
1871         if err != nil {
1872                 return off, err
1873         }
1874         return off, nil
1875 }
1876
1877 func (rr *NS) unpack(msg []byte, off int) (off1 int, err error) {
1878         rdStart := off
1879         _ = rdStart
1880
1881         rr.Ns, off, err = UnpackDomainName(msg, off)
1882         if err != nil {
1883                 return off, err
1884         }
1885         return off, nil
1886 }
1887
1888 func (rr *NSAPPTR) unpack(msg []byte, off int) (off1 int, err error) {
1889         rdStart := off
1890         _ = rdStart
1891
1892         rr.Ptr, off, err = UnpackDomainName(msg, off)
1893         if err != nil {
1894                 return off, err
1895         }
1896         return off, nil
1897 }
1898
1899 func (rr *NSEC) unpack(msg []byte, off int) (off1 int, err error) {
1900         rdStart := off
1901         _ = rdStart
1902
1903         rr.NextDomain, off, err = UnpackDomainName(msg, off)
1904         if err != nil {
1905                 return off, err
1906         }
1907         if off == len(msg) {
1908                 return off, nil
1909         }
1910         rr.TypeBitMap, off, err = unpackDataNsec(msg, off)
1911         if err != nil {
1912                 return off, err
1913         }
1914         return off, nil
1915 }
1916
1917 func (rr *NSEC3) unpack(msg []byte, off int) (off1 int, err error) {
1918         rdStart := off
1919         _ = rdStart
1920
1921         rr.Hash, off, err = unpackUint8(msg, off)
1922         if err != nil {
1923                 return off, err
1924         }
1925         if off == len(msg) {
1926                 return off, nil
1927         }
1928         rr.Flags, off, err = unpackUint8(msg, off)
1929         if err != nil {
1930                 return off, err
1931         }
1932         if off == len(msg) {
1933                 return off, nil
1934         }
1935         rr.Iterations, off, err = unpackUint16(msg, off)
1936         if err != nil {
1937                 return off, err
1938         }
1939         if off == len(msg) {
1940                 return off, nil
1941         }
1942         rr.SaltLength, off, err = unpackUint8(msg, off)
1943         if err != nil {
1944                 return off, err
1945         }
1946         if off == len(msg) {
1947                 return off, nil
1948         }
1949         rr.Salt, off, err = unpackStringHex(msg, off, off+int(rr.SaltLength))
1950         if err != nil {
1951                 return off, err
1952         }
1953         rr.HashLength, off, err = unpackUint8(msg, off)
1954         if err != nil {
1955                 return off, err
1956         }
1957         if off == len(msg) {
1958                 return off, nil
1959         }
1960         rr.NextDomain, off, err = unpackStringBase32(msg, off, off+int(rr.HashLength))
1961         if err != nil {
1962                 return off, err
1963         }
1964         rr.TypeBitMap, off, err = unpackDataNsec(msg, off)
1965         if err != nil {
1966                 return off, err
1967         }
1968         return off, nil
1969 }
1970
1971 func (rr *NSEC3PARAM) unpack(msg []byte, off int) (off1 int, err error) {
1972         rdStart := off
1973         _ = rdStart
1974
1975         rr.Hash, off, err = unpackUint8(msg, off)
1976         if err != nil {
1977                 return off, err
1978         }
1979         if off == len(msg) {
1980                 return off, nil
1981         }
1982         rr.Flags, off, err = unpackUint8(msg, off)
1983         if err != nil {
1984                 return off, err
1985         }
1986         if off == len(msg) {
1987                 return off, nil
1988         }
1989         rr.Iterations, off, err = unpackUint16(msg, off)
1990         if err != nil {
1991                 return off, err
1992         }
1993         if off == len(msg) {
1994                 return off, nil
1995         }
1996         rr.SaltLength, off, err = unpackUint8(msg, off)
1997         if err != nil {
1998                 return off, err
1999         }
2000         if off == len(msg) {
2001                 return off, nil
2002         }
2003         rr.Salt, off, err = unpackStringHex(msg, off, off+int(rr.SaltLength))
2004         if err != nil {
2005                 return off, err
2006         }
2007         return off, nil
2008 }
2009
2010 func (rr *NULL) unpack(msg []byte, off int) (off1 int, err error) {
2011         rdStart := off
2012         _ = rdStart
2013
2014         rr.Data, off, err = unpackStringAny(msg, off, rdStart+int(rr.Hdr.Rdlength))
2015         if err != nil {
2016                 return off, err
2017         }
2018         return off, nil
2019 }
2020
2021 func (rr *OPENPGPKEY) unpack(msg []byte, off int) (off1 int, err error) {
2022         rdStart := off
2023         _ = rdStart
2024
2025         rr.PublicKey, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
2026         if err != nil {
2027                 return off, err
2028         }
2029         return off, nil
2030 }
2031
2032 func (rr *OPT) unpack(msg []byte, off int) (off1 int, err error) {
2033         rdStart := off
2034         _ = rdStart
2035
2036         rr.Option, off, err = unpackDataOpt(msg, off)
2037         if err != nil {
2038                 return off, err
2039         }
2040         return off, nil
2041 }
2042
2043 func (rr *PTR) unpack(msg []byte, off int) (off1 int, err error) {
2044         rdStart := off
2045         _ = rdStart
2046
2047         rr.Ptr, off, err = UnpackDomainName(msg, off)
2048         if err != nil {
2049                 return off, err
2050         }
2051         return off, nil
2052 }
2053
2054 func (rr *PX) unpack(msg []byte, off int) (off1 int, err error) {
2055         rdStart := off
2056         _ = rdStart
2057
2058         rr.Preference, off, err = unpackUint16(msg, off)
2059         if err != nil {
2060                 return off, err
2061         }
2062         if off == len(msg) {
2063                 return off, nil
2064         }
2065         rr.Map822, off, err = UnpackDomainName(msg, off)
2066         if err != nil {
2067                 return off, err
2068         }
2069         if off == len(msg) {
2070                 return off, nil
2071         }
2072         rr.Mapx400, off, err = UnpackDomainName(msg, off)
2073         if err != nil {
2074                 return off, err
2075         }
2076         return off, nil
2077 }
2078
2079 func (rr *RFC3597) unpack(msg []byte, off int) (off1 int, err error) {
2080         rdStart := off
2081         _ = rdStart
2082
2083         rr.Rdata, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
2084         if err != nil {
2085                 return off, err
2086         }
2087         return off, nil
2088 }
2089
2090 func (rr *RKEY) unpack(msg []byte, off int) (off1 int, err error) {
2091         rdStart := off
2092         _ = rdStart
2093
2094         rr.Flags, off, err = unpackUint16(msg, off)
2095         if err != nil {
2096                 return off, err
2097         }
2098         if off == len(msg) {
2099                 return off, nil
2100         }
2101         rr.Protocol, off, err = unpackUint8(msg, off)
2102         if err != nil {
2103                 return off, err
2104         }
2105         if off == len(msg) {
2106                 return off, nil
2107         }
2108         rr.Algorithm, off, err = unpackUint8(msg, off)
2109         if err != nil {
2110                 return off, err
2111         }
2112         if off == len(msg) {
2113                 return off, nil
2114         }
2115         rr.PublicKey, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
2116         if err != nil {
2117                 return off, err
2118         }
2119         return off, nil
2120 }
2121
2122 func (rr *RP) unpack(msg []byte, off int) (off1 int, err error) {
2123         rdStart := off
2124         _ = rdStart
2125
2126         rr.Mbox, off, err = UnpackDomainName(msg, off)
2127         if err != nil {
2128                 return off, err
2129         }
2130         if off == len(msg) {
2131                 return off, nil
2132         }
2133         rr.Txt, off, err = UnpackDomainName(msg, off)
2134         if err != nil {
2135                 return off, err
2136         }
2137         return off, nil
2138 }
2139
2140 func (rr *RRSIG) unpack(msg []byte, off int) (off1 int, err error) {
2141         rdStart := off
2142         _ = rdStart
2143
2144         rr.TypeCovered, off, err = unpackUint16(msg, off)
2145         if err != nil {
2146                 return off, err
2147         }
2148         if off == len(msg) {
2149                 return off, nil
2150         }
2151         rr.Algorithm, off, err = unpackUint8(msg, off)
2152         if err != nil {
2153                 return off, err
2154         }
2155         if off == len(msg) {
2156                 return off, nil
2157         }
2158         rr.Labels, off, err = unpackUint8(msg, off)
2159         if err != nil {
2160                 return off, err
2161         }
2162         if off == len(msg) {
2163                 return off, nil
2164         }
2165         rr.OrigTtl, off, err = unpackUint32(msg, off)
2166         if err != nil {
2167                 return off, err
2168         }
2169         if off == len(msg) {
2170                 return off, nil
2171         }
2172         rr.Expiration, off, err = unpackUint32(msg, off)
2173         if err != nil {
2174                 return off, err
2175         }
2176         if off == len(msg) {
2177                 return off, nil
2178         }
2179         rr.Inception, off, err = unpackUint32(msg, off)
2180         if err != nil {
2181                 return off, err
2182         }
2183         if off == len(msg) {
2184                 return off, nil
2185         }
2186         rr.KeyTag, off, err = unpackUint16(msg, off)
2187         if err != nil {
2188                 return off, err
2189         }
2190         if off == len(msg) {
2191                 return off, nil
2192         }
2193         rr.SignerName, off, err = UnpackDomainName(msg, off)
2194         if err != nil {
2195                 return off, err
2196         }
2197         if off == len(msg) {
2198                 return off, nil
2199         }
2200         rr.Signature, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
2201         if err != nil {
2202                 return off, err
2203         }
2204         return off, nil
2205 }
2206
2207 func (rr *RT) unpack(msg []byte, off int) (off1 int, err error) {
2208         rdStart := off
2209         _ = rdStart
2210
2211         rr.Preference, off, err = unpackUint16(msg, off)
2212         if err != nil {
2213                 return off, err
2214         }
2215         if off == len(msg) {
2216                 return off, nil
2217         }
2218         rr.Host, off, err = UnpackDomainName(msg, off)
2219         if err != nil {
2220                 return off, err
2221         }
2222         return off, nil
2223 }
2224
2225 func (rr *SIG) unpack(msg []byte, off int) (off1 int, err error) {
2226         rdStart := off
2227         _ = rdStart
2228
2229         rr.TypeCovered, off, err = unpackUint16(msg, off)
2230         if err != nil {
2231                 return off, err
2232         }
2233         if off == len(msg) {
2234                 return off, nil
2235         }
2236         rr.Algorithm, off, err = unpackUint8(msg, off)
2237         if err != nil {
2238                 return off, err
2239         }
2240         if off == len(msg) {
2241                 return off, nil
2242         }
2243         rr.Labels, off, err = unpackUint8(msg, off)
2244         if err != nil {
2245                 return off, err
2246         }
2247         if off == len(msg) {
2248                 return off, nil
2249         }
2250         rr.OrigTtl, off, err = unpackUint32(msg, off)
2251         if err != nil {
2252                 return off, err
2253         }
2254         if off == len(msg) {
2255                 return off, nil
2256         }
2257         rr.Expiration, off, err = unpackUint32(msg, off)
2258         if err != nil {
2259                 return off, err
2260         }
2261         if off == len(msg) {
2262                 return off, nil
2263         }
2264         rr.Inception, off, err = unpackUint32(msg, off)
2265         if err != nil {
2266                 return off, err
2267         }
2268         if off == len(msg) {
2269                 return off, nil
2270         }
2271         rr.KeyTag, off, err = unpackUint16(msg, off)
2272         if err != nil {
2273                 return off, err
2274         }
2275         if off == len(msg) {
2276                 return off, nil
2277         }
2278         rr.SignerName, off, err = UnpackDomainName(msg, off)
2279         if err != nil {
2280                 return off, err
2281         }
2282         if off == len(msg) {
2283                 return off, nil
2284         }
2285         rr.Signature, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
2286         if err != nil {
2287                 return off, err
2288         }
2289         return off, nil
2290 }
2291
2292 func (rr *SMIMEA) unpack(msg []byte, off int) (off1 int, err error) {
2293         rdStart := off
2294         _ = rdStart
2295
2296         rr.Usage, off, err = unpackUint8(msg, off)
2297         if err != nil {
2298                 return off, err
2299         }
2300         if off == len(msg) {
2301                 return off, nil
2302         }
2303         rr.Selector, off, err = unpackUint8(msg, off)
2304         if err != nil {
2305                 return off, err
2306         }
2307         if off == len(msg) {
2308                 return off, nil
2309         }
2310         rr.MatchingType, off, err = unpackUint8(msg, off)
2311         if err != nil {
2312                 return off, err
2313         }
2314         if off == len(msg) {
2315                 return off, nil
2316         }
2317         rr.Certificate, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
2318         if err != nil {
2319                 return off, err
2320         }
2321         return off, nil
2322 }
2323
2324 func (rr *SOA) unpack(msg []byte, off int) (off1 int, err error) {
2325         rdStart := off
2326         _ = rdStart
2327
2328         rr.Ns, off, err = UnpackDomainName(msg, off)
2329         if err != nil {
2330                 return off, err
2331         }
2332         if off == len(msg) {
2333                 return off, nil
2334         }
2335         rr.Mbox, off, err = UnpackDomainName(msg, off)
2336         if err != nil {
2337                 return off, err
2338         }
2339         if off == len(msg) {
2340                 return off, nil
2341         }
2342         rr.Serial, off, err = unpackUint32(msg, off)
2343         if err != nil {
2344                 return off, err
2345         }
2346         if off == len(msg) {
2347                 return off, nil
2348         }
2349         rr.Refresh, off, err = unpackUint32(msg, off)
2350         if err != nil {
2351                 return off, err
2352         }
2353         if off == len(msg) {
2354                 return off, nil
2355         }
2356         rr.Retry, off, err = unpackUint32(msg, off)
2357         if err != nil {
2358                 return off, err
2359         }
2360         if off == len(msg) {
2361                 return off, nil
2362         }
2363         rr.Expire, off, err = unpackUint32(msg, off)
2364         if err != nil {
2365                 return off, err
2366         }
2367         if off == len(msg) {
2368                 return off, nil
2369         }
2370         rr.Minttl, off, err = unpackUint32(msg, off)
2371         if err != nil {
2372                 return off, err
2373         }
2374         return off, nil
2375 }
2376
2377 func (rr *SPF) unpack(msg []byte, off int) (off1 int, err error) {
2378         rdStart := off
2379         _ = rdStart
2380
2381         rr.Txt, off, err = unpackStringTxt(msg, off)
2382         if err != nil {
2383                 return off, err
2384         }
2385         return off, nil
2386 }
2387
2388 func (rr *SRV) unpack(msg []byte, off int) (off1 int, err error) {
2389         rdStart := off
2390         _ = rdStart
2391
2392         rr.Priority, off, err = unpackUint16(msg, off)
2393         if err != nil {
2394                 return off, err
2395         }
2396         if off == len(msg) {
2397                 return off, nil
2398         }
2399         rr.Weight, off, err = unpackUint16(msg, off)
2400         if err != nil {
2401                 return off, err
2402         }
2403         if off == len(msg) {
2404                 return off, nil
2405         }
2406         rr.Port, off, err = unpackUint16(msg, off)
2407         if err != nil {
2408                 return off, err
2409         }
2410         if off == len(msg) {
2411                 return off, nil
2412         }
2413         rr.Target, off, err = UnpackDomainName(msg, off)
2414         if err != nil {
2415                 return off, err
2416         }
2417         return off, nil
2418 }
2419
2420 func (rr *SSHFP) unpack(msg []byte, off int) (off1 int, err error) {
2421         rdStart := off
2422         _ = rdStart
2423
2424         rr.Algorithm, off, err = unpackUint8(msg, off)
2425         if err != nil {
2426                 return off, err
2427         }
2428         if off == len(msg) {
2429                 return off, nil
2430         }
2431         rr.Type, off, err = unpackUint8(msg, off)
2432         if err != nil {
2433                 return off, err
2434         }
2435         if off == len(msg) {
2436                 return off, nil
2437         }
2438         rr.FingerPrint, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
2439         if err != nil {
2440                 return off, err
2441         }
2442         return off, nil
2443 }
2444
2445 func (rr *TA) unpack(msg []byte, off int) (off1 int, err error) {
2446         rdStart := off
2447         _ = rdStart
2448
2449         rr.KeyTag, off, err = unpackUint16(msg, off)
2450         if err != nil {
2451                 return off, err
2452         }
2453         if off == len(msg) {
2454                 return off, nil
2455         }
2456         rr.Algorithm, off, err = unpackUint8(msg, off)
2457         if err != nil {
2458                 return off, err
2459         }
2460         if off == len(msg) {
2461                 return off, nil
2462         }
2463         rr.DigestType, off, err = unpackUint8(msg, off)
2464         if err != nil {
2465                 return off, err
2466         }
2467         if off == len(msg) {
2468                 return off, nil
2469         }
2470         rr.Digest, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
2471         if err != nil {
2472                 return off, err
2473         }
2474         return off, nil
2475 }
2476
2477 func (rr *TALINK) unpack(msg []byte, off int) (off1 int, err error) {
2478         rdStart := off
2479         _ = rdStart
2480
2481         rr.PreviousName, off, err = UnpackDomainName(msg, off)
2482         if err != nil {
2483                 return off, err
2484         }
2485         if off == len(msg) {
2486                 return off, nil
2487         }
2488         rr.NextName, off, err = UnpackDomainName(msg, off)
2489         if err != nil {
2490                 return off, err
2491         }
2492         return off, nil
2493 }
2494
2495 func (rr *TKEY) unpack(msg []byte, off int) (off1 int, err error) {
2496         rdStart := off
2497         _ = rdStart
2498
2499         rr.Algorithm, off, err = UnpackDomainName(msg, off)
2500         if err != nil {
2501                 return off, err
2502         }
2503         if off == len(msg) {
2504                 return off, nil
2505         }
2506         rr.Inception, off, err = unpackUint32(msg, off)
2507         if err != nil {
2508                 return off, err
2509         }
2510         if off == len(msg) {
2511                 return off, nil
2512         }
2513         rr.Expiration, off, err = unpackUint32(msg, off)
2514         if err != nil {
2515                 return off, err
2516         }
2517         if off == len(msg) {
2518                 return off, nil
2519         }
2520         rr.Mode, off, err = unpackUint16(msg, off)
2521         if err != nil {
2522                 return off, err
2523         }
2524         if off == len(msg) {
2525                 return off, nil
2526         }
2527         rr.Error, off, err = unpackUint16(msg, off)
2528         if err != nil {
2529                 return off, err
2530         }
2531         if off == len(msg) {
2532                 return off, nil
2533         }
2534         rr.KeySize, off, err = unpackUint16(msg, off)
2535         if err != nil {
2536                 return off, err
2537         }
2538         if off == len(msg) {
2539                 return off, nil
2540         }
2541         rr.Key, off, err = unpackStringHex(msg, off, off+int(rr.KeySize))
2542         if err != nil {
2543                 return off, err
2544         }
2545         rr.OtherLen, off, err = unpackUint16(msg, off)
2546         if err != nil {
2547                 return off, err
2548         }
2549         if off == len(msg) {
2550                 return off, nil
2551         }
2552         rr.OtherData, off, err = unpackStringHex(msg, off, off+int(rr.OtherLen))
2553         if err != nil {
2554                 return off, err
2555         }
2556         return off, nil
2557 }
2558
2559 func (rr *TLSA) unpack(msg []byte, off int) (off1 int, err error) {
2560         rdStart := off
2561         _ = rdStart
2562
2563         rr.Usage, off, err = unpackUint8(msg, off)
2564         if err != nil {
2565                 return off, err
2566         }
2567         if off == len(msg) {
2568                 return off, nil
2569         }
2570         rr.Selector, off, err = unpackUint8(msg, off)
2571         if err != nil {
2572                 return off, err
2573         }
2574         if off == len(msg) {
2575                 return off, nil
2576         }
2577         rr.MatchingType, off, err = unpackUint8(msg, off)
2578         if err != nil {
2579                 return off, err
2580         }
2581         if off == len(msg) {
2582                 return off, nil
2583         }
2584         rr.Certificate, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
2585         if err != nil {
2586                 return off, err
2587         }
2588         return off, nil
2589 }
2590
2591 func (rr *TSIG) unpack(msg []byte, off int) (off1 int, err error) {
2592         rdStart := off
2593         _ = rdStart
2594
2595         rr.Algorithm, off, err = UnpackDomainName(msg, off)
2596         if err != nil {
2597                 return off, err
2598         }
2599         if off == len(msg) {
2600                 return off, nil
2601         }
2602         rr.TimeSigned, off, err = unpackUint48(msg, off)
2603         if err != nil {
2604                 return off, err
2605         }
2606         if off == len(msg) {
2607                 return off, nil
2608         }
2609         rr.Fudge, off, err = unpackUint16(msg, off)
2610         if err != nil {
2611                 return off, err
2612         }
2613         if off == len(msg) {
2614                 return off, nil
2615         }
2616         rr.MACSize, off, err = unpackUint16(msg, off)
2617         if err != nil {
2618                 return off, err
2619         }
2620         if off == len(msg) {
2621                 return off, nil
2622         }
2623         rr.MAC, off, err = unpackStringHex(msg, off, off+int(rr.MACSize))
2624         if err != nil {
2625                 return off, err
2626         }
2627         rr.OrigId, off, err = unpackUint16(msg, off)
2628         if err != nil {
2629                 return off, err
2630         }
2631         if off == len(msg) {
2632                 return off, nil
2633         }
2634         rr.Error, off, err = unpackUint16(msg, off)
2635         if err != nil {
2636                 return off, err
2637         }
2638         if off == len(msg) {
2639                 return off, nil
2640         }
2641         rr.OtherLen, off, err = unpackUint16(msg, off)
2642         if err != nil {
2643                 return off, err
2644         }
2645         if off == len(msg) {
2646                 return off, nil
2647         }
2648         rr.OtherData, off, err = unpackStringHex(msg, off, off+int(rr.OtherLen))
2649         if err != nil {
2650                 return off, err
2651         }
2652         return off, nil
2653 }
2654
2655 func (rr *TXT) unpack(msg []byte, off int) (off1 int, err error) {
2656         rdStart := off
2657         _ = rdStart
2658
2659         rr.Txt, off, err = unpackStringTxt(msg, off)
2660         if err != nil {
2661                 return off, err
2662         }
2663         return off, nil
2664 }
2665
2666 func (rr *UID) unpack(msg []byte, off int) (off1 int, err error) {
2667         rdStart := off
2668         _ = rdStart
2669
2670         rr.Uid, off, err = unpackUint32(msg, off)
2671         if err != nil {
2672                 return off, err
2673         }
2674         return off, nil
2675 }
2676
2677 func (rr *UINFO) unpack(msg []byte, off int) (off1 int, err error) {
2678         rdStart := off
2679         _ = rdStart
2680
2681         rr.Uinfo, off, err = unpackString(msg, off)
2682         if err != nil {
2683                 return off, err
2684         }
2685         return off, nil
2686 }
2687
2688 func (rr *URI) unpack(msg []byte, off int) (off1 int, err error) {
2689         rdStart := off
2690         _ = rdStart
2691
2692         rr.Priority, off, err = unpackUint16(msg, off)
2693         if err != nil {
2694                 return off, err
2695         }
2696         if off == len(msg) {
2697                 return off, nil
2698         }
2699         rr.Weight, off, err = unpackUint16(msg, off)
2700         if err != nil {
2701                 return off, err
2702         }
2703         if off == len(msg) {
2704                 return off, nil
2705         }
2706         rr.Target, off, err = unpackStringOctet(msg, off)
2707         if err != nil {
2708                 return off, err
2709         }
2710         return off, nil
2711 }
2712
2713 func (rr *X25) unpack(msg []byte, off int) (off1 int, err error) {
2714         rdStart := off
2715         _ = rdStart
2716
2717         rr.PSDNAddress, off, err = unpackString(msg, off)
2718         if err != nil {
2719                 return off, err
2720         }
2721         return off, nil
2722 }