]>
Commit | Line | Data |
---|---|---|
107c1cdb ND |
1 | package msgpack |
2 | ||
3 | import ( | |
4 | "bufio" | |
5 | "bytes" | |
6 | "errors" | |
7 | "fmt" | |
8 | "io" | |
9 | "reflect" | |
10 | "time" | |
11 | ||
12 | "github.com/vmihailenco/msgpack/codes" | |
13 | ) | |
14 | ||
15 | const bytesAllocLimit = 1024 * 1024 // 1mb | |
16 | ||
17 | type bufReader interface { | |
18 | io.Reader | |
19 | io.ByteScanner | |
20 | } | |
21 | ||
22 | func newBufReader(r io.Reader) bufReader { | |
23 | if br, ok := r.(bufReader); ok { | |
24 | return br | |
25 | } | |
26 | return bufio.NewReader(r) | |
27 | } | |
28 | ||
29 | func makeBuffer() []byte { | |
30 | return make([]byte, 0, 64) | |
31 | } | |
32 | ||
33 | // Unmarshal decodes the MessagePack-encoded data and stores the result | |
34 | // in the value pointed to by v. | |
35 | func Unmarshal(data []byte, v interface{}) error { | |
36 | return NewDecoder(bytes.NewReader(data)).Decode(v) | |
37 | } | |
38 | ||
39 | type Decoder struct { | |
40 | r io.Reader | |
41 | s io.ByteScanner | |
42 | buf []byte | |
43 | ||
44 | extLen int | |
45 | rec []byte // accumulates read data if not nil | |
46 | ||
47 | useLoose bool | |
48 | useJSONTag bool | |
49 | ||
50 | decodeMapFunc func(*Decoder) (interface{}, error) | |
51 | } | |
52 | ||
53 | // NewDecoder returns a new decoder that reads from r. | |
54 | // | |
55 | // The decoder introduces its own buffering and may read data from r | |
56 | // beyond the MessagePack values requested. Buffering can be disabled | |
57 | // by passing a reader that implements io.ByteScanner interface. | |
58 | func NewDecoder(r io.Reader) *Decoder { | |
59 | d := &Decoder{ | |
60 | buf: makeBuffer(), | |
61 | } | |
62 | d.resetReader(r) | |
63 | return d | |
64 | } | |
65 | ||
66 | func (d *Decoder) SetDecodeMapFunc(fn func(*Decoder) (interface{}, error)) { | |
67 | d.decodeMapFunc = fn | |
68 | } | |
69 | ||
70 | // UseDecodeInterfaceLoose causes decoder to use DecodeInterfaceLoose | |
71 | // to decode msgpack value into Go interface{}. | |
72 | func (d *Decoder) UseDecodeInterfaceLoose(flag bool) { | |
73 | d.useLoose = flag | |
74 | } | |
75 | ||
76 | // UseJSONTag causes the Decoder to use json struct tag as fallback option | |
77 | // if there is no msgpack tag. | |
78 | func (d *Decoder) UseJSONTag(v bool) *Decoder { | |
79 | d.useJSONTag = v | |
80 | return d | |
81 | } | |
82 | ||
83 | func (d *Decoder) Reset(r io.Reader) error { | |
84 | d.resetReader(r) | |
85 | return nil | |
86 | } | |
87 | ||
88 | func (d *Decoder) resetReader(r io.Reader) { | |
89 | reader := newBufReader(r) | |
90 | d.r = reader | |
91 | d.s = reader | |
92 | } | |
93 | ||
94 | func (d *Decoder) Decode(v interface{}) error { | |
95 | var err error | |
96 | switch v := v.(type) { | |
97 | case *string: | |
98 | if v != nil { | |
99 | *v, err = d.DecodeString() | |
100 | return err | |
101 | } | |
102 | case *[]byte: | |
103 | if v != nil { | |
104 | return d.decodeBytesPtr(v) | |
105 | } | |
106 | case *int: | |
107 | if v != nil { | |
108 | *v, err = d.DecodeInt() | |
109 | return err | |
110 | } | |
111 | case *int8: | |
112 | if v != nil { | |
113 | *v, err = d.DecodeInt8() | |
114 | return err | |
115 | } | |
116 | case *int16: | |
117 | if v != nil { | |
118 | *v, err = d.DecodeInt16() | |
119 | return err | |
120 | } | |
121 | case *int32: | |
122 | if v != nil { | |
123 | *v, err = d.DecodeInt32() | |
124 | return err | |
125 | } | |
126 | case *int64: | |
127 | if v != nil { | |
128 | *v, err = d.DecodeInt64() | |
129 | return err | |
130 | } | |
131 | case *uint: | |
132 | if v != nil { | |
133 | *v, err = d.DecodeUint() | |
134 | return err | |
135 | } | |
136 | case *uint8: | |
137 | if v != nil { | |
138 | *v, err = d.DecodeUint8() | |
139 | return err | |
140 | } | |
141 | case *uint16: | |
142 | if v != nil { | |
143 | *v, err = d.DecodeUint16() | |
144 | return err | |
145 | } | |
146 | case *uint32: | |
147 | if v != nil { | |
148 | *v, err = d.DecodeUint32() | |
149 | return err | |
150 | } | |
151 | case *uint64: | |
152 | if v != nil { | |
153 | *v, err = d.DecodeUint64() | |
154 | return err | |
155 | } | |
156 | case *bool: | |
157 | if v != nil { | |
158 | *v, err = d.DecodeBool() | |
159 | return err | |
160 | } | |
161 | case *float32: | |
162 | if v != nil { | |
163 | *v, err = d.DecodeFloat32() | |
164 | return err | |
165 | } | |
166 | case *float64: | |
167 | if v != nil { | |
168 | *v, err = d.DecodeFloat64() | |
169 | return err | |
170 | } | |
171 | case *[]string: | |
172 | return d.decodeStringSlicePtr(v) | |
173 | case *map[string]string: | |
174 | return d.decodeMapStringStringPtr(v) | |
175 | case *map[string]interface{}: | |
176 | return d.decodeMapStringInterfacePtr(v) | |
177 | case *time.Duration: | |
178 | if v != nil { | |
179 | vv, err := d.DecodeInt64() | |
180 | *v = time.Duration(vv) | |
181 | return err | |
182 | } | |
183 | case *time.Time: | |
184 | if v != nil { | |
185 | *v, err = d.DecodeTime() | |
186 | return err | |
187 | } | |
188 | } | |
189 | ||
190 | vv := reflect.ValueOf(v) | |
191 | if !vv.IsValid() { | |
192 | return errors.New("msgpack: Decode(nil)") | |
193 | } | |
194 | if vv.Kind() != reflect.Ptr { | |
195 | return fmt.Errorf("msgpack: Decode(nonsettable %T)", v) | |
196 | } | |
197 | vv = vv.Elem() | |
198 | if !vv.IsValid() { | |
199 | return fmt.Errorf("msgpack: Decode(nonsettable %T)", v) | |
200 | } | |
201 | return d.DecodeValue(vv) | |
202 | } | |
203 | ||
204 | func (d *Decoder) DecodeMulti(v ...interface{}) error { | |
205 | for _, vv := range v { | |
206 | if err := d.Decode(vv); err != nil { | |
207 | return err | |
208 | } | |
209 | } | |
210 | return nil | |
211 | } | |
212 | ||
213 | func (d *Decoder) decodeInterfaceCond() (interface{}, error) { | |
214 | if d.useLoose { | |
215 | return d.DecodeInterfaceLoose() | |
216 | } | |
217 | return d.DecodeInterface() | |
218 | } | |
219 | ||
220 | func (d *Decoder) DecodeValue(v reflect.Value) error { | |
221 | decode := getDecoder(v.Type()) | |
222 | return decode(d, v) | |
223 | } | |
224 | ||
225 | func (d *Decoder) DecodeNil() error { | |
226 | c, err := d.readCode() | |
227 | if err != nil { | |
228 | return err | |
229 | } | |
230 | if c != codes.Nil { | |
231 | return fmt.Errorf("msgpack: invalid code=%x decoding nil", c) | |
232 | } | |
233 | return nil | |
234 | } | |
235 | ||
236 | func (d *Decoder) decodeNilValue(v reflect.Value) error { | |
237 | err := d.DecodeNil() | |
238 | if v.IsNil() { | |
239 | return err | |
240 | } | |
241 | if v.Kind() == reflect.Ptr { | |
242 | v = v.Elem() | |
243 | } | |
244 | v.Set(reflect.Zero(v.Type())) | |
245 | return err | |
246 | } | |
247 | ||
248 | func (d *Decoder) DecodeBool() (bool, error) { | |
249 | c, err := d.readCode() | |
250 | if err != nil { | |
251 | return false, err | |
252 | } | |
253 | return d.bool(c) | |
254 | } | |
255 | ||
256 | func (d *Decoder) bool(c codes.Code) (bool, error) { | |
257 | if c == codes.False { | |
258 | return false, nil | |
259 | } | |
260 | if c == codes.True { | |
261 | return true, nil | |
262 | } | |
263 | return false, fmt.Errorf("msgpack: invalid code=%x decoding bool", c) | |
264 | } | |
265 | ||
266 | // DecodeInterface decodes value into interface. It returns following types: | |
267 | // - nil, | |
268 | // - bool, | |
269 | // - int8, int16, int32, int64, | |
270 | // - uint8, uint16, uint32, uint64, | |
271 | // - float32 and float64, | |
272 | // - string, | |
273 | // - []byte, | |
274 | // - slices of any of the above, | |
275 | // - maps of any of the above. | |
276 | // | |
277 | // DecodeInterface should be used only when you don't know the type of value | |
278 | // you are decoding. For example, if you are decoding number it is better to use | |
279 | // DecodeInt64 for negative numbers and DecodeUint64 for positive numbers. | |
280 | func (d *Decoder) DecodeInterface() (interface{}, error) { | |
281 | c, err := d.readCode() | |
282 | if err != nil { | |
283 | return nil, err | |
284 | } | |
285 | ||
286 | if codes.IsFixedNum(c) { | |
287 | return int8(c), nil | |
288 | } | |
289 | if codes.IsFixedMap(c) { | |
290 | err = d.s.UnreadByte() | |
291 | if err != nil { | |
292 | return nil, err | |
293 | } | |
294 | return d.DecodeMap() | |
295 | } | |
296 | if codes.IsFixedArray(c) { | |
297 | return d.decodeSlice(c) | |
298 | } | |
299 | if codes.IsFixedString(c) { | |
300 | return d.string(c) | |
301 | } | |
302 | ||
303 | switch c { | |
304 | case codes.Nil: | |
305 | return nil, nil | |
306 | case codes.False, codes.True: | |
307 | return d.bool(c) | |
308 | case codes.Float: | |
309 | return d.float32(c) | |
310 | case codes.Double: | |
311 | return d.float64(c) | |
312 | case codes.Uint8: | |
313 | return d.uint8() | |
314 | case codes.Uint16: | |
315 | return d.uint16() | |
316 | case codes.Uint32: | |
317 | return d.uint32() | |
318 | case codes.Uint64: | |
319 | return d.uint64() | |
320 | case codes.Int8: | |
321 | return d.int8() | |
322 | case codes.Int16: | |
323 | return d.int16() | |
324 | case codes.Int32: | |
325 | return d.int32() | |
326 | case codes.Int64: | |
327 | return d.int64() | |
328 | case codes.Bin8, codes.Bin16, codes.Bin32: | |
329 | return d.bytes(c, nil) | |
330 | case codes.Str8, codes.Str16, codes.Str32: | |
331 | return d.string(c) | |
332 | case codes.Array16, codes.Array32: | |
333 | return d.decodeSlice(c) | |
334 | case codes.Map16, codes.Map32: | |
335 | err = d.s.UnreadByte() | |
336 | if err != nil { | |
337 | return nil, err | |
338 | } | |
339 | return d.DecodeMap() | |
340 | case codes.FixExt1, codes.FixExt2, codes.FixExt4, codes.FixExt8, codes.FixExt16, | |
341 | codes.Ext8, codes.Ext16, codes.Ext32: | |
342 | return d.extInterface(c) | |
343 | } | |
344 | ||
345 | return 0, fmt.Errorf("msgpack: unknown code %x decoding interface{}", c) | |
346 | } | |
347 | ||
348 | // DecodeInterfaceLoose is like DecodeInterface except that: | |
349 | // - int8, int16, and int32 are converted to int64, | |
350 | // - uint8, uint16, and uint32 are converted to uint64, | |
351 | // - float32 is converted to float64. | |
352 | func (d *Decoder) DecodeInterfaceLoose() (interface{}, error) { | |
353 | c, err := d.readCode() | |
354 | if err != nil { | |
355 | return nil, err | |
356 | } | |
357 | ||
358 | if codes.IsFixedNum(c) { | |
359 | return int64(c), nil | |
360 | } | |
361 | if codes.IsFixedMap(c) { | |
362 | err = d.s.UnreadByte() | |
363 | if err != nil { | |
364 | return nil, err | |
365 | } | |
366 | return d.DecodeMap() | |
367 | } | |
368 | if codes.IsFixedArray(c) { | |
369 | return d.decodeSlice(c) | |
370 | } | |
371 | if codes.IsFixedString(c) { | |
372 | return d.string(c) | |
373 | } | |
374 | ||
375 | switch c { | |
376 | case codes.Nil: | |
377 | return nil, nil | |
378 | case codes.False, codes.True: | |
379 | return d.bool(c) | |
380 | case codes.Float, codes.Double: | |
381 | return d.float64(c) | |
382 | case codes.Uint8, codes.Uint16, codes.Uint32, codes.Uint64: | |
383 | return d.uint(c) | |
384 | case codes.Int8, codes.Int16, codes.Int32, codes.Int64: | |
385 | return d.int(c) | |
386 | case codes.Bin8, codes.Bin16, codes.Bin32: | |
387 | return d.bytes(c, nil) | |
388 | case codes.Str8, codes.Str16, codes.Str32: | |
389 | return d.string(c) | |
390 | case codes.Array16, codes.Array32: | |
391 | return d.decodeSlice(c) | |
392 | case codes.Map16, codes.Map32: | |
393 | err = d.s.UnreadByte() | |
394 | if err != nil { | |
395 | return nil, err | |
396 | } | |
397 | return d.DecodeMap() | |
398 | case codes.FixExt1, codes.FixExt2, codes.FixExt4, codes.FixExt8, codes.FixExt16, | |
399 | codes.Ext8, codes.Ext16, codes.Ext32: | |
400 | return d.extInterface(c) | |
401 | } | |
402 | ||
403 | return 0, fmt.Errorf("msgpack: unknown code %x decoding interface{}", c) | |
404 | } | |
405 | ||
406 | // Skip skips next value. | |
407 | func (d *Decoder) Skip() error { | |
408 | c, err := d.readCode() | |
409 | if err != nil { | |
410 | return err | |
411 | } | |
412 | ||
413 | if codes.IsFixedNum(c) { | |
414 | return nil | |
415 | } else if codes.IsFixedMap(c) { | |
416 | return d.skipMap(c) | |
417 | } else if codes.IsFixedArray(c) { | |
418 | return d.skipSlice(c) | |
419 | } else if codes.IsFixedString(c) { | |
420 | return d.skipBytes(c) | |
421 | } | |
422 | ||
423 | switch c { | |
424 | case codes.Nil, codes.False, codes.True: | |
425 | return nil | |
426 | case codes.Uint8, codes.Int8: | |
427 | return d.skipN(1) | |
428 | case codes.Uint16, codes.Int16: | |
429 | return d.skipN(2) | |
430 | case codes.Uint32, codes.Int32, codes.Float: | |
431 | return d.skipN(4) | |
432 | case codes.Uint64, codes.Int64, codes.Double: | |
433 | return d.skipN(8) | |
434 | case codes.Bin8, codes.Bin16, codes.Bin32: | |
435 | return d.skipBytes(c) | |
436 | case codes.Str8, codes.Str16, codes.Str32: | |
437 | return d.skipBytes(c) | |
438 | case codes.Array16, codes.Array32: | |
439 | return d.skipSlice(c) | |
440 | case codes.Map16, codes.Map32: | |
441 | return d.skipMap(c) | |
442 | case codes.FixExt1, codes.FixExt2, codes.FixExt4, codes.FixExt8, codes.FixExt16, | |
443 | codes.Ext8, codes.Ext16, codes.Ext32: | |
444 | return d.skipExt(c) | |
445 | } | |
446 | ||
447 | return fmt.Errorf("msgpack: unknown code %x", c) | |
448 | } | |
449 | ||
450 | // PeekCode returns the next MessagePack code without advancing the reader. | |
451 | // Subpackage msgpack/codes contains list of available codes. | |
452 | func (d *Decoder) PeekCode() (codes.Code, error) { | |
453 | c, err := d.s.ReadByte() | |
454 | if err != nil { | |
455 | return 0, err | |
456 | } | |
457 | return codes.Code(c), d.s.UnreadByte() | |
458 | } | |
459 | ||
460 | func (d *Decoder) hasNilCode() bool { | |
461 | code, err := d.PeekCode() | |
462 | return err == nil && code == codes.Nil | |
463 | } | |
464 | ||
465 | func (d *Decoder) readCode() (codes.Code, error) { | |
466 | d.extLen = 0 | |
467 | c, err := d.s.ReadByte() | |
468 | if err != nil { | |
469 | return 0, err | |
470 | } | |
471 | if d.rec != nil { | |
472 | d.rec = append(d.rec, c) | |
473 | } | |
474 | return codes.Code(c), nil | |
475 | } | |
476 | ||
477 | func (d *Decoder) readFull(b []byte) error { | |
478 | _, err := io.ReadFull(d.r, b) | |
479 | if err != nil { | |
480 | return err | |
481 | } | |
482 | if d.rec != nil { | |
483 | d.rec = append(d.rec, b...) | |
484 | } | |
485 | return nil | |
486 | } | |
487 | ||
488 | func (d *Decoder) readN(n int) ([]byte, error) { | |
489 | buf, err := readN(d.r, d.buf, n) | |
490 | if err != nil { | |
491 | return nil, err | |
492 | } | |
493 | d.buf = buf | |
494 | if d.rec != nil { | |
495 | d.rec = append(d.rec, buf...) | |
496 | } | |
497 | return buf, nil | |
498 | } | |
499 | ||
500 | func readN(r io.Reader, b []byte, n int) ([]byte, error) { | |
501 | if b == nil { | |
502 | if n == 0 { | |
503 | return make([]byte, 0), nil | |
504 | } | |
505 | if n <= bytesAllocLimit { | |
506 | b = make([]byte, n) | |
507 | } else { | |
508 | b = make([]byte, bytesAllocLimit) | |
509 | } | |
510 | } | |
511 | ||
512 | if n <= cap(b) { | |
513 | b = b[:n] | |
514 | _, err := io.ReadFull(r, b) | |
515 | return b, err | |
516 | } | |
517 | b = b[:cap(b)] | |
518 | ||
519 | var pos int | |
520 | for { | |
521 | alloc := n - len(b) | |
522 | if alloc > bytesAllocLimit { | |
523 | alloc = bytesAllocLimit | |
524 | } | |
525 | b = append(b, make([]byte, alloc)...) | |
526 | ||
527 | _, err := io.ReadFull(r, b[pos:]) | |
528 | if err != nil { | |
529 | return nil, err | |
530 | } | |
531 | ||
532 | if len(b) == n { | |
533 | break | |
534 | } | |
535 | pos = len(b) | |
536 | } | |
537 | ||
538 | return b, nil | |
539 | } | |
540 | ||
541 | func min(a, b int) int { | |
542 | if a <= b { | |
543 | return a | |
544 | } | |
545 | return b | |
546 | } |