1/*
2 * MessagePack for C unpacking routine
3 *
4 * Copyright (C) 2008-2009 FURUHASHI Sadayuki
5 *
6 *    Distributed under the Boost Software License, Version 1.0.
7 *    (See accompanying file LICENSE_1_0.txt or copy at
8 *    http://www.boost.org/LICENSE_1_0.txt)
9 */
10#include "msgpack/unpack.h"
11#include "msgpack/unpack_define.h"
12#include "msgpack/util.h"
13#include <stdlib.h>
14
15#ifdef _msgpack_atomic_counter_header
16#include _msgpack_atomic_counter_header
17#endif
18
19
20typedef struct {
21    msgpack_zone* z;
22    bool referenced;
23} unpack_user;
24
25
26#define msgpack_unpack_struct(name) \
27    struct template ## name
28
29#define msgpack_unpack_func(ret, name) \
30    ret template ## name
31
32#define msgpack_unpack_callback(name) \
33    template_callback ## name
34
35#define msgpack_unpack_object msgpack_object
36
37#define msgpack_unpack_user unpack_user
38
39
40struct template_context;
41typedef struct template_context template_context;
42
43static void template_init(template_context* ctx);
44
45static msgpack_object template_data(template_context* ctx);
46
47static int template_execute(
48    template_context* ctx, const char* data, size_t len, size_t* off);
49
50
51static inline msgpack_object template_callback_root(unpack_user* u)
52{
53    msgpack_object o;
54    MSGPACK_UNUSED(u);
55    o.type = MSGPACK_OBJECT_NIL;
56    return o;
57}
58
59static inline int template_callback_uint8(unpack_user* u, uint8_t d, msgpack_object* o)
60{
61    MSGPACK_UNUSED(u);
62    o->type = MSGPACK_OBJECT_POSITIVE_INTEGER;
63    o->via.u64 = d;
64    return 0;
65}
66
67static inline int template_callback_uint16(unpack_user* u, uint16_t d, msgpack_object* o)
68{
69    MSGPACK_UNUSED(u);
70    o->type = MSGPACK_OBJECT_POSITIVE_INTEGER;
71    o->via.u64 = d;
72    return 0;
73}
74
75static inline int template_callback_uint32(unpack_user* u, uint32_t d, msgpack_object* o)
76{
77    MSGPACK_UNUSED(u);
78    o->type = MSGPACK_OBJECT_POSITIVE_INTEGER;
79    o->via.u64 = d;
80    return 0;
81}
82
83static inline int template_callback_uint64(unpack_user* u, uint64_t d, msgpack_object* o)
84{
85    MSGPACK_UNUSED(u);
86    o->type = MSGPACK_OBJECT_POSITIVE_INTEGER;
87    o->via.u64 = d;
88    return 0;
89}
90
91static inline int template_callback_int8(unpack_user* u, int8_t d, msgpack_object* o)
92{
93    MSGPACK_UNUSED(u);
94    if(d >= 0) {
95        o->type = MSGPACK_OBJECT_POSITIVE_INTEGER;
96        o->via.u64 = (uint64_t)d;
97        return 0;
98    }
99    else {
100        o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER;
101        o->via.i64 = d;
102        return 0;
103    }
104}
105
106static inline int template_callback_int16(unpack_user* u, int16_t d, msgpack_object* o)
107{
108    MSGPACK_UNUSED(u);
109    if(d >= 0) {
110        o->type = MSGPACK_OBJECT_POSITIVE_INTEGER;
111        o->via.u64 = (uint64_t)d;
112        return 0;
113    }
114    else {
115        o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER;
116        o->via.i64 = d;
117        return 0;
118    }
119}
120
121static inline int template_callback_int32(unpack_user* u, int32_t d, msgpack_object* o)
122{
123    MSGPACK_UNUSED(u);
124    if(d >= 0) {
125        o->type = MSGPACK_OBJECT_POSITIVE_INTEGER;
126        o->via.u64 = (uint64_t)d;
127        return 0;
128    }
129    else {
130        o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER;
131        o->via.i64 = d;
132        return 0;
133    }
134}
135
136static inline int template_callback_int64(unpack_user* u, int64_t d, msgpack_object* o)
137{
138    MSGPACK_UNUSED(u);
139    if(d >= 0) {
140        o->type = MSGPACK_OBJECT_POSITIVE_INTEGER;
141        o->via.u64 = (uint64_t)d;
142        return 0;
143    }
144    else {
145        o->type = MSGPACK_OBJECT_NEGATIVE_INTEGER;
146        o->via.i64 = d;
147        return 0;
148    }
149}
150
151static inline int template_callback_float(unpack_user* u, float d, msgpack_object* o)
152{
153    MSGPACK_UNUSED(u);
154    o->type = MSGPACK_OBJECT_FLOAT;
155    o->via.f64 = d;
156    return 0;
157}
158
159static inline int template_callback_double(unpack_user* u, double d, msgpack_object* o)
160{
161    MSGPACK_UNUSED(u);
162    o->type = MSGPACK_OBJECT_FLOAT;
163    o->via.f64 = d;
164    return 0;
165}
166
167static inline int template_callback_nil(unpack_user* u, msgpack_object* o)
168{
169    MSGPACK_UNUSED(u);
170    o->type = MSGPACK_OBJECT_NIL;
171    return 0;
172}
173
174static inline int template_callback_true(unpack_user* u, msgpack_object* o)
175{
176    MSGPACK_UNUSED(u);
177    o->type = MSGPACK_OBJECT_BOOLEAN;
178    o->via.boolean = true;
179    return 0;
180}
181
182static inline int template_callback_false(unpack_user* u, msgpack_object* o)
183{
184    MSGPACK_UNUSED(u);
185    o->type = MSGPACK_OBJECT_BOOLEAN;
186    o->via.boolean = false;
187    return 0;
188}
189
190static inline int template_callback_array(unpack_user* u, unsigned int n, msgpack_object* o)
191{
192    o->type = MSGPACK_OBJECT_ARRAY;
193    o->via.array.size = 0;
194    o->via.array.ptr = (msgpack_object*)msgpack_zone_malloc(u->z, n*sizeof(msgpack_object));
195    if(o->via.array.ptr == NULL) { return -1; }
196    return 0;
197}
198
199static inline int template_callback_array_item(unpack_user* u, msgpack_object* c, msgpack_object o)
200{
201    MSGPACK_UNUSED(u);
202#if defined(__GNUC__) && !defined(__clang__)
203    memcpy(&c->via.array.ptr[c->via.array.size], &o, sizeof(msgpack_object));
204#else  /* __GNUC__ && !__clang__ */
205    c->via.array.ptr[c->via.array.size] = o;
206#endif /* __GNUC__ && !__clang__ */
207    ++c->via.array.size;
208    return 0;
209}
210
211static inline int template_callback_map(unpack_user* u, unsigned int n, msgpack_object* o)
212{
213    o->type = MSGPACK_OBJECT_MAP;
214    o->via.map.size = 0;
215    o->via.map.ptr = (msgpack_object_kv*)msgpack_zone_malloc(u->z, n*sizeof(msgpack_object_kv));
216    if(o->via.map.ptr == NULL) { return -1; }
217    return 0;
218}
219
220static inline int template_callback_map_item(unpack_user* u, msgpack_object* c, msgpack_object k, msgpack_object v)
221{
222    MSGPACK_UNUSED(u);
223#if defined(__GNUC__) && !defined(__clang__)
224    memcpy(&c->via.map.ptr[c->via.map.size].key, &k, sizeof(msgpack_object));
225    memcpy(&c->via.map.ptr[c->via.map.size].val, &v, sizeof(msgpack_object));
226#else  /* __GNUC__ && !__clang__ */
227    c->via.map.ptr[c->via.map.size].key = k;
228    c->via.map.ptr[c->via.map.size].val = v;
229#endif /* __GNUC__ && !__clang__ */
230    ++c->via.map.size;
231    return 0;
232}
233
234static inline int template_callback_str(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o)
235{
236    MSGPACK_UNUSED(u);
237    MSGPACK_UNUSED(b);
238    o->type = MSGPACK_OBJECT_STR;
239    o->via.str.ptr = p;
240    o->via.str.size = l;
241    u->referenced = true;
242    return 0;
243}
244
245static inline int template_callback_bin(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o)
246{
247    MSGPACK_UNUSED(u);
248    MSGPACK_UNUSED(b);
249    o->type = MSGPACK_OBJECT_BIN;
250    o->via.bin.ptr = p;
251    o->via.bin.size = l;
252    u->referenced = true;
253    return 0;
254}
255
256static inline int template_callback_ext(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o)
257{
258    MSGPACK_UNUSED(u);
259    MSGPACK_UNUSED(b);
260    o->type = MSGPACK_OBJECT_EXT;
261    o->via.ext.type = *p;
262    o->via.ext.ptr = p + 1;
263    o->via.ext.size = l - 1;
264    u->referenced = true;
265    return 0;
266}
267
268#include "msgpack/unpack_template.h"
269
270
271#define CTX_CAST(m) ((template_context*)(m))
272#define CTX_REFERENCED(mpac) CTX_CAST((mpac)->ctx)->user.referenced
273
274#define COUNTER_SIZE (sizeof(_msgpack_atomic_counter_t))
275
276
277static inline void init_count(void* buffer)
278{
279    *(volatile _msgpack_atomic_counter_t*)buffer = 1;
280}
281
282static inline void decr_count(void* buffer)
283{
284    // atomic if(--*(_msgpack_atomic_counter_t*)buffer == 0) { free(buffer); }
285    if(_msgpack_sync_decr_and_fetch((volatile _msgpack_atomic_counter_t*)buffer) == 0) {
286        free(buffer);
287    }
288}
289
290static inline void incr_count(void* buffer)
291{
292    // atomic ++*(_msgpack_atomic_counter_t*)buffer;
293    _msgpack_sync_incr_and_fetch((volatile _msgpack_atomic_counter_t*)buffer);
294}
295
296static inline _msgpack_atomic_counter_t get_count(void* buffer)
297{
298    return *(volatile _msgpack_atomic_counter_t*)buffer;
299}
300
301bool msgpack_unpacker_init(msgpack_unpacker* mpac, size_t initial_buffer_size)
302{
303    char* buffer;
304    void* ctx;
305    msgpack_zone* z;
306
307    if(initial_buffer_size < COUNTER_SIZE) {
308        initial_buffer_size = COUNTER_SIZE;
309    }
310
311    buffer = (char*)malloc(initial_buffer_size);
312    if(buffer == NULL) {
313        return false;
314    }
315
316    ctx = malloc(sizeof(template_context));
317    if(ctx == NULL) {
318        free(buffer);
319        return false;
320    }
321
322    z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
323    if(z == NULL) {
324        free(ctx);
325        free(buffer);
326        return false;
327    }
328
329    mpac->buffer = buffer;
330    mpac->used = COUNTER_SIZE;
331    mpac->free = initial_buffer_size - mpac->used;
332    mpac->off = COUNTER_SIZE;
333    mpac->parsed = 0;
334    mpac->initial_buffer_size = initial_buffer_size;
335    mpac->z = z;
336    mpac->ctx = ctx;
337
338    init_count(mpac->buffer);
339
340    template_init(CTX_CAST(mpac->ctx));
341    CTX_CAST(mpac->ctx)->user.z = mpac->z;
342    CTX_CAST(mpac->ctx)->user.referenced = false;
343
344    return true;
345}
346
347void msgpack_unpacker_destroy(msgpack_unpacker* mpac)
348{
349    msgpack_zone_free(mpac->z);
350    free(mpac->ctx);
351    decr_count(mpac->buffer);
352}
353
354msgpack_unpacker* msgpack_unpacker_new(size_t initial_buffer_size)
355{
356    msgpack_unpacker* mpac = (msgpack_unpacker*)malloc(sizeof(msgpack_unpacker));
357    if(mpac == NULL) {
358        return NULL;
359    }
360
361    if(!msgpack_unpacker_init(mpac, initial_buffer_size)) {
362        free(mpac);
363        return NULL;
364    }
365
366    return mpac;
367}
368
369void msgpack_unpacker_free(msgpack_unpacker* mpac)
370{
371    msgpack_unpacker_destroy(mpac);
372    free(mpac);
373}
374
375bool msgpack_unpacker_expand_buffer(msgpack_unpacker* mpac, size_t size)
376{
377    if(mpac->used == mpac->off && get_count(mpac->buffer) == 1
378            && !CTX_REFERENCED(mpac)) {
379        // rewind buffer
380        mpac->free += mpac->used - COUNTER_SIZE;
381        mpac->used = COUNTER_SIZE;
382        mpac->off = COUNTER_SIZE;
383
384        if(mpac->free >= size) {
385            return true;
386        }
387    }
388
389    if(mpac->off == COUNTER_SIZE) {
390        char* tmp;
391        size_t next_size = (mpac->used + mpac->free) * 2;  // include COUNTER_SIZE
392        while(next_size < size + mpac->used) {
393            size_t tmp_next_size = next_size * 2;
394            if (tmp_next_size <= next_size) {
395                next_size = size + mpac->used;
396                break;
397            }
398            next_size = tmp_next_size;
399        }
400
401        tmp = (char*)realloc(mpac->buffer, next_size);
402        if(tmp == NULL) {
403            return false;
404        }
405
406        mpac->buffer = tmp;
407        mpac->free = next_size - mpac->used;
408
409    } else {
410        char* tmp;
411        size_t next_size = mpac->initial_buffer_size;  // include COUNTER_SIZE
412        size_t not_parsed = mpac->used - mpac->off;
413        while(next_size < size + not_parsed + COUNTER_SIZE) {
414            size_t tmp_next_size = next_size * 2;
415            if (tmp_next_size <= next_size) {
416                next_size = size + not_parsed + COUNTER_SIZE;
417                break;
418            }
419            next_size = tmp_next_size;
420        }
421
422        tmp = (char*)malloc(next_size);
423        if(tmp == NULL) {
424            return false;
425        }
426
427        init_count(tmp);
428
429        memcpy(tmp+COUNTER_SIZE, mpac->buffer+mpac->off, not_parsed);
430
431        if(CTX_REFERENCED(mpac)) {
432            if(!msgpack_zone_push_finalizer(mpac->z, decr_count, mpac->buffer)) {
433                free(tmp);
434                return false;
435            }
436            CTX_REFERENCED(mpac) = false;
437        } else {
438            decr_count(mpac->buffer);
439        }
440
441        mpac->buffer = tmp;
442        mpac->used = not_parsed + COUNTER_SIZE;
443        mpac->free = next_size - mpac->used;
444        mpac->off = COUNTER_SIZE;
445    }
446
447    return true;
448}
449
450int msgpack_unpacker_execute(msgpack_unpacker* mpac)
451{
452    size_t off = mpac->off;
453    int ret = template_execute(CTX_CAST(mpac->ctx),
454            mpac->buffer, mpac->used, &mpac->off);
455    if(mpac->off > off) {
456        mpac->parsed += mpac->off - off;
457    }
458    return ret;
459}
460
461msgpack_object msgpack_unpacker_data(msgpack_unpacker* mpac)
462{
463    return template_data(CTX_CAST(mpac->ctx));
464}
465
466msgpack_zone* msgpack_unpacker_release_zone(msgpack_unpacker* mpac)
467{
468    msgpack_zone* r;
469    msgpack_zone* old;
470
471    if(!msgpack_unpacker_flush_zone(mpac)) {
472        return NULL;
473    }
474
475    r = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
476    if(r == NULL) {
477        return NULL;
478    }
479
480    old = mpac->z;
481    mpac->z = r;
482    CTX_CAST(mpac->ctx)->user.z = mpac->z;
483
484    return old;
485}
486
487void msgpack_unpacker_reset_zone(msgpack_unpacker* mpac)
488{
489    msgpack_zone_clear(mpac->z);
490}
491
492bool msgpack_unpacker_flush_zone(msgpack_unpacker* mpac)
493{
494    if(CTX_REFERENCED(mpac)) {
495        if(!msgpack_zone_push_finalizer(mpac->z, decr_count, mpac->buffer)) {
496            return false;
497        }
498        CTX_REFERENCED(mpac) = false;
499
500        incr_count(mpac->buffer);
501    }
502
503    return true;
504}
505
506void msgpack_unpacker_reset(msgpack_unpacker* mpac)
507{
508    template_init(CTX_CAST(mpac->ctx));
509    // don't reset referenced flag
510    mpac->parsed = 0;
511}
512
513msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpacked* result)
514{
515    int ret;
516
517    msgpack_unpacked_destroy(result);
518
519    ret = msgpack_unpacker_execute(mpac);
520
521    if(ret < 0) {
522        result->zone = NULL;
523        memset(&result->data, 0, sizeof(msgpack_object));
524        return MSGPACK_UNPACK_PARSE_ERROR;
525    }
526
527    if(ret == 0) {
528        return MSGPACK_UNPACK_CONTINUE;
529    }
530    result->zone = msgpack_unpacker_release_zone(mpac);
531    result->data = msgpack_unpacker_data(mpac);
532    msgpack_unpacker_reset(mpac);
533
534    return MSGPACK_UNPACK_SUCCESS;
535}
536
537
538msgpack_unpack_return
539msgpack_unpack(const char* data, size_t len, size_t* off,
540        msgpack_zone* result_zone, msgpack_object* result)
541{
542    size_t noff = 0;
543    if(off != NULL) { noff = *off; }
544
545    if(len <= noff) {
546        // FIXME
547        return MSGPACK_UNPACK_CONTINUE;
548    }
549    else {
550        int e;
551        template_context ctx;
552        template_init(&ctx);
553
554        ctx.user.z = result_zone;
555        ctx.user.referenced = false;
556
557        e = template_execute(&ctx, data, len, &noff);
558        if(e < 0) {
559            return MSGPACK_UNPACK_PARSE_ERROR;
560        }
561
562        if(off != NULL) { *off = noff; }
563
564        if(e == 0) {
565            return MSGPACK_UNPACK_CONTINUE;
566        }
567
568        *result = template_data(&ctx);
569
570        if(noff < len) {
571            return MSGPACK_UNPACK_EXTRA_BYTES;
572        }
573
574        return MSGPACK_UNPACK_SUCCESS;
575    }
576}
577
578msgpack_unpack_return
579msgpack_unpack_next(msgpack_unpacked* result,
580        const char* data, size_t len, size_t* off)
581{
582    size_t noff = 0;
583    msgpack_unpacked_destroy(result);
584
585    if(off != NULL) { noff = *off; }
586
587    if(len <= noff) {
588        return MSGPACK_UNPACK_CONTINUE;
589    }
590
591    if (!result->zone) {
592        result->zone = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
593    }
594
595    if (!result->zone) {
596        return MSGPACK_UNPACK_NOMEM_ERROR;
597    }
598    else {
599        int e;
600        template_context ctx;
601        template_init(&ctx);
602
603        ctx.user.z = result->zone;
604        ctx.user.referenced = false;
605
606        e = template_execute(&ctx, data, len, &noff);
607        if(e < 0) {
608            msgpack_zone_free(result->zone);
609            result->zone = NULL;
610            return MSGPACK_UNPACK_PARSE_ERROR;
611        }
612
613
614        if(e == 0) {
615            return MSGPACK_UNPACK_CONTINUE;
616        }
617
618        if(off != NULL) { *off = noff; }
619
620        result->data = template_data(&ctx);
621
622        return MSGPACK_UNPACK_SUCCESS;
623    }
624}
625
626#if defined(MSGPACK_OLD_COMPILER_BUS_ERROR_WORKAROUND)
627// FIXME: Dirty hack to avoid a bus error caused by OS X's old gcc.
628static void dummy_function_to_avoid_bus_error()
629{
630}
631#endif
632