| #include <msgpack.hpp> | |
| #include <gtest/gtest.h> | |
| #include <sstream> | |
| TEST(limit, unpack_array_no_over) | |
| { | |
| std::stringstream ss; | |
| std::vector<int> v; | |
| v.push_back(1); | |
| v.push_back(2); | |
| v.push_back(3); | |
| msgpack::pack(ss, v); | |
| try { | |
| msgpack::unpacked unp; | |
| msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, | |
| msgpack::unpack_limit(3, 0, 0, 0, 0)); | |
| EXPECT_TRUE(true); | |
| } | |
| catch(msgpack::array_size_overflow const&) { | |
| EXPECT_TRUE(false); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| TEST(limit, unpack_array_over) | |
| { | |
| std::stringstream ss; | |
| std::vector<int> v; | |
| v.push_back(1); | |
| v.push_back(2); | |
| v.push_back(3); | |
| msgpack::pack(ss, v); | |
| try { | |
| msgpack::unpacked unp; | |
| msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, | |
| msgpack::unpack_limit(2, 0, 0, 0, 0)); | |
| EXPECT_TRUE(false); | |
| } | |
| catch(msgpack::array_size_overflow const&) { | |
| EXPECT_TRUE(true); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| TEST(limit, unpack_map_no_over) | |
| { | |
| std::stringstream ss; | |
| std::map<int, int> m; | |
| m[1] = 1; | |
| m[2] = 2; | |
| m[3] = 3; | |
| msgpack::pack(ss, m); | |
| try { | |
| msgpack::unpacked unp; | |
| msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, | |
| msgpack::unpack_limit(0, 3, 0, 0, 0)); | |
| EXPECT_TRUE(true); | |
| } | |
| catch(msgpack::map_size_overflow const&) { | |
| EXPECT_TRUE(false); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| TEST(limit, unpack_map_over) | |
| { | |
| std::stringstream ss; | |
| std::map<int, int> m; | |
| m[1] = 1; | |
| m[2] = 2; | |
| m[3] = 3; | |
| msgpack::pack(ss, m); | |
| try { | |
| msgpack::unpacked unp; | |
| msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, | |
| msgpack::unpack_limit(0, 2, 0, 0, 0)); | |
| EXPECT_TRUE(false); | |
| } | |
| catch(msgpack::map_size_overflow const&) { | |
| EXPECT_TRUE(true); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| TEST(limit, unpack_str_no_over) | |
| { | |
| std::stringstream ss; | |
| std::string s("123"); | |
| msgpack::pack(ss, s); | |
| try { | |
| msgpack::unpacked unp; | |
| msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, | |
| msgpack::unpack_limit(0, 0, 3, 0, 0)); | |
| EXPECT_TRUE(true); | |
| } | |
| catch(msgpack::str_size_overflow const&) { | |
| EXPECT_TRUE(false); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| TEST(limit, unpack_str_over) | |
| { | |
| std::stringstream ss; | |
| std::string s("123"); | |
| msgpack::pack(ss, s); | |
| try { | |
| msgpack::unpacked unp; | |
| msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, | |
| msgpack::unpack_limit(0, 0, 2, 0, 0)); | |
| EXPECT_TRUE(false); | |
| } | |
| catch(msgpack::str_size_overflow const&) { | |
| EXPECT_TRUE(true); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| TEST(limit, unpack_bin_no_over) | |
| { | |
| std::stringstream ss; | |
| std::vector<char> v; | |
| v.push_back('1'); | |
| v.push_back('2'); | |
| v.push_back('3'); | |
| msgpack::pack(ss, v); | |
| try { | |
| msgpack::unpacked unp; | |
| msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, | |
| msgpack::unpack_limit(0, 0, 0, 3, 0)); | |
| EXPECT_TRUE(true); | |
| } | |
| catch(msgpack::bin_size_overflow const&) { | |
| EXPECT_TRUE(false); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| TEST(limit, unpack_bin_over) | |
| { | |
| std::stringstream ss; | |
| std::vector<char> v; | |
| v.push_back('1'); | |
| v.push_back('2'); | |
| v.push_back('3'); | |
| msgpack::pack(ss, v); | |
| try { | |
| msgpack::unpacked unp; | |
| msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, | |
| msgpack::unpack_limit(0, 0, 0, 2, 0)); | |
| EXPECT_TRUE(false); | |
| } | |
| catch(msgpack::bin_size_overflow const&) { | |
| EXPECT_TRUE(true); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| TEST(limit, unpack_ext_no_over) | |
| { | |
| std::stringstream ss; | |
| msgpack::packer<std::stringstream> packer(ss); | |
| char const buf [] = { 1, 2, 3 }; | |
| packer.pack_ext(sizeof(buf), 1); | |
| packer.pack_ext_body(buf, sizeof(buf)); | |
| try { | |
| msgpack::unpacked unp; | |
| msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, | |
| msgpack::unpack_limit(0, 0, 0, 0, 3+1)); | |
| EXPECT_TRUE(true); | |
| } | |
| catch(msgpack::ext_size_overflow const&) { | |
| EXPECT_TRUE(false); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| TEST(limit, unpack_ext_over) | |
| { | |
| std::stringstream ss; | |
| msgpack::packer<std::stringstream> packer(ss); | |
| char const buf [] = { 1, 2, 3 }; | |
| packer.pack_ext(sizeof(buf), 1); | |
| packer.pack_ext_body(buf, sizeof(buf)); | |
| try { | |
| msgpack::unpacked unp; | |
| msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, | |
| msgpack::unpack_limit(0, 0, 0, 0, 2+1)); | |
| EXPECT_TRUE(false); | |
| } | |
| catch(msgpack::ext_size_overflow const&) { | |
| EXPECT_TRUE(true); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| TEST(limit, unpack_ext_over_32_bit) | |
| { | |
| if (sizeof(std::size_t) == 4) { | |
| char const buf [] = { | |
| static_cast<char>(0xc9u), | |
| static_cast<char>(0xffu), | |
| static_cast<char>(0xffu), | |
| static_cast<char>(0xffu), | |
| static_cast<char>(0xffu), | |
| static_cast<char>(0x01u), | |
| }; | |
| try { | |
| msgpack::unpacked unp; | |
| msgpack::unpack(unp, buf, sizeof(buf), nullptr, nullptr, | |
| msgpack::unpack_limit(0, 0, 0, 0, 0xffffffff)); | |
| EXPECT_TRUE(false); | |
| } | |
| catch(msgpack::ext_size_overflow const&) { | |
| EXPECT_TRUE(true); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| } | |
| TEST(limit, unpack_ext_no_over_64_bit) | |
| { | |
| if (sizeof(std::size_t) == 8) { | |
| char const buf [] = { | |
| static_cast<char>(0xc9u), | |
| static_cast<char>(0xffu), | |
| static_cast<char>(0xffu), | |
| static_cast<char>(0xffu), | |
| static_cast<char>(0xffu), | |
| static_cast<char>(0x01u), | |
| }; | |
| try { | |
| msgpack::unpacked unp; | |
| msgpack::unpack(unp, buf, sizeof(buf), nullptr, nullptr, | |
| msgpack::unpack_limit(0, 0, 0, 0, 0xffffffff)); | |
| EXPECT_TRUE(false); | |
| } | |
| catch(msgpack::ext_size_overflow const&) { | |
| EXPECT_TRUE(false); | |
| } | |
| catch(msgpack::insufficient_bytes const&) { | |
| EXPECT_TRUE(true); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| } | |
| TEST(limit, unpack_depth_no_over) | |
| { | |
| std::stringstream ss; | |
| std::vector<int> inner; | |
| inner.push_back(1); | |
| std::vector<std::vector<int> > outer; | |
| outer.push_back(inner); | |
| msgpack::pack(ss, outer); | |
| try { | |
| msgpack::unpacked unp; | |
| msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, | |
| msgpack::unpack_limit(1, 0, 0, 0, 0, 2)); | |
| EXPECT_TRUE(true); | |
| } | |
| catch(msgpack::depth_size_overflow const&) { | |
| EXPECT_TRUE(false); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| TEST(limit, unpack_depth_over) | |
| { | |
| std::stringstream ss; | |
| std::vector<int> inner; | |
| inner.push_back(1); | |
| std::vector<std::vector<int> > outer; | |
| outer.push_back(inner); | |
| msgpack::pack(ss, outer); | |
| try { | |
| msgpack::unpacked unp; | |
| msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, | |
| msgpack::unpack_limit(1, 0, 0, 0, 0, 1)); | |
| EXPECT_TRUE(false); | |
| } | |
| catch(msgpack::depth_size_overflow const&) { | |
| EXPECT_TRUE(true); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| #if !defined(MSGPACK_USE_CPP03) | |
| TEST(limit, unpack_array_over_cpp11_no_off_no_ref) | |
| { | |
| std::stringstream ss; | |
| std::vector<int> v; | |
| v.push_back(1); | |
| v.push_back(2); | |
| v.push_back(3); | |
| msgpack::pack(ss, v); | |
| try { | |
| msgpack::unpacked unp = | |
| msgpack::unpack(ss.str().c_str(), ss.str().size(), nullptr, nullptr, | |
| msgpack::unpack_limit(2, 0, 0, 0, 0)); | |
| EXPECT_TRUE(false); | |
| } | |
| catch(msgpack::array_size_overflow const&) { | |
| EXPECT_TRUE(true); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| TEST(limit, unpack_array_over_cpp11_no_off_ref) | |
| { | |
| std::stringstream ss; | |
| std::vector<int> v; | |
| v.push_back(1); | |
| v.push_back(2); | |
| v.push_back(3); | |
| msgpack::pack(ss, v); | |
| try { | |
| bool ref; | |
| msgpack::unpacked unp = | |
| msgpack::unpack(ss.str().c_str(), ss.str().size(), ref, nullptr, nullptr, | |
| msgpack::unpack_limit(2, 0, 0, 0, 0)); | |
| EXPECT_TRUE(false); | |
| } | |
| catch(msgpack::array_size_overflow const&) { | |
| EXPECT_TRUE(true); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| TEST(limit, unpack_array_over_cpp11_off_no_ref) | |
| { | |
| std::stringstream ss; | |
| std::vector<int> v; | |
| v.push_back(1); | |
| v.push_back(2); | |
| v.push_back(3); | |
| msgpack::pack(ss, v); | |
| try { | |
| std::size_t off = 0; | |
| msgpack::unpacked unp = | |
| msgpack::unpack(ss.str().c_str(), ss.str().size(), off, nullptr, nullptr, | |
| msgpack::unpack_limit(2, 0, 0, 0, 0)); | |
| EXPECT_TRUE(false); | |
| } | |
| catch(msgpack::array_size_overflow const&) { | |
| EXPECT_TRUE(true); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| TEST(limit, unpack_array_over_cpp11_off_ref) | |
| { | |
| std::stringstream ss; | |
| std::vector<int> v; | |
| v.push_back(1); | |
| v.push_back(2); | |
| v.push_back(3); | |
| msgpack::pack(ss, v); | |
| try { | |
| bool ref; | |
| std::size_t off = 0; | |
| msgpack::unpacked unp = | |
| msgpack::unpack(ss.str().c_str(), ss.str().size(), off, ref, nullptr, nullptr, | |
| msgpack::unpack_limit(2, 0, 0, 0, 0)); | |
| EXPECT_TRUE(false); | |
| } | |
| catch(msgpack::array_size_overflow const&) { | |
| EXPECT_TRUE(true); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| #endif // !defined(MSGPACK_USE_CPP03) | |
| TEST(limit, unpack_array_over_no_off_no_ref) | |
| { | |
| std::stringstream ss; | |
| std::vector<int> v; | |
| v.push_back(1); | |
| v.push_back(2); | |
| v.push_back(3); | |
| msgpack::pack(ss, v); | |
| try { | |
| msgpack::unpacked unp; | |
| msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), nullptr, nullptr, | |
| msgpack::unpack_limit(2, 0, 0, 0, 0)); | |
| EXPECT_TRUE(false); | |
| } | |
| catch(msgpack::array_size_overflow const&) { | |
| EXPECT_TRUE(true); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| TEST(limit, unpack_array_over_no_off_ref) | |
| { | |
| std::stringstream ss; | |
| std::vector<int> v; | |
| v.push_back(1); | |
| v.push_back(2); | |
| v.push_back(3); | |
| msgpack::pack(ss, v); | |
| try { | |
| bool ref; | |
| msgpack::unpacked unp; | |
| msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), ref, nullptr, nullptr, | |
| msgpack::unpack_limit(2, 0, 0, 0, 0)); | |
| EXPECT_TRUE(false); | |
| } | |
| catch(msgpack::array_size_overflow const&) { | |
| EXPECT_TRUE(true); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| TEST(limit, unpack_array_over_off_no_ref) | |
| { | |
| std::stringstream ss; | |
| std::vector<int> v; | |
| v.push_back(1); | |
| v.push_back(2); | |
| v.push_back(3); | |
| msgpack::pack(ss, v); | |
| try { | |
| std::size_t off = 0; | |
| msgpack::unpacked unp; | |
| msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), off, nullptr, nullptr, | |
| msgpack::unpack_limit(2, 0, 0, 0, 0)); | |
| EXPECT_TRUE(false); | |
| } | |
| catch(msgpack::array_size_overflow const&) { | |
| EXPECT_TRUE(true); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| TEST(limit, unpack_array_over_off_ref) | |
| { | |
| std::stringstream ss; | |
| std::vector<int> v; | |
| v.push_back(1); | |
| v.push_back(2); | |
| v.push_back(3); | |
| msgpack::pack(ss, v); | |
| try { | |
| bool ref; | |
| std::size_t off = 0; | |
| msgpack::unpacked unp; | |
| msgpack::unpack(unp, ss.str().c_str(), ss.str().size(), off, ref, nullptr, nullptr, | |
| msgpack::unpack_limit(2, 0, 0, 0, 0)); | |
| EXPECT_TRUE(false); | |
| } | |
| catch(msgpack::array_size_overflow const&) { | |
| EXPECT_TRUE(true); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| // obsolete | |
| TEST(limit, unpack_array_over_off_ref_pointer) | |
| { | |
| std::stringstream ss; | |
| std::vector<int> v; | |
| v.push_back(1); | |
| v.push_back(2); | |
| v.push_back(3); | |
| msgpack::pack(ss, v); | |
| try { | |
| bool ref; | |
| std::size_t off = 0; | |
| msgpack::unpacked unp; | |
| msgpack::unpack(&unp, ss.str().c_str(), ss.str().size(), &off, &ref, nullptr, nullptr, | |
| msgpack::unpack_limit(2, 0, 0, 0, 0)); | |
| EXPECT_TRUE(false); | |
| } | |
| catch(msgpack::array_size_overflow const&) { | |
| EXPECT_TRUE(true); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| TEST(limit, unpacker_array_over) | |
| { | |
| std::stringstream ss; | |
| std::vector<int> v; | |
| v.push_back(1); | |
| v.push_back(2); | |
| v.push_back(3); | |
| msgpack::pack(ss, v); | |
| try { | |
| msgpack::unpacker u(nullptr, nullptr, MSGPACK_UNPACKER_INIT_BUFFER_SIZE, | |
| msgpack::unpack_limit(2, 0, 0, 0, 0)); | |
| u.reserve_buffer(ss.str().size()); | |
| memcpy(u.buffer(), ss.str().c_str(), ss.str().size()); | |
| u.buffer_consumed(ss.str().size()); | |
| msgpack::unpacked unp; | |
| u.next(unp); | |
| EXPECT_TRUE(false); | |
| } | |
| catch(msgpack::array_size_overflow const&) { | |
| EXPECT_TRUE(true); | |
| } | |
| catch(...) { | |
| EXPECT_TRUE(false); | |
| } | |
| } | |
| TEST(limit, unpacker_reserve) | |
| { | |
| msgpack::unpacker u(nullptr, nullptr, MSGPACK_UNPACKER_INIT_BUFFER_SIZE, | |
| msgpack::unpack_limit()); | |
| std::size_t original_capacity = u.buffer_capacity(); | |
| u.reserve_buffer(original_capacity + 1u); | |
| EXPECT_EQ((original_capacity + COUNTER_SIZE) * 2 - COUNTER_SIZE, u.buffer_capacity()); | |
| } | |
| TEST(limit, unpacker_reserve_more_than_twice) | |
| { | |
| msgpack::unpacker u(nullptr, nullptr, MSGPACK_UNPACKER_INIT_BUFFER_SIZE, | |
| msgpack::unpack_limit()); | |
| std::size_t original_capacity = u.buffer_capacity(); | |
| u.reserve_buffer(original_capacity * 3); | |
| EXPECT_EQ((original_capacity + COUNTER_SIZE) * 4 - COUNTER_SIZE, u.buffer_capacity()); | |
| } |