Lines Matching refs:msg
18 func unpackDataA(msg []byte, off int) (net.IP, int, error) {
19 if off+net.IPv4len > len(msg) {
20 return nil, len(msg), &Error{err: "overflow unpacking a"}
22 a := append(make(net.IP, 0, net.IPv4len), msg[off:off+net.IPv4len]...)
27 func packDataA(a net.IP, msg []byte, off int) (int, error) {
29 if off+net.IPv4len > len(msg) {
30 return len(msg), &Error{err: "overflow packing a"}
34 copy(msg[off:], a.To4())
39 return len(msg), &Error{err: "overflow packing a"}
44 func unpackDataAAAA(msg []byte, off int) (net.IP, int, error) {
45 if off+net.IPv6len > len(msg) {
46 return nil, len(msg), &Error{err: "overflow unpacking aaaa"}
48 aaaa := append(make(net.IP, 0, net.IPv6len), msg[off:off+net.IPv6len]...)
53 func packDataAAAA(aaaa net.IP, msg []byte, off int) (int, error) {
54 if off+net.IPv6len > len(msg) {
55 return len(msg), &Error{err: "overflow packing aaaa"}
60 copy(msg[off:], aaaa)
65 return len(msg), &Error{err: "overflow packing aaaa"}
72 func unpackHeader(msg []byte, off int) (rr RR_Header, off1 int, truncmsg []byte, err error) {
74 if off == len(msg) {
75 return hdr, off, msg, nil
78 hdr.Name, off, err = UnpackDomainName(msg, off)
80 return hdr, len(msg), msg, err
82 hdr.Rrtype, off, err = unpackUint16(msg, off)
84 return hdr, len(msg), msg, err
86 hdr.Class, off, err = unpackUint16(msg, off)
88 return hdr, len(msg), msg, err
90 hdr.Ttl, off, err = unpackUint32(msg, off)
92 return hdr, len(msg), msg, err
94 hdr.Rdlength, off, err = unpackUint16(msg, off)
96 return hdr, len(msg), msg, err
98 msg, err = truncateMsgFromRdlength(msg, off, hdr.Rdlength)
99 return hdr, off, msg, nil
104 func (hdr RR_Header) pack(msg []byte, off int, compression map[string]int, compress bool) (off1 int…
105 if off == len(msg) {
109 off, err = PackDomainName(hdr.Name, msg, off, compression, compress)
111 return len(msg), err
113 off, err = packUint16(hdr.Rrtype, msg, off)
115 return len(msg), err
117 off, err = packUint16(hdr.Class, msg, off)
119 return len(msg), err
121 off, err = packUint32(hdr.Ttl, msg, off)
123 return len(msg), err
125 off, err = packUint16(hdr.Rdlength, msg, off)
127 return len(msg), err
136 func truncateMsgFromRdlength(msg []byte, off int, rdlength uint16) (truncmsg []byte, err error) {
138 if lenrd > len(msg) {
139 return msg, &Error{err: "overflowing header size"}
141 return msg[:lenrd], nil
167 func unpackUint8(msg []byte, off int) (i uint8, off1 int, err error) {
168 if off+1 > len(msg) {
169 return 0, len(msg), &Error{err: "overflow unpacking uint8"}
171 return uint8(msg[off]), off + 1, nil
174 func packUint8(i uint8, msg []byte, off int) (off1 int, err error) {
175 if off+1 > len(msg) {
176 return len(msg), &Error{err: "overflow packing uint8"}
178 msg[off] = byte(i)
182 func unpackUint16(msg []byte, off int) (i uint16, off1 int, err error) {
183 if off+2 > len(msg) {
184 return 0, len(msg), &Error{err: "overflow unpacking uint16"}
186 return binary.BigEndian.Uint16(msg[off:]), off + 2, nil
189 func packUint16(i uint16, msg []byte, off int) (off1 int, err error) {
190 if off+2 > len(msg) {
191 return len(msg), &Error{err: "overflow packing uint16"}
193 binary.BigEndian.PutUint16(msg[off:], i)
197 func unpackUint32(msg []byte, off int) (i uint32, off1 int, err error) {
198 if off+4 > len(msg) {
199 return 0, len(msg), &Error{err: "overflow unpacking uint32"}
201 return binary.BigEndian.Uint32(msg[off:]), off + 4, nil
204 func packUint32(i uint32, msg []byte, off int) (off1 int, err error) {
205 if off+4 > len(msg) {
206 return len(msg), &Error{err: "overflow packing uint32"}
208 binary.BigEndian.PutUint32(msg[off:], i)
212 func unpackUint48(msg []byte, off int) (i uint64, off1 int, err error) {
213 if off+6 > len(msg) {
214 return 0, len(msg), &Error{err: "overflow unpacking uint64 as uint48"}
217 …i = (uint64(uint64(msg[off])<<40 | uint64(msg[off+1])<<32 | uint64(msg[off+2])<<24 | uint64(msg[of…
218 uint64(msg[off+4])<<8 | uint64(msg[off+5])))
223 func packUint48(i uint64, msg []byte, off int) (off1 int, err error) {
224 if off+6 > len(msg) {
225 return len(msg), &Error{err: "overflow packing uint64 as uint48"}
227 msg[off] = byte(i >> 40)
228 msg[off+1] = byte(i >> 32)
229 msg[off+2] = byte(i >> 24)
230 msg[off+3] = byte(i >> 16)
231 msg[off+4] = byte(i >> 8)
232 msg[off+5] = byte(i)
237 func unpackUint64(msg []byte, off int) (i uint64, off1 int, err error) {
238 if off+8 > len(msg) {
239 return 0, len(msg), &Error{err: "overflow unpacking uint64"}
241 return binary.BigEndian.Uint64(msg[off:]), off + 8, nil
244 func packUint64(i uint64, msg []byte, off int) (off1 int, err error) {
245 if off+8 > len(msg) {
246 return len(msg), &Error{err: "overflow packing uint64"}
248 binary.BigEndian.PutUint64(msg[off:], i)
253 func unpackString(msg []byte, off int) (string, int, error) {
254 if off+1 > len(msg) {
257 l := int(msg[off])
258 if off+l+1 > len(msg) {
262 for _, b := range msg[off+1 : off+1+l] {
288 func packString(s string, msg []byte, off int) (int, error) {
290 off, err := packTxtString(s, msg, off, txtTmp)
292 return len(msg), err
297 func unpackStringBase32(msg []byte, off, end int) (string, int, error) {
298 if end > len(msg) {
299 return "", len(msg), &Error{err: "overflow unpacking base32"}
301 s := toBase32(msg[off:end])
305 func packStringBase32(s string, msg []byte, off int) (int, error) {
308 return len(msg), err
310 if off+len(b32) > len(msg) {
311 return len(msg), &Error{err: "overflow packing base32"}
313 copy(msg[off:off+len(b32)], b32)
318 func unpackStringBase64(msg []byte, off, end int) (string, int, error) {
322 if end > len(msg) {
323 return "", len(msg), &Error{err: "overflow unpacking base64"}
325 s := toBase64(msg[off:end])
329 func packStringBase64(s string, msg []byte, off int) (int, error) {
332 return len(msg), err
334 if off+len(b64) > len(msg) {
335 return len(msg), &Error{err: "overflow packing base64"}
337 copy(msg[off:off+len(b64)], b64)
342 func unpackStringHex(msg []byte, off, end int) (string, int, error) {
346 if end > len(msg) {
347 return "", len(msg), &Error{err: "overflow unpacking hex"}
350 s := hex.EncodeToString(msg[off:end])
354 func packStringHex(s string, msg []byte, off int) (int, error) {
357 return len(msg), err
359 if off+(len(h)) > len(msg) {
360 return len(msg), &Error{err: "overflow packing hex"}
362 copy(msg[off:off+len(h)], h)
367 func unpackStringTxt(msg []byte, off int) ([]string, int, error) {
368 txt, off, err := unpackTxt(msg, off)
370 return nil, len(msg), err
375 func packStringTxt(s []string, msg []byte, off int) (int, error) {
377 off, err := packTxt(s, msg, off, txtTmp)
379 return len(msg), err
384 func unpackDataOpt(msg []byte, off int) ([]EDNS0, int, error) {
388 if off+4 > len(msg) {
389 return nil, len(msg), &Error{err: "overflow unpacking opt"}
391 code = binary.BigEndian.Uint16(msg[off:])
393 optlen := binary.BigEndian.Uint16(msg[off:])
395 if off+int(optlen) > len(msg) {
396 return nil, len(msg), &Error{err: "overflow unpacking opt"}
401 if err := e.unpack(msg[off : off+int(optlen)]); err != nil {
402 return nil, len(msg), err
408 if err := e.unpack(msg[off : off+int(optlen)]); err != nil {
409 return nil, len(msg), err
418 if err := e.unpack(msg[off : off+int(optlen)]); err != nil {
419 return nil, len(msg), err
425 if err := e.unpack(msg[off : off+int(optlen)]); err != nil {
426 return nil, len(msg), err
432 if err := e.unpack(msg[off : off+int(optlen)]); err != nil {
433 return nil, len(msg), err
439 if err := e.unpack(msg[off : off+int(optlen)]); err != nil {
440 return nil, len(msg), err
446 if err := e.unpack(msg[off : off+int(optlen)]); err != nil {
447 return nil, len(msg), err
453 if err := e.unpack(msg[off : off+int(optlen)]); err != nil {
454 return nil, len(msg), err
461 if err := e.unpack(msg[off : off+int(optlen)]); err != nil {
462 return nil, len(msg), err
468 if off < len(msg) {
475 func packDataOpt(options []EDNS0, msg []byte, off int) (int, error) {
478 if err != nil || off+3 > len(msg) {
479 return len(msg), &Error{err: "overflow packing opt"}
481 binary.BigEndian.PutUint16(msg[off:], el.Option()) // Option code
482 binary.BigEndian.PutUint16(msg[off+2:], uint16(len(b))) // Length
484 if off+len(b) > len(msg) {
485 copy(msg[off:], b)
486 off = len(msg)
490 copy(msg[off:off+len(b)], b)
496 func unpackStringOctet(msg []byte, off int) (string, int, error) {
497 s := string(msg[off:])
498 return s, len(msg), nil
501 func packStringOctet(s string, msg []byte, off int) (int, error) {
503 off, err := packOctetString(s, msg, off, txtTmp)
505 return len(msg), err
510 func unpackDataNsec(msg []byte, off int) ([]uint16, int, error) {
513 for off < len(msg) {
514 if off+2 > len(msg) {
515 return nsec, len(msg), &Error{err: "overflow unpacking nsecx"}
517 window = int(msg[off])
518 length = int(msg[off+1])
523 return nsec, len(msg), &Error{err: "out of order NSEC block"}
527 return nsec, len(msg), &Error{err: "empty NSEC block"}
530 return nsec, len(msg), &Error{err: "NSEC block too long"}
532 if off+length > len(msg) {
533 return nsec, len(msg), &Error{err: "overflowing NSEC block"}
538 b := msg[off+j]
571 func packDataNsec(bitmap []uint16, msg []byte, off int) (int, error) {
585 return len(msg), &Error{err: "nsec bits out of order"}
587 if off+2+int(length) > len(msg) {
588 return len(msg), &Error{err: "overflow packing nsec"}
591 msg[off] = byte(window)
593 msg[off+1] = byte(length)
595 msg[off+1+int(length)] |= byte(1 << (7 - (t % 8)))
602 func unpackDataDomainNames(msg []byte, off, end int) ([]string, int, error) {
608 if end > len(msg) {
609 return nil, len(msg), &Error{err: "overflow unpacking domain names"}
612 s, off, err = UnpackDomainName(msg, off)
614 return servers, len(msg), err
621 func packDataDomainNames(names []string, msg []byte, off int, compression map[string]int, compress …
624 off, err = PackDomainName(names[j], msg, off, compression, false && compress)
626 return len(msg), err