| // |
| // MessagePack for C++ deserializing routine |
| // |
| // Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi |
| // |
| // Distributed under the Boost Software License, Version 1.0. |
| // (See accompanying file LICENSE_1_0.txt or copy at |
| // http://www.boost.org/LICENSE_1_0.txt) |
| // |
| #ifndef MSGPACK_UNPACK_HPP |
| #define MSGPACK_UNPACK_HPP |
| |
| #include "msgpack/versioning.hpp" |
| #include "object.hpp" |
| #include "zone.hpp" |
| #include "unpack_define.h" |
| #include "cpp_config.hpp" |
| #include "sysdep.h" |
| |
| #include <memory> |
| #include <stdexcept> |
| |
| #if !defined(MSGPACK_USE_CPP03) |
| #include <atomic> |
| #endif |
| |
| |
| #if defined(_MSC_VER) |
| // avoiding confliction std::max, std::min, and macro in windows.h |
| #ifndef NOMINMAX |
| #define NOMINMAX |
| #endif |
| #endif // defined(_MSC_VER) |
| |
| #ifdef _msgpack_atomic_counter_header |
| #include _msgpack_atomic_counter_header |
| #endif |
| |
| |
| const size_t COUNTER_SIZE = sizeof(_msgpack_atomic_counter_t); |
| |
| #ifndef MSGPACK_UNPACKER_INIT_BUFFER_SIZE |
| #define MSGPACK_UNPACKER_INIT_BUFFER_SIZE (64*1024) |
| #endif |
| |
| #ifndef MSGPACK_UNPACKER_RESERVE_SIZE |
| #define MSGPACK_UNPACKER_RESERVE_SIZE (32*1024) |
| #endif |
| |
| |
| // backward compatibility |
| #ifndef MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE |
| #define MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE MSGPACK_UNPACKER_INIT_BUFFER_SIZE |
| #endif |
| |
| |
| namespace msgpack { |
| |
| /// @cond |
| MSGPACK_API_VERSION_NAMESPACE(v1) { |
| /// @endcond |
| |
| /// The type of reference or copy judging function. |
| /** |
| * @param type msgpack data type. |
| * @param size msgpack data size. |
| * @param user_data The user_data that is set by msgpack::unpack functions. |
| * |
| * @return If the data should be referenced, then return true, otherwise (should be copied) false. |
| * |
| * This function is called when unpacking STR, BIN, or EXT. |
| * |
| */ |
| typedef bool (*unpack_reference_func)(msgpack::type::object_type type, std::size_t size, void* user_data); |
| |
| struct unpack_error : public std::runtime_error { |
| explicit unpack_error(const std::string& msg) |
| :std::runtime_error(msg) {} |
| #if !defined(MSGPACK_USE_CPP03) |
| explicit unpack_error(const char* msg): |
| std::runtime_error(msg) {} |
| #endif // !defined(MSGPACK_USE_CPP03) |
| }; |
| |
| struct parse_error : public unpack_error { |
| explicit parse_error(const std::string& msg) |
| :unpack_error(msg) {} |
| #if !defined(MSGPACK_USE_CPP03) |
| explicit parse_error(const char* msg) |
| :unpack_error(msg) {} |
| #endif // !defined(MSGPACK_USE_CPP03) |
| }; |
| |
| struct insufficient_bytes : public unpack_error { |
| explicit insufficient_bytes(const std::string& msg) |
| :unpack_error(msg) {} |
| #if !defined(MSGPACK_USE_CPP03) |
| explicit insufficient_bytes(const char* msg) |
| :unpack_error(msg) {} |
| #endif // !defined(MSGPACK_USE_CPP03) |
| }; |
| |
| struct size_overflow : public unpack_error { |
| explicit size_overflow(const std::string& msg) |
| :unpack_error(msg) {} |
| #if !defined(MSGPACK_USE_CPP03) |
| explicit size_overflow(const char* msg) |
| :unpack_error(msg) {} |
| #endif |
| }; |
| |
| struct array_size_overflow : public size_overflow { |
| array_size_overflow(const std::string& msg) |
| :size_overflow(msg) {} |
| #if !defined(MSGPACK_USE_CPP03) |
| array_size_overflow(const char* msg) |
| :size_overflow(msg) {} |
| #endif |
| }; |
| |
| struct map_size_overflow : public size_overflow { |
| map_size_overflow(const std::string& msg) |
| :size_overflow(msg) {} |
| #if !defined(MSGPACK_USE_CPP03) |
| map_size_overflow(const char* msg) |
| :size_overflow(msg) {} |
| #endif |
| }; |
| |
| struct str_size_overflow : public size_overflow { |
| str_size_overflow(const std::string& msg) |
| :size_overflow(msg) {} |
| #if !defined(MSGPACK_USE_CPP03) |
| str_size_overflow(const char* msg) |
| :size_overflow(msg) {} |
| #endif |
| }; |
| |
| struct bin_size_overflow : public size_overflow { |
| bin_size_overflow(const std::string& msg) |
| :size_overflow(msg) {} |
| #if !defined(MSGPACK_USE_CPP03) |
| bin_size_overflow(const char* msg) |
| :size_overflow(msg) {} |
| #endif |
| }; |
| |
| struct ext_size_overflow : public size_overflow { |
| ext_size_overflow(const std::string& msg) |
| :size_overflow(msg) {} |
| #if !defined(MSGPACK_USE_CPP03) |
| ext_size_overflow(const char* msg) |
| :size_overflow(msg) {} |
| #endif |
| }; |
| |
| struct depth_size_overflow : public size_overflow { |
| depth_size_overflow(const std::string& msg) |
| :size_overflow(msg) {} |
| #if !defined(MSGPACK_USE_CPP03) |
| depth_size_overflow(const char* msg) |
| :size_overflow(msg) {} |
| #endif |
| }; |
| |
| class unpack_limit { |
| public: |
| unpack_limit( |
| std::size_t array = 0xffffffff, |
| std::size_t map = 0xffffffff, |
| std::size_t str = 0xffffffff, |
| std::size_t bin = 0xffffffff, |
| std::size_t ext = 0xffffffff, |
| std::size_t depth = 0xffffffff) |
| :array_(array), |
| map_(map), |
| str_(str), |
| bin_(bin), |
| ext_(ext), |
| depth_(depth) {} |
| std::size_t array() const { return array_; } |
| std::size_t map() const { return map_; } |
| std::size_t str() const { return str_; } |
| std::size_t bin() const { return bin_; } |
| std::size_t ext() const { return ext_; } |
| std::size_t depth() const { return depth_; } |
| |
| private: |
| std::size_t array_; |
| std::size_t map_; |
| std::size_t str_; |
| std::size_t bin_; |
| std::size_t ext_; |
| std::size_t depth_; |
| }; |
| |
| namespace detail { |
| |
| class unpack_user { |
| public: |
| unpack_user(unpack_reference_func f = nullptr, |
| void* user_data = nullptr, |
| unpack_limit const& limit = unpack_limit()) |
| :m_func(f), m_user_data(user_data), m_limit(limit) {} |
| msgpack::zone const& zone() const { return *m_zone; } |
| msgpack::zone& zone() { return *m_zone; } |
| void set_zone(msgpack::zone& zone) { m_zone = &zone; } |
| bool referenced() const { return m_referenced; } |
| void set_referenced(bool referenced) { m_referenced = referenced; } |
| unpack_reference_func reference_func() const { return m_func; } |
| void* user_data() const { return m_user_data; } |
| unpack_limit const& limit() const { return m_limit; } |
| unpack_limit& limit() { return m_limit; } |
| |
| private: |
| msgpack::zone* m_zone; |
| bool m_referenced; |
| unpack_reference_func m_func; |
| void* m_user_data; |
| unpack_limit m_limit; |
| }; |
| |
| inline void unpack_uint8(uint8_t d, msgpack::object& o) |
| { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; } |
| |
| inline void unpack_uint16(uint16_t d, msgpack::object& o) |
| { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; } |
| |
| inline void unpack_uint32(uint32_t d, msgpack::object& o) |
| { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; } |
| |
| inline void unpack_uint64(uint64_t d, msgpack::object& o) |
| { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; } |
| |
| inline void unpack_int8(int8_t d, msgpack::object& o) |
| { if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; } |
| else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } } |
| |
| inline void unpack_int16(int16_t d, msgpack::object& o) |
| { if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; } |
| else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } } |
| |
| inline void unpack_int32(int32_t d, msgpack::object& o) |
| { if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; } |
| else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } } |
| |
| inline void unpack_int64(int64_t d, msgpack::object& o) |
| { if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; } |
| else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } } |
| |
| inline void unpack_float(float d, msgpack::object& o) |
| { o.type = msgpack::type::FLOAT; o.via.f64 = d; } |
| |
| inline void unpack_double(double d, msgpack::object& o) |
| { o.type = msgpack::type::FLOAT; o.via.f64 = d; } |
| |
| inline void unpack_nil(msgpack::object& o) |
| { o.type = msgpack::type::NIL; } |
| |
| inline void unpack_true(msgpack::object& o) |
| { o.type = msgpack::type::BOOLEAN; o.via.boolean = true; } |
| |
| inline void unpack_false(msgpack::object& o) |
| { o.type = msgpack::type::BOOLEAN; o.via.boolean = false; } |
| |
| struct unpack_array { |
| void operator()(unpack_user& u, uint32_t n, msgpack::object& o) const { |
| if (n > u.limit().array()) throw msgpack::array_size_overflow("array size overflow"); |
| o.type = msgpack::type::ARRAY; |
| o.via.array.size = 0; |
| o.via.array.ptr = static_cast<msgpack::object*>(u.zone().allocate_align(n*sizeof(msgpack::object))); |
| } |
| }; |
| |
| inline void unpack_array_item(msgpack::object& c, msgpack::object const& o) |
| { |
| #if defined(__GNUC__) && !defined(__clang__) |
| std::memcpy(&c.via.array.ptr[c.via.array.size++], &o, sizeof(msgpack::object)); |
| #else /* __GNUC__ && !__clang__ */ |
| c.via.array.ptr[c.via.array.size++] = o; |
| #endif /* __GNUC__ && !__clang__ */ |
| } |
| |
| struct unpack_map { |
| void operator()(unpack_user& u, uint32_t n, msgpack::object& o) const { |
| if (n > u.limit().map()) throw msgpack::map_size_overflow("map size overflow"); |
| o.type = msgpack::type::MAP; |
| o.via.map.size = 0; |
| o.via.map.ptr = static_cast<msgpack::object_kv*>(u.zone().allocate_align(n*sizeof(msgpack::object_kv))); |
| } |
| }; |
| |
| inline void unpack_map_item(msgpack::object& c, msgpack::object const& k, msgpack::object const& v) |
| { |
| #if defined(__GNUC__) && !defined(__clang__) |
| std::memcpy(&c.via.map.ptr[c.via.map.size].key, &k, sizeof(msgpack::object)); |
| std::memcpy(&c.via.map.ptr[c.via.map.size].val, &v, sizeof(msgpack::object)); |
| #else /* __GNUC__ && !__clang__ */ |
| c.via.map.ptr[c.via.map.size].key = k; |
| c.via.map.ptr[c.via.map.size].val = v; |
| #endif /* __GNUC__ && !__clang__ */ |
| ++c.via.map.size; |
| } |
| |
| inline void unpack_str(unpack_user& u, const char* p, uint32_t l, msgpack::object& o) |
| { |
| o.type = msgpack::type::STR; |
| if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) { |
| o.via.str.ptr = p; |
| u.set_referenced(true); |
| } |
| else { |
| if (l > u.limit().str()) throw msgpack::str_size_overflow("str size overflow"); |
| char* tmp = static_cast<char*>(u.zone().allocate_align(l)); |
| std::memcpy(tmp, p, l); |
| o.via.str.ptr = tmp; |
| } |
| o.via.str.size = l; |
| } |
| |
| inline void unpack_bin(unpack_user& u, const char* p, uint32_t l, msgpack::object& o) |
| { |
| o.type = msgpack::type::BIN; |
| if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) { |
| o.via.bin.ptr = p; |
| u.set_referenced(true); |
| } |
| else { |
| if (l > u.limit().bin()) throw msgpack::bin_size_overflow("bin size overflow"); |
| char* tmp = static_cast<char*>(u.zone().allocate_align(l)); |
| std::memcpy(tmp, p, l); |
| o.via.bin.ptr = tmp; |
| } |
| o.via.bin.size = l; |
| } |
| |
| inline void unpack_ext(unpack_user& u, const char* p, std::size_t l, msgpack::object& o) |
| { |
| o.type = msgpack::type::EXT; |
| if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) { |
| o.via.ext.ptr = p; |
| u.set_referenced(true); |
| } |
| else { |
| if (l > u.limit().ext()) throw msgpack::ext_size_overflow("ext size overflow"); |
| char* tmp = static_cast<char*>(u.zone().allocate_align(l)); |
| std::memcpy(tmp, p, l); |
| o.via.ext.ptr = tmp; |
| } |
| o.via.ext.size = static_cast<uint32_t>(l - 1); |
| } |
| |
| |
| class unpack_stack { |
| public: |
| msgpack::object const& obj() const { return m_obj; } |
| msgpack::object& obj() { return m_obj; } |
| void set_obj(msgpack::object const& obj) { m_obj = obj; } |
| std::size_t count() const { return m_count; } |
| void set_count(std::size_t count) { m_count = count; } |
| std::size_t decr_count() { return --m_count; } |
| uint32_t container_type() const { return m_container_type; } |
| void set_container_type(uint32_t container_type) { m_container_type = container_type; } |
| msgpack::object const& map_key() const { return m_map_key; } |
| void set_map_key(msgpack::object const& map_key) { m_map_key = map_key; } |
| private: |
| msgpack::object m_obj; |
| std::size_t m_count; |
| uint32_t m_container_type; |
| msgpack::object m_map_key; |
| }; |
| |
| inline void init_count(void* buffer) |
| { |
| #if defined(MSGPACK_USE_CPP03) |
| *reinterpret_cast<volatile _msgpack_atomic_counter_t*>(buffer) = 1; |
| #else // defined(MSGPACK_USE_CPP03) |
| new (buffer) std::atomic<unsigned int>(1); |
| #endif // defined(MSGPACK_USE_CPP03) |
| } |
| |
| inline void decr_count(void* buffer) |
| { |
| #if defined(MSGPACK_USE_CPP03) |
| if(_msgpack_sync_decr_and_fetch(reinterpret_cast<volatile _msgpack_atomic_counter_t*>(buffer)) == 0) { |
| free(buffer); |
| } |
| #else // defined(MSGPACK_USE_CPP03) |
| if (--*reinterpret_cast<std::atomic<unsigned int>*>(buffer) == 0) { |
| free(buffer); |
| } |
| #endif // defined(MSGPACK_USE_CPP03) |
| } |
| |
| inline void incr_count(void* buffer) |
| { |
| #if defined(MSGPACK_USE_CPP03) |
| _msgpack_sync_incr_and_fetch(reinterpret_cast<volatile _msgpack_atomic_counter_t*>(buffer)); |
| #else // defined(MSGPACK_USE_CPP03) |
| ++*reinterpret_cast<std::atomic<unsigned int>*>(buffer); |
| #endif // defined(MSGPACK_USE_CPP03) |
| } |
| |
| #if defined(MSGPACK_USE_CPP03) |
| inline _msgpack_atomic_counter_t get_count(void* buffer) |
| { |
| return *reinterpret_cast<volatile _msgpack_atomic_counter_t*>(buffer); |
| } |
| #else // defined(MSGPACK_USE_CPP03) |
| inline std::atomic<unsigned int> const& get_count(void* buffer) |
| { |
| return *reinterpret_cast<std::atomic<unsigned int>*>(buffer); |
| } |
| #endif // defined(MSGPACK_USE_CPP03) |
| |
| struct fix_tag { |
| char f1[65]; // FIXME unique size is required. or use is_same meta function. |
| }; |
| |
| template <typename T> |
| struct value { |
| typedef T type; |
| }; |
| template <> |
| struct value<fix_tag> { |
| typedef uint32_t type; |
| }; |
| |
| template <typename T> |
| inline void load(uint32_t& dst, const char* n, typename msgpack::enable_if<sizeof(T) == sizeof(fix_tag)>::type* = nullptr) { |
| dst = static_cast<uint32_t>(*reinterpret_cast<const uint8_t*>(n)) & 0x0f; |
| } |
| |
| template <typename T> |
| inline void load(T& dst, const char* n, typename msgpack::enable_if<sizeof(T) == 1>::type* = nullptr) { |
| dst = static_cast<T>(*reinterpret_cast<const uint8_t*>(n)); |
| } |
| |
| template <typename T> |
| inline void load(T& dst, const char* n, typename msgpack::enable_if<sizeof(T) == 2>::type* = nullptr) { |
| _msgpack_load16(T, n, &dst); |
| } |
| |
| template <typename T> |
| inline void load(T& dst, const char* n, typename msgpack::enable_if<sizeof(T) == 4>::type* = nullptr) { |
| _msgpack_load32(T, n, &dst); |
| } |
| |
| template <typename T> |
| inline void load(T& dst, const char* n, typename msgpack::enable_if<sizeof(T) == 8>::type* = nullptr) { |
| _msgpack_load64(T, n, &dst); |
| } |
| |
| class context { |
| public: |
| context(unpack_reference_func f, void* user_data, unpack_limit const& limit) |
| :m_trail(0), m_user(f, user_data, limit), m_cs(MSGPACK_CS_HEADER) |
| { |
| m_stack.reserve(MSGPACK_EMBED_STACK_SIZE); |
| m_stack.push_back(unpack_stack()); |
| } |
| |
| void init() |
| { |
| m_cs = MSGPACK_CS_HEADER; |
| m_trail = 0; |
| m_stack.resize(1); |
| m_stack[0].set_obj(msgpack::object()); |
| } |
| |
| msgpack::object const& data() const |
| { |
| return m_stack[0].obj(); |
| } |
| |
| unpack_user& user() |
| { |
| return m_user; |
| } |
| |
| unpack_user const& user() const |
| { |
| return m_user; |
| } |
| |
| int execute(const char* data, std::size_t len, std::size_t& off); |
| |
| private: |
| template <typename T> |
| static uint32_t next_cs(T p) |
| { |
| return static_cast<uint32_t>(*p) & 0x1f; |
| } |
| |
| template <typename T, typename Func> |
| int push_aggregate( |
| Func const& f, |
| uint32_t container_type, |
| msgpack::object& obj, |
| const char* load_pos, |
| std::size_t& off) { |
| typename value<T>::type tmp; |
| load<T>(tmp, load_pos); |
| f(m_user, tmp, m_stack.back().obj()); |
| if(tmp == 0) { |
| obj = m_stack.back().obj(); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } |
| else { |
| m_stack.back().set_container_type(container_type); |
| m_stack.back().set_count(tmp); |
| if (m_stack.size() <= m_user.limit().depth()) { |
| m_stack.push_back(unpack_stack()); |
| } |
| else { |
| throw msgpack::depth_size_overflow("depth size overflow"); |
| } |
| m_cs = MSGPACK_CS_HEADER; |
| ++m_current; |
| } |
| return 0; |
| } |
| |
| int push_item(msgpack::object& obj) { |
| bool finish = false; |
| while (!finish) { |
| if(m_stack.size() == 1) { |
| return 1; |
| } |
| unpack_stack& sp = *(m_stack.end() - 2); |
| switch(sp.container_type()) { |
| case MSGPACK_CT_ARRAY_ITEM: |
| unpack_array_item(sp.obj(), obj); |
| if(sp.decr_count() == 0) { |
| obj = sp.obj(); |
| m_stack.pop_back(); |
| } |
| else { |
| finish = true; |
| } |
| break; |
| case MSGPACK_CT_MAP_KEY: |
| sp.set_map_key(obj); |
| sp.set_container_type(MSGPACK_CT_MAP_VALUE); |
| finish = true; |
| break; |
| case MSGPACK_CT_MAP_VALUE: |
| unpack_map_item(sp.obj(), sp.map_key(), obj); |
| if(sp.decr_count() == 0) { |
| obj = sp.obj(); |
| m_stack.pop_back(); |
| } |
| else { |
| sp.set_container_type(MSGPACK_CT_MAP_KEY); |
| finish = true; |
| } |
| break; |
| default: |
| return -1; |
| } |
| } |
| return 0; |
| } |
| |
| int push_proc(msgpack::object& obj, std::size_t& off) { |
| int ret = push_item(obj); |
| if (ret > 0) { |
| m_stack[0].set_obj(obj); |
| ++m_current; |
| /*printf("-- finish --\n"); */ |
| off = m_current - m_start; |
| } |
| else if (ret < 0) { |
| off = m_current - m_start; |
| } |
| else { |
| m_cs = MSGPACK_CS_HEADER; |
| ++m_current; |
| } |
| return ret; |
| } |
| |
| template <std::size_t N> |
| static void check_ext_size(std::size_t /*size*/) { |
| } |
| |
| private: |
| char const* m_start; |
| char const* m_current; |
| |
| std::size_t m_trail; |
| unpack_user m_user; |
| uint32_t m_cs; |
| std::vector<unpack_stack> m_stack; |
| }; |
| |
| template <> |
| inline void context::check_ext_size<4>(std::size_t size) { |
| if (size == 0xffffffff) throw msgpack::ext_size_overflow("ext size overflow"); |
| } |
| |
| inline int context::execute(const char* data, std::size_t len, std::size_t& off) |
| { |
| assert(len >= off); |
| |
| m_start = data; |
| m_current = data + off; |
| const char* const pe = data + len; |
| const char* n = nullptr; |
| |
| msgpack::object obj; |
| |
| if(m_current == pe) { |
| off = m_current - m_start; |
| return 0; |
| } |
| bool fixed_trail_again = false; |
| do { |
| if (m_cs == MSGPACK_CS_HEADER) { |
| fixed_trail_again = false; |
| int selector = *reinterpret_cast<const unsigned char*>(m_current); |
| if (0x00 <= selector && selector <= 0x7f) { // Positive Fixnum |
| unpack_uint8(*reinterpret_cast<const uint8_t*>(m_current), obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } else if(0xe0 <= selector && selector <= 0xff) { // Negative Fixnum |
| unpack_int8(*reinterpret_cast<const int8_t*>(m_current), obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } else if (0xc4 <= selector && selector <= 0xdf) { |
| const uint32_t trail[] = { |
| 1, // bin 8 0xc4 |
| 2, // bin 16 0xc5 |
| 4, // bin 32 0xc6 |
| 1, // ext 8 0xc7 |
| 2, // ext 16 0xc8 |
| 4, // ext 32 0xc9 |
| 4, // float 32 0xca |
| 8, // float 64 0xcb |
| 1, // uint 8 0xcc |
| 2, // uint 16 0xcd |
| 4, // uint 32 0xce |
| 8, // uint 64 0xcf |
| 1, // int 8 0xd0 |
| 2, // int 16 0xd1 |
| 4, // int 32 0xd2 |
| 8, // int 64 0xd3 |
| 2, // fixext 1 0xd4 |
| 3, // fixext 2 0xd5 |
| 5, // fixext 4 0xd6 |
| 9, // fixext 8 0xd7 |
| 17,// fixext 16 0xd8 |
| 1, // str 8 0xd9 |
| 2, // str 16 0xda |
| 4, // str 32 0xdb |
| 2, // array 16 0xdc |
| 4, // array 32 0xdd |
| 2, // map 16 0xde |
| 4, // map 32 0xdf |
| }; |
| m_trail = trail[selector - 0xc4]; |
| m_cs = next_cs(m_current); |
| fixed_trail_again = true; |
| } else if(0xa0 <= selector && selector <= 0xbf) { // FixStr |
| m_trail = static_cast<uint32_t>(*m_current) & 0x1f; |
| if(m_trail == 0) { |
| unpack_str(m_user, n, static_cast<uint32_t>(m_trail), obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } |
| else { |
| m_cs = MSGPACK_ACS_STR_VALUE; |
| fixed_trail_again = true; |
| } |
| |
| } else if(0x90 <= selector && selector <= 0x9f) { // FixArray |
| int ret = push_aggregate<fix_tag>( |
| unpack_array(), MSGPACK_CT_ARRAY_ITEM, obj, m_current, off); |
| if (ret != 0) return ret; |
| } else if(0x80 <= selector && selector <= 0x8f) { // FixMap |
| int ret = push_aggregate<fix_tag>( |
| unpack_map(), MSGPACK_CT_MAP_KEY, obj, m_current, off); |
| if (ret != 0) return ret; |
| } else if(selector == 0xc2) { // false |
| unpack_false(obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } else if(selector == 0xc3) { // true |
| unpack_true(obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } else if(selector == 0xc0) { // nil |
| unpack_nil(obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } else { |
| off = m_current - m_start; |
| return -1; |
| } |
| // end MSGPACK_CS_HEADER |
| } |
| if (m_cs != MSGPACK_CS_HEADER || fixed_trail_again) { |
| if (fixed_trail_again) { |
| ++m_current; |
| fixed_trail_again = false; |
| } |
| if(static_cast<std::size_t>(pe - m_current) < m_trail) { |
| off = m_current - m_start; |
| return 0; |
| } |
| n = m_current; |
| m_current += m_trail - 1; |
| switch(m_cs) { |
| //case MSGPACK_CS_ |
| //case MSGPACK_CS_ |
| case MSGPACK_CS_FLOAT: { |
| union { uint32_t i; float f; } mem; |
| load<uint32_t>(mem.i, n); |
| unpack_float(mem.f, obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } break; |
| case MSGPACK_CS_DOUBLE: { |
| union { uint64_t i; double f; } mem; |
| load<uint64_t>(mem.i, n); |
| #if defined(TARGET_OS_IPHONE) |
| // ok |
| #elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi |
| // https://github.com/msgpack/msgpack-perl/pull/1 |
| mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); |
| #endif |
| unpack_double(mem.f, obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } break; |
| case MSGPACK_CS_UINT_8: { |
| uint8_t tmp; |
| load<uint8_t>(tmp, n); |
| unpack_uint8(tmp, obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } break; |
| case MSGPACK_CS_UINT_16: { |
| uint16_t tmp; |
| load<uint16_t>(tmp, n); |
| unpack_uint16(tmp, obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } break; |
| case MSGPACK_CS_UINT_32: { |
| uint32_t tmp; |
| load<uint32_t>(tmp, n); |
| unpack_uint32(tmp, obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } break; |
| case MSGPACK_CS_UINT_64: { |
| uint64_t tmp; |
| load<uint64_t>(tmp, n); |
| unpack_uint64(tmp, obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } break; |
| case MSGPACK_CS_INT_8: { |
| int8_t tmp; |
| load<int8_t>(tmp, n); |
| unpack_int8(tmp, obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } break; |
| case MSGPACK_CS_INT_16: { |
| int16_t tmp; |
| load<int16_t>(tmp, n); |
| unpack_int16(tmp, obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } break; |
| case MSGPACK_CS_INT_32: { |
| int32_t tmp; |
| load<int32_t>(tmp, n); |
| unpack_int32(tmp, obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } break; |
| case MSGPACK_CS_INT_64: { |
| int64_t tmp; |
| load<int64_t>(tmp, n); |
| unpack_int64(tmp, obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } break; |
| case MSGPACK_CS_FIXEXT_1: { |
| unpack_ext(m_user, n, 1+1, obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } break; |
| case MSGPACK_CS_FIXEXT_2: { |
| unpack_ext(m_user, n, 2+1, obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } break; |
| case MSGPACK_CS_FIXEXT_4: { |
| unpack_ext(m_user, n, 4+1, obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } break; |
| case MSGPACK_CS_FIXEXT_8: { |
| unpack_ext(m_user, n, 8+1, obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } break; |
| case MSGPACK_CS_FIXEXT_16: { |
| unpack_ext(m_user, n, 16+1, obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } break; |
| case MSGPACK_CS_STR_8: { |
| uint8_t tmp; |
| load<uint8_t>(tmp, n); |
| m_trail = tmp; |
| if(m_trail == 0) { |
| unpack_str(m_user, n, static_cast<uint32_t>(m_trail), obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } |
| else { |
| m_cs = MSGPACK_ACS_STR_VALUE; |
| fixed_trail_again = true; |
| } |
| } break; |
| case MSGPACK_CS_BIN_8: { |
| uint8_t tmp; |
| load<uint8_t>(tmp, n); |
| m_trail = tmp; |
| if(m_trail == 0) { |
| unpack_bin(m_user, n, static_cast<uint32_t>(m_trail), obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } |
| else { |
| m_cs = MSGPACK_ACS_BIN_VALUE; |
| fixed_trail_again = true; |
| } |
| } break; |
| case MSGPACK_CS_EXT_8: { |
| uint8_t tmp; |
| load<uint8_t>(tmp, n); |
| m_trail = tmp + 1; |
| if(m_trail == 0) { |
| unpack_ext(m_user, n, m_trail, obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } |
| else { |
| m_cs = MSGPACK_ACS_EXT_VALUE; |
| fixed_trail_again = true; |
| } |
| } break; |
| case MSGPACK_CS_STR_16: { |
| uint16_t tmp; |
| load<uint16_t>(tmp, n); |
| m_trail = tmp; |
| if(m_trail == 0) { |
| unpack_str(m_user, n, static_cast<uint32_t>(m_trail), obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } |
| else { |
| m_cs = MSGPACK_ACS_STR_VALUE; |
| fixed_trail_again = true; |
| } |
| } break; |
| case MSGPACK_CS_BIN_16: { |
| uint16_t tmp; |
| load<uint16_t>(tmp, n); |
| m_trail = tmp; |
| if(m_trail == 0) { |
| unpack_bin(m_user, n, static_cast<uint32_t>(m_trail), obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } |
| else { |
| m_cs = MSGPACK_ACS_BIN_VALUE; |
| fixed_trail_again = true; |
| } |
| } break; |
| case MSGPACK_CS_EXT_16: { |
| uint16_t tmp; |
| load<uint16_t>(tmp, n); |
| m_trail = tmp + 1; |
| if(m_trail == 0) { |
| unpack_ext(m_user, n, m_trail, obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } |
| else { |
| m_cs = MSGPACK_ACS_EXT_VALUE; |
| fixed_trail_again = true; |
| } |
| } break; |
| case MSGPACK_CS_STR_32: { |
| uint32_t tmp; |
| load<uint32_t>(tmp, n); |
| m_trail = tmp; |
| if(m_trail == 0) { |
| unpack_str(m_user, n, static_cast<uint32_t>(m_trail), obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } |
| else { |
| m_cs = MSGPACK_ACS_STR_VALUE; |
| fixed_trail_again = true; |
| } |
| } break; |
| case MSGPACK_CS_BIN_32: { |
| uint32_t tmp; |
| load<uint32_t>(tmp, n); |
| m_trail = tmp; |
| if(m_trail == 0) { |
| unpack_bin(m_user, n, static_cast<uint32_t>(m_trail), obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } |
| else { |
| m_cs = MSGPACK_ACS_BIN_VALUE; |
| fixed_trail_again = true; |
| } |
| } break; |
| case MSGPACK_CS_EXT_32: { |
| uint32_t tmp; |
| load<uint32_t>(tmp, n); |
| check_ext_size<sizeof(std::size_t)>(tmp); |
| m_trail = tmp; |
| ++m_trail; |
| if(m_trail == 0) { |
| unpack_ext(m_user, n, m_trail, obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } |
| else { |
| m_cs = MSGPACK_ACS_EXT_VALUE; |
| fixed_trail_again = true; |
| } |
| } break; |
| case MSGPACK_ACS_STR_VALUE: { |
| unpack_str(m_user, n, static_cast<uint32_t>(m_trail), obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } break; |
| case MSGPACK_ACS_BIN_VALUE: { |
| unpack_bin(m_user, n, static_cast<uint32_t>(m_trail), obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } break; |
| case MSGPACK_ACS_EXT_VALUE: { |
| unpack_ext(m_user, n, m_trail, obj); |
| int ret = push_proc(obj, off); |
| if (ret != 0) return ret; |
| } break; |
| case MSGPACK_CS_ARRAY_16: { |
| int ret = push_aggregate<uint16_t>( |
| unpack_array(), MSGPACK_CT_ARRAY_ITEM, obj, n, off); |
| if (ret != 0) return ret; |
| } break; |
| case MSGPACK_CS_ARRAY_32: { |
| /* FIXME security guard */ |
| int ret = push_aggregate<uint32_t>( |
| unpack_array(), MSGPACK_CT_ARRAY_ITEM, obj, n, off); |
| if (ret != 0) return ret; |
| } break; |
| case MSGPACK_CS_MAP_16: { |
| int ret = push_aggregate<uint16_t>( |
| unpack_map(), MSGPACK_CT_MAP_KEY, obj, n, off); |
| if (ret != 0) return ret; |
| } break; |
| case MSGPACK_CS_MAP_32: { |
| /* FIXME security guard */ |
| int ret = push_aggregate<uint32_t>( |
| unpack_map(), MSGPACK_CT_MAP_KEY, obj, n, off); |
| if (ret != 0) return ret; |
| } break; |
| default: |
| off = m_current - m_start; |
| return -1; |
| } |
| } |
| } while(m_current != pe); |
| |
| off = m_current - m_start; |
| return 0; |
| } |
| |
| } // detail |
| |
| |
| typedef object_handle unpacked; |
| |
| /// Unpacking class for a stream deserialization. |
| class unpacker { |
| public: |
| /// Constructor |
| /** |
| * @param referenced If the unpacked object contains reference of the buffer, then set as true, otherwise false. |
| * @param f A judging function that msgpack::object refer to the buffer. |
| * @param user_data This parameter is passed to f. |
| * @param initial_buffer_size The memory size to allocate when unpacker is constructed. |
| * @param limit The size limit information of msgpack::object. |
| * |
| */ |
| unpacker(unpack_reference_func f = &unpacker::default_reference_func, |
| void* user_data = nullptr, |
| std::size_t initial_buffer_size = MSGPACK_UNPACKER_INIT_BUFFER_SIZE, |
| unpack_limit const& limit = unpack_limit()); |
| |
| #if !defined(MSGPACK_USE_CPP03) |
| unpacker(unpacker&& other); |
| unpacker& operator=(unpacker&& other); |
| #endif // !defined(MSGPACK_USE_CPP03) |
| |
| ~unpacker(); |
| |
| public: |
| /// Reserve a buffer memory. |
| /** |
| * @param size The size of allocating memory. |
| * |
| * After returning this function, buffer_capacity() returns at least 'size'. |
| * See: |
| * https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_unpacker#msgpack-controls-a-buffer |
| */ |
| void reserve_buffer(std::size_t size = MSGPACK_UNPACKER_RESERVE_SIZE); |
| |
| /// Get buffer pointer. |
| /** |
| * You need to care about the memory is enable between buffer() and buffer() + buffer_capacity() |
| * See: |
| * https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_unpacker#msgpack-controls-a-buffer |
| */ |
| char* buffer(); |
| |
| /// Get buffer capacity. |
| /** |
| * @return The memory size that you can write. |
| * |
| * See: |
| * https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_unpacker#msgpack-controls-a-buffer |
| */ |
| std::size_t buffer_capacity() const; |
| |
| /// Notify a buffer consumed information to msgpack::unpacker. |
| /** |
| * @param size The size of memory that you consumed. |
| * |
| * After copying the data to the memory that is pointed by buffer(), you need to call the |
| * function to notify how many bytes are consumed. Then you can call next() functions. |
| * |
| * See: |
| * https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_unpacker#msgpack-controls-a-buffer |
| */ |
| void buffer_consumed(std::size_t size); |
| |
| /// Unpack one msgpack::object. [obsolete] |
| /** |
| * |
| * @param result The object that contains unpacked data. |
| * |
| * @return If one msgpack::object is unpacked, then return true, if msgpack::object is incomplete |
| * and additional data is required, then return false. If data format is invalid, throw |
| * msgpack::parse_error. |
| * |
| * See: |
| * https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_unpacker#msgpack-controls-a-buffer |
| * This function is obsolete. Use the reference inteface version of next() function instead of |
| * the pointer interface version. |
| */ |
| bool next(unpacked* result); |
| |
| /// Unpack one msgpack::object. |
| /** |
| * |
| * @param result The object that contains unpacked data. |
| * @param referenced If the unpacked object contains reference of the buffer, |
| * then set as true, otherwise false. |
| * |
| * @return If one msgpack::object is unpacked, then return true, if msgpack::object is incomplete |
| * and additional data is required, then return false. If data format is invalid, throw |
| * msgpack::parse_error. |
| * |
| * See: |
| * https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_unpacker#msgpack-controls-a-buffer |
| */ |
| bool next(unpacked& result, bool& referenced); |
| |
| /// Unpack one msgpack::object. |
| /** |
| * |
| * @param result The object that contains unpacked data. |
| * |
| * @return If one msgpack::object is unpacked, then return true, if msgpack::object is incomplete |
| * and additional data is required, then return false. If data format is invalid, throw |
| * msgpack::parse_error. |
| * |
| * See: |
| * https://github.com/msgpack/msgpack-c/wiki/v1_1_cpp_unpacker#msgpack-controls-a-buffer |
| */ |
| bool next(unpacked& result); |
| |
| /// Get message size. |
| /** |
| * @return Returns parsed_size() + nonparsed_size() |
| */ |
| std::size_t message_size() const; |
| |
| /*! for backward compatibility */ |
| bool execute(); |
| |
| /*! for backward compatibility */ |
| msgpack::object const& data(); |
| |
| /*! for backward compatibility */ |
| msgpack::zone* release_zone(); |
| |
| /*! for backward compatibility */ |
| void reset_zone(); |
| |
| /*! for backward compatibility */ |
| void reset(); |
| |
| public: |
| /// Get parsed message size. |
| /** |
| * @return Parsed message size. |
| * |
| * This function is usable when non-MessagePack message follows after |
| * MessagePack message. |
| */ |
| std::size_t parsed_size() const; |
| |
| /// Get the address that is not parsed in the buffer. |
| /** |
| * @return Address of the buffer that is not parsed |
| * |
| * This function is usable when non-MessagePack message follows after |
| * MessagePack message. |
| */ |
| char* nonparsed_buffer(); |
| |
| /// Get the size of the buffer that is not parsed. |
| /** |
| * @return Size of the buffer that is not parsed |
| * |
| * This function is usable when non-MessagePack message follows after |
| * MessagePack message. |
| */ |
| std::size_t nonparsed_size() const; |
| |
| /// Skip the specified size of non-parsed buffer. |
| /** |
| * @param size to skip |
| * |
| * Note that the `size' argument must be smaller than nonparsed_size(). |
| * This function is usable when non-MessagePack message follows after |
| * MessagePack message. |
| */ |
| void skip_nonparsed_buffer(std::size_t size); |
| |
| /// Remove nonparsed buffer and reset the current position as a new start point. |
| /** |
| * This function is usable when non-MessagePack message follows after |
| * MessagePack message. |
| */ |
| void remove_nonparsed_buffer(); |
| |
| private: |
| void expand_buffer(std::size_t size); |
| int execute_imp(); |
| bool flush_zone(); |
| static bool default_reference_func(msgpack::type::object_type type, std::size_t len, void*); |
| |
| private: |
| char* m_buffer; |
| std::size_t m_used; |
| std::size_t m_free; |
| std::size_t m_off; |
| std::size_t m_parsed; |
| msgpack::unique_ptr<msgpack::zone> m_z; |
| std::size_t m_initial_buffer_size; |
| detail::context m_ctx; |
| |
| #if defined(MSGPACK_USE_CPP03) |
| private: |
| unpacker(const unpacker&); |
| unpacker& operator=(const unpacker&); |
| #else // defined(MSGPACK_USE_CPP03) |
| unpacker(const unpacker&) = delete; |
| unpacker& operator=(const unpacker&) = delete; |
| #endif // defined(MSGPACK_USE_CPP03) |
| }; |
| |
| /// Unpack msgpack::object from a buffer. |
| /** |
| * @param data The pointer to the buffer. |
| * @param len The length of the buffer. |
| * @param off The offset position of the buffer. It is read and overwritten. |
| * @param referenced If the unpacked object contains reference of the buffer, then set as true, otherwise false. |
| * @param f A judging function that msgpack::object refer to the buffer. |
| * @param user_data This parameter is passed to f. |
| * @param limit The size limit information of msgpack::object. |
| * |
| * @return unpacked object that contains unpacked data. |
| * |
| */ |
| unpacked unpack( |
| const char* data, std::size_t len, std::size_t& off, bool& referenced, |
| unpack_reference_func f = nullptr, void* user_data = nullptr, |
| unpack_limit const& limit = unpack_limit()); |
| |
| /// Unpack msgpack::object from a buffer. |
| /** |
| * @param data The pointer to the buffer. |
| * @param len The length of the buffer. |
| * @param off The offset position of the buffer. It is read and overwritten. |
| * @param f A judging function that msgpack::object refer to the buffer. |
| * @param user_data This parameter is passed to f. |
| * @param limit The size limit information of msgpack::object. |
| * |
| * @return unpacked object that contains unpacked data. |
| * |
| */ |
| unpacked unpack( |
| const char* data, std::size_t len, std::size_t& off, |
| unpack_reference_func f = nullptr, void* user_data = nullptr, |
| unpack_limit const& limit = unpack_limit()); |
| |
| /// Unpack msgpack::object from a buffer. |
| /** |
| * @param data The pointer to the buffer. |
| * @param len The length of the buffer. |
| * @param referenced If the unpacked object contains reference of the buffer, then set as true, otherwise false. |
| * @param f A judging function that msgpack::object refer to the buffer. |
| * @param user_data This parameter is passed to f. |
| * @param limit The size limit information of msgpack::object. |
| * |
| * @return unpacked object that contains unpacked data. |
| * |
| */ |
| unpacked unpack( |
| const char* data, std::size_t len, bool& referenced, |
| unpack_reference_func f = nullptr, void* user_data = nullptr, |
| unpack_limit const& limit = unpack_limit()); |
| |
| /// Unpack msgpack::object from a buffer. |
| /** |
| * @param data The pointer to the buffer. |
| * @param len The length of the buffer. |
| * @param f A judging function that msgpack::object refer to the buffer. |
| * @param user_data This parameter is passed to f. |
| * @param limit The size limit information of msgpack::object. |
| * |
| * @return unpacked object that contains unpacked data. |
| * |
| */ |
| unpacked unpack( |
| const char* data, std::size_t len, |
| unpack_reference_func f = nullptr, void* user_data = nullptr, |
| unpack_limit const& limit = unpack_limit()); |
| |
| |
| /// Unpack msgpack::object from a buffer. |
| /** |
| * @param result The object that contains unpacked data. |
| * @param data The pointer to the buffer. |
| * @param len The length of the buffer. |
| * @param off The offset position of the buffer. It is read and overwritten. |
| * @param referenced If the unpacked object contains reference of the buffer, then set as true, otherwise false. |
| * @param f A judging function that msgpack::object refer to the buffer. |
| * @param user_data This parameter is passed to f. |
| * @param limit The size limit information of msgpack::object. |
| * |
| * |
| */ |
| void unpack(unpacked& result, |
| const char* data, std::size_t len, std::size_t& off, bool& referenced, |
| unpack_reference_func f = nullptr, void* user_data = nullptr, |
| unpack_limit const& limit = unpack_limit()); |
| |
| /// Unpack msgpack::object from a buffer. |
| /** |
| * @param result The object that contains unpacked data. |
| * @param data The pointer to the buffer. |
| * @param len The length of the buffer. |
| * @param off The offset position of the buffer. It is read and overwritten. |
| * @param f A judging function that msgpack::object refer to the buffer. |
| * @param user_data This parameter is passed to f. |
| * @param limit The size limit information of msgpack::object. |
| * |
| * |
| */ |
| void unpack(unpacked& result, |
| const char* data, std::size_t len, std::size_t& off, |
| unpack_reference_func f = nullptr, void* user_data = nullptr, |
| unpack_limit const& limit = unpack_limit()); |
| |
| /// Unpack msgpack::object from a buffer. |
| /** |
| * @param result The object that contains unpacked data. |
| * @param data The pointer to the buffer. |
| * @param len The length of the buffer. |
| * @param referenced If the unpacked object contains reference of the buffer, then set as true, otherwise false. |
| * @param f A judging function that msgpack::object refer to the buffer. |
| * @param user_data This parameter is passed to f. |
| * @param limit The size limit information of msgpack::object. |
| * |
| * |
| */ |
| void unpack(unpacked& result, |
| const char* data, std::size_t len, bool& referenced, |
| unpack_reference_func f = nullptr, void* user_data = nullptr, |
| unpack_limit const& limit = unpack_limit()); |
| |
| /// Unpack msgpack::object from a buffer. |
| /** |
| * @param result The object that contains unpacked data. |
| * @param data The pointer to the buffer. |
| * @param len The length of the buffer. |
| * @param f A judging function that msgpack::object refer to the buffer. |
| * @param user_data This parameter is passed to f. |
| * @param limit The size limit information of msgpack::object. |
| * |
| * |
| */ |
| void unpack(unpacked& result, |
| const char* data, std::size_t len, |
| unpack_reference_func f = nullptr, void* user_data = nullptr, |
| unpack_limit const& limit = unpack_limit()); |
| |
| /// Unpack msgpack::object from a buffer. |
| /** |
| * @param z The msgpack::zone that is used as a memory of unpacked msgpack objects. |
| * @param data The pointer to the buffer. |
| * @param len The length of the buffer. |
| * @param off The offset position of the buffer. It is read and overwritten. |
| * @param referenced If the unpacked object contains reference of the buffer, then set as true, otherwise false. |
| * @param f A judging function that msgpack::object refer to the buffer. |
| * @param user_data This parameter is passed to f. |
| * @param limit The size limit information of msgpack::object. |
| * |
| * @return msgpack::object that contains unpacked data. |
| * |
| */ |
| msgpack::object unpack( |
| msgpack::zone& z, |
| const char* data, std::size_t len, std::size_t& off, bool& referenced, |
| unpack_reference_func f = nullptr, void* user_data = nullptr, |
| unpack_limit const& limit = unpack_limit()); |
| |
| /// Unpack msgpack::object from a buffer. |
| /** |
| * @param z The msgpack::zone that is used as a memory of unpacked msgpack objects. |
| * @param data The pointer to the buffer. |
| * @param len The length of the buffer. |
| * @param off The offset position of the buffer. It is read and overwritten. |
| * @param f A judging function that msgpack::object refer to the buffer. |
| * @param user_data This parameter is passed to f. |
| * @param limit The size limit information of msgpack::object. |
| * |
| * @return msgpack::object that contains unpacked data. |
| * |
| */ |
| msgpack::object unpack( |
| msgpack::zone& z, |
| const char* data, std::size_t len, std::size_t& off, |
| unpack_reference_func f = nullptr, void* user_data = nullptr, |
| unpack_limit const& limit = unpack_limit()); |
| |
| /// Unpack msgpack::object from a buffer. |
| /** |
| * @param z The msgpack::zone that is used as a memory of unpacked msgpack objects. |
| * @param data The pointer to the buffer. |
| * @param len The length of the buffer. |
| * @param referenced If the unpacked object contains reference of the buffer, then set as true, otherwise false. |
| * @param f A judging function that msgpack::object refer to the buffer. |
| * @param user_data This parameter is passed to f. |
| * @param limit The size limit information of msgpack::object. |
| * |
| * @return msgpack::object that contains unpacked data. |
| * |
| */ |
| msgpack::object unpack( |
| msgpack::zone& z, |
| const char* data, std::size_t len, bool& referenced, |
| unpack_reference_func f = nullptr, void* user_data = nullptr, |
| unpack_limit const& limit = unpack_limit()); |
| |
| /// Unpack msgpack::object from a buffer. |
| /** |
| * @param z The msgpack::zone that is used as a memory of unpacked msgpack objects. |
| * @param data The pointer to the buffer. |
| * @param len The length of the buffer. |
| * @param f A judging function that msgpack::object refer to the buffer. |
| * @param user_data This parameter is passed to f. |
| * @param limit The size limit information of msgpack::object. |
| * |
| * @return msgpack::object that contains unpacked data. |
| * |
| */ |
| msgpack::object unpack( |
| msgpack::zone& z, |
| const char* data, std::size_t len, |
| unpack_reference_func f = nullptr, void* user_data = nullptr, |
| unpack_limit const& limit = unpack_limit()); |
| |
| |
| /// Unpack msgpack::object from a buffer. [obsolete] |
| /** |
| * @param result The object that contains unpacked data. |
| * @param data The pointer to the buffer. |
| * @param len The length of the buffer. |
| * @param off The offset position of the buffer. It is read and overwritten. |
| * @param referenced If the unpacked object contains reference of the buffer, then set as true, otherwise false. |
| * @param f A judging function that msgpack::object refer to the buffer. |
| * @param user_data This parameter is passed to f. |
| * @param limit The size limit information of msgpack::object. |
| * |
| * This function is obsolete. Use the reference inteface version of unpack functions instead of the pointer interface version. |
| */ |
| void unpack(unpacked* result, |
| const char* data, std::size_t len, std::size_t* off = nullptr, bool* referenced = nullptr, |
| unpack_reference_func f = nullptr, void* user_data = nullptr, |
| unpack_limit const& limit = unpack_limit()); |
| |
| |
| // for internal use |
| typedef enum { |
| UNPACK_SUCCESS = 2, |
| UNPACK_EXTRA_BYTES = 1, |
| UNPACK_CONTINUE = 0, |
| UNPACK_PARSE_ERROR = -1 |
| } unpack_return; |
| |
| inline unpacker::unpacker(unpack_reference_func f, |
| void* user_data, |
| std::size_t initial_buffer_size, |
| unpack_limit const& limit) |
| :m_z(new msgpack::zone), m_ctx(f, user_data, limit) |
| { |
| if(initial_buffer_size < COUNTER_SIZE) { |
| initial_buffer_size = COUNTER_SIZE; |
| } |
| |
| char* buffer = static_cast<char*>(::malloc(initial_buffer_size)); |
| if(!buffer) { |
| throw std::bad_alloc(); |
| } |
| |
| m_buffer = buffer; |
| m_used = COUNTER_SIZE; |
| m_free = initial_buffer_size - m_used; |
| m_off = COUNTER_SIZE; |
| m_parsed = 0; |
| m_initial_buffer_size = initial_buffer_size; |
| |
| detail::init_count(m_buffer); |
| |
| m_ctx.init(); |
| m_ctx.user().set_zone(*m_z); |
| m_ctx.user().set_referenced(false); |
| } |
| |
| #if !defined(MSGPACK_USE_CPP03) |
| // Move constructor and move assignment operator |
| |
| inline unpacker::unpacker(unpacker&& other) |
| :m_buffer(other.m_buffer), |
| m_used(other.m_used), |
| m_free(other.m_free), |
| m_off(other.m_off), |
| m_parsed(other.m_parsed), |
| m_z(std::move(other.m_z)), |
| m_initial_buffer_size(other.m_initial_buffer_size), |
| m_ctx(other.m_ctx) { |
| other.m_buffer = nullptr; |
| } |
| |
| inline unpacker& unpacker::operator=(unpacker&& other) { |
| this->~unpacker(); |
| new (this) unpacker(std::move(other)); |
| return *this; |
| } |
| |
| #endif // !defined(MSGPACK_USE_CPP03) |
| |
| |
| inline unpacker::~unpacker() |
| { |
| // These checks are required for move operations. |
| if (m_buffer) detail::decr_count(m_buffer); |
| } |
| |
| |
| inline void unpacker::reserve_buffer(std::size_t size) |
| { |
| if(m_free >= size) return; |
| expand_buffer(size); |
| } |
| |
| inline void unpacker::expand_buffer(std::size_t size) |
| { |
| if(m_used == m_off && detail::get_count(m_buffer) == 1 |
| && !m_ctx.user().referenced()) { |
| // rewind buffer |
| m_free += m_used - COUNTER_SIZE; |
| m_used = COUNTER_SIZE; |
| m_off = COUNTER_SIZE; |
| |
| if(m_free >= size) return; |
| } |
| |
| if(m_off == COUNTER_SIZE) { |
| std::size_t next_size = (m_used + m_free) * 2; // include COUNTER_SIZE |
| while(next_size < size + m_used) { |
| std::size_t tmp_next_size = next_size * 2; |
| if (tmp_next_size <= next_size) { |
| next_size = size + m_used; |
| break; |
| } |
| next_size = tmp_next_size; |
| } |
| |
| char* tmp = static_cast<char*>(::realloc(m_buffer, next_size)); |
| if(!tmp) { |
| throw std::bad_alloc(); |
| } |
| |
| m_buffer = tmp; |
| m_free = next_size - m_used; |
| |
| } else { |
| std::size_t next_size = m_initial_buffer_size; // include COUNTER_SIZE |
| std::size_t not_parsed = m_used - m_off; |
| while(next_size < size + not_parsed + COUNTER_SIZE) { |
| std::size_t tmp_next_size = next_size * 2; |
| if (tmp_next_size <= next_size) { |
| next_size = size + not_parsed + COUNTER_SIZE; |
| break; |
| } |
| next_size = tmp_next_size; |
| } |
| |
| char* tmp = static_cast<char*>(::malloc(next_size)); |
| if(!tmp) { |
| throw std::bad_alloc(); |
| } |
| |
| detail::init_count(tmp); |
| |
| std::memcpy(tmp+COUNTER_SIZE, m_buffer + m_off, not_parsed); |
| |
| if(m_ctx.user().referenced()) { |
| try { |
| m_z->push_finalizer(&detail::decr_count, m_buffer); |
| } |
| catch (...) { |
| ::free(tmp); |
| throw; |
| } |
| m_ctx.user().set_referenced(false); |
| } else { |
| detail::decr_count(m_buffer); |
| } |
| |
| m_buffer = tmp; |
| m_used = not_parsed + COUNTER_SIZE; |
| m_free = next_size - m_used; |
| m_off = COUNTER_SIZE; |
| } |
| } |
| |
| inline char* unpacker::buffer() |
| { |
| return m_buffer + m_used; |
| } |
| |
| inline std::size_t unpacker::buffer_capacity() const |
| { |
| return m_free; |
| } |
| |
| inline void unpacker::buffer_consumed(std::size_t size) |
| { |
| m_used += size; |
| m_free -= size; |
| } |
| |
| inline bool unpacker::next(unpacked& result, bool& referenced) |
| { |
| referenced = false; |
| int ret = execute_imp(); |
| if(ret < 0) { |
| throw msgpack::parse_error("parse error"); |
| } |
| |
| if(ret == 0) { |
| result.zone().reset(); |
| result.set(object()); |
| return false; |
| |
| } else { |
| referenced = m_ctx.user().referenced(); |
| result.zone().reset( release_zone() ); |
| result.set(data()); |
| reset(); |
| return true; |
| } |
| } |
| |
| inline bool unpacker::next(unpacked& result) |
| { |
| bool referenced; |
| return next(result, referenced); |
| } |
| |
| inline bool unpacker::next(unpacked* result) |
| { |
| return next(*result); |
| } |
| |
| |
| inline bool unpacker::execute() |
| { |
| int ret = execute_imp(); |
| if(ret < 0) { |
| throw msgpack::parse_error("parse error"); |
| } else if(ret == 0) { |
| return false; |
| } else { |
| return true; |
| } |
| } |
| |
| inline int unpacker::execute_imp() |
| { |
| std::size_t off = m_off; |
| int ret = m_ctx.execute(m_buffer, m_used, m_off); |
| if(m_off > off) { |
| m_parsed += m_off - off; |
| } |
| return ret; |
| } |
| |
| inline msgpack::object const& unpacker::data() |
| { |
| return m_ctx.data(); |
| } |
| |
| inline msgpack::zone* unpacker::release_zone() |
| { |
| if(!flush_zone()) { |
| return nullptr; |
| } |
| |
| msgpack::zone* r = new msgpack::zone; |
| msgpack::zone* old = m_z.release(); |
| m_z.reset(r); |
| m_ctx.user().set_zone(*m_z); |
| |
| return old; |
| } |
| |
| inline void unpacker::reset_zone() |
| { |
| m_z->clear(); |
| } |
| |
| inline bool unpacker::flush_zone() |
| { |
| if(m_ctx.user().referenced()) { |
| try { |
| m_z->push_finalizer(&detail::decr_count, m_buffer); |
| } catch (...) { |
| return false; |
| } |
| m_ctx.user().set_referenced(false); |
| |
| detail::incr_count(m_buffer); |
| } |
| |
| return true; |
| } |
| |
| inline void unpacker::reset() |
| { |
| m_ctx.init(); |
| // don't reset referenced flag |
| m_parsed = 0; |
| } |
| |
| inline std::size_t unpacker::message_size() const |
| { |
| return m_parsed - m_off + m_used; |
| } |
| |
| inline std::size_t unpacker::parsed_size() const |
| { |
| return m_parsed; |
| } |
| |
| inline char* unpacker::nonparsed_buffer() |
| { |
| return m_buffer + m_off; |
| } |
| |
| inline std::size_t unpacker::nonparsed_size() const |
| { |
| return m_used - m_off; |
| } |
| |
| inline void unpacker::skip_nonparsed_buffer(std::size_t size) |
| { |
| m_off += size; |
| } |
| |
| inline void unpacker::remove_nonparsed_buffer() |
| { |
| m_used = m_off; |
| } |
| |
| namespace detail { |
| |
| inline unpack_return |
| unpack_imp(const char* data, std::size_t len, std::size_t& off, |
| msgpack::zone& result_zone, msgpack::object& result, bool& referenced, |
| unpack_reference_func f = nullptr, void* user_data = nullptr, |
| unpack_limit const& limit = unpack_limit()) |
| { |
| std::size_t noff = off; |
| |
| if(len <= noff) { |
| // FIXME |
| return UNPACK_CONTINUE; |
| } |
| |
| detail::context ctx(f, user_data, limit); |
| ctx.init(); |
| |
| ctx.user().set_zone(result_zone); |
| ctx.user().set_referenced(false); |
| referenced = false; |
| |
| int e = ctx.execute(data, len, noff); |
| if(e < 0) { |
| return UNPACK_PARSE_ERROR; |
| } |
| |
| referenced = ctx.user().referenced(); |
| off = noff; |
| |
| if(e == 0) { |
| return UNPACK_CONTINUE; |
| } |
| |
| result = ctx.data(); |
| |
| if(noff < len) { |
| return UNPACK_EXTRA_BYTES; |
| } |
| |
| return UNPACK_SUCCESS; |
| } |
| |
| } // detail |
| |
| // reference version |
| |
| inline unpacked unpack( |
| const char* data, std::size_t len, std::size_t& off, bool& referenced, |
| unpack_reference_func f, void* user_data, unpack_limit const& limit) |
| { |
| msgpack::object obj; |
| msgpack::unique_ptr<msgpack::zone> z(new msgpack::zone); |
| referenced = false; |
| std::size_t noff = off; |
| unpack_return ret = detail::unpack_imp( |
| data, len, noff, *z, obj, referenced, f, user_data, limit); |
| |
| switch(ret) { |
| case UNPACK_SUCCESS: |
| off = noff; |
| return unpacked(obj, msgpack::move(z)); |
| case UNPACK_EXTRA_BYTES: |
| off = noff; |
| return unpacked(obj, msgpack::move(z)); |
| case UNPACK_CONTINUE: |
| throw msgpack::insufficient_bytes("insufficient bytes"); |
| case UNPACK_PARSE_ERROR: |
| default: |
| throw msgpack::parse_error("parse error"); |
| } |
| return unpacked(); |
| } |
| |
| inline unpacked unpack( |
| const char* data, std::size_t len, std::size_t& off, |
| unpack_reference_func f, void* user_data, unpack_limit const& limit) |
| { |
| bool referenced; |
| return unpack(data, len, off, referenced, f, user_data, limit); |
| } |
| |
| inline unpacked unpack( |
| const char* data, std::size_t len, bool& referenced, |
| unpack_reference_func f, void* user_data, unpack_limit const& limit) |
| { |
| std::size_t off = 0; |
| return unpack(data, len, off, referenced, f, user_data, limit); |
| } |
| |
| inline unpacked unpack( |
| const char* data, std::size_t len, |
| unpack_reference_func f, void* user_data, unpack_limit const& limit) |
| { |
| bool referenced; |
| std::size_t off = 0; |
| return unpack(data, len, off, referenced, f, user_data, limit); |
| } |
| |
| inline void unpack(unpacked& result, |
| const char* data, std::size_t len, std::size_t& off, bool& referenced, |
| unpack_reference_func f, void* user_data, unpack_limit const& limit) |
| { |
| msgpack::object obj; |
| msgpack::unique_ptr<msgpack::zone> z(new msgpack::zone); |
| referenced = false; |
| std::size_t noff = off; |
| unpack_return ret = detail::unpack_imp( |
| data, len, noff, *z, obj, referenced, f, user_data, limit); |
| |
| switch(ret) { |
| case UNPACK_SUCCESS: |
| off = noff; |
| result.set(obj); |
| result.zone() = msgpack::move(z); |
| return; |
| case UNPACK_EXTRA_BYTES: |
| off = noff; |
| result.set(obj); |
| result.zone() = msgpack::move(z); |
| return; |
| case UNPACK_CONTINUE: |
| throw msgpack::insufficient_bytes("insufficient bytes"); |
| case UNPACK_PARSE_ERROR: |
| default: |
| throw msgpack::parse_error("parse error"); |
| } |
| } |
| |
| inline void unpack(unpacked& result, |
| const char* data, std::size_t len, std::size_t& off, |
| unpack_reference_func f, void* user_data, unpack_limit const& limit) |
| { |
| bool referenced; |
| unpack(result, data, len, off, referenced, f, user_data, limit); |
| } |
| |
| inline void unpack(unpacked& result, |
| const char* data, std::size_t len, bool& referenced, |
| unpack_reference_func f, void* user_data, unpack_limit const& limit) |
| { |
| std::size_t off = 0; |
| unpack(result, data, len, off, referenced, f, user_data, limit); |
| } |
| |
| inline void unpack(unpacked& result, |
| const char* data, std::size_t len, |
| unpack_reference_func f, void* user_data, unpack_limit const& limit) |
| { |
| bool referenced; |
| std::size_t off = 0; |
| unpack(result, data, len, off, referenced, f, user_data, limit); |
| } |
| |
| |
| inline msgpack::object unpack( |
| msgpack::zone& z, |
| const char* data, std::size_t len, std::size_t& off, bool& referenced, |
| unpack_reference_func f, void* user_data, unpack_limit const& limit) |
| { |
| msgpack::object obj; |
| std::size_t noff = off; |
| referenced = false; |
| unpack_return ret = detail::unpack_imp( |
| data, len, noff, z, obj, referenced, f, user_data, limit); |
| |
| switch(ret) { |
| case UNPACK_SUCCESS: |
| off = noff; |
| return obj; |
| case UNPACK_EXTRA_BYTES: |
| off = noff; |
| return obj; |
| case UNPACK_CONTINUE: |
| throw msgpack::insufficient_bytes("insufficient bytes"); |
| case UNPACK_PARSE_ERROR: |
| default: |
| throw msgpack::parse_error("parse error"); |
| } |
| return obj; |
| } |
| |
| inline msgpack::object unpack( |
| msgpack::zone& z, |
| const char* data, std::size_t len, std::size_t& off, |
| unpack_reference_func f, void* user_data, unpack_limit const& limit) |
| { |
| bool referenced; |
| return unpack(z, data, len, off, referenced, f, user_data, limit); |
| } |
| |
| inline msgpack::object unpack( |
| msgpack::zone& z, |
| const char* data, std::size_t len, bool& referenced, |
| unpack_reference_func f, void* user_data, unpack_limit const& limit) |
| { |
| std::size_t off = 0; |
| return unpack(z, data, len, off, referenced, f, user_data, limit); |
| } |
| |
| inline msgpack::object unpack( |
| msgpack::zone& z, |
| const char* data, std::size_t len, |
| unpack_reference_func f, void* user_data, unpack_limit const& limit) |
| { |
| bool referenced; |
| std::size_t off = 0; |
| return unpack(z, data, len, off, referenced, f, user_data, limit); |
| } |
| |
| // obsolete |
| // pointer version |
| inline void unpack(unpacked* result, |
| const char* data, std::size_t len, std::size_t* off, bool* referenced, |
| unpack_reference_func f, void* user_data, unpack_limit const& limit) |
| { |
| if (off) |
| if (referenced) unpack(*result, data, len, *off, *referenced, f, user_data, limit); |
| else unpack(*result, data, len, *off, f, user_data, limit); |
| else |
| if (referenced) unpack(*result, data, len, *referenced, f, user_data, limit); |
| else unpack(*result, data, len, f, user_data, limit); |
| } |
| |
| inline bool unpacker::default_reference_func(msgpack::type::object_type /*type*/, std::size_t /*len*/, void*) |
| { |
| return true; |
| } |
| |
| /// @cond |
| } // MSGPACK_API_VERSION_NAMESPACE(v1) |
| /// @endcond |
| |
| } // namespace msgpack |
| |
| |
| #endif /* msgpack/unpack.hpp */ |
