script_core 0.1.1 → 0.2.4

data/ext/enterprise_script_service/msgpack/include/msgpack/zbuffer.h

@@ -100,8 +100,9 @@ static inline void msgpack_zbuffer_free(msgpack_zbuffer* zbuf)
 
 static inline bool msgpack_zbuffer_expand(msgpack_zbuffer* zbuf)
 {
-    size_t used = (char*)zbuf->stream.next_out - zbuf->data;
+    size_t used = static_cast<size_t>(reinterpret_cast<char*>(zbuf->stream.next_out) - zbuf->data);
     size_t csize = used + zbuf->stream.avail_out;
+
     size_t nsize = (csize == 0) ? zbuf->init_size : csize * 2;
 
     char* tmp = (char*)realloc(zbuf->data, nsize);
@@ -111,7 +112,7 @@ static inline bool msgpack_zbuffer_expand(msgpack_zbuffer* zbuf)
 
     zbuf->data = tmp;
     zbuf->stream.next_out  = (Bytef*)(tmp + used);
-    zbuf->stream.avail_out = nsize - used;
+    zbuf->stream.avail_out = static_cast<uInt>(nsize - used);
 
     return true;
 }
@@ -121,7 +122,7 @@ static inline int msgpack_zbuffer_write(void* data, const char* buf, size_t len)
     msgpack_zbuffer* zbuf = (msgpack_zbuffer*)data;
 
     zbuf->stream.next_in = (Bytef*)buf;
-    zbuf->stream.avail_in = len;
+    zbuf->stream.avail_in = static_cast<uInt>(len);
 
     while(zbuf->stream.avail_in > 0) {
         if(zbuf->stream.avail_out < MSGPACK_ZBUFFER_RESERVE_SIZE) {
@@ -145,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;
             }
@@ -162,12 +164,12 @@ static inline const char* msgpack_zbuffer_data(const msgpack_zbuffer* zbuf)
 
 static inline size_t msgpack_zbuffer_size(const msgpack_zbuffer* zbuf)
 {
-    return (char*)zbuf->stream.next_out - zbuf->data;
+    return static_cast<size_t>(reinterpret_cast<char*>(zbuf->stream.next_out) - zbuf->data);
 }
 
 static inline void msgpack_zbuffer_reset_buffer(msgpack_zbuffer* zbuf)
 {
-    zbuf->stream.avail_out += (char*)zbuf->stream.next_out - zbuf->data;
+    zbuf->stream.avail_out += (uInt)((char*)zbuf->stream.next_out - zbuf->data);
     zbuf->stream.next_out = (Bytef*)zbuf->data;
 }
 
@@ -197,4 +199,3 @@ static inline char* msgpack_zbuffer_release_buffer(msgpack_zbuffer* zbuf)
 #endif
 
 #endif /* msgpack/zbuffer.h */
-

data/ext/enterprise_script_service/msgpack/include/msgpack/zone.h

@@ -111,7 +111,7 @@ static inline void* msgpack_zone_malloc(msgpack_zone* zone, size_t size)
                 zone->chunk_list.ptr + (MSGPACK_ZONE_ALIGN - 1)
             ) / MSGPACK_ZONE_ALIGN * MSGPACK_ZONE_ALIGN
         );
-    size_t adjusted_size = size + (aligned - zone->chunk_list.ptr);
+    size_t adjusted_size = size + (size_t)(aligned - zone->chunk_list.ptr);
     if(zone->chunk_list.free >= adjusted_size) {
         zone->chunk_list.free -= adjusted_size;
         zone->chunk_list.ptr  += adjusted_size;

data/ext/enterprise_script_service/msgpack/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()

data/ext/enterprise_script_service/msgpack/src/objectc.c

@@ -7,9 +7,15 @@
  *    (See accompanying file LICENSE_1_0.txt or copy at
  *    http://www.boost.org/LICENSE_1_0.txt)
  */
+#if defined(_KERNEL_MODE)
+#  undef  _NO_CRT_STDIO_INLINE
+#  define _NO_CRT_STDIO_INLINE
+#endif
+
 #include "msgpack/object.h"
 #include "msgpack/pack.h"
 #include <ctype.h>
+
 #include <stdio.h>
 #include <string.h>
 
@@ -25,6 +31,10 @@
 #include <inttypes.h>
 #endif
 
+#if defined(_KERNEL_MODE)
+#  undef  snprintf
+#  define snprintf _snprintf
+#endif
 
 int msgpack_pack_object(msgpack_packer* pk, msgpack_object d)
 {
@@ -115,6 +125,7 @@ int msgpack_pack_object(msgpack_packer* pk, msgpack_object d)
     }
 }
 
+#if !defined(_KERNEL_MODE)
 
 static void msgpack_object_bin_print(FILE* out, const char *ptr, size_t size)
 {
@@ -130,35 +141,6 @@ static void msgpack_object_bin_print(FILE* out, const char *ptr, size_t size)
     }
 }
 
-static int msgpack_object_bin_print_buffer(char *buffer, size_t buffer_size, const char *ptr, size_t size)
-{
-    size_t i;
-    char *aux_buffer = buffer;
-    size_t aux_buffer_size = buffer_size;
-    int ret;
-
-    for (i = 0; i < size; ++i) {
-        if (ptr[i] == '"') {
-            ret = snprintf(aux_buffer, aux_buffer_size, "\\\"");
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
-        } else if (isprint((unsigned char)ptr[i])) {
-            if (aux_buffer_size > 0) {
-                memcpy(aux_buffer, ptr + i, 1);
-                aux_buffer = aux_buffer + 1;
-                aux_buffer_size = aux_buffer_size - 1;
-            }
-        } else {
-            ret = snprintf(aux_buffer, aux_buffer_size, "\\x%02x", (unsigned char)ptr[i]);
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
-        }
-    }
-
-    return buffer_size - aux_buffer_size;
-}
-
-
 void msgpack_object_print(FILE* out, msgpack_object o)
 {
     switch(o.type) {
@@ -270,6 +252,38 @@ void msgpack_object_print(FILE* out, msgpack_object o)
     }
 }
 
+#endif
+
+#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;                \
+    aux_buffer = aux_buffer + ret;                                        \
+    aux_buffer_size = aux_buffer_size - ret                               \
+
+static int msgpack_object_bin_print_buffer(char *buffer, size_t buffer_size, const char *ptr, size_t size)
+{
+    size_t i;
+    char *aux_buffer = buffer;
+    size_t aux_buffer_size = buffer_size;
+    int ret;
+
+    for (i = 0; i < size; ++i) {
+        if (ptr[i] == '"') {
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\\\"");
+        } else if (isprint((unsigned char)ptr[i])) {
+            if (aux_buffer_size > 0) {
+                memcpy(aux_buffer, ptr + i, 1);
+                aux_buffer = aux_buffer + 1;
+                aux_buffer_size = aux_buffer_size - 1;
+            }
+        } else {
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\\x%02x", (unsigned char)ptr[i]);
+        }
+    }
+
+    return (int)(buffer_size - aux_buffer_size);
+}
+
 int msgpack_object_print_buffer(char *buffer, size_t buffer_size, msgpack_object o)
 {
     char *aux_buffer = buffer;
@@ -277,197 +291,118 @@ int msgpack_object_print_buffer(char *buffer, size_t buffer_size, msgpack_object
     int ret;
     switch(o.type) {
     case MSGPACK_OBJECT_NIL:
-        ret = snprintf(aux_buffer, aux_buffer_size, "nil");
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "nil");
         break;
 
     case MSGPACK_OBJECT_BOOLEAN:
-        ret = snprintf(aux_buffer, aux_buffer_size, (o.via.boolean ? "true" : "false"));
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, (o.via.boolean ? "true" : "false"));
         break;
 
     case MSGPACK_OBJECT_POSITIVE_INTEGER:
 #if defined(PRIu64)
-        ret = snprintf(aux_buffer, aux_buffer_size, "%" PRIu64, o.via.u64);
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%" PRIu64, o.via.u64);
 #else
         if (o.via.u64 > ULONG_MAX) {
-            ret = snprintf(aux_buffer, aux_buffer_size, "over 4294967295");
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "over 4294967295");
         } else {
-            ret = snprintf(aux_buffer, aux_buffer_size, "%lu", (unsigned long)o.via.u64);
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%lu", (unsigned long)o.via.u64);
         }
 #endif
         break;
 
     case MSGPACK_OBJECT_NEGATIVE_INTEGER:
 #if defined(PRIi64)
-        ret = snprintf(aux_buffer, aux_buffer_size, "%" PRIi64, o.via.i64);
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%" PRIi64, o.via.i64);
 #else
         if (o.via.i64 > LONG_MAX) {
-            ret = snprintf(aux_buffer, aux_buffer_size, "over +2147483647");
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "over +2147483647");
         } else if (o.via.i64 < LONG_MIN) {
-            ret = snprintf(aux_buffer, aux_buffer_size, "under -2147483648");
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "under -2147483648");
         } else {
-            ret = snprintf(aux_buffer, aux_buffer_size, "%ld", (signed long)o.via.i64);
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%ld", (signed long)o.via.i64);
         }
 #endif
         break;
 
     case MSGPACK_OBJECT_FLOAT32:
     case MSGPACK_OBJECT_FLOAT64:
-        ret = snprintf(aux_buffer, aux_buffer_size, "%f", o.via.f64);
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%f", o.via.f64);
         break;
 
     case MSGPACK_OBJECT_STR:
-        ret = snprintf(aux_buffer, aux_buffer_size, "\"");
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
-        ret = snprintf(aux_buffer, aux_buffer_size, "%.*s", (int)o.via.str.size, o.via.str.ptr);
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
-        ret = snprintf(aux_buffer, aux_buffer_size, "\"");
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\"");
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%.*s", (int)o.via.str.size, o.via.str.ptr);
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\"");
         break;
 
     case MSGPACK_OBJECT_BIN:
-        ret = snprintf(aux_buffer, aux_buffer_size, "\"");
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
-
-        ret = msgpack_object_bin_print_buffer(aux_buffer, aux_buffer_size, o.via.bin.ptr, o.via.bin.size);
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
-
-        ret = snprintf(aux_buffer, aux_buffer_size, "\"");
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\"");
+        MSGPACK_CHECKED_CALL(ret, msgpack_object_bin_print_buffer, aux_buffer, aux_buffer_size, o.via.bin.ptr, o.via.bin.size);
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\"");
         break;
 
     case MSGPACK_OBJECT_EXT:
 #if defined(PRIi8)
-        ret = snprintf(aux_buffer, aux_buffer_size, "(ext: %" PRIi8 ")", o.via.ext.type);
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "(ext: %" PRIi8 ")", o.via.ext.type);
 #else
-        ret = snprintf(aux_buffer, aux_buffer_size, "(ext: %d)", (int)o.via.ext.type);
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "(ext: %d)", (int)o.via.ext.type);
 #endif
-        ret = snprintf(aux_buffer, aux_buffer_size, "\"");
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
-
-        ret = msgpack_object_bin_print_buffer(aux_buffer, aux_buffer_size, o.via.ext.ptr, o.via.ext.size);
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
-
-        ret = snprintf(aux_buffer, aux_buffer_size, "\"");
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\"");
+        MSGPACK_CHECKED_CALL(ret, msgpack_object_bin_print_buffer, aux_buffer, aux_buffer_size, o.via.ext.ptr, o.via.ext.size);
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\"");
         break;
 
     case MSGPACK_OBJECT_ARRAY:
-        ret = snprintf(aux_buffer, aux_buffer_size, "[");
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "[");
         if(o.via.array.size != 0) {
             msgpack_object* p = o.via.array.ptr;
             msgpack_object* const pend = o.via.array.ptr + o.via.array.size;
-            ret = msgpack_object_print_buffer(aux_buffer, aux_buffer_size, *p);
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
+            MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, *p);
             ++p;
             for(; p < pend; ++p) {
-                ret = snprintf(aux_buffer, aux_buffer_size, ", ");
-                aux_buffer = aux_buffer + ret;
-                aux_buffer_size = aux_buffer_size - ret;
-                ret = msgpack_object_print_buffer(aux_buffer, aux_buffer_size, *p);
-                aux_buffer = aux_buffer + ret;
-                aux_buffer_size = aux_buffer_size - ret;
+                MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, ", ");
+                MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, *p);
             }
         }
-        ret = snprintf(aux_buffer, aux_buffer_size, "]");
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "]");
         break;
 
     case MSGPACK_OBJECT_MAP:
-        ret = snprintf(aux_buffer, aux_buffer_size, "{");
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "{");
         if(o.via.map.size != 0) {
             msgpack_object_kv* p = o.via.map.ptr;
             msgpack_object_kv* const pend = o.via.map.ptr + o.via.map.size;
-            ret = msgpack_object_print_buffer(aux_buffer, aux_buffer_size, p->key);
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
-            ret = snprintf(aux_buffer, aux_buffer_size, "=>");
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
-            ret = msgpack_object_print_buffer(aux_buffer, aux_buffer_size, p->val);
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
+            MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, p->key);
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "=>");
+            MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, p->val);
             ++p;
             for(; p < pend; ++p) {
-                ret = snprintf(aux_buffer, aux_buffer_size, ", ");
-                aux_buffer = aux_buffer + ret;
-                aux_buffer_size = aux_buffer_size - ret;
-                ret = msgpack_object_print_buffer(aux_buffer, aux_buffer_size, p->key);
-                aux_buffer = aux_buffer + ret;
-                aux_buffer_size = aux_buffer_size - ret;
-                ret = snprintf(aux_buffer, aux_buffer_size, "=>");
-                aux_buffer = aux_buffer + ret;
-                aux_buffer_size = aux_buffer_size - ret;
-                ret = msgpack_object_print_buffer(aux_buffer, aux_buffer_size, p->val);
-                aux_buffer = aux_buffer + ret;
-                aux_buffer_size = aux_buffer_size - ret;
+                MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, ", ");
+                MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, p->key);
+                MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "=>");
+                MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, p->val);
             }
         }
-        ret = snprintf(aux_buffer, aux_buffer_size, "}");
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "}");
         break;
 
     default:
     // FIXME
 #if defined(PRIu64)
-        ret = snprintf(aux_buffer, aux_buffer_size, "#<UNKNOWN %i %" PRIu64 ">", o.type, o.via.u64);
-        aux_buffer = aux_buffer + ret;
-        aux_buffer_size = aux_buffer_size - ret;
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "#<UNKNOWN %i %" PRIu64 ">", o.type, o.via.u64);
 #else
         if (o.via.u64 > ULONG_MAX) {
-            ret = snprintf(aux_buffer, aux_buffer_size, "#<UNKNOWN %i over 4294967295>", o.type);
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "#<UNKNOWN %i over 4294967295>", o.type);
         } else {
-            ret = snprintf(aux_buffer, aux_buffer_size, "#<UNKNOWN %i %lu>", o.type, (unsigned long)o.via.u64);
-            aux_buffer = aux_buffer + ret;
-            aux_buffer_size = aux_buffer_size - ret;
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "#<UNKNOWN %i %lu>", o.type, (unsigned long)o.via.u64);
         }
 #endif
     }
 
-    return buffer_size - aux_buffer_size;
+    return (int)(buffer_size - aux_buffer_size);
 }
 
+#undef MSGPACK_CHECKED_CALL
 
 bool msgpack_object_equal(const msgpack_object x, const msgpack_object y)
 {

data/ext/enterprise_script_service/msgpack/src/unpack.c

@@ -18,7 +18,7 @@
 
 
 typedef struct {
-    msgpack_zone* z;
+    msgpack_zone** z;
     bool referenced;
 } unpack_user;
 
@@ -189,15 +189,30 @@ static inline int template_callback_false(unpack_user* u, msgpack_object* o)
 
 static inline int template_callback_array(unpack_user* u, unsigned int n, msgpack_object* o)
 {
-    unsigned int size;
+    size_t size;
+    // Let's leverage the fact that sizeof(msgpack_object) is a compile time constant
+    // to check for int overflows.
+    // Note - while n is constrained to 32-bit, the product of n * sizeof(msgpack_object)
+    // might not be constrained to 4GB on 64-bit systems
+#if SIZE_MAX == UINT_MAX
+    if (n > SIZE_MAX/sizeof(msgpack_object))
+        return MSGPACK_UNPACK_NOMEM_ERROR;
+#endif
+
     o->type = MSGPACK_OBJECT_ARRAY;
     o->via.array.size = 0;
-    size = n*sizeof(msgpack_object);
-    if (size / sizeof(msgpack_object) != n) {
-        // integer overflow
-        return MSGPACK_UNPACK_NOMEM_ERROR;
+
+    size = n * sizeof(msgpack_object);
+
+    if (*u->z == NULL) {
+        *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
+        if(*u->z == NULL) {
+            return MSGPACK_UNPACK_NOMEM_ERROR;
+        }
     }
-    o->via.array.ptr = (msgpack_object*)msgpack_zone_malloc(u->z, size);
+
+    // Unsure whether size = 0 should be an error, and if so, what to return
+    o->via.array.ptr = (msgpack_object*)msgpack_zone_malloc(*u->z, size);
     if(o->via.array.ptr == NULL) { return MSGPACK_UNPACK_NOMEM_ERROR; }
     return 0;
 }
@@ -216,15 +231,32 @@ static inline int template_callback_array_item(unpack_user* u, msgpack_object* c
 
 static inline int template_callback_map(unpack_user* u, unsigned int n, msgpack_object* o)
 {
-    unsigned int size;
+    size_t size;
+    // Let's leverage the fact that sizeof(msgpack_object_kv) is a compile time constant
+    // to check for int overflows
+    // Note - while n is constrained to 32-bit, the product of n * sizeof(msgpack_object)
+    // might not be constrained to 4GB on 64-bit systems
+
+    // Note - this will always be false on 64-bit systems
+#if SIZE_MAX == UINT_MAX
+    if (n > SIZE_MAX/sizeof(msgpack_object_kv))
+        return MSGPACK_UNPACK_NOMEM_ERROR;
+#endif
+
     o->type = MSGPACK_OBJECT_MAP;
     o->via.map.size = 0;
-    size = n*sizeof(msgpack_object_kv);
-    if (size / sizeof(msgpack_object_kv) != n) {
-        // integer overflow
-        return MSGPACK_UNPACK_NOMEM_ERROR;
+
+    size = n * sizeof(msgpack_object_kv);
+
+    if (*u->z == NULL) {
+        *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
+        if(*u->z == NULL) {
+            return MSGPACK_UNPACK_NOMEM_ERROR;
+        }
     }
-    o->via.map.ptr = (msgpack_object_kv*)msgpack_zone_malloc(u->z, size);
+
+    // Should size = 0 be an error? If so, what error to return?
+    o->via.map.ptr = (msgpack_object_kv*)msgpack_zone_malloc(*u->z, size);
     if(o->via.map.ptr == NULL) { return MSGPACK_UNPACK_NOMEM_ERROR; }
     return 0;
 }
@@ -245,8 +277,13 @@ static inline int template_callback_map_item(unpack_user* u, msgpack_object* c,
 
 static inline int template_callback_str(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o)
 {
-    MSGPACK_UNUSED(u);
     MSGPACK_UNUSED(b);
+    if (*u->z == NULL) {
+        *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
+        if(*u->z == NULL) {
+            return MSGPACK_UNPACK_NOMEM_ERROR;
+        }
+    }
     o->type = MSGPACK_OBJECT_STR;
     o->via.str.ptr = p;
     o->via.str.size = l;
@@ -256,8 +293,13 @@ static inline int template_callback_str(unpack_user* u, const char* b, const cha
 
 static inline int template_callback_bin(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o)
 {
-    MSGPACK_UNUSED(u);
     MSGPACK_UNUSED(b);
+    if (*u->z == NULL) {
+        *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
+        if(*u->z == NULL) {
+            return MSGPACK_UNPACK_NOMEM_ERROR;
+        }
+    }
     o->type = MSGPACK_OBJECT_BIN;
     o->via.bin.ptr = p;
     o->via.bin.size = l;
@@ -267,11 +309,16 @@ static inline int template_callback_bin(unpack_user* u, const char* b, const cha
 
 static inline int template_callback_ext(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o)
 {
+    MSGPACK_UNUSED(b);
     if (l == 0) {
         return MSGPACK_UNPACK_PARSE_ERROR;
     }
-    MSGPACK_UNUSED(u);
-    MSGPACK_UNUSED(b);
+    if (*u->z == NULL) {
+        *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
+        if(*u->z == NULL) {
+            return MSGPACK_UNPACK_NOMEM_ERROR;
+        }
+    }
     o->type = MSGPACK_OBJECT_EXT;
     o->via.ext.type = *p;
     o->via.ext.ptr = p + 1;
@@ -317,7 +364,6 @@ bool msgpack_unpacker_init(msgpack_unpacker* mpac, size_t initial_buffer_size)
 {
     char* buffer;
     void* ctx;
-    msgpack_zone* z;
 
     if(initial_buffer_size < COUNTER_SIZE) {
         initial_buffer_size = COUNTER_SIZE;
@@ -334,26 +380,19 @@ bool msgpack_unpacker_init(msgpack_unpacker* mpac, size_t initial_buffer_size)
         return false;
     }
 
-    z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
-    if(z == NULL) {
-        free(ctx);
-        free(buffer);
-        return false;
-    }
-
     mpac->buffer = buffer;
     mpac->used = COUNTER_SIZE;
     mpac->free = initial_buffer_size - mpac->used;
     mpac->off = COUNTER_SIZE;
     mpac->parsed = 0;
     mpac->initial_buffer_size = initial_buffer_size;
-    mpac->z = z;
+    mpac->z = NULL;
     mpac->ctx = ctx;
 
     init_count(mpac->buffer);
 
     template_init(CTX_CAST(mpac->ctx));
-    CTX_CAST(mpac->ctx)->user.z = mpac->z;
+    CTX_CAST(mpac->ctx)->user.z = &mpac->z;
     CTX_CAST(mpac->ctx)->user.referenced = false;
 
     return true;
@@ -480,21 +519,15 @@ msgpack_object msgpack_unpacker_data(msgpack_unpacker* mpac)
 
 msgpack_zone* msgpack_unpacker_release_zone(msgpack_unpacker* mpac)
 {
-    msgpack_zone* r;
-    msgpack_zone* old;
+    msgpack_zone* old = mpac->z;
 
+    if (old == NULL) return NULL;
     if(!msgpack_unpacker_flush_zone(mpac)) {
         return NULL;
     }
 
-    r = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
-    if(r == NULL) {
-        return NULL;
-    }
-
-    old = mpac->z;
-    mpac->z = r;
-    CTX_CAST(mpac->ctx)->user.z = mpac->z;
+    mpac->z = NULL;
+    CTX_CAST(mpac->ctx)->user.z = &mpac->z;
 
     return old;
 }
@@ -596,7 +629,7 @@ msgpack_unpack(const char* data, size_t len, size_t* off,
         template_context ctx;
         template_init(&ctx);
 
-        ctx.user.z = result_zone;
+        ctx.user.z = &result_zone;
         ctx.user.referenced = false;
 
         e = template_execute(&ctx, data, len, &noff);
@@ -633,19 +666,12 @@ msgpack_unpack_next(msgpack_unpacked* result,
         return MSGPACK_UNPACK_CONTINUE;
     }
 
-    if (!result->zone) {
-        result->zone = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
-    }
-
-    if (!result->zone) {
-        return MSGPACK_UNPACK_NOMEM_ERROR;
-    }
-    else {
+    {
         int e;
         template_context ctx;
         template_init(&ctx);
 
-        ctx.user.z = result->zone;
+        ctx.user.z = &result->zone;
         ctx.user.referenced = false;
 
         e = template_execute(&ctx, data, len, &noff);