2017-12-06 21:02:47 +11:00
|
|
|
// Code generated by "go run msg_generate.go"; DO NOT EDIT.
|
2016-05-15 02:56:20 +10:00
|
|
|
|
|
|
|
package dns
|
|
|
|
|
|
|
|
// pack*() functions
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *A) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-05-15 02:56:20 +10:00
|
|
|
off, err = packDataA(rr.A, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *AAAA) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-05-15 02:56:20 +10:00
|
|
|
off, err = packDataAAAA(rr.AAAA, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *AFSDB) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint16(rr.Subtype, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Hostname, msg, off, compression, false)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *ANY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2020-01-03 23:41:45 +11:00
|
|
|
func (rr *APL) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
|
|
|
off, err = packDataApl(rr.Prefixes, msg, off)
|
|
|
|
if err != nil {
|
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
return off, nil
|
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *AVC) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2017-03-30 07:17:13 +11:00
|
|
|
off, err = packStringTxt(rr.Txt, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2017-03-30 07:17:13 +11:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2017-03-30 07:17:13 +11:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *CAA) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint8(rr.Flag, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packString(rr.Tag, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 01:09:37 +10:00
|
|
|
off, err = packStringOctet(rr.Value, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *CDNSKEY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-13 01:09:37 +10:00
|
|
|
off, err = packUint16(rr.Flags, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Protocol, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Algorithm, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
off, err = packStringBase64(rr.PublicKey, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *CDS) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-13 01:09:37 +10:00
|
|
|
off, err = packUint16(rr.KeyTag, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Algorithm, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.DigestType, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
off, err = packStringHex(rr.Digest, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *CERT) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint16(rr.Type, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint16(rr.KeyTag, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Algorithm, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packStringBase64(rr.Certificate, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *CNAME) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Target, msg, off, compression, compress)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *CSYNC) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
Implement CSYNC (#585)
Implement the CSYNC record.
Fixes #290
Long overdue, lets add this record. Similar in vain as NSEC/NSEC3, we
need to implement len() our selves. Presentation format parsing and
tests are done as well.
This is CoreDNS running with CSYNC support, `dig` doesn't support this
at the moment, so:
~~~
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 40323
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 2, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;csync.example.org. IN TYPE62
;; ANSWER SECTION:
csync.example.org. 10 IN TYPE62 \# 12 000335240042000460000008
;; AUTHORITY SECTION:
example.org. 10 IN NS a.iana-servers.net.
example.org. 10 IN NS b.iana-servers.net.
~~~
2017-11-25 19:19:06 +11:00
|
|
|
off, err = packUint32(rr.Serial, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
Implement CSYNC (#585)
Implement the CSYNC record.
Fixes #290
Long overdue, lets add this record. Similar in vain as NSEC/NSEC3, we
need to implement len() our selves. Presentation format parsing and
tests are done as well.
This is CoreDNS running with CSYNC support, `dig` doesn't support this
at the moment, so:
~~~
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 40323
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 2, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;csync.example.org. IN TYPE62
;; ANSWER SECTION:
csync.example.org. 10 IN TYPE62 \# 12 000335240042000460000008
;; AUTHORITY SECTION:
example.org. 10 IN NS a.iana-servers.net.
example.org. 10 IN NS b.iana-servers.net.
~~~
2017-11-25 19:19:06 +11:00
|
|
|
}
|
|
|
|
off, err = packUint16(rr.Flags, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
Implement CSYNC (#585)
Implement the CSYNC record.
Fixes #290
Long overdue, lets add this record. Similar in vain as NSEC/NSEC3, we
need to implement len() our selves. Presentation format parsing and
tests are done as well.
This is CoreDNS running with CSYNC support, `dig` doesn't support this
at the moment, so:
~~~
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 40323
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 2, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;csync.example.org. IN TYPE62
;; ANSWER SECTION:
csync.example.org. 10 IN TYPE62 \# 12 000335240042000460000008
;; AUTHORITY SECTION:
example.org. 10 IN NS a.iana-servers.net.
example.org. 10 IN NS b.iana-servers.net.
~~~
2017-11-25 19:19:06 +11:00
|
|
|
}
|
|
|
|
off, err = packDataNsec(rr.TypeBitMap, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
Implement CSYNC (#585)
Implement the CSYNC record.
Fixes #290
Long overdue, lets add this record. Similar in vain as NSEC/NSEC3, we
need to implement len() our selves. Presentation format parsing and
tests are done as well.
This is CoreDNS running with CSYNC support, `dig` doesn't support this
at the moment, so:
~~~
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 40323
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 2, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;csync.example.org. IN TYPE62
;; ANSWER SECTION:
csync.example.org. 10 IN TYPE62 \# 12 000335240042000460000008
;; AUTHORITY SECTION:
example.org. 10 IN NS a.iana-servers.net.
example.org. 10 IN NS b.iana-servers.net.
~~~
2017-11-25 19:19:06 +11:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
Implement CSYNC (#585)
Implement the CSYNC record.
Fixes #290
Long overdue, lets add this record. Similar in vain as NSEC/NSEC3, we
need to implement len() our selves. Presentation format parsing and
tests are done as well.
This is CoreDNS running with CSYNC support, `dig` doesn't support this
at the moment, so:
~~~
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 40323
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 2, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;csync.example.org. IN TYPE62
;; ANSWER SECTION:
csync.example.org. 10 IN TYPE62 \# 12 000335240042000460000008
;; AUTHORITY SECTION:
example.org. 10 IN NS a.iana-servers.net.
example.org. 10 IN NS b.iana-servers.net.
~~~
2017-11-25 19:19:06 +11:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *DHCID) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packStringBase64(rr.Digest, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *DLV) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-13 01:09:37 +10:00
|
|
|
off, err = packUint16(rr.KeyTag, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Algorithm, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.DigestType, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
off, err = packStringHex(rr.Digest, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *DNAME) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Target, msg, off, compression, false)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *DNSKEY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-05-15 02:56:20 +10:00
|
|
|
off, err = packUint16(rr.Flags, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Protocol, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Algorithm, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
off, err = packStringBase64(rr.PublicKey, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *DS) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint16(rr.KeyTag, msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint8(rr.Algorithm, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.DigestType, msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-13 01:09:37 +10:00
|
|
|
off, err = packStringHex(rr.Digest, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *EID) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-13 01:09:37 +10:00
|
|
|
off, err = packStringHex(rr.Endpoint, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *EUI48) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint48(rr.Address, msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *EUI64) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint64(rr.Address, msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *GID) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint32(rr.Gid, msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *GPOS) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packString(rr.Longitude, msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packString(rr.Latitude, msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packString(rr.Altitude, msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *HINFO) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packString(rr.Cpu, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packString(rr.Os, msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *HIP) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint8(rr.HitLength, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.PublicKeyAlgorithm, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint16(rr.PublicKeyLength, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 01:09:37 +10:00
|
|
|
off, err = packStringHex(rr.Hit, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packStringBase64(rr.PublicKey, msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2018-11-30 18:49:06 +11:00
|
|
|
off, err = packDataDomainNames(rr.RendezvousServers, msg, off, compression, false)
|
2016-06-13 01:09:37 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
Implement SVCB (#1067)
* Implement SVCB
* Fix serialization and deserialization of double quotes
* More effort (?)
4 months old commit
* DEBUG
* _
* Presentation format serialization/deserialization
* _
Remove generated
* Progress on presentation format parse & write
* _
* Finish parsing presentation format
* Regenerate
* Pack unpack
* Move to svcb.go
Scan_rr.go and types.go should be untouched now
* :bug:
Thanks ghedo
* Definitions
* TypeHTTPSSVC
* Generated
and isDuplicate
* Goodbye lenient functions
Now private key=value pairs have to be defined as structs too. They are no longer automatically named as KeyNNNNN
* Encode/decode
* Experimental svc
* Read method
* Implement some of the methods, use trick...
to report where the error is while reading it. This should be applied to EDNS too. Todo: Find if case can only contain e := new(SVC_ALPN) and rest moved out
Also fix two compile errors
* Add SVC_LOCAL methods, reorder, remove alpn value, bugs
* Errors
* Alpn, make it build
* Correct testsuite
* Fully implement parser
Change from keeping a state variable to reading in one iteration until the key=value pair is fully consumed
* Simplify and document
EDNS should be simplified too
* Attempt to fix fuzzer
And Alpn bug
* A bug and change type values to match @ghedo's implementation
* IP bug
Also there are two ip duplicating patterns, one with copy, one with append. Maybe change it to be consistent.
* Check for strictly increasing keys as required
* Don't panic on invalid alpn
* Redundant check, don't modify original array
* Size calculation
* Fix the fuzzer, match the style
* 65535 is reserved too, don't delay errors
* Check keyNNN, check for aliasform having values
* IPvNHint is an array
* Fix ipvNHint
* Rename everything
* Unrecognized keys according to the updated specification
* Skip zero-length structs in generators. Fix CI
* Doc cleanup
* Off by one
* Add parse tests
* Check if private key doesn't collide with known key, invalid tests
* Disallow IPv4 as IPv6. More tests.
Related #1107
* Style fixes
* More consistency, more tests
* :bug: Deep copy as in the documentation
a := make([]net.IP, 1)
a[0] = net.ParseIP("1.1.1.1").To4()
b := append(make([]net.IP, 0, 1), a...)
b[0] = net.ParseIP("3.1.1.1").To4()
fmt.Println(a[0][0])
* Make tests readable
* Move valid parse tests to different file
* :bug: One of previous commits not fully committed
* Test binary single value encoding/decoding and full encode/decode
* Add worst-case grows to builders, :bug: Wrong visible character range, redundant tests
* Testing improvements
And don't convert to IPv4 twice
* Doc update only
* Document worst case allocations
and ipv6 can be at most of length 39, not 40
* Redundant IP copy, consistent IPv6 behavior, fix deep copy
* isDuplicate for SVCB
* Optimizations
* echoconfig
* Svc => SVCB
* Fix CI
* Regenerate after REBASE (2)
Rebased twice on 15th and 20th May
* Rename svc, use escapeByte.
* Fix parsing whitespaces between quotes, rename ECHOHOConfig
* resolve
Remove svcbFieldLen
Use reverseInt
Uppercase SVCB
Rename key_value
"invalid" => bad
Alpn comments
> 65535 check
Unneeded slices
* a little more
read => parse
IP array meaning
Force pushed because forgot to change read in svcb_test.go
* HTTPSSVC -> HTTPS
* Use new values
* mandatory code
https://github.com/MikeBishop/dns-alt-svc/pull/205
* Resolve comments
Rename svcb-pairs
Remove SVCB_PRIVATE ranges
Comment on SVCB_KEY65535
ParseError return l.token
rename svcbKeyToString and svcbStringToKey
privatize SVCBKeyToString, SVCBStringToKey
* Refactor 1
Rename sorted, originalPairs
Use append instead of copy
Use svcb_RESERVED instead of 65535, with it now being private
"type SVCBKey uint16"
* Refactor 2
svcbKeyToString as method
svcbStringToKey updated after key 0
:bug: mandatory has missing key
Rename str
idx < 0
* Refactor 3
Use l.token as z
var key, value string
Comment wrap
0:
Sentences with '.'
keyValue => kv
* Refactor 4
* Refactor 5
len() int
* Refactor 6
* Refactor 7
* Test remove parsing
* Error messages
* Rewrite two estimate comments
* parse shouldn't modify original array :bug:
* Remove two unneeded comments
* Address review comments
Push 2 because can't build fuzzer python
Push 3 to try again
* Simplify argument duplication as per tmthrgd's suggestion
And add the relevant test
Force push edit: Make sorting code fit into one line
* Rewrite ECHConfig and address the review
* Remove the optional tab
* Add To4() Check
* More cleanup and fix mandatory not sorting bug
2020-10-11 18:09:36 +11:00
|
|
|
func (rr *HTTPS) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
|
|
|
off, err = packUint16(rr.Priority, msg, off)
|
|
|
|
if err != nil {
|
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
off, err = packDomainName(rr.Target, msg, off, compression, false)
|
|
|
|
if err != nil {
|
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
off, err = packDataSVCB(rr.Value, msg, off)
|
|
|
|
if err != nil {
|
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
return off, nil
|
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *KEY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-13 01:09:37 +10:00
|
|
|
off, err = packUint16(rr.Flags, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Protocol, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Algorithm, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
off, err = packStringBase64(rr.PublicKey, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *KX) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint16(rr.Preference, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Exchanger, msg, off, compression, false)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *L32) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint16(rr.Preference, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packDataA(rr.Locator32, msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *L64) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-05-15 02:56:20 +10:00
|
|
|
off, err = packUint16(rr.Preference, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint64(rr.Locator64, msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *LOC) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint8(rr.Version, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Size, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.HorizPre, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.VertPre, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint32(rr.Latitude, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint32(rr.Longitude, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint32(rr.Altitude, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *LP) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-05-15 02:56:20 +10:00
|
|
|
off, err = packUint16(rr.Preference, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Fqdn, msg, off, compression, false)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *MB) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Mb, msg, off, compression, compress)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *MD) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Md, msg, off, compression, compress)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *MF) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Mf, msg, off, compression, compress)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *MG) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Mg, msg, off, compression, compress)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *MINFO) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Rmail, msg, off, compression, compress)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Email, msg, off, compression, compress)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *MR) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Mr, msg, off, compression, compress)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *MX) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint16(rr.Preference, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Mx, msg, off, compression, compress)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *NAPTR) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint16(rr.Order, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint16(rr.Preference, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packString(rr.Flags, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packString(rr.Service, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packString(rr.Regexp, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Replacement, msg, off, compression, false)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *NID) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint16(rr.Preference, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint64(rr.NodeID, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *NIMLOC) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-13 01:09:37 +10:00
|
|
|
off, err = packStringHex(rr.Locator, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *NINFO) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packStringTxt(rr.ZSData, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *NS) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Ns, msg, off, compression, compress)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *NSAPPTR) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Ptr, msg, off, compression, false)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *NSEC) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.NextDomain, msg, off, compression, false)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 01:09:37 +10:00
|
|
|
off, err = packDataNsec(rr.TypeBitMap, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *NSEC3) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint8(rr.Hash, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Flags, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint16(rr.Iterations, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.SaltLength, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2017-03-22 06:35:21 +11:00
|
|
|
// Only pack salt if value is not "-", i.e. empty
|
|
|
|
if rr.Salt != "-" {
|
|
|
|
off, err = packStringHex(rr.Salt, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2017-03-22 06:35:21 +11:00
|
|
|
}
|
2016-06-13 03:31:50 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint8(rr.HashLength, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 03:31:50 +10:00
|
|
|
off, err = packStringBase32(rr.NextDomain, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 03:31:50 +10:00
|
|
|
}
|
2016-06-13 01:09:37 +10:00
|
|
|
off, err = packDataNsec(rr.TypeBitMap, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *NSEC3PARAM) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint8(rr.Hash, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Flags, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint16(rr.Iterations, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.SaltLength, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2017-03-22 06:35:21 +11:00
|
|
|
// Only pack salt if value is not "-", i.e. empty
|
|
|
|
if rr.Salt != "-" {
|
|
|
|
off, err = packStringHex(rr.Salt, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2017-03-22 06:35:21 +11:00
|
|
|
}
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *NULL) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2019-01-03 21:33:38 +11:00
|
|
|
off, err = packStringAny(rr.Data, msg, off)
|
2018-12-30 20:45:18 +11:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2018-12-30 20:45:18 +11:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2018-12-30 20:45:18 +11:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *OPENPGPKEY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packStringBase64(rr.PublicKey, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *OPT) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-13 01:09:37 +10:00
|
|
|
off, err = packDataOpt(rr.Option, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *PTR) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Ptr, msg, off, compression, compress)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *PX) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint16(rr.Preference, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Map822, msg, off, compression, false)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Mapx400, msg, off, compression, false)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *RFC3597) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-13 01:09:37 +10:00
|
|
|
off, err = packStringHex(rr.Rdata, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *RKEY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint16(rr.Flags, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Protocol, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Algorithm, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packStringBase64(rr.PublicKey, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *RP) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Mbox, msg, off, compression, false)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Txt, msg, off, compression, false)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *RRSIG) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint16(rr.TypeCovered, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Algorithm, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Labels, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint32(rr.OrigTtl, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint32(rr.Expiration, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint32(rr.Inception, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint16(rr.KeyTag, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.SignerName, msg, off, compression, false)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packStringBase64(rr.Signature, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *RT) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint16(rr.Preference, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Host, msg, off, compression, false)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *SIG) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-13 01:09:37 +10:00
|
|
|
off, err = packUint16(rr.TypeCovered, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Algorithm, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Labels, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
off, err = packUint32(rr.OrigTtl, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
off, err = packUint32(rr.Expiration, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
off, err = packUint32(rr.Inception, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
off, err = packUint16(rr.KeyTag, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.SignerName, msg, off, compression, false)
|
2016-06-13 01:09:37 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
off, err = packStringBase64(rr.Signature, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *SMIMEA) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-10-18 04:09:52 +11:00
|
|
|
off, err = packUint8(rr.Usage, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-10-18 04:09:52 +11:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Selector, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-10-18 04:09:52 +11:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.MatchingType, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-10-18 04:09:52 +11:00
|
|
|
}
|
|
|
|
off, err = packStringHex(rr.Certificate, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-10-18 04:09:52 +11:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-10-18 04:09:52 +11:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *SOA) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Ns, msg, off, compression, compress)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Mbox, msg, off, compression, compress)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint32(rr.Serial, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint32(rr.Refresh, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint32(rr.Retry, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint32(rr.Expire, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint32(rr.Minttl, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *SPF) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packStringTxt(rr.Txt, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *SRV) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint16(rr.Priority, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint16(rr.Weight, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint16(rr.Port, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Target, msg, off, compression, false)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *SSHFP) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint8(rr.Algorithm, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Type, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 01:09:37 +10:00
|
|
|
off, err = packStringHex(rr.FingerPrint, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
Implement SVCB (#1067)
* Implement SVCB
* Fix serialization and deserialization of double quotes
* More effort (?)
4 months old commit
* DEBUG
* _
* Presentation format serialization/deserialization
* _
Remove generated
* Progress on presentation format parse & write
* _
* Finish parsing presentation format
* Regenerate
* Pack unpack
* Move to svcb.go
Scan_rr.go and types.go should be untouched now
* :bug:
Thanks ghedo
* Definitions
* TypeHTTPSSVC
* Generated
and isDuplicate
* Goodbye lenient functions
Now private key=value pairs have to be defined as structs too. They are no longer automatically named as KeyNNNNN
* Encode/decode
* Experimental svc
* Read method
* Implement some of the methods, use trick...
to report where the error is while reading it. This should be applied to EDNS too. Todo: Find if case can only contain e := new(SVC_ALPN) and rest moved out
Also fix two compile errors
* Add SVC_LOCAL methods, reorder, remove alpn value, bugs
* Errors
* Alpn, make it build
* Correct testsuite
* Fully implement parser
Change from keeping a state variable to reading in one iteration until the key=value pair is fully consumed
* Simplify and document
EDNS should be simplified too
* Attempt to fix fuzzer
And Alpn bug
* A bug and change type values to match @ghedo's implementation
* IP bug
Also there are two ip duplicating patterns, one with copy, one with append. Maybe change it to be consistent.
* Check for strictly increasing keys as required
* Don't panic on invalid alpn
* Redundant check, don't modify original array
* Size calculation
* Fix the fuzzer, match the style
* 65535 is reserved too, don't delay errors
* Check keyNNN, check for aliasform having values
* IPvNHint is an array
* Fix ipvNHint
* Rename everything
* Unrecognized keys according to the updated specification
* Skip zero-length structs in generators. Fix CI
* Doc cleanup
* Off by one
* Add parse tests
* Check if private key doesn't collide with known key, invalid tests
* Disallow IPv4 as IPv6. More tests.
Related #1107
* Style fixes
* More consistency, more tests
* :bug: Deep copy as in the documentation
a := make([]net.IP, 1)
a[0] = net.ParseIP("1.1.1.1").To4()
b := append(make([]net.IP, 0, 1), a...)
b[0] = net.ParseIP("3.1.1.1").To4()
fmt.Println(a[0][0])
* Make tests readable
* Move valid parse tests to different file
* :bug: One of previous commits not fully committed
* Test binary single value encoding/decoding and full encode/decode
* Add worst-case grows to builders, :bug: Wrong visible character range, redundant tests
* Testing improvements
And don't convert to IPv4 twice
* Doc update only
* Document worst case allocations
and ipv6 can be at most of length 39, not 40
* Redundant IP copy, consistent IPv6 behavior, fix deep copy
* isDuplicate for SVCB
* Optimizations
* echoconfig
* Svc => SVCB
* Fix CI
* Regenerate after REBASE (2)
Rebased twice on 15th and 20th May
* Rename svc, use escapeByte.
* Fix parsing whitespaces between quotes, rename ECHOHOConfig
* resolve
Remove svcbFieldLen
Use reverseInt
Uppercase SVCB
Rename key_value
"invalid" => bad
Alpn comments
> 65535 check
Unneeded slices
* a little more
read => parse
IP array meaning
Force pushed because forgot to change read in svcb_test.go
* HTTPSSVC -> HTTPS
* Use new values
* mandatory code
https://github.com/MikeBishop/dns-alt-svc/pull/205
* Resolve comments
Rename svcb-pairs
Remove SVCB_PRIVATE ranges
Comment on SVCB_KEY65535
ParseError return l.token
rename svcbKeyToString and svcbStringToKey
privatize SVCBKeyToString, SVCBStringToKey
* Refactor 1
Rename sorted, originalPairs
Use append instead of copy
Use svcb_RESERVED instead of 65535, with it now being private
"type SVCBKey uint16"
* Refactor 2
svcbKeyToString as method
svcbStringToKey updated after key 0
:bug: mandatory has missing key
Rename str
idx < 0
* Refactor 3
Use l.token as z
var key, value string
Comment wrap
0:
Sentences with '.'
keyValue => kv
* Refactor 4
* Refactor 5
len() int
* Refactor 6
* Refactor 7
* Test remove parsing
* Error messages
* Rewrite two estimate comments
* parse shouldn't modify original array :bug:
* Remove two unneeded comments
* Address review comments
Push 2 because can't build fuzzer python
Push 3 to try again
* Simplify argument duplication as per tmthrgd's suggestion
And add the relevant test
Force push edit: Make sorting code fit into one line
* Rewrite ECHConfig and address the review
* Remove the optional tab
* Add To4() Check
* More cleanup and fix mandatory not sorting bug
2020-10-11 18:09:36 +11:00
|
|
|
func (rr *SVCB) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
|
|
|
off, err = packUint16(rr.Priority, msg, off)
|
|
|
|
if err != nil {
|
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
off, err = packDomainName(rr.Target, msg, off, compression, false)
|
|
|
|
if err != nil {
|
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
off, err = packDataSVCB(rr.Value, msg, off)
|
|
|
|
if err != nil {
|
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
return off, nil
|
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *TA) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint16(rr.KeyTag, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Algorithm, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.DigestType, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 01:09:37 +10:00
|
|
|
off, err = packStringHex(rr.Digest, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *TALINK) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.PreviousName, msg, off, compression, false)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.NextName, msg, off, compression, false)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *TKEY) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Algorithm, msg, off, compression, false)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint32(rr.Inception, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint32(rr.Expiration, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint16(rr.Mode, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint16(rr.Error, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint16(rr.KeySize, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2017-11-28 18:48:02 +11:00
|
|
|
off, err = packStringHex(rr.Key, msg, off)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint16(rr.OtherLen, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2017-11-28 18:48:02 +11:00
|
|
|
off, err = packStringHex(rr.OtherData, msg, off)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *TLSA) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint8(rr.Usage, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Selector, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint8(rr.MatchingType, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 01:09:37 +10:00
|
|
|
off, err = packStringHex(rr.Certificate, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *TSIG) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2019-01-04 03:39:37 +11:00
|
|
|
off, err = packDomainName(rr.Algorithm, msg, off, compression, false)
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint48(rr.TimeSigned, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint16(rr.Fudge, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint16(rr.MACSize, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 03:31:50 +10:00
|
|
|
off, err = packStringHex(rr.MAC, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 03:31:50 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint16(rr.OrigId, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint16(rr.Error, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint16(rr.OtherLen, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 03:31:50 +10:00
|
|
|
off, err = packStringHex(rr.OtherData, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 03:31:50 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *TXT) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packStringTxt(rr.Txt, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *UID) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint32(rr.Uid, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *UINFO) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packString(rr.Uinfo, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *URI) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packUint16(rr.Priority, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
off, err = packUint16(rr.Weight, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 01:09:37 +10:00
|
|
|
off, err = packStringOctet(rr.Target, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 10:39:14 +11:00
|
|
|
func (rr *X25) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
off, err = packString(rr.PSDNAddress, msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 10:39:14 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2021-02-27 02:35:05 +11:00
|
|
|
func (rr *ZONEMD) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
|
|
|
|
off, err = packUint32(rr.Serial, msg, off)
|
|
|
|
if err != nil {
|
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Scheme, msg, off)
|
|
|
|
if err != nil {
|
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
off, err = packUint8(rr.Hash, msg, off)
|
|
|
|
if err != nil {
|
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
off, err = packStringHex(rr.Digest, msg, off)
|
|
|
|
if err != nil {
|
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
return off, nil
|
|
|
|
}
|
|
|
|
|
2016-06-05 16:53:12 +10:00
|
|
|
// unpack*() functions
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *A) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.A, off, err = unpackDataA(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *AAAA) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.AAAA, off, err = unpackDataAAAA(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *AFSDB) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Subtype, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Hostname, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *ANY) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2020-01-03 23:41:45 +11:00
|
|
|
func (rr *APL) unpack(msg []byte, off int) (off1 int, err error) {
|
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Prefixes, off, err = unpackDataApl(msg, off)
|
|
|
|
if err != nil {
|
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
return off, nil
|
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *AVC) unpack(msg []byte, off int) (off1 int, err error) {
|
2017-03-30 07:17:13 +11:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Txt, off, err = unpackStringTxt(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2017-03-30 07:17:13 +11:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2017-03-30 07:17:13 +11:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *CAA) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Flag, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Tag, off, err = unpackString(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 01:09:37 +10:00
|
|
|
rr.Value, off, err = unpackStringOctet(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *CDNSKEY) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-13 01:09:37 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Flags, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
rr.Protocol, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
rr.Algorithm, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
rr.PublicKey, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *CDS) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-13 01:09:37 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.KeyTag, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
rr.Algorithm, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
rr.DigestType, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
rr.Digest, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *CERT) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Type, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.KeyTag, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Algorithm, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Certificate, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *CNAME) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Target, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *CSYNC) unpack(msg []byte, off int) (off1 int, err error) {
|
Implement CSYNC (#585)
Implement the CSYNC record.
Fixes #290
Long overdue, lets add this record. Similar in vain as NSEC/NSEC3, we
need to implement len() our selves. Presentation format parsing and
tests are done as well.
This is CoreDNS running with CSYNC support, `dig` doesn't support this
at the moment, so:
~~~
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 40323
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 2, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;csync.example.org. IN TYPE62
;; ANSWER SECTION:
csync.example.org. 10 IN TYPE62 \# 12 000335240042000460000008
;; AUTHORITY SECTION:
example.org. 10 IN NS a.iana-servers.net.
example.org. 10 IN NS b.iana-servers.net.
~~~
2017-11-25 19:19:06 +11:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Serial, off, err = unpackUint32(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
Implement CSYNC (#585)
Implement the CSYNC record.
Fixes #290
Long overdue, lets add this record. Similar in vain as NSEC/NSEC3, we
need to implement len() our selves. Presentation format parsing and
tests are done as well.
This is CoreDNS running with CSYNC support, `dig` doesn't support this
at the moment, so:
~~~
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 40323
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 2, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;csync.example.org. IN TYPE62
;; ANSWER SECTION:
csync.example.org. 10 IN TYPE62 \# 12 000335240042000460000008
;; AUTHORITY SECTION:
example.org. 10 IN NS a.iana-servers.net.
example.org. 10 IN NS b.iana-servers.net.
~~~
2017-11-25 19:19:06 +11:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
Implement CSYNC (#585)
Implement the CSYNC record.
Fixes #290
Long overdue, lets add this record. Similar in vain as NSEC/NSEC3, we
need to implement len() our selves. Presentation format parsing and
tests are done as well.
This is CoreDNS running with CSYNC support, `dig` doesn't support this
at the moment, so:
~~~
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 40323
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 2, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;csync.example.org. IN TYPE62
;; ANSWER SECTION:
csync.example.org. 10 IN TYPE62 \# 12 000335240042000460000008
;; AUTHORITY SECTION:
example.org. 10 IN NS a.iana-servers.net.
example.org. 10 IN NS b.iana-servers.net.
~~~
2017-11-25 19:19:06 +11:00
|
|
|
}
|
|
|
|
rr.Flags, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
Implement CSYNC (#585)
Implement the CSYNC record.
Fixes #290
Long overdue, lets add this record. Similar in vain as NSEC/NSEC3, we
need to implement len() our selves. Presentation format parsing and
tests are done as well.
This is CoreDNS running with CSYNC support, `dig` doesn't support this
at the moment, so:
~~~
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 40323
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 2, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;csync.example.org. IN TYPE62
;; ANSWER SECTION:
csync.example.org. 10 IN TYPE62 \# 12 000335240042000460000008
;; AUTHORITY SECTION:
example.org. 10 IN NS a.iana-servers.net.
example.org. 10 IN NS b.iana-servers.net.
~~~
2017-11-25 19:19:06 +11:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
Implement CSYNC (#585)
Implement the CSYNC record.
Fixes #290
Long overdue, lets add this record. Similar in vain as NSEC/NSEC3, we
need to implement len() our selves. Presentation format parsing and
tests are done as well.
This is CoreDNS running with CSYNC support, `dig` doesn't support this
at the moment, so:
~~~
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 40323
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 2, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;csync.example.org. IN TYPE62
;; ANSWER SECTION:
csync.example.org. 10 IN TYPE62 \# 12 000335240042000460000008
;; AUTHORITY SECTION:
example.org. 10 IN NS a.iana-servers.net.
example.org. 10 IN NS b.iana-servers.net.
~~~
2017-11-25 19:19:06 +11:00
|
|
|
}
|
|
|
|
rr.TypeBitMap, off, err = unpackDataNsec(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
Implement CSYNC (#585)
Implement the CSYNC record.
Fixes #290
Long overdue, lets add this record. Similar in vain as NSEC/NSEC3, we
need to implement len() our selves. Presentation format parsing and
tests are done as well.
This is CoreDNS running with CSYNC support, `dig` doesn't support this
at the moment, so:
~~~
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 40323
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 2, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;csync.example.org. IN TYPE62
;; ANSWER SECTION:
csync.example.org. 10 IN TYPE62 \# 12 000335240042000460000008
;; AUTHORITY SECTION:
example.org. 10 IN NS a.iana-servers.net.
example.org. 10 IN NS b.iana-servers.net.
~~~
2017-11-25 19:19:06 +11:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
Implement CSYNC (#585)
Implement the CSYNC record.
Fixes #290
Long overdue, lets add this record. Similar in vain as NSEC/NSEC3, we
need to implement len() our selves. Presentation format parsing and
tests are done as well.
This is CoreDNS running with CSYNC support, `dig` doesn't support this
at the moment, so:
~~~
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 40323
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 2, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;csync.example.org. IN TYPE62
;; ANSWER SECTION:
csync.example.org. 10 IN TYPE62 \# 12 000335240042000460000008
;; AUTHORITY SECTION:
example.org. 10 IN NS a.iana-servers.net.
example.org. 10 IN NS b.iana-servers.net.
~~~
2017-11-25 19:19:06 +11:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *DHCID) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Digest, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *DLV) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-13 01:09:37 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.KeyTag, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
rr.Algorithm, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
rr.DigestType, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
rr.Digest, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *DNAME) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Target, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *DNSKEY) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Flags, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Protocol, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Algorithm, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.PublicKey, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *DS) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.KeyTag, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Algorithm, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.DigestType, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 01:09:37 +10:00
|
|
|
rr.Digest, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *EID) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
2016-06-13 01:09:37 +10:00
|
|
|
rr.Endpoint, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *EUI48) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Address, off, err = unpackUint48(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *EUI64) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Address, off, err = unpackUint64(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *GID) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Gid, off, err = unpackUint32(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *GPOS) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Longitude, off, err = unpackString(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Latitude, off, err = unpackString(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Altitude, off, err = unpackString(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *HINFO) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Cpu, off, err = unpackString(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Os, off, err = unpackString(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *HIP) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.HitLength, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.PublicKeyAlgorithm, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.PublicKeyLength, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 03:31:50 +10:00
|
|
|
rr.Hit, off, err = unpackStringHex(msg, off, off+int(rr.HitLength))
|
2016-06-13 01:09:37 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2016-06-13 03:31:50 +10:00
|
|
|
rr.PublicKey, off, err = unpackStringBase64(msg, off, off+int(rr.PublicKeyLength))
|
2016-06-05 16:53:12 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 01:09:37 +10:00
|
|
|
rr.RendezvousServers, off, err = unpackDataDomainNames(msg, off, rdStart+int(rr.Hdr.Rdlength))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
Implement SVCB (#1067)
* Implement SVCB
* Fix serialization and deserialization of double quotes
* More effort (?)
4 months old commit
* DEBUG
* _
* Presentation format serialization/deserialization
* _
Remove generated
* Progress on presentation format parse & write
* _
* Finish parsing presentation format
* Regenerate
* Pack unpack
* Move to svcb.go
Scan_rr.go and types.go should be untouched now
* :bug:
Thanks ghedo
* Definitions
* TypeHTTPSSVC
* Generated
and isDuplicate
* Goodbye lenient functions
Now private key=value pairs have to be defined as structs too. They are no longer automatically named as KeyNNNNN
* Encode/decode
* Experimental svc
* Read method
* Implement some of the methods, use trick...
to report where the error is while reading it. This should be applied to EDNS too. Todo: Find if case can only contain e := new(SVC_ALPN) and rest moved out
Also fix two compile errors
* Add SVC_LOCAL methods, reorder, remove alpn value, bugs
* Errors
* Alpn, make it build
* Correct testsuite
* Fully implement parser
Change from keeping a state variable to reading in one iteration until the key=value pair is fully consumed
* Simplify and document
EDNS should be simplified too
* Attempt to fix fuzzer
And Alpn bug
* A bug and change type values to match @ghedo's implementation
* IP bug
Also there are two ip duplicating patterns, one with copy, one with append. Maybe change it to be consistent.
* Check for strictly increasing keys as required
* Don't panic on invalid alpn
* Redundant check, don't modify original array
* Size calculation
* Fix the fuzzer, match the style
* 65535 is reserved too, don't delay errors
* Check keyNNN, check for aliasform having values
* IPvNHint is an array
* Fix ipvNHint
* Rename everything
* Unrecognized keys according to the updated specification
* Skip zero-length structs in generators. Fix CI
* Doc cleanup
* Off by one
* Add parse tests
* Check if private key doesn't collide with known key, invalid tests
* Disallow IPv4 as IPv6. More tests.
Related #1107
* Style fixes
* More consistency, more tests
* :bug: Deep copy as in the documentation
a := make([]net.IP, 1)
a[0] = net.ParseIP("1.1.1.1").To4()
b := append(make([]net.IP, 0, 1), a...)
b[0] = net.ParseIP("3.1.1.1").To4()
fmt.Println(a[0][0])
* Make tests readable
* Move valid parse tests to different file
* :bug: One of previous commits not fully committed
* Test binary single value encoding/decoding and full encode/decode
* Add worst-case grows to builders, :bug: Wrong visible character range, redundant tests
* Testing improvements
And don't convert to IPv4 twice
* Doc update only
* Document worst case allocations
and ipv6 can be at most of length 39, not 40
* Redundant IP copy, consistent IPv6 behavior, fix deep copy
* isDuplicate for SVCB
* Optimizations
* echoconfig
* Svc => SVCB
* Fix CI
* Regenerate after REBASE (2)
Rebased twice on 15th and 20th May
* Rename svc, use escapeByte.
* Fix parsing whitespaces between quotes, rename ECHOHOConfig
* resolve
Remove svcbFieldLen
Use reverseInt
Uppercase SVCB
Rename key_value
"invalid" => bad
Alpn comments
> 65535 check
Unneeded slices
* a little more
read => parse
IP array meaning
Force pushed because forgot to change read in svcb_test.go
* HTTPSSVC -> HTTPS
* Use new values
* mandatory code
https://github.com/MikeBishop/dns-alt-svc/pull/205
* Resolve comments
Rename svcb-pairs
Remove SVCB_PRIVATE ranges
Comment on SVCB_KEY65535
ParseError return l.token
rename svcbKeyToString and svcbStringToKey
privatize SVCBKeyToString, SVCBStringToKey
* Refactor 1
Rename sorted, originalPairs
Use append instead of copy
Use svcb_RESERVED instead of 65535, with it now being private
"type SVCBKey uint16"
* Refactor 2
svcbKeyToString as method
svcbStringToKey updated after key 0
:bug: mandatory has missing key
Rename str
idx < 0
* Refactor 3
Use l.token as z
var key, value string
Comment wrap
0:
Sentences with '.'
keyValue => kv
* Refactor 4
* Refactor 5
len() int
* Refactor 6
* Refactor 7
* Test remove parsing
* Error messages
* Rewrite two estimate comments
* parse shouldn't modify original array :bug:
* Remove two unneeded comments
* Address review comments
Push 2 because can't build fuzzer python
Push 3 to try again
* Simplify argument duplication as per tmthrgd's suggestion
And add the relevant test
Force push edit: Make sorting code fit into one line
* Rewrite ECHConfig and address the review
* Remove the optional tab
* Add To4() Check
* More cleanup and fix mandatory not sorting bug
2020-10-11 18:09:36 +11:00
|
|
|
func (rr *HTTPS) unpack(msg []byte, off int) (off1 int, err error) {
|
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Priority, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
if off == len(msg) {
|
|
|
|
return off, nil
|
|
|
|
}
|
|
|
|
rr.Target, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
if off == len(msg) {
|
|
|
|
return off, nil
|
|
|
|
}
|
|
|
|
rr.Value, off, err = unpackDataSVCB(msg, off)
|
|
|
|
if err != nil {
|
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
return off, nil
|
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *KEY) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-13 01:09:37 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Flags, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
rr.Protocol, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
rr.Algorithm, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
rr.PublicKey, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *KX) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Preference, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Exchanger, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *L32) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Preference, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Locator32, off, err = unpackDataA(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *L64) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Preference, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Locator64, off, err = unpackUint64(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *LOC) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Version, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Size, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.HorizPre, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.VertPre, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Latitude, off, err = unpackUint32(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Longitude, off, err = unpackUint32(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Altitude, off, err = unpackUint32(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *LP) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Preference, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Fqdn, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *MB) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Mb, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *MD) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Md, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *MF) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Mf, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *MG) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Mg, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *MINFO) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Rmail, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Email, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *MR) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Mr, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *MX) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Preference, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Mx, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *NAPTR) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Order, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Preference, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Flags, off, err = unpackString(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Service, off, err = unpackString(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Regexp, off, err = unpackString(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Replacement, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *NID) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Preference, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.NodeID, off, err = unpackUint64(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *NIMLOC) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
2016-06-13 01:09:37 +10:00
|
|
|
rr.Locator, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *NINFO) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.ZSData, off, err = unpackStringTxt(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *NS) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Ns, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *NSAPPTR) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Ptr, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *NSEC) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.NextDomain, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 01:09:37 +10:00
|
|
|
rr.TypeBitMap, off, err = unpackDataNsec(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *NSEC3) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Hash, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Flags, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Iterations, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.SaltLength, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 03:31:50 +10:00
|
|
|
rr.Salt, off, err = unpackStringHex(msg, off, off+int(rr.SaltLength))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.HashLength, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 03:31:50 +10:00
|
|
|
rr.NextDomain, off, err = unpackStringBase32(msg, off, off+int(rr.HashLength))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 01:09:37 +10:00
|
|
|
rr.TypeBitMap, off, err = unpackDataNsec(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *NSEC3PARAM) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Hash, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Flags, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Iterations, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.SaltLength, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-07-26 13:20:27 +10:00
|
|
|
rr.Salt, off, err = unpackStringHex(msg, off, off+int(rr.SaltLength))
|
2016-06-13 01:09:37 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *NULL) unpack(msg []byte, off int) (off1 int, err error) {
|
2018-12-30 20:45:18 +11:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
2019-01-03 21:33:38 +11:00
|
|
|
rr.Data, off, err = unpackStringAny(msg, off, rdStart+int(rr.Hdr.Rdlength))
|
2018-12-30 20:45:18 +11:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2018-12-30 20:45:18 +11:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2018-12-30 20:45:18 +11:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *OPENPGPKEY) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.PublicKey, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *OPT) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
2016-06-13 01:09:37 +10:00
|
|
|
rr.Option, off, err = unpackDataOpt(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *PTR) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Ptr, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *PX) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Preference, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Map822, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Mapx400, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *RFC3597) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
2016-06-13 01:09:37 +10:00
|
|
|
rr.Rdata, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *RKEY) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Flags, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Protocol, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Algorithm, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.PublicKey, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *RP) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Mbox, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Txt, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *RRSIG) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.TypeCovered, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Algorithm, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Labels, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.OrigTtl, off, err = unpackUint32(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Expiration, off, err = unpackUint32(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Inception, off, err = unpackUint32(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.KeyTag, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.SignerName, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Signature, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *RT) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Preference, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Host, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *SIG) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-13 01:09:37 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.TypeCovered, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
rr.Algorithm, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
rr.Labels, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
rr.OrigTtl, off, err = unpackUint32(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
rr.Expiration, off, err = unpackUint32(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
rr.Inception, off, err = unpackUint32(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
rr.KeyTag, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
rr.SignerName, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
rr.Signature, off, err = unpackStringBase64(msg, off, rdStart+int(rr.Hdr.Rdlength))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *SMIMEA) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-10-18 04:09:52 +11:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Usage, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-10-18 04:09:52 +11:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-10-18 04:09:52 +11:00
|
|
|
}
|
|
|
|
rr.Selector, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-10-18 04:09:52 +11:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-10-18 04:09:52 +11:00
|
|
|
}
|
|
|
|
rr.MatchingType, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-10-18 04:09:52 +11:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-10-18 04:09:52 +11:00
|
|
|
}
|
|
|
|
rr.Certificate, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-10-18 04:09:52 +11:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-10-18 04:09:52 +11:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *SOA) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Ns, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Mbox, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Serial, off, err = unpackUint32(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Refresh, off, err = unpackUint32(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Retry, off, err = unpackUint32(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Expire, off, err = unpackUint32(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Minttl, off, err = unpackUint32(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *SPF) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-05-15 02:56:20 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.Txt, off, err = unpackStringTxt(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *SRV) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-05-15 02:56:20 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.Priority, off, err = unpackUint16(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.Weight, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Port, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
rr.Target, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *SSHFP) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-05-15 02:56:20 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.Algorithm, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Type, off, err = unpackUint8(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 01:09:37 +10:00
|
|
|
rr.FingerPrint, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
Implement SVCB (#1067)
* Implement SVCB
* Fix serialization and deserialization of double quotes
* More effort (?)
4 months old commit
* DEBUG
* _
* Presentation format serialization/deserialization
* _
Remove generated
* Progress on presentation format parse & write
* _
* Finish parsing presentation format
* Regenerate
* Pack unpack
* Move to svcb.go
Scan_rr.go and types.go should be untouched now
* :bug:
Thanks ghedo
* Definitions
* TypeHTTPSSVC
* Generated
and isDuplicate
* Goodbye lenient functions
Now private key=value pairs have to be defined as structs too. They are no longer automatically named as KeyNNNNN
* Encode/decode
* Experimental svc
* Read method
* Implement some of the methods, use trick...
to report where the error is while reading it. This should be applied to EDNS too. Todo: Find if case can only contain e := new(SVC_ALPN) and rest moved out
Also fix two compile errors
* Add SVC_LOCAL methods, reorder, remove alpn value, bugs
* Errors
* Alpn, make it build
* Correct testsuite
* Fully implement parser
Change from keeping a state variable to reading in one iteration until the key=value pair is fully consumed
* Simplify and document
EDNS should be simplified too
* Attempt to fix fuzzer
And Alpn bug
* A bug and change type values to match @ghedo's implementation
* IP bug
Also there are two ip duplicating patterns, one with copy, one with append. Maybe change it to be consistent.
* Check for strictly increasing keys as required
* Don't panic on invalid alpn
* Redundant check, don't modify original array
* Size calculation
* Fix the fuzzer, match the style
* 65535 is reserved too, don't delay errors
* Check keyNNN, check for aliasform having values
* IPvNHint is an array
* Fix ipvNHint
* Rename everything
* Unrecognized keys according to the updated specification
* Skip zero-length structs in generators. Fix CI
* Doc cleanup
* Off by one
* Add parse tests
* Check if private key doesn't collide with known key, invalid tests
* Disallow IPv4 as IPv6. More tests.
Related #1107
* Style fixes
* More consistency, more tests
* :bug: Deep copy as in the documentation
a := make([]net.IP, 1)
a[0] = net.ParseIP("1.1.1.1").To4()
b := append(make([]net.IP, 0, 1), a...)
b[0] = net.ParseIP("3.1.1.1").To4()
fmt.Println(a[0][0])
* Make tests readable
* Move valid parse tests to different file
* :bug: One of previous commits not fully committed
* Test binary single value encoding/decoding and full encode/decode
* Add worst-case grows to builders, :bug: Wrong visible character range, redundant tests
* Testing improvements
And don't convert to IPv4 twice
* Doc update only
* Document worst case allocations
and ipv6 can be at most of length 39, not 40
* Redundant IP copy, consistent IPv6 behavior, fix deep copy
* isDuplicate for SVCB
* Optimizations
* echoconfig
* Svc => SVCB
* Fix CI
* Regenerate after REBASE (2)
Rebased twice on 15th and 20th May
* Rename svc, use escapeByte.
* Fix parsing whitespaces between quotes, rename ECHOHOConfig
* resolve
Remove svcbFieldLen
Use reverseInt
Uppercase SVCB
Rename key_value
"invalid" => bad
Alpn comments
> 65535 check
Unneeded slices
* a little more
read => parse
IP array meaning
Force pushed because forgot to change read in svcb_test.go
* HTTPSSVC -> HTTPS
* Use new values
* mandatory code
https://github.com/MikeBishop/dns-alt-svc/pull/205
* Resolve comments
Rename svcb-pairs
Remove SVCB_PRIVATE ranges
Comment on SVCB_KEY65535
ParseError return l.token
rename svcbKeyToString and svcbStringToKey
privatize SVCBKeyToString, SVCBStringToKey
* Refactor 1
Rename sorted, originalPairs
Use append instead of copy
Use svcb_RESERVED instead of 65535, with it now being private
"type SVCBKey uint16"
* Refactor 2
svcbKeyToString as method
svcbStringToKey updated after key 0
:bug: mandatory has missing key
Rename str
idx < 0
* Refactor 3
Use l.token as z
var key, value string
Comment wrap
0:
Sentences with '.'
keyValue => kv
* Refactor 4
* Refactor 5
len() int
* Refactor 6
* Refactor 7
* Test remove parsing
* Error messages
* Rewrite two estimate comments
* parse shouldn't modify original array :bug:
* Remove two unneeded comments
* Address review comments
Push 2 because can't build fuzzer python
Push 3 to try again
* Simplify argument duplication as per tmthrgd's suggestion
And add the relevant test
Force push edit: Make sorting code fit into one line
* Rewrite ECHConfig and address the review
* Remove the optional tab
* Add To4() Check
* More cleanup and fix mandatory not sorting bug
2020-10-11 18:09:36 +11:00
|
|
|
func (rr *SVCB) unpack(msg []byte, off int) (off1 int, err error) {
|
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Priority, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
if off == len(msg) {
|
|
|
|
return off, nil
|
|
|
|
}
|
|
|
|
rr.Target, off, err = UnpackDomainName(msg, off)
|
|
|
|
if err != nil {
|
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
if off == len(msg) {
|
|
|
|
return off, nil
|
|
|
|
}
|
|
|
|
rr.Value, off, err = unpackDataSVCB(msg, off)
|
|
|
|
if err != nil {
|
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
return off, nil
|
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *TA) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-05-15 02:56:20 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.KeyTag, off, err = unpackUint16(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.Algorithm, off, err = unpackUint8(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.DigestType, off, err = unpackUint8(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-13 01:09:37 +10:00
|
|
|
rr.Digest, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *TALINK) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-05-15 02:56:20 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.PreviousName, off, err = UnpackDomainName(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.NextName, off, err = UnpackDomainName(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *TKEY) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-05-15 02:56:20 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.Algorithm, off, err = UnpackDomainName(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.Inception, off, err = unpackUint32(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.Expiration, off, err = unpackUint32(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.Mode, off, err = unpackUint16(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.Error, off, err = unpackUint16(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.KeySize, off, err = unpackUint16(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2017-11-28 18:48:02 +11:00
|
|
|
rr.Key, off, err = unpackStringHex(msg, off, off+int(rr.KeySize))
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.OtherLen, off, err = unpackUint16(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2017-11-28 18:48:02 +11:00
|
|
|
rr.OtherData, off, err = unpackStringHex(msg, off, off+int(rr.OtherLen))
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *TLSA) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-05-15 02:56:20 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.Usage, off, err = unpackUint8(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.Selector, off, err = unpackUint8(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.MatchingType, off, err = unpackUint8(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 01:09:37 +10:00
|
|
|
rr.Certificate, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *TSIG) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-05-15 02:56:20 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.Algorithm, off, err = UnpackDomainName(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.TimeSigned, off, err = unpackUint48(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.Fudge, off, err = unpackUint16(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.MACSize, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 03:31:50 +10:00
|
|
|
rr.MAC, off, err = unpackStringHex(msg, off, off+int(rr.MACSize))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.OrigId, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.Error, off, err = unpackUint16(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
|
|
|
rr.OtherLen, off, err = unpackUint16(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 03:31:50 +10:00
|
|
|
rr.OtherData, off, err = unpackStringHex(msg, off, off+int(rr.OtherLen))
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 03:31:50 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *TXT) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-05-15 02:56:20 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.Txt, off, err = unpackStringTxt(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *UID) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-05-15 02:56:20 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.Uid, off, err = unpackUint32(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *UINFO) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-05-15 02:56:20 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.Uinfo, off, err = unpackString(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *URI) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-05-15 02:56:20 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.Priority, off, err = unpackUint16(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
rr.Weight, off, err = unpackUint16(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
2016-06-05 16:53:12 +10:00
|
|
|
if off == len(msg) {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-06-05 16:53:12 +10:00
|
|
|
}
|
2016-06-13 01:09:37 +10:00
|
|
|
rr.Target, off, err = unpackStringOctet(msg, off)
|
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, nil
|
2016-05-15 02:56:20 +10:00
|
|
|
}
|
|
|
|
|
2019-01-04 03:35:32 +11:00
|
|
|
func (rr *X25) unpack(msg []byte, off int) (off1 int, err error) {
|
2016-06-05 16:53:12 +10:00
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.PSDNAddress, off, err = unpackString(msg, off)
|
2016-05-15 02:56:20 +10:00
|
|
|
if err != nil {
|
2019-01-04 03:35:32 +11:00
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
return off, nil
|
2016-06-13 01:09:37 +10:00
|
|
|
}
|
2021-02-27 02:35:05 +11:00
|
|
|
|
|
|
|
func (rr *ZONEMD) unpack(msg []byte, off int) (off1 int, err error) {
|
|
|
|
rdStart := off
|
|
|
|
_ = rdStart
|
|
|
|
|
|
|
|
rr.Serial, off, err = unpackUint32(msg, off)
|
|
|
|
if err != nil {
|
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
if off == len(msg) {
|
|
|
|
return off, nil
|
|
|
|
}
|
|
|
|
rr.Scheme, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
if off == len(msg) {
|
|
|
|
return off, nil
|
|
|
|
}
|
|
|
|
rr.Hash, off, err = unpackUint8(msg, off)
|
|
|
|
if err != nil {
|
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
if off == len(msg) {
|
|
|
|
return off, nil
|
|
|
|
}
|
|
|
|
rr.Digest, off, err = unpackStringHex(msg, off, rdStart+int(rr.Hdr.Rdlength))
|
|
|
|
if err != nil {
|
|
|
|
return off, err
|
|
|
|
}
|
|
|
|
return off, nil
|
|
|
|
}
|