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