...
1
2
3
4
5 package gob
6
7 import (
8 "bufio"
9 "errors"
10 "io"
11 "reflect"
12 "sync"
13 )
14
15
16
17
18 const tooBig = (1 << 30) << (^uint(0) >> 62)
19
20
21
22
23
24
25
26
27 type Decoder struct {
28 mutex sync.Mutex
29 r io.Reader
30 buf decBuffer
31 wireType map[typeId]*wireType
32 decoderCache map[reflect.Type]map[typeId]**decEngine
33 ignorerCache map[typeId]**decEngine
34 freeList *decoderState
35 countBuf []byte
36 err error
37 }
38
39
40
41
42 func NewDecoder(r io.Reader) *Decoder {
43 dec := new(Decoder)
44
45 if _, ok := r.(io.ByteReader); !ok {
46 r = bufio.NewReader(r)
47 }
48 dec.r = r
49 dec.wireType = make(map[typeId]*wireType)
50 dec.decoderCache = make(map[reflect.Type]map[typeId]**decEngine)
51 dec.ignorerCache = make(map[typeId]**decEngine)
52 dec.countBuf = make([]byte, 9)
53
54 return dec
55 }
56
57
58 func (dec *Decoder) recvType(id typeId) {
59
60 if id < firstUserId || dec.wireType[id] != nil {
61 dec.err = errors.New("gob: duplicate type received")
62 return
63 }
64
65
66 wire := new(wireType)
67 dec.decodeValue(tWireType, reflect.ValueOf(wire))
68 if dec.err != nil {
69 return
70 }
71
72 dec.wireType[id] = wire
73 }
74
75 var errBadCount = errors.New("invalid message length")
76
77
78
79 func (dec *Decoder) recvMessage() bool {
80
81 nbytes, _, err := decodeUintReader(dec.r, dec.countBuf)
82 if err != nil {
83 dec.err = err
84 return false
85 }
86 if nbytes >= tooBig {
87 dec.err = errBadCount
88 return false
89 }
90 dec.readMessage(int(nbytes))
91 return dec.err == nil
92 }
93
94
95 func (dec *Decoder) readMessage(nbytes int) {
96 if dec.buf.Len() != 0 {
97
98 panic("non-empty decoder buffer")
99 }
100
101 dec.buf.Size(nbytes)
102 _, dec.err = io.ReadFull(dec.r, dec.buf.Bytes())
103 if dec.err == io.EOF {
104 dec.err = io.ErrUnexpectedEOF
105 }
106 }
107
108
109 func toInt(x uint64) int64 {
110 i := int64(x >> 1)
111 if x&1 != 0 {
112 i = ^i
113 }
114 return i
115 }
116
117 func (dec *Decoder) nextInt() int64 {
118 n, _, err := decodeUintReader(&dec.buf, dec.countBuf)
119 if err != nil {
120 dec.err = err
121 }
122 return toInt(n)
123 }
124
125 func (dec *Decoder) nextUint() uint64 {
126 n, _, err := decodeUintReader(&dec.buf, dec.countBuf)
127 if err != nil {
128 dec.err = err
129 }
130 return n
131 }
132
133
134
135
136
137
138
139
140
141
142 func (dec *Decoder) decodeTypeSequence(isInterface bool) typeId {
143 firstMessage := true
144 for dec.err == nil {
145 if dec.buf.Len() == 0 {
146 if !dec.recvMessage() {
147
148
149
150
151 if !firstMessage && dec.err == io.EOF {
152 dec.err = io.ErrUnexpectedEOF
153 }
154 break
155 }
156 }
157
158 id := typeId(dec.nextInt())
159 if id >= 0 {
160
161 return id
162 }
163
164 dec.recvType(-id)
165 if dec.err != nil {
166 break
167 }
168
169
170
171
172 if dec.buf.Len() > 0 {
173 if !isInterface {
174 dec.err = errors.New("extra data in buffer")
175 break
176 }
177 dec.nextUint()
178 }
179 firstMessage = false
180 }
181 return -1
182 }
183
184
185
186
187
188
189
190
191 func (dec *Decoder) Decode(e any) error {
192 if e == nil {
193 return dec.DecodeValue(reflect.Value{})
194 }
195 value := reflect.ValueOf(e)
196
197
198 if value.Type().Kind() != reflect.Pointer {
199 dec.err = errors.New("gob: attempt to decode into a non-pointer")
200 return dec.err
201 }
202 return dec.DecodeValue(value)
203 }
204
205
206
207
208
209
210
211 func (dec *Decoder) DecodeValue(v reflect.Value) error {
212 if v.IsValid() {
213 if v.Kind() == reflect.Pointer && !v.IsNil() {
214
215 } else if !v.CanSet() {
216 return errors.New("gob: DecodeValue of unassignable value")
217 }
218 }
219
220 dec.mutex.Lock()
221 defer dec.mutex.Unlock()
222
223 dec.buf.Reset()
224 dec.err = nil
225 id := dec.decodeTypeSequence(false)
226 if dec.err == nil {
227 dec.decodeValue(id, v)
228 }
229 return dec.err
230 }
231
232
233
234
235 var debugFunc func(io.Reader)
236
View as plain text