1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
package dns
import "fmt"
type unpacker struct {
buf []byte
off int
}
func (u *unpacker) readUint16() (uint16, error) {
if u.off+2 > len(u.buf) {
return 0, fmt.Errorf("dns: short uint16 at %d", u.off)
}
v := uint16(u.buf[u.off])<<8 | uint16(u.buf[u.off+1])
u.off += 2
return v, nil
}
func (u *unpacker) readUint32() (uint32, error) {
if u.off+4 > len(u.buf) {
return 0, fmt.Errorf("dns: short uint32 at %d", u.off)
}
v := uint32(u.buf[u.off])<<24 | uint32(u.buf[u.off+1])<<16 |
uint32(u.buf[u.off+2])<<8 | uint32(u.buf[u.off+3])
u.off += 4
return v, nil
}
func (u *unpacker) readName() (Name, error) {
var name Name
start := u.off
jumped := false
jumps := 0
for {
if u.off >= len(u.buf) {
return Name{}, fmt.Errorf("dns: name overflow")
}
c := u.buf[u.off]
// Compression pointer
if c&0xC0 == 0xC0 {
if u.off+2 > len(u.buf) {
return Name{}, fmt.Errorf("dns: short pointer")
}
ptr := int(uint16(c&0x3F)<<8 | uint16(u.buf[u.off+1]))
if ptr >= len(u.buf) {
return Name{}, fmt.Errorf("dns: pointer out of range")
}
if !jumped {
start = u.off + 2
}
u.off = ptr
jumped = true
jumps++
if jumps > 10 {
return Name{}, fmt.Errorf("dns: too many compression jumps")
}
continue
}
// Reserved label type (0x40, 0x80)
if c&0xC0 != 0 {
return Name{}, fmt.Errorf("dns: reserved label type")
}
// Root label
if c == 0 {
name.Data = append(name.Data, 0)
u.off++
break
}
// Normal label
length := int(c)
if length > 63 {
return Name{}, fmt.Errorf("dns: label too long")
}
if u.off+1+length > len(u.buf) {
return Name{}, fmt.Errorf("dns: short label")
}
name.Data = append(name.Data, u.buf[u.off:u.off+1+length]...)
u.off += 1 + length
}
if jumped {
u.off = start
}
return name, nil
}
func Unpack(buf []byte) (*Msg, error) {
if len(buf) < 12 {
return nil, fmt.Errorf("dns: message too short")
}
u := &unpacker{buf: buf}
m := &Msg{}
m.Header.ID, _ = u.readUint16()
m.Header.Flags, _ = u.readUint16()
qdcount, _ := u.readUint16()
ancount, _ := u.readUint16()
nscount, _ := u.readUint16()
arcount, _ := u.readUint16()
m.Question = make([]Question, qdcount)
for i := range m.Question {
if err := m.Question[i].unpack(u); err != nil {
return nil, err
}
}
m.Answer = make([]RR, ancount)
for i := range m.Answer {
rr, err := unpackRR(u)
if err != nil {
return nil, err
}
m.Answer[i] = rr
}
m.Ns = make([]RR, nscount)
for i := range m.Ns {
rr, err := unpackRR(u)
if err != nil {
return nil, err
}
m.Ns[i] = rr
}
m.Extra = make([]RR, arcount)
for i := range m.Extra {
rr, err := unpackRR(u)
if err != nil {
return nil, err
}
m.Extra[i] = rr
}
return m, nil
}
|
