Merge pull request #823 from redboltz/update_to_3.2.1

Updated the version to 3.2.1.

.travis.yml

@@ -232,6 +232,25 @@ matrix:
             - clang-5.0
       script:
         - CMAKE_CXX_COMPILER="${CXX}" CMAKE_C_COMPILER="${CC}" CMAKE_LIBRARY_PATH="${BASE}" GTEST_ROOT="${BASE}/gtest" BOOST_ROOT="${BASE}/boost" CTEST_OUTPUT_ON_FAILURE=1 MSGPACK_SAN="${SAN}" ci/build_regression.sh
+    - os: linux
+      compiler: gcc
+      env: ACTION="ci/build_cmake_embedded.sh"     ARCH="64"
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-multilib
+            - gcc-multilib
+            - gcc-7-multilib
+            - g++-7-multilib
+            - lib32stdc++6-6-dbg
+            - lib32gcc1
+            - libc6-i386
+            - lib32z1-dev
+            - zlib1g-dev
+            - bzip2
+            - libc6-dbg
 
 
 script:

CHANGELOG.md

@@ -1,3 +1,15 @@
+# 2019-12-10 version 3.2.1
+  * Fix snprintf return value checking (#821)
+  * Remove some warnings (#819)
+  * Fix fbuffer result checking (#812)
+  * Fix temporary object handling (#807)
+  * Improve cmake support (#804)
+  * Fix invalid `int main` parameter (#800)
+  * Improve supporting platform (#797, #817)
+  * Fix ZLIB error handling (#795)
+  * Remove unused variable (#793)
+  * Improve integer overflow checking (#792)
+
 # 2019-05-27 version 3.2.0
 
   * Fix invalid include (#783)

CMakeLists.txt

@@ -181,6 +181,7 @@ ELSE ()
     IF (NOT DEFINED MSGPACK_ENABLE_STATIC)
         SET (MSGPACK_ENABLE_STATIC ON)
     ENDIF ()
+    SET (BUILD_SHARED_LIBS ${MSGPACK_ENABLE_SHARED})
 ENDIF ()
 
 OPTION (MSGPACK_ENABLE_CXX "Enable C++ interface." ON)
@@ -209,8 +210,9 @@ CONFIGURE_FILE (
     @ONLY
 )
 
-IF (MSGPACK_ENABLE_SHARED)
+
-    ADD_LIBRARY (msgpackc SHARED
+IF (MSGPACK_ENABLE_SHARED OR MSGPACK_ENABLE_STATIC)
+    ADD_LIBRARY (msgpackc
         ${msgpackc_SOURCES}
         ${msgpackc_HEADERS}
     )
@@ -238,7 +240,7 @@ IF (MSGPACK_ENABLE_CXX AND ((CMAKE_VERSION VERSION_GREATER 3.0) OR (CMAKE_VERSIO
     )
 ENDIF ()
 
-IF (MSGPACK_ENABLE_STATIC)
+IF (MSGPACK_ENABLE_SHARED AND MSGPACK_ENABLE_STATIC)
     ADD_LIBRARY (msgpackc-static STATIC
         ${msgpackc_SOURCES}
         ${msgpackc_HEADERS}
@@ -253,11 +255,6 @@ IF (MSGPACK_ENABLE_STATIC)
             ${CMAKE_CURRENT_SOURCE_DIR}
     )
 
-    IF (NOT MSGPACK_ENABLE_SHARED)
-        # Add alias for subdirectories
-        ADD_LIBRARY (msgpackc ALIAS msgpackc-static)
-    ENDIF ()
-
     SET_TARGET_PROPERTIES (msgpackc-static PROPERTIES OUTPUT_NAME "msgpackc")
 
     IF (MSGPACK_ENABLE_SHARED)
@@ -291,19 +288,19 @@ IF (MSGPACK_BUILD_TESTS)
 ENDIF ()
 
 IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-    IF (MSGPACK_ENABLE_SHARED)
+    IF (MSGPACK_ENABLE_SHARED OR MSGPACK_ENABLE_STATIC)
         SET_PROPERTY (TARGET msgpackc APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra -DPIC")
     ENDIF ()
-    IF (MSGPACK_ENABLE_STATIC)
+    IF (MSGPACK_ENABLE_SHARED AND MSGPACK_ENABLE_STATIC)
        SET_PROPERTY (TARGET msgpackc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra" )
     ENDIF ()
 ENDIF ()
 
 IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-    IF (MSGPACK_ENABLE_SHARED)
+    IF (MSGPACK_ENABLE_SHARED OR MSGPACK_ENABLE_STATIC)
         SET_PROPERTY (TARGET msgpackc APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
     ENDIF ()
-    IF (MSGPACK_ENABLE_STATIC)
+    IF (MSGPACK_ENABLE_SHARED AND MSGPACK_ENABLE_STATIC)
         SET_PROPERTY (TARGET msgpackc-static APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-mismatched-tags")
     ENDIF ()
 ENDIF ()
@@ -337,7 +334,7 @@ IF (MSGPACK_BUILD_EXAMPLES)
     ADD_SUBDIRECTORY (example)
 ENDIF ()
 
-IF (MSGPACK_ENABLE_SHARED)
+IF (MSGPACK_ENABLE_SHARED OR MSGPACK_ENABLE_STATIC)
     SET (MSGPACK_INSTALLTARGETS msgpackc)
 ENDIF ()
 
@@ -345,7 +342,7 @@ IF (MSGPACK_ENABLE_CXX AND ((CMAKE_VERSION VERSION_GREATER 3.0) OR (CMAKE_VERSIO
     LIST (APPEND MSGPACK_INSTALLTARGETS msgpackc-cxx)
 ENDIF ()
 
-IF (MSGPACK_ENABLE_STATIC)
+IF (MSGPACK_ENABLE_SHARED AND MSGPACK_ENABLE_STATIC)
     LIST (APPEND MSGPACK_INSTALLTARGETS msgpackc-static)
 ENDIF ()
 

QUICKSTART-CPP.md

@@ -59,7 +59,7 @@ $ ./hello
 #include <iostream>
 #include <string>
 
-int main(void) {
+int main() {
         // serializes multiple objects using msgpack::packer.
         msgpack::sbuffer buffer;
 
@@ -98,7 +98,7 @@ int main(void) {
 #include <iostream>
 #include <string>
 
-int main(void) {
+int main() {
         // serializes multiple objects into one message containing an array using msgpack::packer.
         msgpack::sbuffer buffer;
 
@@ -139,7 +139,7 @@ public:
     MSGPACK_DEFINE(m_str, m_vec);
 };
 
-int main(void) {
+int main() {
         std::vector<myclass> vec;
         // add some elements into vec...
 

README.md

@@ -1,7 +1,7 @@
 `msgpack` for C/C++
 ===================
 
-Version 3.2.0 [![Build Status](https://travis-ci.org/msgpack/msgpack-c.svg?branch=master)](https://travis-ci.org/msgpack/msgpack-c) [![Build status](https://ci.appveyor.com/api/projects/status/8kstcgt79qj123mw/branch/master?svg=true)](https://ci.appveyor.com/project/redboltz/msgpack-c/branch/master)
+Version 3.2.1 [![Build Status](https://travis-ci.org/msgpack/msgpack-c.svg?branch=master)](https://travis-ci.org/msgpack/msgpack-c) [![Build status](https://ci.appveyor.com/api/projects/status/8kstcgt79qj123mw/branch/master?svg=true)](https://ci.appveyor.com/project/redboltz/msgpack-c/branch/master)
 
 It's like JSON but smaller and faster.
 
@@ -68,7 +68,7 @@ In C++:
 #include <iostream>
 #include <sstream>
 
-int main(void)
+int main()
 {
     msgpack::type::tuple<int, bool, std::string> src(1, true, "example");
 

appveyor.yml

@@ -1,4 +1,4 @@
-version: 3.2.0.{build}
+version: 3.2.1.{build}
 
 image:
 - Visual Studio 2015

ci/build_cmake.sh

@@ -72,4 +72,39 @@ then
     fi
 fi
 
+if [ "${ARCH}" != "32" ]
+then
+    mkdir install-test
+
+    ret=$?
+    if [ $ret -ne 0 ]
+    then
+        exit $ret
+    fi
+
+    cd install-test
+
+    ret=$?
+    if [ $ret -ne 0 ]
+    then
+        exit $ret
+    fi
+
+    cmake -DCMAKE_PREFIX_PATH=`pwd`/../install/usr/local/lib/cmake ../../example/cmake
+
+    ret=$?
+    if [ $ret -ne 0 ]
+    then
+        exit $ret
+    fi
+
+    make
+
+    ret=$?
+    if [ $ret -ne 0 ]
+    then
+        exit $ret
+    fi
+fi
+
 exit 0

ci/build_cmake_embedded.sh

@@ -0,0 +1,59 @@
+#!/bin/bash
+
+cd example/cmake
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+rm -f msgpack-c
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+ln -s ../.. msgpack-c
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+mkdir build
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+cd build
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+cmake -DEXAMPLE_MSGPACK_EMBEDDED=ON ..
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+make example example-static
+
+ret=$?
+if [ $ret -ne 0 ]
+then
+    exit $ret
+fi
+
+exit 0

example/boost/msgpack_variant_mapbased.cpp

@@ -83,7 +83,8 @@ int main() {
     u.address = "Tokyo";
     msgpack::pack(ss, u);
 
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     msgpack::object const& obj = oh.get();
     std::cout << "Unpacked msgpack object." << std::endl;
     std::cout << obj << std::endl;

example/c/CMakeLists.txt

@@ -1,12 +1,3 @@
-IF (MSGPACK_ENABLE_SHARED)
-    SET (MSGPACK_LIB msgpackc)
-ENDIF ()
-
-IF (MSGPACK_ENABLE_STATIC)
-    SET (MSGPACK_LIB msgpackc-static)
-ENDIF ()
-
-
 LIST (APPEND exec_PROGRAMS
     lib_buffer_unpack.c
     simple_c.c
@@ -22,7 +13,7 @@ FOREACH (source_file ${exec_PROGRAMS})
         ${source_file}
     )
     TARGET_LINK_LIBRARIES (${source_file_we}
-        ${MSGPACK_LIB}
+        msgpackc
     )
     IF ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
         SET_PROPERTY (TARGET ${source_file_we} APPEND_STRING PROPERTY COMPILE_FLAGS " -Wall -Wextra")

example/cmake/CMakeLists.txt

@@ -0,0 +1,17 @@
+cmake_minimum_required (VERSION 3.0)
+project (example)
+
+if(EXAMPLE_MSGPACK_EMBEDDED)
+    add_subdirectory(msgpack-c)
+    set(msgpack_DIR ${CMAKE_CURRENT_BINARY_DIR}/msgpack-c)
+endif()
+
+find_package(msgpack REQUIRED)
+
+add_executable (${PROJECT_NAME} ${CMAKE_CURRENT_LIST_DIR}/../c/simple_c.c)
+target_link_libraries(${PROJECT_NAME} msgpackc)
+
+if(TARGET msgpackc-static)
+    add_executable (${PROJECT_NAME}-static ${CMAKE_CURRENT_LIST_DIR}/../c/simple_c.c)
+    target_link_libraries(${PROJECT_NAME}-static msgpackc-static)
+endif()

example/cpp03/class_intrusive.cpp

@@ -82,10 +82,11 @@ int main() {
         std::stringstream ss;
         msgpack::pack(ss, my);
 
-        print(ss.str());
+        std::string const& str = ss.str();
+        print(str);
 
         msgpack::object_handle oh =
-            msgpack::unpack(ss.str().data(), ss.str().size());
+            msgpack::unpack(str.data(), str.size());
         msgpack::object obj = oh.get();
         std::cout << obj << std::endl;
         assert(obj.as<my_class>() == my);

example/cpp03/class_intrusive_map.cpp

@@ -59,8 +59,9 @@ int main() {
 
         print(ss.str());
 
+        std::string const& str = ss.str();
         msgpack::object_handle oh =
-            msgpack::unpack(ss.str().data(), ss.str().size());
+            msgpack::unpack(str.data(), str.size());
         msgpack::object obj = oh.get();
         std::cout << obj << std::endl;
         assert(obj.as<my_class>() == my);

example/cpp03/class_non_intrusive.cpp

@@ -100,10 +100,11 @@ int main() {
         std::stringstream ss;
         msgpack::pack(ss, my);
 
-        print(ss.str());
+        std::string const& str = ss.str();
+        print(str);
 
         msgpack::object_handle oh =
-            msgpack::unpack(ss.str().data(), ss.str().size());
+            msgpack::unpack(str.data(), str.size());
         msgpack::object obj = oh.get();
         std::cout << obj << std::endl;
         assert(obj.as<my_class>() == my);

example/cpp03/map_based_versionup.cpp

@@ -71,7 +71,8 @@ int main() {
 
         print(ss.str());
 
-        msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+        std::string const& str = ss.str();
+        msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
 
         msgpack::object obj = oh.get();
         std::cout << obj << std::endl;

example/cpp03/reuse_zone.cpp

@@ -31,12 +31,13 @@ int main() {
     std::size_t offset = 0;
 
     // msgpack array is constructed on z.
-    msgpack::object obj = msgpack::unpack(z, ss.str().data(), ss.str().size(), offset);
+    std::string const& ps = ss.str();
+    msgpack::object obj = msgpack::unpack(z, ps.data(), ps.size(), offset);
     std::cout << obj << std::endl;
     assert(obj.as<std::vector<int> >() == v);
 
     // msgpack str is constructed on z.
-    std::string const& str = msgpack::unpack(z, ss.str().data(), ss.str().size(), offset).as<std::string>();
+    std::string const& str = msgpack::unpack(z, ps.data(), ps.size(), offset).as<std::string>();
     std::cout << str << std::endl;
     assert(str == s);
 }

example/cpp11/container.cpp

@@ -37,7 +37,8 @@ void tuple() {
     std::stringstream ss;
     msgpack::pack(ss, t);
 
-    auto oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    auto const& str = ss.str();
+    auto oh = msgpack::unpack(str.data(), str.size());
     auto obj = oh.get();
 
     std::cout << obj << std::endl;
@@ -49,7 +50,8 @@ void unordered_map() {
     std::stringstream ss;
     msgpack::pack(ss, m);
 
-    auto oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    auto const& str = ss.str();
+    auto oh = msgpack::unpack(str.data(), str.size());
     msgpack::object obj = oh.get();
 
     std::cout << obj << std::endl;
@@ -61,7 +63,8 @@ void unordered_set() {
     std::stringstream ss;
     msgpack::pack(ss, s);
 
-    auto oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    auto const& str = ss.str();
+    auto oh = msgpack::unpack(str.data(), str.size());
     auto obj = oh.get();
 
     std::cout << obj << std::endl;
@@ -74,7 +77,8 @@ void forward_list() {
     std::stringstream ss;
     msgpack::pack(ss, f);
 
-    auto oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    auto const& str = ss.str();
+    auto oh = msgpack::unpack(str.data(), str.size());
     auto obj = oh.get();
 
     std::cout << obj << std::endl;
@@ -98,7 +102,8 @@ void combi() {
     std::size_t offset = 0;
     std::cout << "offset: " << offset << std::endl;
     {
-        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto const& str = ss.str();
+        auto oh = msgpack::unpack(str.data(), str.size(), offset);
         auto obj = oh.get();
 
         std::cout << obj << std::endl;
@@ -106,7 +111,8 @@ void combi() {
     }
     std::cout << "offset: " << offset << std::endl;
     {
-        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto const& str = ss.str();
+        auto oh = msgpack::unpack(str.data(), str.size(), offset);
         auto obj = oh.get();
 
         std::cout << obj << std::endl;
@@ -114,7 +120,8 @@ void combi() {
     }
     std::cout << "offset: " << offset << std::endl;
     {
-        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto const& str = ss.str();
+        auto oh = msgpack::unpack(str.data(), str.size(), offset);
         auto obj = oh.get();
 
         std::cout << obj << std::endl;
@@ -122,7 +129,8 @@ void combi() {
     }
     std::cout << "offset: " << offset << std::endl;
     {
-        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto const& str = ss.str();
+        auto oh = msgpack::unpack(str.data(), str.size(), offset);
         auto obj = oh.get();
 
         std::cout << obj << std::endl;
@@ -130,7 +138,8 @@ void combi() {
     }
     std::cout << "offset: " << offset << std::endl;
     {
-        auto oh = msgpack::unpack(ss.str().data(), ss.str().size(), offset);
+        auto const& str = ss.str();
+        auto oh = msgpack::unpack(str.data(), str.size(), offset);
         auto obj = oh.get();
 
         std::cout << obj << std::endl;

include/msgpack/fbuffer.h

@@ -25,7 +25,7 @@ extern "C" {
 
 static inline int msgpack_fbuffer_write(void* data, const char* buf, size_t len)
 {
-    return (len == fwrite(buf, len, 1, (FILE *)data)) ? 0 : -1;
+    return (1 == fwrite(buf, len, 1, (FILE *)data)) ? 0 : -1;
 }
 
 /** @} */

include/msgpack/sysdep.h

@@ -14,7 +14,7 @@
 #include <stddef.h>
 
 #if defined(_MSC_VER) && _MSC_VER <= 1800
-#   define snprintf(buf, len, format,...) _snprintf_s(buf, len, len, format, __VA_ARGS__)
+#   define snprintf(buf, len, format,...) _snprintf_s(buf, len, _TRUNCATE, format, __VA_ARGS__)
 #endif
 
 #if defined(_MSC_VER) && _MSC_VER < 1600

include/msgpack/v1/unpack.hpp

@@ -113,10 +113,13 @@ struct unpack_array {
         if (n > u.limit().array()) throw msgpack::array_size_overflow("array size overflow");
         o.type = msgpack::type::ARRAY;
         o.via.array.size = 0;
-        size_t size = n*sizeof(msgpack::object);
+
-        if (size / sizeof(msgpack::object) != n) {
+#if SIZE_MAX == UINT_MAX
+        if (n > SIZE_MAX/sizeof(msgpack::object))
             throw msgpack::array_size_overflow("array size overflow");
-        }
+#endif // SIZE_MAX == UINT_MAX
+
+        size_t size = n*sizeof(msgpack::object);
         o.via.array.ptr = static_cast<msgpack::object*>(u.zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
     }
 };
@@ -125,6 +128,7 @@ 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__ */
@@ -135,10 +139,13 @@ struct unpack_map {
         if (n > u.limit().map()) throw msgpack::map_size_overflow("map size overflow");
         o.type = msgpack::type::MAP;
         o.via.map.size = 0;
-        size_t size = n*sizeof(msgpack::object_kv);
+
-        if (size / sizeof(msgpack::object_kv) != n) {
+#if SIZE_MAX == UINT_MAX
+        if (n > SIZE_MAX/sizeof(msgpack::object_kv))
             throw msgpack::map_size_overflow("map size overflow");
-        }
+#endif // SIZE_MAX == UINT_MAX
+
+        size_t size = n*sizeof(msgpack::object_kv);
         o.via.map.ptr = static_cast<msgpack::object_kv*>(u.zone().allocate_align(size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
     }
 };

include/msgpack/v1/zbuffer.hpp

@@ -69,6 +69,7 @@ public:
             case Z_STREAM_END:
                 return m_data;
             case Z_OK:
+            case Z_BUF_ERROR:
                 if(!expand()) {
                     throw std::bad_alloc();
                 }

include/msgpack/v2/create_object_visitor.hpp

@@ -163,10 +163,13 @@ public:
             obj->via.array.ptr = MSGPACK_NULLPTR;
         }
         else {
-            size_t size = num_elements*sizeof(msgpack::object);
+
-            if (size / sizeof(msgpack::object) != num_elements) {
+#if SIZE_MAX == UINT_MAX
+            if (num_elements > SIZE_MAX/sizeof(msgpack::object))
                 throw msgpack::array_size_overflow("array size overflow");
-            }
+#endif // SIZE_MAX == UINT_MAX
+
+            size_t size = num_elements*sizeof(msgpack::object);
             obj->via.array.ptr =
                 static_cast<msgpack::object*>(m_zone->allocate_align(size, MSGPACK_ZONE_ALIGNOF(msgpack::object)));
         }
@@ -194,10 +197,12 @@ public:
             obj->via.map.ptr = MSGPACK_NULLPTR;
         }
         else {
-            size_t size = num_kv_pairs*sizeof(msgpack::object_kv);
+
-            if (size / sizeof(msgpack::object_kv) != num_kv_pairs) {
+#if SIZE_MAX == UINT_MAX
+            if (num_kv_pairs > SIZE_MAX/sizeof(msgpack::object_kv))
                 throw msgpack::map_size_overflow("map size overflow");
-            }
+#endif // SIZE_MAX == UINT_MAX
+            size_t size = num_kv_pairs*sizeof(msgpack::object_kv);
             obj->via.map.ptr =
                 static_cast<msgpack::object_kv*>(m_zone->allocate_align(size, MSGPACK_ZONE_ALIGNOF(msgpack::object_kv)));
         }

include/msgpack/v2/parse.hpp

@@ -241,8 +241,6 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
     const char* const pe = data + len;
     const char* n = MSGPACK_NULLPTR;
 
-    msgpack::object obj;
-
     if(m_current == pe) {
         off = static_cast<std::size_t>(m_current - m_start);
         return PARSE_CONTINUE;

include/msgpack/v3/parse.hpp

@@ -250,8 +250,6 @@ inline parse_return context<VisitorHolder>::execute(const char* data, std::size_
     const char* const pe = data + len;
     const char* n = MSGPACK_NULLPTR;
 
-    msgpack::object obj;
-
     if(m_current == pe) {
         off = static_cast<std::size_t>(m_current - m_start);
         return PARSE_CONTINUE;

include/msgpack/version_master.h

@@ -1,3 +1,3 @@
 #define MSGPACK_VERSION_MAJOR    3
 #define MSGPACK_VERSION_MINOR    2
-#define MSGPACK_VERSION_REVISION 0
+#define MSGPACK_VERSION_REVISION 1

include/msgpack/vrefbuffer.h

@@ -13,7 +13,7 @@
 #include "zone.h"
 #include <stdlib.h>
 
-#if defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__QNX__) || defined(__QNXTO__)
+#if defined(unix) || defined(__unix) || defined(__linux__) || defined(__APPLE__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__QNX__) || defined(__QNXTO__) || defined(__HAIKU__)
 #include <sys/uio.h>
 #else
 struct iovec {

include/msgpack/zbuffer.h

@@ -146,6 +146,7 @@ static inline char* msgpack_zbuffer_flush(msgpack_zbuffer* zbuf)
         case Z_STREAM_END:
             return zbuf->data;
         case Z_OK:
+        case Z_BUF_ERROR:
             if(!msgpack_zbuffer_expand(zbuf)) {
                 return NULL;
             }

msgpack-config.cmake.in

@@ -6,8 +6,9 @@
 #
 # ::
 #
-#   msgpackc-static
 #   msgpackc
+#   msgpackc-cxx
+#   msgpackc-static (optional)
 #
 
 @PACKAGE_INIT@
@@ -16,8 +17,4 @@ include(CMakeFindDependencyMacro)
 
 if(NOT TARGET msgpackc AND NOT TARGET msgpackc-static)
   include("${CMAKE_CURRENT_LIST_DIR}/msgpack-targets.cmake")
-
-  if(NOT @MSGPACK_ENABLE_SHARED@)
-    add_library(msgpackc ALIAS msgpackc-static)
-  endif()
 endif()

src/objectc.c

@@ -256,7 +256,7 @@ void msgpack_object_print(FILE* out, msgpack_object o)
 
 #define MSGPACK_CHECKED_CALL(ret, func, aux_buffer, aux_buffer_size, ...) \
     ret = func(aux_buffer, aux_buffer_size, __VA_ARGS__);                 \
-    if (ret <= 0 || ret > (int)aux_buffer_size) return 0;                 \
+    if (ret <= 0 || ret >= (int)aux_buffer_size) return 0;                \
     aux_buffer = aux_buffer + ret;                                        \
     aux_buffer_size = aux_buffer_size - ret                               \
 

test/array_ref.cpp

@@ -25,8 +25,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_char)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::vector<char> v2;
     msgpack::type::array_ref<std::vector<char> > ar2(v2);
@@ -47,8 +48,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_char_const)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::vector<char> v2;
     msgpack::type::array_ref<std::vector<char> > ar2(v2);
@@ -67,8 +69,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_unsigned_char)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::vector<unsigned char> v2;
     msgpack::type::array_ref<std::vector<unsigned char> > ar2(v2);
@@ -89,8 +92,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_vector_unsigned_char_const)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::vector<unsigned char> v2;
     msgpack::type::array_ref<std::vector<unsigned char> > ar2(v2);
@@ -184,8 +188,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_char)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::array<char, 3> v2;
     msgpack::type::array_ref<std::array<char, 3> > ar2(v2);
@@ -203,8 +208,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_char_const)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::array<char, 3> v2;
     msgpack::type::array_ref<std::array<char, 3> > ar2(v2);
@@ -220,8 +226,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_unsigned_char)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::array<unsigned char, 3> v2;
     msgpack::type::array_ref<std::array<unsigned char, 3> > ar2(v2);
@@ -239,8 +246,9 @@ TEST(MSGPACK_ARRAY_REF, pack_unpack_convert_array_unsigned_char_const)
     std::stringstream ss;
     msgpack::pack(ss, ar1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
     std::array<unsigned char, 3> v2;
     msgpack::type::array_ref<std::array<unsigned char, 3> > ar2(v2);

test/boost_fusion.cpp

@@ -35,8 +35,9 @@ TEST(MSGPACK_BOOST, fusion_pack_unpack_convert)
     val1.f1 = 42;
     val1.f2 = 123.45;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     mystruct val2 = oh.get().as<mystruct>();
     EXPECT_TRUE(val1.f1 == val2.f1);
     EXPECT_TRUE(fabs(val2.f2 - val1.f2) <= kEPS);
@@ -156,8 +157,9 @@ TEST(MSGPACK_BOOST, pack_convert_no_def_con)
     std::stringstream ss;
     mystruct_no_def_con val1(no_def_con1(1), no_def_con2(2), no_def_con1(3));
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     mystruct_no_def_con val2 = oh.get().as<mystruct_no_def_con>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -207,8 +209,9 @@ TEST(MSGPACK_BOOST, pack_convert_no_def_con_def_con)
     std::stringstream ss;
     mystruct_no_def_con_def_con val1(no_def_con1(1), no_def_con2(2), 3);
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     mystruct_no_def_con_def_con val2 = oh.get().as<mystruct_no_def_con_def_con>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -224,8 +227,9 @@ TEST(MSGPACK_BOOST, fusion_pack_unpack_convert_pair)
     std::stringstream ss;
     std::pair<bool, int> val1(false, 42);
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::pair<bool, int>  val2 = oh.get().as<std::pair<bool, int> >();
     EXPECT_TRUE(val1.first == val2.first);
     EXPECT_TRUE(val1.second == val2.second);
@@ -240,8 +244,9 @@ TEST(MSGPACK_BOOST, fusion_pack_unpack_convert_tuple)
     std::stringstream ss;
     std::tuple<bool, int> val1(false, 42);
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::tuple<bool, int> val2 = oh.get().as<std::tuple<bool, int> >();
     EXPECT_TRUE(val1 == val2);
 }

test/boost_optional.cpp

@@ -21,8 +21,9 @@ TEST(MSGPACK_BOOST, pack_convert_nil)
     std::stringstream ss;
     boost::optional<int> val1;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     boost::optional<int> val2 = oh.get().as<boost::optional<int> >();
     EXPECT_TRUE(val1 == val2);
 }
@@ -32,8 +33,9 @@ TEST(MSGPACK_BOOST, pack_convert_int)
     std::stringstream ss;
     boost::optional<int> val1 = 1;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     boost::optional<int> val2 = oh.get().as<boost::optional<int> >();
     EXPECT_TRUE(val1 == val2);
 }
@@ -49,8 +51,9 @@ TEST(MSGPACK_BOOST, pack_convert_vector)
     v.push_back(3);
     val1 = v;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     ovi_t  val2 = oh.get().as<ovi_t>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -64,8 +67,9 @@ TEST(MSGPACK_BOOST, pack_convert_vector_optional)
     val1[0] = 1;
     val1[2] = 3;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     voi_t  val2 = oh.get().as<voi_t>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -171,8 +175,9 @@ TEST(MSGPACK_BOOST, pack_convert_no_def_con)
     std::stringstream ss;
     boost::optional<no_def_con> val1 = no_def_con(1);
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     boost::optional<no_def_con> val2 = oh.get().as<boost::optional<no_def_con>>();
     EXPECT_TRUE(val1 == val2);
 }

test/boost_string_ref.cpp

@@ -26,7 +26,8 @@ TEST(MSGPACK_BOOST, pack_convert_string_ref)
     msgpack::pack(ss, val1);
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::unpack(oh, str.data(), str.size());
     boost::string_ref val2 = oh.get().as<boost::string_ref>();
     EXPECT_TRUE(val1 == val2);
 }

test/boost_string_view.cpp

@@ -25,7 +25,8 @@ TEST(MSGPACK_BOOST, pack_convert_string_view)
     msgpack::pack(ss, val1);
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::unpack(oh, str.data(), str.size());
     boost::string_view val2 = oh.get().as<boost::string_view>();
     EXPECT_TRUE(val1 == val2);
 }

test/boost_variant.cpp

@@ -27,8 +27,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_nil)
     EXPECT_TRUE(val1.is_nil());
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_nil());
     EXPECT_NO_THROW(boost::get<msgpack::type::nil_t>(val2));
@@ -65,8 +66,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_nil_default)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_nil());
     EXPECT_NO_THROW(boost::get<msgpack::type::nil_t>(val2));
@@ -104,8 +106,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_bool)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_bool());
     EXPECT_TRUE(val2.as_bool());
@@ -157,8 +160,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_positive_integer)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_uint64_t());
     EXPECT_EQ(val2.as_uint64_t(), 123U);
@@ -204,8 +208,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_negative_integer)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_int64_t());
     EXPECT_EQ(val2.as_int64_t(), -123);
@@ -251,8 +256,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_float)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_double());
     EXPECT_TRUE(fabs(12.34 - val2.as_double()) <= kEPS);
@@ -298,8 +304,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_str)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_string());
     EXPECT_EQ(val2.as_string(), "ABC");
@@ -360,8 +367,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_bin)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_vector_char());
     EXPECT_EQ(val2.as_vector_char(), v);
@@ -431,8 +439,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ext)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_ext());
     EXPECT_EQ(val2.as_ext(), e);
@@ -498,8 +507,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_array)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_vector());
     EXPECT_EQ(val2.as_vector(), v);
@@ -540,8 +550,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_map)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant val2 = oh.get().as<msgpack::type::variant>();
     EXPECT_TRUE(val2.is_multimap());
     EXPECT_EQ(val2.as_multimap(), v);
@@ -584,8 +595,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_str)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
     EXPECT_TRUE(val2.is_boost_string_ref());
     EXPECT_EQ(val2.as_boost_string_ref(), sr);
@@ -629,8 +641,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_bin)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
     EXPECT_TRUE(val2.is_raw_ref());
     EXPECT_EQ(val2.as_raw_ref(), rr);
@@ -676,8 +689,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_ext)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
     EXPECT_NO_THROW(boost::get<msgpack::type::ext_ref>(val2));
     EXPECT_TRUE(val2.is_ext_ref());
@@ -726,8 +740,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_array)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
     EXPECT_TRUE(val2.is_vector());
     EXPECT_EQ(val2.as_vector(), v);
@@ -779,8 +794,9 @@ TEST(MSGPACK_BOOST, pack_convert_variant_ref_map)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     msgpack::type::variant_ref val2 = oh.get().as<msgpack::type::variant_ref>();
     EXPECT_TRUE(val2.is_multimap());
     EXPECT_EQ(val2.as_multimap(), v);

test/carray.cpp

@@ -15,7 +15,8 @@ TEST(carray, pack_unpack_int)
     int v1[] = { 0, 1 };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     int v2[2];
@@ -44,7 +45,8 @@ TEST(carray, pack_unpack_const_int)
     const int v1[] = { 0, 1 };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     int v2[2];
@@ -73,7 +75,8 @@ TEST(carray, pack_unpack_string)
     std::string v1[] = { "ABC", "DEFG" };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     std::string v2[2];
@@ -102,7 +105,8 @@ TEST(carray, pack_unpack_char)
     char v1[] = { 0, 1 };
 
     msgpack::pack(ss, msgpack::type::make_array_ref(v1));
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     char v2[2];
@@ -118,7 +122,8 @@ TEST(carray, pack_unpack_char_as_str)
     char v1[2] = { 1, '\0' };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::STR);
     EXPECT_EQ(oh.get().via.str.size, static_cast<size_t>(1));
 
@@ -164,7 +169,8 @@ TEST(carray, pack_unpack_unsigned_char)
     unsigned char v1[] = { 0, 1 };
 
     msgpack::pack(ss, msgpack::type::make_array_ref(v1));
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     unsigned char v2[2];
@@ -180,7 +186,8 @@ TEST(carray, pack_unpack_unsigned_char_as_bin)
     unsigned char v1[] = { 0, 1 };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::BIN);
     EXPECT_EQ(oh.get().via.bin.size, static_cast<size_t>(2));
 
@@ -226,7 +233,8 @@ TEST(carray, pack_unpack_signed_char)
     signed char v1[] = { 0, 1 };
 
     msgpack::pack(ss, v1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     EXPECT_EQ(oh.get().type, msgpack::type::ARRAY);
 
     signed char v2[2];

test/msgpack_c.cpp

@@ -1368,3 +1368,45 @@ TEST(MSGPACKC, vref_buffer_overflow)
     EXPECT_FALSE(msgpack_vrefbuffer_init(&vbuf, ref_size, chunk_size));
     EXPECT_EQ(-1, msgpack_vrefbuffer_migrate(&vbuf, &to));
 }
+
+TEST(MSGPACKC, object_print_buffer_overflow) {
+  msgpack_object obj;
+  obj.type = MSGPACK_OBJECT_NIL;
+  char buffer[4];
+
+  int ret;
+  ret = msgpack_object_print_buffer(buffer, 1, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 2, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 3, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 4, obj);
+  EXPECT_EQ(3, ret);
+  EXPECT_STREQ("nil", buffer);
+}
+
+TEST(MSGPACKC, object_bin_print_buffer_overflow) {
+  msgpack_object obj;
+  obj.type = MSGPACK_OBJECT_BIN;
+  obj.via.bin.ptr = "test";
+  obj.via.bin.size = 4;
+  char buffer[7];
+
+  int ret;
+  ret = msgpack_object_print_buffer(buffer, 1, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 2, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 3, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 4, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 5, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 6, obj);
+  EXPECT_EQ(0, ret);
+  ret = msgpack_object_print_buffer(buffer, 7, obj);
+  EXPECT_EQ(6, ret);
+  EXPECT_STREQ("\"test\"", buffer);
+}

test/msgpack_cpp11.cpp

@@ -183,7 +183,7 @@ TEST(MSGPACK_CPP11, simple_buffer_array_char)
     for (unsigned int k = 0; k < kLoop; k++) {
         array<char, kElements> val1;
         for (unsigned int i = 0; i < kElements; i++)
-            val1[i] = rand();
+            val1[i] = static_cast<char>(rand());
         msgpack::sbuffer sbuf;
         msgpack::pack(sbuf, val1);
         msgpack::object_handle oh =
@@ -214,7 +214,7 @@ TEST(MSGPACK_CPP11, simple_buffer_array_unsigned_char)
     for (unsigned int k = 0; k < kLoop; k++) {
         array<unsigned char, kElements> val1;
         for (unsigned int i = 0; i < kElements; i++)
-            val1[i] = rand();
+            val1[i] = static_cast<unsigned char>(rand());
         msgpack::sbuffer sbuf;
         msgpack::pack(sbuf, val1);
         msgpack::object_handle oh =
@@ -1055,10 +1055,11 @@ TEST(MSGPACK_TIMESPEC, timespec_pack_convert_zero)
     timespec val1{ 0, 0 };
 
     msgpack::pack(ss, val1);
-    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xd6));
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xd6));
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    msgpack::unpack(oh, str.data(), str.size());
     timespec val2 = oh.get().as<timespec>();
     EXPECT_EQ(val1.tv_sec, val2.tv_sec);
     EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
@@ -1080,10 +1081,11 @@ TEST(MSGPACK_TIMESPEC, timespec_pack_convert_32bit_sec)
     timespec val1{ 0xffffffffUL, 0 };
 
     msgpack::pack(ss, val1);
-    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xd6));
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xd6));
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    msgpack::unpack(oh, str.data(), str.size());
     timespec val2 = oh.get().as<timespec>();
     EXPECT_EQ(val1.tv_sec, val2.tv_sec);
     EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
@@ -1105,9 +1107,10 @@ TEST(MSGPACK_TIMESPEC, timespec_pack_convert_max_nano)
     timespec val1{ 0, 999999999 };
 
     msgpack::pack(ss, val1);
-    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xd7));
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xd7));
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    msgpack::unpack(oh, str.data(), str.size());
     timespec val2 = oh.get().as<timespec>();
     EXPECT_EQ(val1.tv_sec, val2.tv_sec);
     EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
@@ -1130,10 +1133,11 @@ TEST(MSGPACK_TIMESPEC, timespec_pack_convert_34bit_sec_max_nano)
     timespec val1{ static_cast<decltype(std::declval<timespec>().tv_sec)>(0x3ffffffffULL), 999999999 };
 
     msgpack::pack(ss, val1);
-    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xd7));
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xd7));
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    msgpack::unpack(oh, str.data(), str.size());
     timespec val2 = oh.get().as<timespec>();
     EXPECT_EQ(val1.tv_sec, val2.tv_sec);
     EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
@@ -1157,10 +1161,11 @@ TEST(MSGPACK_TIMESPEC, timespec_pack_convert_35bit_sec_max_nano)
     timespec val1{ static_cast<decltype(std::declval<timespec>().tv_sec)>(0x7ffffffffULL), 999999999 };
 
     msgpack::pack(ss, val1);
-    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xc7));
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xc7));
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    msgpack::unpack(oh, str.data(), str.size());
     timespec val2 = oh.get().as<timespec>();
     EXPECT_EQ(val1.tv_sec, val2.tv_sec);
     EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);
@@ -1183,10 +1188,11 @@ TEST(MSGPACK_TIMESPEC, timespec_pack_convert_64bit_sec_max_nano)
     timespec val1{ std::numeric_limits<decltype(std::declval<timespec>().tv_sec)>::max(), 999999999 };
 
     msgpack::pack(ss, val1);
-    EXPECT_EQ(ss.str().data()[0], static_cast<char>(0xc7));
+    std::string const& str = ss.str();
+    EXPECT_EQ(str.data()[0], static_cast<char>(0xc7));
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    msgpack::unpack(oh, str.data(), str.size());
     timespec val2 = oh.get().as<timespec>();
     EXPECT_EQ(val1.tv_sec, val2.tv_sec);
     EXPECT_EQ(val1.tv_nsec, val2.tv_nsec);

test/msgpack_cpp17.cpp

@@ -27,8 +27,9 @@ TEST(MSGPACK_CPP17, optional_pack_convert_nil)
     std::stringstream ss;
     std::optional<int> val1;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::optional<int> val2 = oh.get().as<std::optional<int> >();
     EXPECT_TRUE(val1 == val2);
 }
@@ -38,8 +39,9 @@ TEST(MSGPACK_CPP17, optional_pack_convert_int)
     std::stringstream ss;
     std::optional<int> val1 = 1;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::optional<int> val2 = oh.get().as<std::optional<int> >();
     EXPECT_TRUE(val1 == val2);
 }
@@ -55,8 +57,9 @@ TEST(MSGPACK_CPP17, optional_pack_convert_vector)
     v.push_back(3);
     val1 = v;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     ovi_t  val2 = oh.get().as<ovi_t>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -70,8 +73,9 @@ TEST(MSGPACK_CPP17, optional_pack_convert_vector_optional)
     val1[0] = 1;
     val1[2] = 3;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     voi_t  val2 = oh.get().as<voi_t>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -177,8 +181,9 @@ TEST(MSGPACK_CPP17, optional_pack_convert_no_def_con)
     std::stringstream ss;
     std::optional<no_def_con> val1 = no_def_con(1);
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::optional<no_def_con> val2 = oh.get().as<std::optional<no_def_con>>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -195,8 +200,9 @@ TEST(MSGPACK_CPP17, string_view_pack_convert)
 
     msgpack::pack(ss, val1);
 
+    std::string const& str = ss.str();
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    msgpack::unpack(oh, str.data(), str.size());
     std::string_view val2 = oh.get().as<std::string_view>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -230,7 +236,8 @@ TEST(MSGPACK_CPP17, byte_pack_convert)
     msgpack::pack(ss, val1);
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::unpack(oh, str.data(), str.size());
     std::byte val2 = oh.get().as<std::byte>();
     EXPECT_EQ(val1, val2);
 }
@@ -263,11 +270,13 @@ TEST(MSGPACK_CPP17, vector_byte_pack_convert)
 
     char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) };
     for (size_t i = 0; i != sizeof(packed); ++i) {
-        EXPECT_EQ(ss.str()[i], packed[i]);
+        std::string const& str = ss.str();
+        EXPECT_EQ(str[i], packed[i]);
     }
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::unpack(oh, str.data(), str.size());
     std::vector<std::byte> val2 = oh.get().as<std::vector<std::byte>>();
     EXPECT_EQ(val1, val2);
 }
@@ -308,11 +317,13 @@ TEST(MSGPACK_CPP17, carray_byte_pack_convert)
 
     char packed[] = { char(0xc4), char(0x05), char(0x01), char(0x02), char(0x7f), char(0x80), char(0xff) };
     for (size_t i = 0; i != sizeof(packed); ++i) {
-        EXPECT_EQ(ss.str()[i], packed[i]);
+        std::string const& str = ss.str();
+        EXPECT_EQ(str[i], packed[i]);
     }
 
     msgpack::object_handle oh;
-    msgpack::unpack(oh, ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::unpack(oh, str.data(), str.size());
     std::byte val2[sizeof(val1)];
     oh.get().convert(val2);
     for (size_t i = 0; i != sizeof(val1); ++i) {

test/raw.cpp

@@ -29,7 +29,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack)
     EXPECT_EQ(packed_str[4], 'C');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -46,7 +46,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack_8_l)
     EXPECT_EQ(packed_str[1], static_cast<char>(0x00u));
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -64,7 +64,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack_8_h)
     EXPECT_EQ(packed_str[2], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -83,7 +83,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack_16_l)
     EXPECT_EQ(packed_str[3], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -102,7 +102,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack_16_h)
     EXPECT_EQ(packed_str[3], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -123,7 +123,7 @@ TEST(MSGPACK_RAW_REF, pack_unpack_32_l)
     EXPECT_EQ(packed_str[5], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::raw_ref rr2 = oh.get().as<msgpack::type::raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -142,7 +142,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack)
     EXPECT_EQ(packed_str[3], 'C');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -158,7 +158,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_fix_l)
     EXPECT_EQ(packed_str[0], static_cast<char>(0xa0u));
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -175,7 +175,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_fix_h)
     EXPECT_EQ(packed_str[1], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -194,7 +194,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_16_l)
     EXPECT_EQ(packed_str[3], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -213,7 +213,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_16_h)
     EXPECT_EQ(packed_str[3], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }
@@ -234,7 +234,7 @@ TEST(MSGPACK_V4RAW_REF, pack_unpack_32_l)
     EXPECT_EQ(packed_str[5], 'A');
 
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(packed_str.data(), packed_str.size());
     msgpack::type::v4raw_ref rr2 = oh.get().as<msgpack::type::v4raw_ref>();
     EXPECT_TRUE(rr1 == rr2);
 }

test/reference_wrapper_cpp11.cpp

@@ -20,7 +20,8 @@ TEST(MSGPACK_REFERENCE_WRAPPER, pack_convert)
     std::reference_wrapper<int> val1(i1);
     std::stringstream ss;
     msgpack::pack(ss, val1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     int i2 = 0;
     std::reference_wrapper<int> val2(i2);
     oh.get().convert(val2);
@@ -33,7 +34,8 @@ TEST(MSGPACK_REFERENCE_WRAPPER, pack_convert_const)
     std::reference_wrapper<const int> val1(i1);
     std::stringstream ss;
     msgpack::pack(ss, val1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     int i2 = 0;
     std::reference_wrapper<int> val2(i2);
     oh.get().convert(val2);
@@ -46,7 +48,8 @@ TEST(MSGPACK_REFERENCE_WRAPPER, pack_vector)
     std::vector<std::reference_wrapper<int>> val1{i1};
     std::stringstream ss;
     msgpack::pack(ss, val1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
     std::vector<int> val2 = oh.get().as<std::vector<int>>();
     EXPECT_EQ(val2.size(), static_cast<size_t>(1));
     EXPECT_EQ(val1[0], val2[0]);

test/shared_ptr_cpp11.cpp

@@ -20,8 +20,9 @@ TEST(SHARED_PTR, pack_convert_nil)
     std::stringstream ss;
     std::shared_ptr<int> val1;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::shared_ptr<int> val2 = oh.get().as<std::shared_ptr<int>>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -31,8 +32,9 @@ TEST(SHARED_PTR, pack_convert_int)
     std::stringstream ss;
     std::shared_ptr<int> val1(new int(1));
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::shared_ptr<int> val2 = oh.get().as<std::shared_ptr<int>>();
     EXPECT_TRUE(*val1 == *val2);
 }
@@ -119,8 +121,9 @@ TEST(SHARED_PTR, pack_convert_nil_no_def_con)
     std::stringstream ss;
     std::shared_ptr<no_def_con> val1(new no_def_con(1));
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::shared_ptr<no_def_con> val2 = oh.get().as<std::shared_ptr<no_def_con>>();
     EXPECT_TRUE(*val1 == *val2);
 }

test/size_equal_only.cpp

@@ -15,7 +15,8 @@ TEST(size_equal_only, array)
     msgpack::type::size_equal_only<int[3]> seo(buf);
 
     msgpack::pack(ss, seo);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
 
     int ret_buf1[3];
     oh.get().convert(ret_buf1);
@@ -58,7 +59,8 @@ TEST(size_equal_only, vector)
     msgpack::type::size_equal_only<std::vector<int> > seo(buf);
 
     msgpack::pack(ss, seo);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
 
     std::vector<int> ret_buf1;
     oh.get().convert(ret_buf1);
@@ -91,7 +93,8 @@ TEST(size_equal_only, msgpack_tuple)
     msgpack::type::size_equal_only<msgpack::type::tuple<int, bool, std::string> > seo(buf);
 
     msgpack::pack(ss, seo);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
 
     msgpack::type::tuple<int, bool, std::string> ret_buf1;
     oh.get().convert(ret_buf1);
@@ -148,7 +151,8 @@ TEST(size_equal_only, tuple)
     auto seo = msgpack::type::make_size_equal_only(buf);
 
     msgpack::pack(ss, seo);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
 
     std::tuple<int, bool, std::string> ret_buf1;
     oh.get().convert(ret_buf1);
@@ -210,7 +214,8 @@ TEST(size_equal_only, custom_class)
     std::stringstream ss;
     foo1 f1(42, true);
     msgpack::pack(ss, f1);
-    msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
+    std::string const& str = ss.str();
+    msgpack::object_handle oh = msgpack::unpack(str.data(), str.size());
 
     foo2 f2(123, false, "ABC");
     try {

test/unique_ptr_cpp11.cpp

@@ -20,8 +20,9 @@ TEST(UNIQUE_PTR, pack_convert_nil)
     std::stringstream ss;
     std::unique_ptr<int> val1;
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::unique_ptr<int> val2 = oh.get().as<std::unique_ptr<int>>();
     EXPECT_TRUE(val1 == val2);
 }
@@ -31,8 +32,9 @@ TEST(UNIQUE_PTR, pack_convert_int)
     std::stringstream ss;
     std::unique_ptr<int> val1(new int(1));
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::unique_ptr<int> val2 = oh.get().as<std::unique_ptr<int>>();
     EXPECT_TRUE(*val1 == *val2);
 }
@@ -119,8 +121,9 @@ TEST(UNIQUE_PTR, pack_convert_nil_no_def_con)
     std::stringstream ss;
     std::unique_ptr<no_def_con> val1(new no_def_con(1));
     msgpack::pack(ss, val1);
+    std::string const& str = ss.str();
     msgpack::object_handle oh =
-        msgpack::unpack(ss.str().data(), ss.str().size());
+        msgpack::unpack(str.data(), str.size());
     std::unique_ptr<no_def_con> val2 = oh.get().as<std::unique_ptr<no_def_con>>();
     EXPECT_TRUE(*val1 == *val2);
 }

test/visitor.cpp

@@ -98,7 +98,8 @@ TEST(visitor, json_like)
     std::string json_like;
     json_like_visitor v(json_like);
     std::size_t off = 0;
-    bool ret = msgpack::parse(ss.str().data(), ss.str().size(), off, v);
+    std::string const& str = ss.str();
+    bool ret = msgpack::parse(str.data(), str.size(), off, v);
     EXPECT_TRUE(ret);
     EXPECT_EQ("{\"key\":[42,null,true]}", json_like);
 }